Sequenza matematica ulteriori elementi - f #, programmazione funzionale, sequenza

Diciamo che ho l'equazione seguente . Il mio obiettivo è creare una sequenza che restituisca i prossimi elementi di questo. Ecco la mia soluzione e funziona:

let rec factorial(n:float) =
match n with
|0.0 -> 1.0
|n -> n * factorial(n-1.0)

let seq1 = Seq.initInfinite( fun i -> factorial(float(i)) / sqrt(float(i)+1.0) ))

Ora, analogicamente, mi piacerebbe creare una sequenza che restituisca gli elementi secondo l'equazione:

Ho un po 'di codice, ma è sbagliato, quindi come farlo funzionare?

let seq2(x:float) = Seq.initInfinite(fun a -> let i = float(a)
(1.0/factorial(0.0)) + System.Math.Pow(x,i)/factorial(i) )

risposte:

Non puoi saltare la parte (1.0 / fattoriale (0.0)) dell'equazione (o forse ho frainteso la domanda).

modifica: i.e

let seq2(x:float) =
Seq.initInfinite(fun a ->
let i = float(a) in
System.Math.Pow(x,i)/factorial(i))

edit: per troncare un seq puoi usare "take" e per sommare puoi usare "sum". Come in

let seq2sum nbelems =
seq2 >> Seq.take nbelems >> Seq.sum

allora ottieni seq2sum 12 3.0 uguale a circa 20 :-)

Il bello dei linguaggi funzionali è che puoi avere la tua soluzione come espressione più vicina possibile della definizione originale.

È possibile evitare dichiarazioni di tipo esplicito per la maggior parte delle funzioni:

let rec factorial = function
| 0 -> 1
| n -> n * (factorial (n-1))


let e x n =
seq { 0 .. n }
|> Seq.map(fun i -> x ** (float i) / float (factorial i))
|> Seq.sum

Nella serie infinita, dovrai prendere le prime n voci prima di sommare, poiché una serie infinita non finirà mai di valutare:

let e" x n =
Seq.initInfinite(fun i -> x ** (float i) / float (factorial i))
|> Seq.take n
|> Seq.sum

e 1.0 10 //2.718281801
e" 1.0 10 //2.718281801