Seq.unfold explication in F #

Question

J'essaye de créer une séquence paresseusement en utilisant F #.

La séquence est définie comme suit:

Le nième terme de la séquence de nombres triangle est donnée par, tn = ½n (n + 1); de sorte que les dix premiers numéros triangle sont:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Voici ce que j'ai à ce jour mais il dosnt semblent fonctionner:

let tri_seq = 1.0 |> Seq.unfold (fun x -> match x with           
              | _ -> Some (x, 0.5*x*(x + 1.0))) 

Merci beaucoup qui peut me aider à comprendre comment se déroulent les travaux. Merci

Modifier: J'ai marqué la première réponse comme correcte mais il ne fonctionne pas, mais je l'ai légèrement modifié et cela a fonctionné.

let tri_seq = 1.0 |> Seq.unfold (fun x -> Some (0.5 * x * (x + 1.0),x + 1.0)) 

Answer 1

Tout d'abord, pourquoi utilisez-vous match si vous avez un seul cas?

let tri_seq = 1.0 |> Seq.unfold (fun x -> Some (x, 0.5 * x * (x + 1.0))) 

Deuxièmement, qu'est-ce qui ne semble pas fonctionner? Savez-vous que vous produisez une liste infinie?

/Edit: Pour être complet bien, voici la bonne solution, que l'OP se trouvait et affiché comme commentaire:

let tri_seq = 
    1.0 |> Seq.unfold (fun x -> Some (0.5 * x * (x + 1.0), x + 1.0)) 

Answer 2

Voici une alternative:

let tri = seq { 
    let n = ref 1.0 
    let diff = ref 2.0 
    while true do 
     yield !n 
     n := !n + !diff 
     diff := !diff + 1.0 
    } 

printfn "%A" (tri |> Seq.take 10 |> Seq.to_list) 

Answer 3

Une autre alternative à le code que Brian a posté est d'utiliser la récursivité à la place de la boucle impérative 'while':

let tri = 
    let rec loop(n, diff) = seq { 
    yield n   
    yield! loop(n + diff, diff + 1.0) } 
    loop(1.0, 2.0) 
printfn "%A" (tri |> Seq.take 10 |> Seq.to_list) 

C'est beaucoup moins efficace (il faut donc être un peu prudent ici ...), mais c'est une solution fonctionnelle plus idiomatique, donc il peut être plus facile de voir ce que fait le code.

Answer 4

Je sais que c'est un très vieux, mais je ne comprends pas pourquoi utiliser float quand vous êtes sûr que x * (x + 1) est un nombre pair et en effet divisible par 2. Donc, je voudrais simplement utiliser cette une place (je sais pas beaucoup de différence, mais au moins vous avez une seq int):

let tri_seq = 1 |> Seq.unfold (fun x -> Some (x * (x + 1)/2 , x + 1)) 

tri_seq |> Seq.take 6 |> Seq.toList //[1; 3; 6; 10; 15; 21] 

fiddle

(Sauf si vous face à un nombre bien sûr ....)