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>

{{Trans|JavaScript}}

{{Trans|Python}}

 

-- powers :: Gen [Int]

end |λ|

end script

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

 

=={{header|C sharp}}==

using System.Collections.Generic;

using System.Linq;

while (true) yield return i++;

}

 

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

A templated solution.

 

using namespace std;

 

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

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

 

{{out}}

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

This code requires generator library which was introduced in Emacs 25.2

 

(require 'generator)

 

(iter-defun exp-gen (pow)

(setq o (iter-next g))

(when (>= i 20)

 

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

Using lazy lists for our generators:

prettyprint ;

IN: rosetta-code.generator-exponential

[ 3 mth-powers-generator lmember? not ] <lazy-filter> ;

 

{{out}}

<pre>

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 :: Int -> [Int]

main :: IO ()

{{Out}}

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

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

 

 

====ES6====

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

Compositional derivation of custom generators:

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

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

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

=={{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|M2000 Interpreter}}==

Module Generator {

}

For i=1 to 20 : dropit=Filter() :Next i

Document doc$="Non-cubic squares (21st to 30th)"

Print doc$

doc$={

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

 

{{out}}

I: 30, F: 1089

</pre >

 

=={{header|Nim}}==

 

proc `^`*(base: Natural; exp: Natural): int =

if i > 20: echo x

if i >= 30: break

 

{{out}}

=={{header|OCaml}}==

Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil]

(* Task : Generator/Exponential

 

let _ =

squares_no_cubes |> drop 20 |> take 10

{{out}}

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

 

{{Works with|Python|3.7}}

 

from itertools import count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

=={{header|Quackery}}==

 

this -2 peek **

1 this tally

20 times [ dup do drop ]

10 times [ dup do echo sp ]

 

{{out}}

=={{header|R}}==

 

{n = -1

function()

noncubic.squares()

for (i in 1:10)

 

=={{header|Racket}}==

 

#lang racket

 

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

x)

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

As with Haskell, generators are disguised as lazy lists in Raku.

 

my @squares = powers(2);

my @cubes = powers(3);

 

gather for @veto -> $veto {

take @orig.shift while @orig[0] before $veto;

}

 

 

{{out}}

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

use std::iter::Peekable;

 

.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)

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

The ExponentialGenerator script is a generator object for exponential values.

 

to initialize

add 1 to my base

return my base to the power of my exponent

 

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

return value

end nextValue

 

This script shows the use of both of the generators.

 

set squares to new ExponentialGenerator with {exponent:2}

put n & ":" && filteredSquares.nextValue

end repeat

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

var e = 0;

func { e++ ** m };

var answer = [];

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

{{out}}

<pre>

=={{header|SuperCollider}}==

 

f = { |m| {:x, x<-(0..) } ** m };

g = f.(2);

g.nextN(10); // answers [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]

 

patterns are stream generators:

 

f = Pseries(0, 1)

g = f ** 2;

g.asStream.nextN(10); // answers [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]

)

 

supercollider has no "without" stream function, this builds one:

 

var filter = { |a, b, func| // both streams are assumed to be ordered

Prout {

 

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

 

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

 

=={{header|VBA}}==

Public nextsquare As Long

Public lastcube As Long

End If

Next i

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

 

'''Compiler:''' >= Visual Studio 2012

 

Iterator Function IntegerPowers(exp As Integer) As IEnumerable(Of Integer)

Dim i As Integer = 0

Next

End Sub

 

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

 

{{out}}

1024

1089</pre>

 

=={{header|Wren}}==

Closure based solution. Similar approach to Go (first example).

var i = 0

return Fn.new {

if (i > 19) System.write("%(p) ")

}

 

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