Baffled By Arrays

What I'd like to do is store information for 4 things with 4 sets of values for each one. I've only got to doing 2, as Im baffled by the new ways of Dims.

If someone could help, that would be fantastic.
Thanks.

' arrays '

Graphics 640,480,16,0


Const MaxInfo=4

Global Data#[MaxInfo] 

Data#[1]=[ 3.00, 4.00, 5.00 , 6.00]
Data#[2]=[ 4.00, 5.00, 9.00 , 7.00]


While Not KeyHit(KEY_ESCAPE)
Cls
	DrawText 0,0,"PRESS ESCAPE TO QUIT"
Flip
Wend

Global myData:Float[][] = [[ 3.00, 4.00, 5.00 , 6.00],[ 4.00, 5.00, 9.00 , 7.00],[2.1,1.2,32.247,2.223],[3.4,54.1,43.9,34.0]]

For Local a:Float[] = EachIn myData

	For Local v:Float = EachIn a
		Print v
	Next
	
Next

Ok thanks perturbatio.

So I see there's no need for the number in the brackers, to signify the maximum values as previous with a dim.

Top one!

Still Baffling me.

I know how to store it from the example above. But how now do I use a certain portion of this data. Say for example, I want to use a colour based on an variable to indicate which one to use?

Graphics 640,480

Global ColourInfo[][] = [  [ 064, 125, 064],	[ 064, 150, 128], ..
				       [ 210, 120, 132],	[ 032, 064, 190] ]


While Not KeyHit(KEY_ESCAPE)
Cls
	
DrawText 0,0,"Colour Text"

if keyhit(KEY_C) then ColIndicator:+1
if ColIndicator>5 then ColIndicator=0 

Flip
Wend

It should be noted that the code I posted is an array of float arrays NOT a multi-dimensional array.

But you can address an individual value in a similar way to a normal array:

 
Graphics 640,480,0

Global ColourInfo[][] = [  [ 064, 125, 064],	[ 064, 150, 128], ..
				       [ 210, 120, 132],	[ 032, 064, 190] ]


While Not KeyHit(KEY_ESCAPE)
Cls
	
DrawText "Colour Text",0,0

If KeyHit(KEY_C) Then 
	ColIndicator:+1
	If ColIndicator>3 Then ColIndicator=0 
	SetColor(ColourInfo[ColIndicator][0], ColourInfo[ColIndicator][1], ColourInfo[ColIndicator][2])
EndIf


Flip
Wend

Bear in mind that Arrays are zero-based in Blitzmax

Thanks Mate!

I thought I almost had the hang of them for a split second. Just tried to make some stars. But still not getting it.

'
' Setup the graphics mode.
'
Const XRES=640
Const YRES=480

Graphics XRES,YRES


Const MaxStars=1000

Global Stars:Int[][]		'an array???
Global amount:Int			'normal variable


'
' Setup the stars - data for x and y
'
For amount=1 To MaxStars
	
	Stars[amount] = [Rand(XRES),Rand(YRES)] 

Next


'
' The main program looop.
'
While Not KeyHit(KEY_ESCAPE)
Cls


	'
	' Plot the 2D starfield.
	'
	For amount=1 To MaxStars
	
		Plot Stars[amount][0], Stars[amount][1]

	Next

Flip
Wend 

There are of course much better ways to do this but:

 '
' Setup the graphics mode.
'
Const XRES=640
Const YRES=480

Graphics XRES,YRES,0


Const MaxStars=1000


Global Stars:Int[][]	'an array of arrays

Stars = Stars[..MaxStars] 'resize the main array using a slice

'
' Setup the stars - data for x and y
'
For Local amount=0 To MaxStars-1
	Stars[amount] = Stars[amount][..2] 'resize each sub-array
	Stars[amount][0] = Rand(XRES)
	Stars[amount][1] = Rand(YRES)

Next


'
' The main program looop.
'
While Not KeyHit(KEY_ESCAPE)
Cls


	'
	' Plot the 2D starfield.
	'
	For amount=0 To MaxStars-1
	
		Plot Stars[amount][0], Stars[amount][1]

	Next

Flip
Wend 
  

Greatest!

Is the slice of 2 making all of the 'array of arrays' with just 2 Dimensions (for the info recording of x and y)?

Once again thank you kindly!
.:|THUMBZ|:.

Global Stars:Int[][]	'an array of arrays

Stars = Stars[..MaxStars] 'resize the main array using a slice

