Which language understands 'variable a = 0 , 20, ..., 300'?

Question

Which language is smart so that it could understand variable a = 0 , 20, ..., 300 ? so you could easily create arrays with it giving step start var last var (or, better no last variable (a la infinite array)) and not only for numbers (but even complex numbers and custom structures like Sedenion's which you would probably define on your own as a class or whatever...)

Point is, find a language or algorithm usable in a language that can cach the law of how array of variables you've given (or params of that variables) change. And compose using that law a structure from which you would be able to get any variable(s).

To everyone - examples you provide are very helpful for all beginners out there. And at the same time are the basic knowledge required to build such 'Smart Array' class. So thank you wary much for your enthusiastic help.

As JeffSahol noticed

all possible rules might include some that require evaluation of some/all existing members to generate the nth member.

So it is a hard Question. And I think language that would do it 'Naturally' would be great to play\work with, hopefully not only for mathematicians.

Answer 1

Haskell:

Prelude> let a=[0,20..300]
Prelude> a
[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300]

btw: infinite lists are possible, too:

Prelude> let a=[0,20..]
Prelude> take 20 a
[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380]

Answer 2

Excel:

• Write 0 in A1
• Write 20 in A2
• Select A1:2
• Drag the corner downwards

Answer 3

MatLab:

a = [0:20:300]

Answer 4

F#:

> let a = [|0..20..300|];;

val a : int [] =
  [|0; 20; 40; 60; 80; 100; 120; 140; 160; 180; 200; 220; 240; 260; 280; 300|]

With complex numbers:

let c1   = Complex.Create( 0.0, 0.0)
let c2   = Complex.Create(10.0, 10.0)
let a    = [|c1..c2|]

val a : Complex [] =
 [|0r+0i; 1r+0i; 2r+0i; 3r+0i; 4r+0i; 5r+0i; 6r+0i; 7r+0i; 8r+0i; 9r+0i; 10r+0i|]

As you can see it increments only the real part.

If the step is a complex number too, it will increment the real part AND the imaginary part, till the last var real part has been reached:

let step = Complex.Create(2.0, 1.0)
let a    = [|c1..step..c2|]

val a: Complex [] =
  [|0r+0i; 2r+1i; 4r+2i; 6r+3i; 8r+4i; 10r+5i|]

Note that if this behavior doesn't match your needs you still can overload (..) and (.. ..) operators. E.g. you want that it increments the imaginary part instead of the real part:

let (..) (c1:Complex) (c2:Complex) =
  seq {
    for i in 0..int(c2.i-c1.i) do
      yield Complex.Create(c1.r, c1.i + float i)
  }

let a    = [|c1..c2|]
val a : Complex [] =
 [|0r+0i; 0r+1i; 0r+2i; 0r+3i; 0r+4i; 0r+5i; 0r+6i; 0r+7i; 0r+8i; 0r+9i; 0r+10i|]

Answer 5

Wait...

Python:

print range(0, 320, 20)

gives

[0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300]

Props to the comments (I knew there was a more succinct way :P)

Answer 6

And PHP:

$a = range(1,300,20);

Answer 7

Scala:

scala> val a = 0 to 100 by 20
a: scala.collection.immutable.Range = Range(0, 20, 40, 60, 80, 100)

scala> a foreach println
0
20
40
60
80
100

---

Infinite Lists:

scala> val b = Stream from 1     
b: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> b take 5 foreach println
1
2
3
4
5

Answer 8

In python you have

a = xrange(start, stop, step)

(or simply range in python 3) This gives you an iterator from start to stop. It can be infinite since it is built lazily.

>>> a = xrange(0, 300, 20)
>>> for item in a: print item
...
0
20
40
60
80
100
120
140
160
180
200
220
240
260
280

Answer 9

And C++ too [use FC++ library]:

// List is different from STL list
List<int> integers = enumFrom(1); // Lazy list of all numbers starting from 1

// filter and ptr_to_fun definitions provided by FC++
// The idea is to _filter_ prime numbers in this case
// prime is user provided routine that checks if a number is prime
// So the end result is a list of infinite primes :)
List<int> filtered_nums = filter( ptr_to_fun(&prime), integers );  

FC++ lazy list implementation: http://www.cc.gatech.edu/~yannis/fc++/New/new_list_implementation.html

More details: http://www.cc.gatech.edu/~yannis/fc++/

Arpan

Answer 10

Groovy,

assert [ 1, *3..5, 7, *9..<12 ] == [1,3,4,5,7,9,10,11]

Answer 11

The SWYM language, which appears to no longer be online, could infer arithmetic and geometric progressions from a few example items and generate an appropriate list.

Answer 12

I believe the syntax in perl6 is start ... *+increment_value, end

Answer 13

C# for example does implement Enumerable.Range(int start, int count), PHP offers the function range(mixed low, mixed high, number step), ... There are programming languages that are "smart" enough.

Beside that, an infinite array is pretty much useless - it's not infinite at all but all-memory-consuming.

You cannot do this enumerating simply with complex numbers as there is no direct successor or predecessor for a given number. Edit: This does not mean that you cannot compare complex numbers or create an array with a specified step!

Answer 14

You should instead use math.

- (int) infiniteList: (int)x 
{
    return (x*20);
}

The "smart" arrays use this format since I seriously doubt Haskel could let you do this:

a[1] = 15

after defining a.

Answer 15

I may be misunderstanding the question, but the answers that specify way to code the specific example you gave (counting by 20's) don't really meet the requirement that the array "cache" an arbitrary rule for generating array members...it seems that almost any complete solution would require a custom collection class that allows generation of the members with a delegated function/method, especially since all possible rules might include some that require evaluation of some/all existing members to generate the nth member.

Answer 16

Just about any program language can give you this sequence. The question is what syntax you want to use to express it. For example, in C# you can write:

Enumerable.Range(0, 300).Where(x => (x % 20) == 0)

or

for (int i = 0; i < 300; i += 20) yield return i;

or encapsulated in a class:

new ArithmaticSequence(0, 301, 20);

or in a method in a static class:

Enumerable2.ArithmaticSequence(0, 301, 20);

So, what is your criteria?

Answer 17

Assembly: Assuming edi contains the address of the desired array:

xor eax, eax
loop_location:
    mov [edi], eax
    add edi, #4
    add eax, #20
    cmp eax, #300
    jl loop_location

Answer 18

MATLAB it is not a Programming language itself but its a tool but still u can use it like a programming language.

It is built for such Mathematics operations to easily arrays are a breeze there :)

a = 0:1:20;

creates an array from 0 to 20 with an increment of 1. instead of the number 1 you can also provide any value/operation for the increment

Answer 19

Php always does things much simpler, and sometimes dangerously simple too :)

Answer 20

Well… Java is the only language I've ever seriously used that couldn't do that (although I believe using a Vector instead of an Array allowed that).