Generator/Exponential: Difference between revisions

* [[wp:Generator (computer_science)|Generator]]

<br><br>

 

=={{header|Ada}}==

 

generator.ads:

 

type Generator is tagged private;

end record;

 

 

generator-filtered.ads:

 

type Filtered_Generator is new Generator with private;

end record;

 

 

generator.adb:

 

--------------

end Set_Generator_Function;

 

 

generator-filtered.adb:

 

-----------

end Set_Filter;

 

 

example use:

with Generator.Filtered;

 

end loop;

 

 

{{out}}

{{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''.}}

MODE GENVALUE = PROC(YIELDVALUE)VOID;

 

 

PROC powers = (VALUE m, YIELDVALUE yield)VOID:

 

MODE VALUE = INT;

GENVALUE fil = gen filtered(squares, cubes,);

 

{{out}}

<pre>

529 576 625 676 784 841 900 961 1024 1089

</pre>

 

=={{header|C}}==

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() */

gen.free(&gen); /* Free memory. */

return 0;

 

One must download [http://byuu.org/programming/ libco] and give libco.c to the compiler.

 

===Using struct to store state===

#include <stdlib.h>

#include <math.h>

 

return 0;

{{out}}<pre>529

576

1024

1089</pre>

 

=={{header|C++}}==

A templated solution.

 

using namespace std;

 

for(int i = 20; i < 30; ++i)

cout << i << ": " << gen() << endl;

 

{{out}}

29: 1089

</pre>

 

=={{header|Clojure}}==

Thus we can define squares and cubes as lazy sequences:

 

(def squares (powers 2))

 

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]

(->> (squares-not-cubes) (drop 20) (take 10))

 

If we really need a generator function for some reason, any lazy sequence

function ''repeatedly''.)

 

(let [state (atom (cons nil sequence))]

(fn [] (first (swap! state rest)))

(def f (seq->fn (squares-not-cubes)))

 

=={{header|Common Lisp}}==

(values-list (loop repeat n collect (funcall seq))))

 

(let ((2not3 (filter-seq (power-seq 2) (power-seq 3))))

(take 2not3 20) ;; drop 20

 

=={{header|D}}==

===Efficient Standard Version===

import std.stdio, std.bigint, std.range, std.algorithm;

 

 

squares.setDifference(cubes).drop(20).take(10).writeln;

{{out}}

<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>

===Simple Ranges-Based Implementation===

{{trans|C#}}

import std.stdio, std.bigint, std.range, std.algorithm;

 

.take(10)

.writeln;

The output is the same.

 

===More Efficient Ranges-Based Version===

 

struct Filtered(R1, R2) if (is(ElementType!R1 == ElementType!R2)) {

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 {

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 {

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|E}}==

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() {

print(`${squaresNotCubes()} `)

}

 

=={{header|EchoLisp}}==

(lib 'tasks) ;; for make-generator

 

; inspect

task → #generator:state: 1331

 

=={{header|Elixir}}==

{{trans|Erlang}}

def filter( source_pid, remove_pid ) do

first_remove = next( remove_pid )

end

 

 

{{out}}

[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]

</pre>

 

=={{header|Erlang}}==

-module( generator ).

 

receive {next, Pid} -> Pid ! erlang:round(math:pow(N, M) ) end,

power_loop( M, N + 1 ).

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

let squares = m 2

 

Seq.take 10 (Seq.skip 20 (``squares without cubes``))

{{out}}

<pre>[529; 576; 625; 676; 784; 841; 900; 961; 1024; 1089]</pre>

 

=={{header|Fantom}}==

Using closures to implement generators.

 

class Main

{

}

}

 

{{out}}

 

=={{header|Forth}}==

\ genexp-rcode.fs Generator/Exponential for RosettaCode.org

 

:noname 0 Counter ! 1 Sqroot ! 1 Cbroot ! 0 (go) drop ;

execute cr bye

{{out}}

<pre>

$

</pre>

 

=={{header|FunL}}==

{{trans|Haskell}} (for the powers function)

{{trans|Scala}} (for the filter)

 

def

filtered( _:st, c ) = filtered( st, c )

 

{{out}}

<pre>

=={{header|Go}}==

Most direct and most efficient on a single core is implementing generators with closures.

 

import (

}

fmt.Println()

{{out}}

<pre>

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 (

}

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 m = map (^ m) [0..]

squares = powers 2

cubes = powers 3

 

main :: IO ()

<pre>[529,576,625,676,784,841,900,961,1024,1089]</pre>

 

Co-expressions let us circumvent the normal backtracking mechanism and get results where we need them.

 

 

write("Non-cube Squares (21st to 30th):")

}

}

 

Note: The task could be written without co-expressions but would be likely be ugly.

Here is a generator for mth powers of a number:

 

N=: 0

create=: 3 :0

N=: N+1

n^M

 

And, here are corresponding square and cube generators

 

 

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:

 

 

That said, here is a more natural approach, for J.

 

squares=: 2 mthPower

cubes=: 3 mthPower

 

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:

 

 

=={{header|Java}}==

{{works with|java|8}}

import static java.util.stream.LongStream.generate;

 

return n * n * n++;

}

 

<pre>529 576 625 676 784 841 900 961 1024 1089</pre>

 

=={{header|JavaScript}}==

{{works with|Firefox 3.6 using JavaScript 1.7|}}

 

function PowersGenerator(m) {

var n=0;

for( var x = 20; x < 30; x++ ) console.logfiltered.next());

 

 

let e = 0;

while (1) { e++ && (yield Math.pow(e, n)); }

}

 

