Loops/With multiple ranges: Difference between revisions

Some languages allow multiple '''loop''' ranges, such as the '''PL/I''' example (snippet) below.

 

prod= 1; /*start with a product of unity. */

sum= 0; /* " " " sum " zero. */

/*SUM and PROD are used for verification of J incrementation.*/

display (' sum= ' || sum); /*display strings to term.*/

 

 

 

Show all output here.

 

DO variable = start_expression {TO ending_expression] {BY increment_expression} ;

 

In the example above, the clause: -seven to +seven by x

 

 

{{trans|Nim}}

 

V s = 0

 

V m = max(ss.len, ps.len)

print(‘ sum = ’ss.rjust(m))

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopnrange64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

Ada does not support multiple ranges in a single loop.

{{trans|C++}}

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Containers.Vectors;

 

end Main;

{{out}}

<pre>

=={{header|ALGOL 60}}==

{{works with|MARST}}

integer prod, sum, x, y, z, one, three, seven;

integer j;

outstring(1, "prod= "); outinteger(1, prod); outstring(1, "\n")

end

{{out}}

<pre> sum= 348173

{{Trans|ALGOL W}}

As with most of the other languages, Algol 68 doesn't support multiple loop ranges, so a sequence pf loops is used instead.

# translation of task PL/1 code, with minimal changes, semicolons required by #

# PL/1 but not allowed in Algol 68 removed, unecessary rounding removed #

print(("prod= ", whole(prod,0), newline)) # " " " " #

END

{{out}}

<pre>

=={{header|ALGOL W}}==

As with most of the other languages, Algol W doesn't support multiple loop ranges, so a sequence pf loops is used instead.

% translation of task PL/1 code, with minimal changes, semicolons required by %

% PL/1 but redundant in Algol W retained ( technically they introduce empty %

write(s_w := 0, " sum= ", sum); %display strings to term.%

write(s_w := 0, "prod= ", prod); % " " " " %

{{out}}

<pre>

prod= -793618560

</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program loopnrange.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

-793618560

</pre>

 

=={{header|AutoHotkey}}==

As with most of the other languages, AutoHotkey doesn't support multiple loop ranges, so a workaround function is used instead.

j := start

while (j<=stop) && (start<=stop) && (step>0)

while (j>=stop) && (start>stop) && (step<0)

%doFunction%(j), j+=step

sum := 0

x := +5

prod *= j

}

{{out}}

<pre>sum = 348,173

prod = -793,618,560</pre>

=={{header|AWK}}==

# syntax: GAWK -f LOOPS_WITH_MULTIPLE_RANGES.AWK

