101 lines
2.9 KiB
Plaintext
101 lines
2.9 KiB
Plaintext
// 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
|