for (let n = 0; n < 10; n++) {

console.log(filtered.next().value)

<pre>529

576

1024

1089</pre>

 

=={{header|jq}}==

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]

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;

# emit m states including the initial state

def emit(m; next):

'''Examples''':

[0,0] | emit(4; next_power(2)) | .[1]

 

# Generate all the values in the sequence i^3 less than 100:

'''An aside on streams'''

 

 

'''Part 2: selection from 2 ^ m'''

def last(f): reduce f as $i (null; $i);

 

| skip(20; filtered_next_power(2;3))

| emit(10; filtered_next_power(2;3))

{{out}}

529

576

961

1024

 

=={{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)

 

end

 

 

{{out}}

=={{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

 

ncs.drop(20).take(10).forEach { print("$it ") } // print 21st to 30th items

println()

 

{{out}}

Non-cubic squares (21st to 30th) : 529 576 625 676 784 841 900 961 1024 1089

</pre>

 

=={{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)

if i>10 then exit repeat

put res[1]

 

{{out}}

Parent script "generator.power"

 

property _index

 

on reset (me)

me._index = 0

 

Parent script "generator.filter"

 

property _genf

 

me._genv.reset()

me._genf.reset()

 

=={{header|Lua}}==

Generators can be implemented both as closures and as coroutines. The following example demonstrates both.

 

--could be done with a coroutine, but a simple closure works just as well.

local function powgen(m)

end

end

 

=={{header|Nim}}==

var (base, exp) = (base, exp)

result = 1

while exp != 0:

if (exp and 1) != 0:

base *= base

 

for n in s(): return n

 

yield n ^ m

 

var v = next(s1)

var f = next(s2)

i = 1

for x in filtered(squares, cubes):

{{out}}

<pre>529

1024

1089</pre>

 

=={{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];

 

 

''genpow(power)'' returns a function that returns a simple power generator.<br>

These generators are anonymous subroutines, which are closures.

 

# generate and return the powers 0**m, 1**m, 2**m, ...

sub gen_pow {

my @answer;

push @answer, $squares_without_cubes->() for (1..10);

 

{{out}}<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

{{trans|Python}}

{{works with|PHP|5.5+}}

function powers($m) {

for ($n = 0; ; $n++) {

$f->next();

}

 

{{out}}

=={{header|PicoLisp}}==

Coroutines are available only in the 64-bit version.

(co (intern (pack 'powers M))

(for (I 0 (inc 'I))

 

(do 20 (filtered 2 3))

{{out}}

<pre>529

 

=={{header|PL/I}}==

Generate: procedure options (main); /* 27 October 2013 */

declare j fixed binary;

 

end Generate;

<pre>

20 dropped values:

 

{{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):

squares, cubes = powers(2), powers(3)

f = filtered(squares, cubes)

 

{{out}}

<pre>[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]</pre>

 

=={{header|R}}==

 

{n = -1

function()

noncubic.squares()

for (i in 1:10)

 

=={{header|Racket}}==

 

#lang racket

 

[i 30] #:when (>= i 20))

x)

 

{{out}}

'(529 576 625 676 784 841 900 961 1024 1089)

</pre>

 

=={{header|REXX}}==

<br>The generators &nbsp; (below, the &nbsp; <big> Gxxxxx </big> &nbsp; functions) &nbsp; 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.*/

#=#+1; @.pureSquare.#=? /*assign next pureSquare. */

end /*j*/

'''output''' &nbsp; when using the default value:

<pre>

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)

 

p squares_without_cubes.take(30).drop(20)

{{out}}

<pre>

Here is the correct solution, which obeys the ''requirement'' of ''three'' generators.

 

 

def powers(m)

answer = squares_without_cubes # third generator

20.times { answer.next }

{{out}}

<pre>

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

f = filtered(squares, cubes)

p f.take(30).last(10)

Output is the same as the above.

 

=={{header|Scala}}==

def main(args: Array[String]): Unit = {

def squares(n:Int=0):Stream[Int]=(n*n) #:: squares(n+1)

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}}==

(let ((i 0))

(lambda ()

(newline))

(seq))

{{out}}

<pre>576

1024

1089</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

var e = 0;

func { e++ ** m };

var answer = [];

10.times { answer.append(squares_without_cubes()) };

{{out}}

<pre>

[529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]

</pre>

 

=={{header|Swift}}==

let power = Double(m)

var cur: Double = 0

//961

//1024

 

=={{header|Tcl}}==

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 {

for {} {$i<30} {incr i} {

puts [filtered]

{{out}}

<pre>

1024

1089

</pre>

 

=={{header|XPL0}}==

 

func Gen(M); \Generate Mth powers of positive integers

[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

 

{{out}}

{{trans|Python}}

Generators are implemented with fibers (aka VMs) and return [lazy] iterators.

var squared=Utils.Generator(powers,2), cubed=Utils.Generator(powers,3);

 

var f=Utils.Generator(filtered,squared,cubed);

f.drop(20);

{{out}}

<pre>L(529,576,625,676,784,841,900,961,1024,1089)</pre>

it just has been rewritten in a more functional style.

{{trans|Clojure}}

var squared=powers(2), cubed=powers(3);

 

}

var f=[0..].tweak(filtered.fp(squared,cubed))