BEGIN {

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

global sum, prod

 

print "prod= "; int(prod)

end

 

 

=={{header|C}}==

#include <stdlib.h>

#include <locale.h>

printf("prod = % 'ld\n", prod);

return 0;

 

{{out}}

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

Multiple ranges don't exist in C# out-of-the-box but it is easy to make something.

using System.Collections.Generic;

using System.Linq;

static IEnumerable<int> Concat(params IEnumerable<int>[] ranges) => ranges.Aggregate((acc, r) => acc.Concat(r));

static int Pow(this int b, int e) => (int)Math.Pow(b, e);

{{out}}

<pre>

C++ doesn't natively support multiple ranges, but we can simulate that using a list and then iterating over the values in that list.

 

#include <cmath>

#include <vector>

cout << "sum = " << sum << "\n";

cout << "prod = " << prod << "\n";

{{out}}

<pre>sum = 348173

prod = -793618560</pre>

 

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

Using raw code and DO iterator

(let ((prod 1) ; Initialize aggregator

(sum 0)

(format t "~&sum = ~14<~:d~>" sum)

(format t "~&prod = ~14<~:d~>" prod))

or with loop ranges and increments as list to dolist

(let ((prod 1)

(sum 0)

(format t "~&sum = ~14<~:d~>" sum)

(format t "~&prod = ~14<~:d~>" prod))

 

{{out}}

{{Trans|C}}

Delphi don't have for with multiples ranges and for with different increments (except +1 and -1). The workaround is using while loop.

program with_multiple_ranges;

 

writeln(format('prod = %d ', [prod]));

Readln;

{{out}}

<pre>sum = 348173

prod = -793618560</pre>

 

=={{header|Eiffel}}==

Eiffel does not support multiple ranges in the same fashion as PL/I. However, it does have an across loop, which does the trick, together with an inline agent (lambda function).

class

APPLICATION

 

end

 

Alternatively, there is the "symbolic form" of the across loop, which modifies the code as follows:

 

class

APPLICATION

 

end

{{out}}

<pre>

</pre>

 

=={{header|Factor}}==

Factor doesn't have any special support for this sort of thing, but we can store iterable <code>range</code> objects in a collection and loop over them.

sequences sequences.generalizations tools.memory.private ;

 

! SUM and PROD are used for verification of J incrementation.

sum prod [ commas ] bi@ " sum= %s\nprod= %s\n" printf

{{out}}

<pre>

prod= -793,618,560

</pre>

 

=={{header|FreeBASIC}}==

{{trans|VBA}}

Dim Shared As Long prod, sum

 

Print Using "prod= ####,###,###"; prod

Sleep

 

 

=={{header|Go}}==

Nothing fancy from Go here (is there ever?), just a series of individual for loops.

 

import "fmt"

fmt.Println("sum = ", commatize(sum))

fmt.Println("prod = ", commatize(prod))

 

{{out}}

=={{header|Groovy}}==

Solution:

 

for (

 

println " sum= ${sum}"

 

Output:

Haskell does not have loops. Programmers use either explicit recursion or recursive schemes (folds or unfolds) for looping. The following code mimics the PL/1 example using composition of left folds in order to handle multiple ranges:

 

loop = foldl . foldl

 

, [1927 .. 1939]

, [x, x + z .. y]

 

=={{header|J}}==

 

 

 

end.

 

 

=={{header|Java}}==

Maintain formatting similar to the original code.

 

import java.util.ArrayList;

import java.util.List;

}

{{out}}

<pre>

to facilitate comparison with the PL/I code, this has not been done.

 

# If using gojq, one may want to preserve integer precision, so:

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

| "sum= \(.sum)",

"prod= \(.prod)"

{{out}}

<pre>

=={{header|Julia}}==

Julia allows concatenation of iterators with the ; iterator within a vector. An attempt was made to preserve the shape of the PL/1 code.

 

function PL1example()

 

PL1example()

sum = 348,173

prod = -793,618,560

 

=={{header|Kotlin}}==

 

import kotlin.math.abs

System.out.printf("sum = % ,d\n", sum)

System.out.printf("prod = % ,d\n", prod)

 

{{output}}

prod = -793,618,560

</pre>

 

=={{header|M2000 Interpreter}}==

In M2000 expressions can change numeric type to hold the produced value. Variables take once the type, so we get overflow if we pass a value frome an expression which can't convert to variable's type.

 

def long prod=1, sum=0, x=+5,y=-5, z=-2, one=1, three=3, seven=7, j

Range=lambda (a, b, c=1) ->{

}

MultipleLoop

{{output}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

sum = 0;

x = 5;

]

sum

{{out}}

<pre>348173

This solution is the obvious one, but it supposes that the direction of the loop is known (i.e. the sign of the step is known) as we have to choose between iterators “countup” and “countdown”. Using this method, the PL/1 example can be translated the following way:

 

import math, strutils

 

let m = max(s.len, p.len)

echo " sum = ", s.align(m)

 

Note that for “countdown” we must change the sign of the step to insure that it is positive.

If the sign of the step is not known (or may vary), it is no longer possible to use the previous method. One could use a while loop but it seems better to use an iterator.

 

 

var

let m = max(s.len, p.len)

echo " sum = ", s.align(m)

 

Note that we have defined a function “initRange” to create the ranges. This is needed to make the step optional. If we suppressed this requirement (i.e. we required the step to be always specified), we could get ride of “initRange” and write the loop this way:

 

(-seven, seven, x),

(555, 550 - y),

(11^x, 11^x + one)):

sum += abs(j)

 

=={{header|Perl}}==

use constant three => 3;

use constant seven => 7;

 

printf "%-8s %12s\n", 'Sum:', commatize $sum;

{{out}}

<pre>Sum: 348,173

 

=={{header|Phix}}==

<span style="color: #004080;">integer</span> <span style="color: #000000;">prod</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">total</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- (renamed as sum is a Phix builtin)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" sum = %,d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">total</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"prod = %,d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prod</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

prod = -793,618,560

</pre>

 

=={{header|Picat}}==

Picat has support for multiple loop variables, but the index variables for each range must be different:

% ...

 

Here's a variant using the single loop variable <code>J</code>.

Prod= 1,

Sum= 0,

println(sum=Sum),

println(prod=Prod),

 

{{out}}

 

Another approach is to first concatenate the ranges and then flatten to a single list:

foreach(J in [-Three..Three..3**3,

-Seven..X.. +Seven,

end,

% ...

 

=={{header|Prolog}}==

Prolog does not have the richness of some other languages where it comes to loops, variables and the like, but does have some rather interesting features such as difference lists and backtracking for generating solutions.

for(Lo,Hi,Step,Val) :- Step>0, plus(Lo,Step,V), V=<Hi, !, for(V,Hi,Step,Val).

for(Hi,Lo,Step,Hi) :- Step<0, Lo=<Hi.

calc_values(Sum, Product) :- % Find the sum and product

findall(V, range_value(V), Values),

 

<pre>?- calc_values(Sum, Product).

 

=={{header|PureBasic}}==

#ONE = 1 : #THREE = 3 : #SEVEN = 7

Define j.i

PrintN("prod = " + ifn(prod))

Input()

{{out}}

<pre>sum = 348,173

=={{header|Python}}==

Pythons range function does not include the second argument hence the definition of _range()

 

prod, sum_, x, y, z, one,three,seven = 1, 0, 5, -5, -2, 1, 3, 7

if abs(prod) < 2**27 and (j != 0):

prod *= j

 

{{out}}

 

=={{header|QB64}}==

'Task

'Simulate/translate the above PL/I program snippet as best as possible

 

Loop

 

=={{header|Raku}}==

Displaying the j sequence as well since it isn't very large.

 

 

my \x = 5;

put "\nLiteral minded variant:";

put ' Sum: ', comma [+] $j».abs;

{{Out}}

<pre>j sequence: -3 0 3 6 9 12 15 18 21 24 27 -7 -2 3 555 22 19 16 13 10 7 4 1 -2 -5 -8 -11 -14 -17 -20 -23 -26 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 5 3 1 -1 -3 -5 161051 161052

=={{header|Red}}==

As "to" has another meaning in Red, we name "->" the range operator.

 

->: make op! function [start end][

if all [(absolute prod) < power 2 27 j <> 0] [prod: prod * j]

]

{{Out}}

<pre>sum: 348173

various &nbsp; '''do''' &nbsp; iterating clauses (ranges) into

separate &nbsp; '''do''' &nbsp; loops, &nbsp; and have them invoke a subroutine to perform the actual computations.

prod= 1;

sum= 0;

meat: sum= sum + abs(j);

if abs(prod)<2**27 & j\==0 then prod= prod * j;

{{out|output|text= &nbsp; when using the same variable values:}}

<pre>

=={{header|Ring}}==

{{trans|Phix}}

prod = 1

total = 0

see "total = " + total + nl

see "product = " + prod + nl

{{out}}

<pre>

total = 348173

product = -793618560

</pre>

 

=={{header|Ruby}}==

Uses chaining of enumerables, which was introduced with Ruby 2.6

 

enums = (-three).step(3**3, three) +

prod = enums.inject(1){|prod, j| ((prod.abs < 2**27) && j!=0) ? prod*j : prod}

puts "Product (but not really): #{prod}"

{{out}}

<pre>Sum of absolute numbers: 348173

=={{header|Smalltalk}}==

Ranges (called ''Interval'' in Smalltalk) are collections, which - like all collections - can be concatenated with the <tt>,</tt> (comma) message. Intervals are created by sending a <tt>to:</tt> or <tt>to:by:</tt> message to a magnitude-like thingy (i.e. other than numbers are possible):

sum := 0.

x := 5.

].

Transcript show:' sum = '; showCR:sum.

The above creates a temporary "collection of ranges" and enumerates that, which might be inconvenient, if the collections are huge.

<br>One alternative is to loop over each individually.

and we usually don't want to the code to be non-local (i.e. define another method for it).

<br>That's what blocks (aka lambdas or anonymous functions) are perfect for:

sum := 0.

x := 5.

(11**x to: 11**x + one ) do:action.

Transcript show:' sum = '; showCR:sum.

 

As another alternative to the first solution above, we can loop over the ranges. This avoids the concatenations and generation of the intermediate big collection (which does not really make a difference here, but would, if each collection consisted of millions of objects):

{

(three negated to: 3**3 by: three ) .

]

].

Notice: this creates only 8 objects and also demonstrates an alternative element selection scheme, which may be more readable.

{{out}}

 

Note) Dialects with no <tt>**</tt>-method should use <tt>raisedTo:</tt>, or else define an alias for it in Number as:

 

 

=={{header|True BASIC}}==

{{trans|FreeBASIC}}

SUB process(x)

LET sum = sum + abs(x)

PRINT "prod= "; prod

END

 

 

=={{header|Vala}}==

long prod = 1;

long sum = 0;

stdout.printf("sum = %10ld\n", sum);

stdout.printf("prod = %10ld\n", prod);

{{out}}

<pre>

 

=={{header|VBA}}==

Public Sub LoopsWithMultipleRanges()

Dim x As Integer, y As Integer, z As Integer, one As Integer, three As Integer, seven As Integer, j As Long

sum = sum + Abs(x)

If Abs(prod) < pow(2, 27) And x <> 0 Then prod = prod * x

{{out}}

<pre> sum= 348.173

 

Using the following to provide the functionality of the For loop as a function,

' Stop and Step are language keywords and must be escaped with brackets.

Iterator Function Range(start As Integer, [stop] As Integer, Optional [step] As Integer = 1) As IEnumerable(Of Integer)

Next

End Function

 

and Enumerable.Concat (along with extension method syntax) to splice the ranges, the program ends up looking like this:

 

 

Partial Module Program

Console.WriteLine(String.Format(format, "prod= {0:N}", prod))

End Sub

 

To improve the program's appearance, a ConcatRange method can be defined to combine the two method calls,

Function ConcatRange(source As IEnumerable(Of Integer), start As Integer, [stop] As Integer, Optional [step] As Integer = 1) As IEnumerable(Of Integer)

Return source.Concat(Range(start, [stop], [step]))

 

which results in a loop that looks like this:

ConcatRange(-seven, +seven, x ).

ConcatRange(555, 550 - y ).

ConcatRange(x, y, z ).

ConcatRange(CInt(11 ^ x), CInt(11 ^ x) + one )

 

An alternative to avoid the repeated method calls would be to make a Range function that accepts multiple ranges, in this case as a parameter array of tuples.

' Note: SelectMany is equivalent to bind, flatMap, etc.

Return ranges.SelectMany(Function(r) Range(r.start, r.stop, r.step))

 

resulting in:

(-seven, +seven, x ),

(555, 550 - y, 1 ),

(x, y, z ),

(CInt(11 ^ x), CInt(11 ^ x) + one, 1 ))

 

Note, however, that the inability to have a heterogenous array means that specifying the step is now mandatory. Using a parameter array of arrays is slightly less clear but results in the tersest loop.

Return ranges.SelectMany(Function(r) Range(r(0), r(1), If(r.Length < 3, 1, r(2))))

 

{-seven, +seven, x },

{555, 550 - y },

{x, y, z },

{CInt(11 ^ x), CInt(11 ^ x) + one })

 

{{out|note=for all variations}}

=={{header|Wren}}==

{{trans|Go}}

 

var prod = 1

}

 

 

{{out}}

 

=={{header|XPL0}}==

int A, B;

return fix(Pow(float(A), float(B)));

Text(0, " Sum= "); IntOut(0, Sum); CrLf(0); \display strings to term.

Text(0, "Prod= "); IntOut(0, Prod); CrLf(0); \ " " " "

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

sub process(x)

sum = sum + abs(x)

print "prod= ", prod using "####,###,###"

end

 

 

=={{header|zkl}}==

x,y,z := 5, -5, -2;

one,three,seven := 1,3,7;

}

/* SUM and PROD are used for verification of J incrementation */

{{out}}

<pre>