Data update

Task/Multi-dimensional-array/M2000-Interpreter/multi-dimensional-array.m2000

@@ -0,0 +1,100 @@
+// supports multi-dimensional arrays
+// support row-major and column major order - we can use both on different arrays.
+// this is variant type
+Dim A(0 to 4, 0 to 3, 1 to 2, -1 to 1) = 1
+A(0,0,1,-1)++
+Print A(0,0,1,-1)=2
+// Arrays are values also
+// here we pass a tuple (one dimension array 9 based)
+A(4,3,2,1)=(1,2,3,4,5)
+Print  A(4,3,2,1)(2)=3
+Dim Z(10)
+Z(3)=A()
+Print Z(3)(4,3,2,1)(2)=3
+
+// We can define type: BigInteger, Complex, Decimal, Currency, Double, Single, Long Long, Long, Byte, Date, Boolean, Object
+Dim B(0 to 4, 0 to 3, 1 to 2, -1 to 1) as byte = 255
+B(0,0,1,-1)--
+Print B(0,0,1,-1)=254
+// redim - by default is row-major
+Dim B(0 to 5, 0 to 3, 1 to 2, -1 to 1)
+Print B(0,0,1,-1)=254
+// OLE type are column major
+Dim OLE B(0 to 4, 0 to 3, 1 to 2, -1 to 1) as byte = 255
+B(0,0,1,-1)--
+// redim the last dimension only
+Dim B(0 to 4, 0 to 3, 1 to 2, -1 to 5)
+Print B(0,0,1,-1)=254
+B(4,3,2,5)=253
+Print Dimension(B())=4, Dimension(B(),4,1)=5
+Print B()#pos(253)=279 ' Zero position (trait like one dimension)
+// we can  redim free, but the items change positions..
+k=len(B())
+' one dimension
+DIM B(K)
+Print B(279)=253, type$(B(279))="Byte"
+// we can get the actual address
+Print Varptr(B(279))-Varptr(B(278))=1
+// another type of arrays
+// there is no dim, we set index and we get resize
+Byte z[10]=255
+d=lambda->{
+	object d[number]
+	= d
+}
+object P[2]=d(0)
+p[2]=d(10)
+p[1]=d(3)
+P[2][1]=z  // we get the pointer
+P[2][2]=z[]  // we get the copy
+P[1][1]=z  // we get the pointer
+P[1][2]=z[]  // we get the copy
+p[2][2][2]-=10
+? p[2][2][2]=245
+? p[1][2][2]=255
+DEF TypeVal(x)=type$(x)
+// these are the Seven arrays (two of them are z):
+Print len(p[0])=1, type$(p, 0)="RefArray"
+Print len(p[1])=4, type$(p, 1)="RefArray"
+Print len(p[2])=11, type$(p, 2)="RefArray"
+Print TypeVal(p[1][1])="RefArray"
+Print p[1][1] is z
+Print TypeVal(p[1][2])="RefArray"
+Print len(p[1][2])=11, TypeVal(p[1][2][0])="Byte"
+Print TypeVal(p[2][1])="RefArray"
+Print p[2][1] is z
+Print p[1][1] is p[2][1]
+Print TypeVal(p[2][2])="RefArray"
+Print not p[1][1] is p[2][2]
+z[6]-=100
+Print p[1][1][6]=z[6],  p[2][1][6]=z[6]
+Print len(p[2][2])=11, TypeVal(p[2][2][0])="Byte"
+byte k[0]
+// shallow copy
+k=p[]
+Print k[2][1] is z
+// copy
+k[2][1]=k[2][]
+// so now array at k[2][1] is a copy, different pointer from z
+Print not k[2][1] is z
+
+// Sparse Matrix using a list (has a hash table)
+g=list:= 1:=100, 10:=300, 500:=40
+if exist(g, 10) then print eval(g)=300
+Print g(1)=100, g(10)=300, g(500)=40
+Print valid(g(20)) = false
+Print valid(g(10)) = true
+Append g, 400:=1000
+// this is a quicksort
+Sort ascending g as number
+// Sparse Matrix using a Queue (a list taking same keys)
+t=queue:=2,3,4,4,5,10:="A",10:="C",10:="B", 3
+// this is a stable sort
+sort t as number
+// Access same keys using the hash table
+if exist(t, 10) then
+many=exist(t, 10, 0)
+for i=1 to many
+	if exist(t, 10, i) then print eval$(t), eval(t!)  ' value and position
+next
+end if