Ok, what makes the first line an array of arrays rather than a two dimensional array? Is the syntax different for a two dimensional array?
Then on the second line, shouldn't there be another bracket set after the [..MaxStars] since two sets were used in the declaration? Like this:

Global Stars:Int[][]	'an array of arrays

Stars = Stars[..MaxStars][] 'resize the main array using a slice

Perhaps I should really read up on the whole slice thing! Sounds a bit like ReDim in many BASICs, but with more flexibility.

Thanks in advance,
Russell

p.s. Seems like this would make a great tutorial subject (arrays)...

Russell

Yes. (well two elements rather than dimensions, it is still a 1D array) It loops through each of the elements of the main array and resizes the array that those elements contain.


The two seperate square braces [][] define it as an array of arrays.

To define a two dimensional array you would do:

Local myArray:Int[,]

The comma denotes a new dimension in the current array


No, because the slice re-dimensions the main array, not the arrays it contains.

It *might* help to think of the main array as a list of Types where each type is another array.

Just to complicate things, you could also do:

Local myArray:Int[][,] 

Which would create an array of 2D arrays

I recently added a page to the BlitzWiki which covers arrays to a certain degree (part of it is the original BMax array docs).

http://www.blitzwiki.org/index.php/Arrays



Slices are great! (missing one particular bit of functionality I would like, but hey you can't have everything at once).

It should be pointed out that you cannot use slices with Multi-Dimensional Arrays.

Ah! Ok, NOOOOOOW it makes sense. I guess ;) Seriously, though, it does. But, what advantage does an array of arrays have over a two dimensional array? They seem to work in a similar way. That is, in this:

Global Arr:Int[2,2]

We have two elements per index. That is, we have:

Arr[0,0] = 1  ; index one's first element
Arr[0,1] = 2  ; index one's second element
Arr[1,0] = 3  ; index two's first element
Arr[1,1] = 4  ; index two's second element

Seems to work the same as:

Arr[0][0] = 1
Arr[0][1] = 2
Arr[1][0] = 3
Arr[1][1] = 4

In this instance, are they the same? I guess the difference is that the 'secondary' array COULD be multidimensional if necessary. Am I close?

Thanks,
Russell

It depends on your data structure. The main difference is that a x*y 2D array will always have z positions, while an array of arrays allows you to only have the positions that you really need and thus potentially takes up less space.

There might also be a slight speed benefit, depending on how arrays are addressed in BlitzMAX. If 2D arrays have to be in contigous memory, there's a very real chance they won't fit comfortably in the cache.

Only Mark can say for sure.

For an array of arrays, each index of the main array can have a different amount of subindexes, which can lead to less memory-usage.

If you were to store the handles of 3D models for chess pieces and you would use a 2D array, then you have this setup:

In the first line (first row), all fields (or indexes) are used, because there are 8 pawns in a chess game.
But for all other pieces, most indexes aren't used (the empty fields), but they do exist in memory (the memory for them is allocated).

If you were to use an array of arrays, the first array holds the pointer to all subarrays, which in turn can be sized to any size.
So, at mainarray index 0 (first row), you could create a subarray with 8 indexes.

Type TChessPiece
	Field ModelHandle
End Type

Local ChessPieces:TChessPiece[][]

' There are 6 different kinds of pieces, so set the first array (mainarray) to have 6 indexes (0..5)
ChessPieces = ChessPieces[..6]

' There are 8 pawns, so create a subarray of size 8 at mainarray index 0
ChessPieces[0] = ChessPieces[0][..8]

' There are 2 Rooks, so create a subarray of size 2 at mainarray index 1
ChessPieces[1] = ChessPieces[1][..2]

' There are 2 Knights, so create a subarray of size 2 at mainarray index 2
ChessPieces[2] = ChessPieces[2][..2]

' There are 2 Bishops, so create a subarray of size 2 at mainarray index 3
ChessPieces[3] = ChessPieces[3][..2]

' There is only 1 King, so create a subarray of size 1 at mainarray index 4
ChessPieces[4] = ChessPieces[4][..1]

' There is only 1 Queen, so create a subarray of size 1 at mainarray index 5
ChessPieces[5] = ChessPieces[5][..1]

After this, you have the exact size of the arrays, to hold just the handles which are really used, so there will be no unused arrayindexes.
Now you have the setup as in the picture, with only the marked indexes in memory, the blank fields don't exist in memory and cannot be addressed (you'll get an error if you do).

Now this is a small example, where it is not an issue for a small number of unused indexes, but it can matter in a much bigger project.

I see. Thanks!

Russell