Generator/Exponential: Difference between revisions
m
Moved Wren entry into correct alphabetical order.
(Added Quackery.) |
m (Moved Wren entry into correct alphabetical order.) |
||
(14 intermediate revisions by 12 users not shown) | |||
Line 26:
* [[wp:Generator (computer_science)|Generator]]
<br><br>
=={{header|11l}}==
{{trans|C++}}
<syntaxhighlight lang="11l">T Generator
F.virtual.abstract next() -> Float
T PowersGenerator(Generator)
i = 0.0
Float e
F (e)
.e = e
F.virtual.assign next() -> Float
V r = .i ^ .e
.i++
R r
T Filter
Generator gen, filter
Float lastG, lastF
F (Generator gen, filter)
.gen = gen
.filter = filter
.lastG = .gen.next()
.lastF = .filter.next()
F ()()
L .lastG >= .lastF
I .lastG == .lastF
.lastG = .gen.next()
.lastF = .filter.next()
V out = .lastG
.lastG = .gen.next()
R out
V gen = Filter(PowersGenerator(2), PowersGenerator(3))
L 20
gen()
L 10
print(gen(), end' ‘ ’)</syntaxhighlight>
{{out}}
<pre>
529 576 625 676 784 841 900 961 1024 1089
</pre>
=={{header|Ada}}==
Line 36 ⟶ 86:
generator.ads:
<
type Generator is tagged private;
Line 58 ⟶ 108:
end record;
end Generator;</
generator-filtered.ads:
<
type Filtered_Generator is new Generator with private;
Line 79 ⟶ 129:
end record;
end Generator.Filtered;</
generator.adb:
<
--------------
Line 143 ⟶ 193:
end Set_Generator_Function;
end Generator;</
generator-filtered.adb:
<
-----------
Line 204 ⟶ 254:
end Set_Filter;
end Generator.Filtered;</
example use:
<
with Generator.Filtered;
Line 241 ⟶ 291:
end loop;
end Generator_Test;</
{{out}}
Line 259 ⟶ 309:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.5 algol68g-2.3.5].}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}
'''File: Template.Generator.a68'''<
MODE GENVALUE = PROC(YIELDVALUE)VOID;
Line 321 ⟶ 371:
PROC powers = (VALUE m, YIELDVALUE yield)VOID:
FOR n FROM 0 DO yield(n ** m) OD;</
MODE VALUE = INT;
Line 329 ⟶ 379:
GENVALUE fil = gen filtered(squares, cubes,);
printf(($g(0)x$, get list(gen slice(fil, 20, 30, )) ))</
{{out}}
<pre>
Line 339 ⟶ 389:
{{Trans|JavaScript}}
{{Trans|Python}}
<
-- powers :: Gen [Int]
Line 570 ⟶ 620:
end |λ|
end script
end zipGen</
{{Out}}
<pre>{529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089}</pre>
=={{header|ATS}}==
<syntaxhighlight lang="ats">
(* "Generators" *)
(* I implement "generators" as non-linear closures. *)
#include "share/atspre_staload.hats"
#define NIL list_nil ()
#define :: list_cons
(* Integer powers where base and power are of any unsigned integer
types. *)
fn {tk_b, tk_p : tkind}
g1uint_ipow
(base : g1uint tk_b,
power : g1uint tk_p)
:<> g1uint tk_b =
let
fun
loop {p : nat}
.<p>.
(b : g1uint tk_b,
p : g1uint (tk_p, p),
accum : g1uint tk_b)
:<> g1uint tk_b =
let
val ph = half p
val accum = (if ph + ph = p then accum else accum * b)
in
if ph = g1i2u 0 then
accum
else
loop (b * b, ph, accum)
end
prval () = lemma_g1uint_param base
prval () = lemma_g1uint_param power
in
loop (base, power, g1i2u 1)
end
overload ipow with g1uint_ipow of 100
(* Some unit tests of ipow. *)
val- 0U = ipow (0U, 100U)
val- 1U = ipow (0U, 0U) (* Sometimes a convenient result. *)
val- 9UL = ipow (3UL, 2ULL)
val- 81ULL = ipow (3ULL, 4U)
typedef generator (tk : tkind) =
() -<cloref1> g1uint tk
typedef option_generator (tk : tkind) =
() -<cloref1> Option (g1uint tk)
fn {tk_b : tkind}
{tk_p : tkind}
make_powers_generator
(power : g1uint tk_p)
:<!wrt> generator tk_b =
let
val base : ref (g1uint tk_b) = ref (g1i2u 0)
in
lam () =>
let
val b = !base
val result = ipow (b, power)
in
!base := succ b;
result
end
end
fn {tk : tkind}
make_generator_of_1_that_are_not_also_2
(gen1 : generator tk,
gen2 : generator tk)
:<!wrt> generator tk =
let
val initialized : ref bool = ref false
val x2 : ref (g1uint tk) = ref (g1i2u 0)
fn
check (x1 : g1uint tk)
:<1> bool =
let
fun
loop ()
:<1> bool =
if x1 <= !x2 then
(x1 <> !x2)
else
begin
!x2 := gen2 ();
loop ()
end
in
loop ()
end
in
lam () =>
let
var result : g1uint tk = g1i2u 0
var found_one : bool = false
in
if ~(!initialized) then
begin
!x2 := gen2 ();
!initialized := true
end;
while (~found_one)
let
val next1 = gen1 ()
in
if check next1 then
begin
result := next1;
found_one := true
end
end;
result
end
end
fn {tk : tkind}
make_dropper
(n : size_t,
gen : generator tk)
:<!wrt> generator tk =
let
val counter : ref size_t = ref n
in
lam () =>
begin
while (isneqz (!counter))
let
val _ = gen ()
in
!counter := pred (!counter)
end;
gen ()
end
end
fn {tk : tkind}
make_taker
(n : size_t,
gen : generator tk)
:<!wrt> option_generator tk =
let
val counter : ref size_t = ref n
in
lam () =>
if iseqz (!counter) then
None ()
else
begin
!counter := pred (!counter);
Some (gen ())
end
end
implement
main0 () =
let
stadef tk = uintknd
macdef filter = make_generator_of_1_that_are_not_also_2<tk>
val squares_generator = make_powers_generator<tk> 2U
val cubes_generator = make_powers_generator<tk> 3U
val gen = filter (squares_generator, cubes_generator)
val gen = make_dropper<tk> (i2sz 20, gen)
val gen = make_taker<tk> (i2sz 10, gen)
var done : bool = false
in
while (~done)
begin
case+ gen () of
| None () => done := true
| Some x => print! (" ", x)
end;
println! ()
end
</syntaxhighlight>
{{out}}
<pre>$ patscc -DATS_MEMALLOC_GCBDW generator-exponential.dats -lgc && ./a.out
529 576 625 676 784 841 900 961 1024 1089</pre>
=={{header|C}}==
Line 582 ⟶ 824:
Then the generator passes some 64-bit integer to <tt>yield64()</tt>, which switches to the first cothread, where <tt>next64()</tt> returns this 64-bit integer.
<
#include <stdlib.h> /* exit() */
#include <stdio.h> /* printf() */
Line 743 ⟶ 985:
gen.free(&gen); /* Free memory. */
return 0;
}</
One must download [http://byuu.org/programming/ libco] and give libco.c to the compiler.
Line 753 ⟶ 995:
===Using struct to store state===
<
#include <stdlib.h>
#include <math.h>
Line 826 ⟶ 1,068:
return 0;
}</
{{out}}<pre>529
576
Line 839 ⟶ 1,081:
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Linq;
Line 857 ⟶ 1,099:
while (true) yield return i++;
}
}</
=={{header|C++}}==
Line 863 ⟶ 1,105:
A templated solution.
<
using namespace std;
Line 928 ⟶ 1,170:
for(int i = 20; i < 30; ++i)
cout << i << ": " << gen() << endl;
}</
{{out}}
Line 952 ⟶ 1,194:
Thus we can define squares and cubes as lazy sequences:
<
(def squares (powers 2))
(take 5 squares) ; => (1 4 9 16 25)</
The definition here of the squares-not-cubes lazy sequence uses the loop/recur construct,
which isn't lazy. So we use ''lazy-seq'' explicity:
<
([] (squares-not-cubes (powers 2) (powers 3)))
([squares cubes]
Line 969 ⟶ 1,211:
(->> (squares-not-cubes) (drop 20) (take 10))
; => (529 576 625 676 784 841 900 961 1024 1089)</
If we really need a generator function for some reason, any lazy sequence
Line 975 ⟶ 1,217:
function ''repeatedly''.)
<
(let [state (atom (cons nil sequence))]
(fn [] (first (swap! state rest)))
(def f (seq->fn (squares-not-cubes)))
[(f) (f) (f)] ; => [4 9 16]</
=={{header|Common Lisp}}==
<
(values-list (loop repeat n collect (funcall seq))))
Line 1,003 ⟶ 1,245:
(let ((2not3 (filter-seq (power-seq 2) (power-seq 3))))
(take 2not3 20) ;; drop 20
(princ (multiple-value-list (take 2not3 10))))</
=={{header|D}}==
===Efficient Standard Version===
<
import std.stdio, std.bigint, std.range, std.algorithm;
Line 1,014 ⟶ 1,256:
squares.setDifference(cubes).drop(20).take(10).writeln;
}</
{{out}}
<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>
Line 1,020 ⟶ 1,262:
===Simple Ranges-Based Implementation===
{{trans|C#}}
<
import std.stdio, std.bigint, std.range, std.algorithm;
Line 1,031 ⟶ 1,273:
.take(10)
.writeln;
}</
The output is the same.
===More Efficient Ranges-Based Version===
<
struct Filtered(R1, R2) if (is(ElementType!R1 == ElementType!R2)) {
Line 1,081 ⟶ 1,323:
auto cubes = 0.sequence!"n".map!(i => i.BigInt ^^ 3);
filtered(squares, cubes).drop(20).take(10).writeln;
}</
The output is the same.
===Closures-Based Version===
{{trans|Go}}
<
auto powers(in double e) pure nothrow {
Line 1,119 ⟶ 1,361:
write(fgen(), " ");
writeln;
}</
{{out}}
<pre>529 576 625 676 784 841 900 961 1024 1089 </pre>
===Generator Range Version===
<
auto powers(in uint m) pure nothrow @safe {
Line 1,151 ⟶ 1,393:
auto squares = 2.powers, cubes = 3.powers;
filtered(squares, cubes).drop(20).take(10).writeln;
}</
{{out}}
<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,Math,StdCtrls,ExtCtrls}}
This program demostrates hierarchial object structure. It starts with a base generator object that has all the basic features need by a generator. Child objects are then created which customized the behavior to generate squares, cubes and filtered squares. Once the base object is created, any variation can be created with just a few lines of code. This is the power of polymorphism and inheritance.
<syntaxhighlight lang="Delphi">
{Custom object forms basic generator}
type TCustomGen = class(TObject)
private
FNumber: integer;
FExponent: integer;
FStart: integer;
protected
property Exponent: integer read FExponent write FExponent;
public
constructor Create; virtual;
procedure Reset;
function Next: integer; virtual;
procedure Skip(Count: integer);
property Start: integer read FStart write FStart;
end;
{Child object specifically for generating Squares}
type TSquareGen = class(TCustomGen)
public
constructor Create; override;
end;
{Child object specifically for generating cubes}
type TCubeGen = class(TCustomGen)
public
constructor Create; override;
end;
{Child object specifically for filtering squares}
type TFilterSquareGen = class(TSquareGen)
private
function IsCube(N: integer): boolean;
public
function Next: integer; override;
end;
{ TCustomGen }
constructor TCustomGen.Create;
begin
Start:=0;
{Default to returning X^1}
Exponent:=1;
Reset;
end;
function TCustomGen.Next: integer;
{Find next number in sequence}
var I: integer;
begin
Result:=FNumber;
{Raise to specified power}
for I:=1 to FExponent-1 do Result:=Result * Result;
{Get next base}
Inc(FNumber);
end;
procedure TCustomGen.Reset;
begin
FNumber:=Start;
end;
procedure TCustomGen.Skip(Count: integer);
{Skip specified number of items}
var I: integer;
begin
for I:=1 to Count do Next;
end;
{ TSquareGen }
constructor TSquareGen.Create;
begin
inherited;
Exponent:=2;
end;
{ TCubeGen }
constructor TCubeGen.Create;
begin
inherited;
Exponent:=3;
end;
{ TFilterSquareGen }
function TFilterSquareGen.IsCube(N: integer): boolean;
{Test if number is perfect cube}
var I: integer;
begin
I:=Round(Power(N,1/3));
Result:=I*I*I = N;
end;
function TFilterSquareGen.Next: integer;
begin
{Gets inherited next square, rejects cubes}
repeat Result:=inherited Next
until not IsCube(Result);
end;
{-----------------------------------------------------------}
procedure DoTest(Memo: TMemo; Gen: TCustomGen; SkipCnt: integer; Title: string);
{Carry out TGenerators tests. "Gen" is a TCustomGen which is the parent of}
{all generators. That means "DoTest" can work with any type of generator}
var S: string;
var I,V: integer;
begin
Gen.Reset;
Gen.Skip(SkipCnt);
Memo.Lines.Add(Title);
S:='[';
for I:=1 to 10 do S:=S+Format(' %d',[Gen.Next]);
Memo.Lines.Add(S+']');
end;
procedure TestGenerators(Memo: TMemo);
{Tests all three types of generators}
var SquareGen: TSquareGen;
var CubeGen: TCubeGen;
var Filtered: TFilterSquareGen;
begin
SquareGen:=TSquareGen.Create;
try
CubeGen:=TCubeGen.Create;
try
Filtered:=TFilterSquareGen.Create;
try
DoTest(Memo,SquareGen,0,'Testing Square Generator');
DoTest(Memo,CubeGen,0,'Testing Cube Generator');
DoTest(Memo,Filtered,20,'Testing Squares with cubes removed');
finally Filtered.Free; end;
finally CubeGen.Free; end;
finally SquareGen.Free; end;
end;
</syntaxhighlight>
{{out}}
<pre>
Testing Square Generator
[ 0 1 4 9 16 25 36 49 64 81]
Testing Cube Generator
[ 0 1 16 81 256 625 1296 2401 4096 6561]
Testing Squares with cubes removed
[ 529 576 625 676 784 841 900 961 1024 1089]
</pre>
=={{header|E}}==
Line 1,159 ⟶ 1,572:
E does not provide coroutines on the principle that interleaving of execution of code should be explicit to avoid unexpected interactions. However, this problem does not especially require them. Each generator here is simply a function that returns the next value in the sequence when called.
<
var i := -1
return def powerGenerator() {
Line 1,193 ⟶ 1,606:
print(`${squaresNotCubes()} `)
}
println()</
=={{header|EchoLisp}}==
<
(lib 'tasks) ;; for make-generator
Line 1,233 ⟶ 1,646:
; inspect
task → #generator:state: 1331
</syntaxhighlight>
=={{header|Elixir}}==
{{trans|Erlang}}
<
def filter( source_pid, remove_pid ) do
first_remove = next( remove_pid )
Line 1,283 ⟶ 1,696:
end
IO.inspect Generator.task</
{{out}}
Line 1,294 ⟶ 1,707:
This code requires generator library which was introduced in Emacs 25.2
<syntaxhighlight lang="lisp">;; lexical-binding: t
(require 'generator)
(iter-defun exp-gen (pow)
Line 1,322 ⟶ 1,734:
(setq o (iter-next g))
(when (>= i 20)
(print o))))</
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( generator ).
Line 1,363 ⟶ 1,775:
receive {next, Pid} -> Pid ! erlang:round(math:pow(N, M) ) end,
power_loop( M, N + 1 ).
</syntaxhighlight>
{{out}}
<pre>
Line 1,372 ⟶ 1,784:
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
let squares = m 2
Line 1,382 ⟶ 1,794:
Seq.take 10 (Seq.skip 20 (``squares without cubes``))
|> Seq.toList |> printfn "%A"</
{{out}}
<pre>[529; 576; 625; 676; 784; 841; 900; 961; 1024; 1089]</pre>
Line 1,388 ⟶ 1,800:
=={{header|Factor}}==
Using lazy lists for our generators:
<
prettyprint ;
IN: rosetta-code.generator-exponential
Line 1,402 ⟶ 1,814:
[ 3 mth-powers-generator lmember? not ] <lazy-filter> ;
10 2-not-3-generator 20 [ cdr ] times ltake list>array .</
{{out}}
<pre>
Line 1,412 ⟶ 1,824:
Using closures to implement generators.
<
class Main
{
Line 1,453 ⟶ 1,865:
}
}
</syntaxhighlight>
{{out}}
Line 1,470 ⟶ 1,882:
=={{header|Forth}}==
<syntaxhighlight lang="forth">
\ genexp-rcode.fs Generator/Exponential for RosettaCode.org
Line 1,517 ⟶ 1,929:
:noname 0 Counter ! 1 Sqroot ! 1 Cbroot ! 0 (go) drop ;
execute cr bye
</syntaxhighlight>
{{out}}
<pre>
Line 1,524 ⟶ 1,936:
$
</pre>
=={{header|FreeBASIC}}==
{{trans|VBA}}
<syntaxhighlight lang="freebasic">Dim Shared As Long lastsquare, nextsquare, lastcube, midcube, nextcube
Function squares() As Long
lastsquare += nextsquare
nextsquare += 2
squares = lastsquare
End Function
Function cubes() As Long
lastcube += nextcube
nextcube += midcube
midcube += 6
cubes = lastcube
End Function
lastsquare = 1 : nextsquare = -1 : lastcube = -1 : midcube = 0 : nextcube = 1
Dim As Long cube, square
cube = cubes
For i As Byte = 1 To 30
Do
square = squares
Do While cube < square
cube = cubes
Loop
If square <> cube Then Exit Do
Loop
If i > 20 Then Print square;
Next i
Sleep</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de VBA.
</pre>
=={{header|FunL}}==
{{trans|Haskell}} (for the powers function)
{{trans|Scala}} (for the filter)
<
def
Line 1,535 ⟶ 1,986:
filtered( _:st, c ) = filtered( st, c )
println( filtered(powers(2), powers(3)).drop(20).take(10) )</
{{out}}
<pre>
Line 1,543 ⟶ 1,994:
=={{header|Go}}==
Most direct and most efficient on a single core is implementing generators with closures.
<
import (
Line 1,589 ⟶ 2,040:
}
fmt.Println()
}</
{{out}}
<pre>
Line 1,603 ⟶ 2,054:
A generator implemented as a goroutine, on the other hand, "returns" a value by sending it on a channel, and then the goroutine continues execution from that point.
This allows more flexibility in structuring code.
<
import (
Line 1,650 ⟶ 2,101:
}
fmt.Println()
}</
=={{header|Haskell}}==
Generators in most cases can be implemented using infinite lists in Haskell. Because Haskell is lazy, only as many elements as needed is computed from the infinite list:
<
powers :: Int -> [Int]
Line 1,669 ⟶ 2,120:
main :: IO ()
main = print $ take 10 $ drop 20 foo</
{{Out}}
<pre>[529,576,625,676,784,841,900,961,1024,1089]</pre>
Line 1,677 ⟶ 2,128:
Co-expressions let us circumvent the normal backtracking mechanism and get results where we need them.
<
write("Non-cube Squares (21st to 30th):")
Line 1,701 ⟶ 2,152:
}
}
end</
Note: The task could be written without co-expressions but would be likely be ugly.
Line 1,725 ⟶ 2,176:
Here is a generator for mth powers of a number:
<
N=: 0
create=: 3 :0
Line 1,734 ⟶ 2,185:
N=: N+1
n^M
)</
And, here are corresponding square and cube generators
<
stateyCube=: 3 conew 'mthPower'</
Here is a generator for squares which are not cubes:
<
N=: 0
next=: 3 :0"0
while. (-: <.) 3 %: *: n=. N do. N=: N+1 end. N=: N+1
*: n
)</
And here is an example of its use:
<
529 576 625 676 784 841 900 961 1024 1089</
That said, here is a more natural approach, for J.
<
squares=: 2 mthPower
cubes=: 3 mthPower
uncubicalSquares=: squares -. cubes</
The downside of this approach is that it is computing independent sequences. And for the "uncubicalSquares" verb, it is removing some elements from that sequence. So you must estimate how many values to generate. However, this can be made transparent to the user with a simplistic estimator:
<
Example use:
<
529 576 625 676 784 841 900 961 1024 1089</
=={{header|Java}}==
{{works with|java|8}}
<
import static java.util.stream.LongStream.generate;
Line 1,825 ⟶ 2,276:
return n * n * n++;
}
}</
<pre>529 576 625 676 784 841 900 961 1024 1089</pre>
Line 1,833 ⟶ 2,284:
{{works with|Firefox 3.6 using JavaScript 1.7|}}
<syntaxhighlight lang="javascript">
function PowersGenerator(m) {
var n=0;
Line 1,871 ⟶ 2,322:
for( var x = 20; x < 30; x++ ) console.logfiltered.next());
</syntaxhighlight>
====ES6====
<
let e = 0;
while (1) { e++ && (yield Math.pow(e, n)); }
Line 1,893 ⟶ 2,344:
}
const filtered = filterGen(nPowerGen(2), nPowerGen(3), skip=20);</
<
for (let n = 0; n < 10; n++) {
console.log(filtered.next().value)
}</
<pre>529
576
Line 1,913 ⟶ 2,364:
Compositional derivation of custom generators:
{{Trans|Python}}
<
'use strict';
Line 2,067 ⟶ 2,518:
// MAIN ---
return main();
})();</
{{Out}}
<pre>[529,576,625,676,784,841,900,961,1024,1089]</pre>
Line 2,080 ⟶ 2,531:
relevant state information. For convenience, a counter is usually
included. For generating i^m, therefore, we would have:
<
def pow(m): . as $in | reduce range(0;m) as $i (1; .*$in);
# state: [i, i^m]
def next_power(m): .[0] + 1 | [., pow(m) ];</
To make such generators easier to use, we shall define filters to
skip and to emit a specified number of items:
<
def skip(m; next):
if m <= 0 then . else next | skip(m-1; next) end;
Line 2,093 ⟶ 2,544:
# emit m states including the initial state
def emit(m; next):
if m <= 0 then empty else ., (next | emit(m-1; next)) end;</
'''Examples''':
<
[0,0] | emit(4; next_power(2)) | .[1]
# Generate all the values in the sequence i^3 less than 100:
[0,0] | recurse(next_power(3) | if .[1] < 100 then . else empty end) | .[1]</
'''An aside on streams'''
Line 2,108 ⟶ 2,559:
'''Part 2: selection from 2 ^ m'''
<
def last(f): reduce f as $i (null; $i);
Line 2,134 ⟶ 2,585:
| skip(20; filtered_next_power(2;3))
| emit(10; filtered_next_power(2;3))
| .[0][1]</
{{out}}
<
529
576
Line 2,146 ⟶ 2,597:
961
1024
1089</
=={{header|Julia}}==
The task can be achieved by using closures, iterators or tasks. Here is a solution using anonymous functions and closures.
<
take(gen::Function, n::Integer) = collect(gen() for _ in 1:n)
Line 2,170 ⟶ 2,621:
end
@show take(drop(genfilter(pgen(2), pgen(3)), 20), 10)</
{{out}}
Line 2,177 ⟶ 2,628:
=={{header|Kotlin}}==
Coroutines were introduced in version 1.1 of Kotlin but, as yet, are an experimental feature:
<
// compiled with flag -Xcoroutines=enable to suppress 'experimental' warning
Line 2,213 ⟶ 2,664:
ncs.drop(20).take(10).forEach { print("$it ") } // print 21st to 30th items
println()
}</
{{out}}
Line 2,222 ⟶ 2,673:
=={{header|Lingo}}==
Lingo neither supports coroutines nor first-class functions, and also misses syntactic sugar for implementing real generators. But in the context of for or while loops, simple pseudo-generator objects that store states internally and manipulate data passed by reference can be used to implement generator-like behavior and solve the given task.
<
cubes = script("generator.power").new(3)
filter = script("generator.filter").new(squares, cubes)
Line 2,232 ⟶ 2,683:
if i>10 then exit repeat
put res[1]
end repeat</
{{out}}
Line 2,250 ⟶ 2,701:
Parent script "generator.power"
<
property _index
Line 2,272 ⟶ 2,723:
on reset (me)
me._index = 0
end</
Parent script "generator.filter"
<
property _genf
Line 2,318 ⟶ 2,769:
me._genv.reset()
me._genf.reset()
end</
=={{header|Lua}}==
Generators can be implemented both as closures and as coroutines. The following example demonstrates both.
<syntaxhighlight lang="lua">
--could be done with a coroutine, but a simple closure works just as well.
local function powgen(m)
Line 2,362 ⟶ 2,813:
end
end
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Generator {
PowGen = Lambda (e)
e // closure
-> {
i++
= i**e
}
}
Squares=Lambda
PowGen=PowGen(2) // closure
->{
= PowGen()
}
Cubes=Lambda
PowGen=PowGen(3) // closure
-> {
= PowGen()
}
Filter=Lambda
z=Squares(), // closure
Squares, // closure
m, // closure
Cubes // closure
->{
while m<z :m=cubes():end while
if z=m then z=Squares()
= z : z=Squares()
}
For i=1 to 20 : dropit=Filter() :Next i
Document doc$="Non-cubic squares (21st to 30th)"
Print doc$
doc$={
} \\ a new line to doc$
For i=1 to 10
f=Filter()
Print Format$("I: {0::-2}, F: {1}",i+20, f)
doc$=Format$("I: {0::-2}, F: {1}",i+20, f)+{
}
Clipboard doc$
}
Generator
</syntaxhighlight>
{{out}}
Line 2,421 ⟶ 2,878:
I: 30, F: 1089
</pre >
=={{header|Mathematica}} / {{header|Wolfram Language}}==
{{trans|VBA}}
Generators are not very natural in Mathemetica, because they avoid the use of lists and instead rely on sequential processing.
<syntaxhighlight lang="mathematica">lastsquare = 1;
nextsquare = -1;
lastcube = -1;
midcube = 0;
nextcube = 1;
Gensquares[] := Module[{},
lastsquare += nextsquare;
nextsquare += 2;
squares = lastsquare;
squares
]
Gencubes[] := Module[{},
lastcube += nextcube;
nextcube += midcube;
midcube += 6;
cubes = lastcube
]
c = Gencubes[];
Do[
While[True,
s = Gensquares[];
While[c < s,
c = Gencubes[];
];
If[s =!= c,
Break[]
];
];
If[i > 20,
Print[s]
]
,
{i, 30}
]</syntaxhighlight>
{{out}}
<pre>529
576
625
676
784
841
900
961
1024
1089</pre>
=={{header|Nim}}==
<
proc `^`*(base: Natural; exp: Natural): int =
Line 2,461 ⟶ 2,969:
if i > 20: echo x
if i >= 30: break
inc i</
{{out}}
Line 2,477 ⟶ 2,985:
=={{header|OCaml}}==
Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil]
<syntaxhighlight lang="ocaml">
(* Task : Generator/Exponential
Line 2,568 ⟶ 3,076:
let _ =
squares_no_cubes |> drop 20 |> take 10
</syntaxhighlight>
{{out}}
<pre>
Line 2,576 ⟶ 3,084:
=={{header|PARI/GP}}==
Define two generator functions genpow() and genpow2().
<
genpow(p) = my(a=g[1]++);listput(g,[0,p]);()->g[a][1]++^g[a][2];
genpowf(p,f) = my(a=g[1]++);listput(g,[0,p]);(s=0)->my(q);while(ispower(p=g[a][1]++^g[a][2],f)||(s&&q++<=s),);p;</
''genpow(power)'' returns a function that returns a simple power generator.<br>
Line 2,618 ⟶ 3,126:
These generators are anonymous subroutines, which are closures.
<
# generate and return the powers 0**m, 1**m, 2**m, ...
sub gen_pow {
Line 2,654 ⟶ 3,162:
my @answer;
push @answer, $squares_without_cubes->() for (1..10);
print "[", join(", ", @answer), "]\n";</
{{out}}<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\Generator_Exponential.exw
-- ======================================
--</span>
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- tasks</span>
<span style="color: #004080;">bool</span> <span style="color: #000000;">terminate</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">powers</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #008080;">not</span> <span style="color: #000000;">terminate</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">task_suspend</span><span style="color: #0000FF;">(</span><span style="color: #000000;">task_self</span><span style="color: #0000FF;">())</span>
<span style="color: #000000;">task_yield</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">squares</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">task_create</span><span style="color: #0000FF;">(</span><span style="color: #000000;">powers</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}),</span>
<span style="color: #000000;">cubes</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">task_create</span><span style="color: #0000FF;">(</span><span style="color: #000000;">powers</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">square</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cube</span>
<span style="color: #000000;">task_schedule</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">task_yield</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">cube</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">30</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">task_schedule</span><span style="color: #0000FF;">(</span><span style="color: #000000;">squares</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">task_yield</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">square</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">cube</span><span style="color: #0000FF;"><</span><span style="color: #000000;">square</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">task_schedule</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">task_yield</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">cube</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">square</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">cube</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">></span><span style="color: #000000;">20</span> <span style="color: #008080;">then</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">square</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">terminate</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,718 ⟶ 3,231:
{{trans|Python}}
{{works with|PHP|5.5+}}
<
function powers($m) {
for ($n = 0; ; $n++) {
Line 2,747 ⟶ 3,260:
$f->next();
}
?></
{{out}}
Line 2,765 ⟶ 3,278:
=={{header|PicoLisp}}==
Coroutines are available only in the 64-bit version.
<
(co (intern (pack 'powers M))
(for (I 0 (inc 'I))
Line 2,780 ⟶ 3,293:
(do 20 (filtered 2 3))
(do 10 (println (filtered 2 3)))</
{{out}}
<pre>529
Line 2,794 ⟶ 3,307:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
Generate: procedure options (main); /* 27 October 2013 */
declare j fixed binary;
Line 2,839 ⟶ 3,352:
end Generate;
</syntaxhighlight>
<pre>
20 dropped values:
Line 2,853 ⟶ 3,366:
{{works with|Python|2.6+ and 3.x}} (in versions prior to 2.6, replace <code>next(something)</code> with <code>something.next()</code>)
<
def powers(m):
Line 2,871 ⟶ 3,384:
squares, cubes = powers(2), powers(3)
f = filtered(squares, cubes)
print(list(islice(f, 20, 30)))</
{{out}}
Line 2,880 ⟶ 3,393:
{{Works with|Python|3.7}}
<
from itertools import count, islice
Line 2,961 ⟶ 3,474:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>
Line 2,967 ⟶ 3,480:
=={{header|Quackery}}==
<
this -2 peek **
1 this tally
Line 2,989 ⟶ 3,502:
dip nested
dup dip nested
do
2 expogen
Line 2,996 ⟶ 3,509:
20 times [ dup do drop ]
10 times [ dup do echo sp ]
drop</
{{out}}
Line 3,004 ⟶ 3,517:
=={{header|R}}==
<
{n = -1
function()
Line 3,028 ⟶ 3,541:
noncubic.squares()
for (i in 1:10)
message(noncubic.squares())</
=={{header|Racket}}==
<
#lang racket
Line 3,056 ⟶ 3,569:
[i 30] #:when (>= i 20))
x)
</syntaxhighlight>
{{out}}
Line 3,065 ⟶ 3,578:
=={{header|Raku}}==
(formerly Perl 6)
As with Haskell, generators are disguised as lazy lists in Raku.
<syntaxhighlight lang="raku"
my @squares = powers(2);
my @cubes = powers(3);
sub infix:<with-out> (@orig, @veto) {
gather for @veto -> $veto {
take @orig.shift while @orig[0] before $veto;
Line 3,079 ⟶ 3,592:
}
say (@squares with-out @cubes)[20 ..^ 20+10].join(', ');</
{{out}}
Line 3,086 ⟶ 3,599:
=={{header|REXX}}==
<br>The generators (below, the <big> Gxxxxx </big> functions) lie dormant until a request is made for a specific generator index.
<
parse arg N .; if N=='' | N=="," then N=20 /*N not specified? Then use default.*/
@.= /* [↓] calculate squares,cubes,pureSq.*/
Line 3,121 ⟶ 3,634:
#=#+1; @.pureSquare.#=? /*assign next pureSquare. */
end /*j*/
return @.pureSquare.x</
'''output''' when using the default value:
<pre>
Line 3,141 ⟶ 3,654:
An iterator is a Ruby method that takes a block parameter, and loops the block for each element. So <tt>powers(2) { |i| puts "Got #{i}" }</tt> would loop forever and print Got 0, Got 1, Got 4, Got 9 and so on. Starting with Ruby 1.8.7, one can use <tt>Object#enum_for</tt> to convert an iterator method to an <tt>Enumerator</tt> object. The <tt>Enumerator#next</tt> method is a generator that runs the iterator method on a separate coroutine. Here <tt>cubes.next</tt> generates the next cube number.
<
def powers(m)
Line 3,160 ⟶ 3,673:
p squares_without_cubes.take(30).drop(20)
# p squares_without_cubes.lazy.drop(20).first(10) # Ruby 2.0+</
{{out}}
<pre>
Line 3,170 ⟶ 3,683:
Here is the correct solution, which obeys the ''requirement'' of ''three'' generators.
<
def powers(m)
Line 3,192 ⟶ 3,705:
answer = squares_without_cubes # third generator
20.times { answer.next }
p 10.times.map { answer.next }</
{{out}}
<pre>
Line 3,204 ⟶ 3,717:
Powers method is the same as the above.
{{trans|Python}}
<
return enum_for(__method__, s1, s2) unless block_given?
v, f = s1.next, s2.next
Line 3,217 ⟶ 3,730:
f = filtered(squares, cubes)
p f.take(30).last(10)
# p f.lazy.drop(20).first(10) # Ruby 2.0+</
Output is the same as the above.
=={{header|Rust}}==
<
use std::iter::Peekable;
Line 3,259 ⟶ 3,772:
.for_each(|x| print!("{} ", x));
println!();
}</
{{out}}
<pre>529 576 625 676 784 841 900 961 1024 1089 </pre>
=={{header|Scala}}==
<
def main(args: Array[String]): Unit = {
def squares(n:Int=0):Stream[Int]=(n*n) #:: squares(n+1)
Line 3,277 ⟶ 3,790:
filtered(squares(), cubes()) drop 20 take 10 print
}
}</
Here is an alternative filter implementation using pattern matching.
<
case (sh#::_, ch#::ct) if (sh>ch) => filtered2(s, ct)
case (sh#::st, ch#::_) if (sh<ch) => sh #:: filtered2(st, c)
case (_#::st, _) => filtered2(st, c)
}</
{{out}}
<pre>529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089, empty</pre>
=={{header|Scheme}}==
===Scheme using conventional closures===
<syntaxhighlight lang="lisp">(define (power-seq n)
(let ((i 0))
(lambda ()
Line 3,314 ⟶ 3,828:
(newline))
(seq))
(loop seq (+ 1 i)))))</
{{out}}
<pre>576
Line 3,325 ⟶ 3,839:
1024
1089</pre>
===Scheme using ''call with current continuation''===
This method can be elaborated upon to, for instance, provide functionality similar to that of Icon co-expressions.
<syntaxhighlight lang="scheme">
;;; Generators using call/cc.
(cond-expand
(r7rs)
(chicken (import r7rs)))
(define-library (suspendable-procedures)
(export suspend)
(export make-generator-procedure)
(import (scheme base))
(begin
(define *suspend* (make-parameter (lambda (x) x)))
(define (suspend v) ((*suspend*) v))
(define (make-generator-procedure thunk)
;; This is for making a suspendable procedure that takes no
;; arguments when resumed. The result is a simple generator of
;; values.
(define (next-run return)
(define (my-suspend v)
(set! return (call/cc (lambda (resumption-point)
(set! next-run resumption-point)
(return v)))))
(parameterize ((*suspend* my-suspend))
(suspend (thunk))))
(lambda () (call/cc next-run)))
)) ;; end library (suspendable-procedures)
(import (scheme base))
(import (scheme case-lambda))
(import (scheme write))
(import (suspendable-procedures))
(define (make-integers-generator i0)
(make-generator-procedure
(lambda ()
(let loop ((i i0))
(suspend i)
(loop (+ i 1))))))
(define make-nth-powers-generator
(case-lambda
((n i0)
(define next-int (make-integers-generator i0))
(make-generator-procedure
(lambda ()
(let loop ()
(suspend (expt (next-int) n))
(loop)))))
((n)
(make-nth-powers-generator n 0))))
(define (make-filter-generator gen1 gen2)
(make-generator-procedure
(lambda ()
(let loop ((x1 (gen1))
(x2 (gen2)))
(cond ((= x1 x2) (loop (gen1) x2)) ; Skip this x1.
((< x1 x2) (begin ; Return this x1.
(suspend x1)
(loop (gen1) x2)))
(else (loop x1 (gen2))))))))
(define (gen-drop n)
(lambda (generator)
(make-generator-procedure
(lambda ()
(do ((i 0 (+ i 1)))
((= i n))
(generator))
(let loop ()
(suspend (generator))
(loop))))))
(define (gen-take n)
(lambda (generator)
(make-generator-procedure
(lambda ()
(do ((i 0 (+ i 1)))
((= i n))
(suspend (generator)))
(let loop ()
(suspend #f)
(loop))))))
(define my-generator
((gen-take 10)
((gen-drop 20)
(make-filter-generator
(make-nth-powers-generator 2)
(make-nth-powers-generator 3)))))
(let loop ()
(let ((x (my-generator)))
(when x
(display " ")
(display x)
(loop))))
(newline)
</syntaxhighlight>
{{out}}
Using Gauche Scheme.
<pre>$ gosh generator-exponential.scm
529 576 625 676 784 841 900 961 1024 1089</pre>
Using CHICKEN Scheme (which has efficient '''call/cc'''). You will need the '''r7rs''' egg.
<pre>$ csi -s generator-exponential.scm && ./a.out
529 576 625 676 784 841 900 961 1024 1089</pre>
=={{header|SenseTalk}}==
The ExponentialGenerator script is a generator object for exponential values.
<
to initialize
Line 3,338 ⟶ 3,967:
add 1 to my base
return my base to the power of my exponent
end nextValue</
The FilteredGenerator takes source and filter generators. It gets values from the source generator but excludes those from the filter generator.
<
// Takes a source generator, and a filter generator, which must both produce increasing values
Line 3,362 ⟶ 3,991:
return value
end nextValue
</syntaxhighlight>
This script shows the use of both of the generators.
<
set squares to new ExponentialGenerator with {exponent:2}
Line 3,398 ⟶ 4,027:
put n & ":" && filteredSquares.nextValue
end repeat
</syntaxhighlight>
{{out}}
<pre>
Line 3,440 ⟶ 4,069:
=={{header|Sidef}}==
{{trans|Perl}}
<
var e = 0;
func { e++ ** m };
Line 3,467 ⟶ 4,096:
var answer = [];
10.times { answer.append(squares_without_cubes()) };
say answer;</
{{out}}
<pre>
Line 3,475 ⟶ 4,104:
=={{header|SuperCollider}}==
<syntaxhighlight lang="supercollider">
f = { |m| {:x, x<-(0..) } ** m };
g = f.(2);
g.nextN(10); // answers [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]
</syntaxhighlight>
patterns are stream generators:
<syntaxhighlight lang="supercollider">(
f = Pseries(0, 1)
g = f ** 2;
g.asStream.nextN(10); // answers [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]
)
</syntaxhighlight>
supercollider has no "without" stream function, this builds one:
<syntaxhighlight lang="supercollider">(
var filter = { |a, b, func| // both streams are assumed to be ordered
Prout {
Line 3,523 ⟶ 4,152:
answers: [ 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089 ]
</syntaxhighlight>
=={{header|Swift}}==
<
let power = Double(m)
var cur: Double = 0
Line 3,572 ⟶ 4,201:
//961
//1024
//1089</
=={{header|Tcl}}==
Line 3,578 ⟶ 4,207:
Tcl implements generators in terms of coroutines.
If these generators were terminating, they would finish by doing <code>return -code break</code> so as to terminate the calling loop context that is doing the extraction of the values from the generator.
<
proc powers m {
Line 3,608 ⟶ 4,237:
for {} {$i<30} {incr i} {
puts [filtered]
}</
{{out}}
<pre>
Line 3,624 ⟶ 4,253:
=={{header|VBA}}==
<
Public nextsquare As Long
Public lastcube As Long
Line 3,667 ⟶ 4,296:
End If
Next i
End Sub</
<pre> 529 576 625 676 784 841 900 961 1024 1089 </pre>
Line 3,673 ⟶ 4,302:
'''Compiler:''' >= Visual Studio 2012
<
Iterator Function IntegerPowers(exp As Integer) As IEnumerable(Of Integer)
Dim i As Integer = 0
Line 3,707 ⟶ 4,336:
Next
End Sub
End Module</
More concise but slower implementation that relies on LINQ-to-objects to achieve generator behavior (runs slower due to re-enumerating Cubes() for every element of Squares()).
<
Return Squares().Where(Function(s) s <> Cubes().First(Function(c) c >= s))
End Function</
{{out}}
Line 3,725 ⟶ 4,354:
1024
1089</pre>
=={{header|Wren}}==
Closure based solution. Similar approach to Go (first example).
<
var i = 0
return Fn.new {
Line 3,793 ⟶ 4,390:
if (i > 19) System.write("%(p) ")
}
System.print()</
{{out}}
<pre>
529 576 625 676 784 841 900 961 1024 1089
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code ChOut=8, IntOut=11;
func Gen(M); \Generate Mth powers of positive integers
int M;
int N, R, I;
[N:= [0, 0, 0, 0]; \provides own/static variables
R:= 1;
for I:= 1 to M do R:= R*N(M);
N(M):= N(M)+1;
return R;
];
func Filter; \Generate squares of positive integers that aren't cubes
int S, C;
[C:= [0]; \static variable = smallest cube > current square
repeat S:= Gen(2);
while S > C(0) do C(0):= Gen(3);
until S # C(0);
return S;
];
int I;
[for I:= 1 to 20 do Filter; \drop first 20 values
for I:= 1 to 10 do [IntOut(0, Filter); ChOut(0, ^ )]; \show next 10 values
]</syntaxhighlight>
{{out}}
Line 3,803 ⟶ 4,432:
{{trans|Python}}
Generators are implemented with fibers (aka VMs) and return [lazy] iterators.
<
var squared=Utils.Generator(powers,2), cubed=Utils.Generator(powers,3);
Line 3,815 ⟶ 4,444:
var f=Utils.Generator(filtered,squared,cubed);
f.drop(20);
f.walk(10).println();</
{{out}}
<pre>L(529,576,625,676,784,841,900,961,1024,1089)</pre>
Line 3,823 ⟶ 4,452:
it just has been rewritten in a more functional style.
{{trans|Clojure}}
<
var squared=powers(2), cubed=powers(3);
Line 3,832 ⟶ 4,461:
}
var f=[0..].tweak(filtered.fp(squared,cubed))
f.drop(20).walk(10).println();</
|