diff --git a/collects/math/private/flonum/flonum-factorial.rkt b/collects/math/private/flonum/flonum-factorial.rkt
index 924c584812..4f7d9fa9be 100644
--- a/collects/math/private/flonum/flonum-factorial.rkt
+++ b/collects/math/private/flonum/flonum-factorial.rkt
@@ -13,6 +13,7 @@
 (provide flfactorial
          flbinomial
          flpermutations
+         flmultinomial
          fllog-factorial
          fllog-permutations
          fllog-binomial
@@ -138,10 +139,14 @@
 ;; ===================================================================================================
 ;; Multinomial
 
-(: fllog-multinomial (Flonum Flonum * -> Flonum))
-(define (fllog-multinomial n . ks)
+(: fllog-multinomial (Flonum (Listof Flonum) -> Flonum))
+(define (fllog-multinomial n ks)
   (cond [(n . < . 0)  +nan.0]
         [(ormap negative? ks)  +nan.0]
         [(not (= n (apply + ks)))  -inf.0]
         [(ormap (λ: ([k : Flonum]) (= n k)) ks)  0.0]
         [else  (apply - (fllog-factorial n) (map fllog-factorial ks))]))
+
+(: flmultinomial (Flonum (Listof Flonum) -> Flonum))
+(define (flmultinomial n ks)
+  (flexp (fllog-multinomial n ks)))
diff --git a/collects/math/scribblings/math-flonum.scrbl b/collects/math/scribblings/math-flonum.scrbl
index 459a37b2ef..ac6f5a238c 100644
--- a/collects/math/scribblings/math-flonum.scrbl
+++ b/collects/math/scribblings/math-flonum.scrbl
@@ -92,21 +92,21 @@ These functions are as robust and accurate as their corresponding inverses.
 @deftogether[(@defproc[(flfactorial [n Flonum]) Flonum]
               @defproc[(flbinomial [n Flonum] [k Flonum]) Flonum]
               @defproc[(flpermutations [n Flonum] [k Flonum]) Flonum]
-              @defproc[(flmultinomial [n Flonum] [k Flonum] ...) Flonum])]{
+              @defproc[(flmultinomial [n Flonum] [ks (Listof Flonum)]) Flonum])]{
 Like @racket[(fl (factorial (fl->exact-integer n)))] and so on, but computed in constant
 time. Also, these return @racket[+nan.0] instead of raising exceptions.
 
-For @racket[factorial]-family functions that return sensible values for non-integers, see
+For factorial-like functions that return sensible values for non-integers, see
 @racket[gamma] and @racket[beta].
 }
 
 @deftogether[(@defproc[(fllog-factorial [n Flonum]) Flonum]
               @defproc[(fllog-binomial [n Flonum] [k Flonum]) Flonum]
               @defproc[(fllog-permutations [n Flonum] [k Flonum]) Flonum]
-              @defproc[(fllog-multinomial [n Flonum] [k Flonum] ...) Flonum])]{
+              @defproc[(fllog-multinomial [n Flonum] [ks (Listof Flonum)]) Flonum])]{
 Like @racket[(fllog (flfactorial n))] and so on, but more accurate and without unnecessary overflow.
 
-For log-@racket[factorial]-family functions that return sensible values for non-integers, see
+For log-factorial-like functions that return sensible values for non-integers, see
 @racket[log-gamma] and @racket[log-beta].
 }