Demo: Getting arrays into an array of a UDT

[bplus]

Inspired by what I think @Dimster might be able to use for his recurring data problem.

It's nice trick even if it doesn't help him with that.

This demo records a hand written word (forget about dotting i's and crossing t's for moment) into an array of points and records the name of word and stores both into same UDT array item.

First part just collects words, 2nd part just plays them back in same order as entered, nothing fancy here:

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "Getting an Array into UDT Array" 'b+ 2020-01-29
3.  
4. CONST Xmax = 1200, Ymax = 700, Comma = ","
5. TYPE ArrayType
6.     Aname AS STRING ' here is the name of the array
7.     A AS STRING '    here is the array joined into a long string so it may be stored in a UDT
8. END TYPE
9.  
10. REDIM words(100) AS ArrayType ' record the script positions of handwritten words and save the word and positions into a UDT
11.  
12. SCREEN _NEWIMAGE(Xmax, Ymax, 32)
13. _DELAY .25 'need time for screen to load before attempting to move it.
14. _SCREENMOVE _MIDDLE
15. DIM mx AS LONG, my AS LONG, mb AS LONG, w$, wi AS LONG, i AS LONG, j AS LONG
16.  
17. _TITLE "To gather data:  Hand write words with mouse and then enter the word, up to 100 words or escape."
18. wi = 0
19. DO
20.     CLS
21.     WHILE _MOUSEINPUT: WEND
22.     mb = _MOUSEBUTTON(1)
23.     IF mb THEN
24.         REDIM temp(0) AS LONG
25.         mx = _MOUSEX: my = _MOUSEY
26.         LongAppend temp(), mx
27.         LongAppend temp(), my
28.         PSET (mx, my)
29.         WHILE mb
30.             WHILE _MOUSEINPUT: WEND
31.             mx = _MOUSEX: my = _MOUSEY: mb = _MOUSEBUTTON(1)
32.             LongAppend temp(), mx
33.             LongAppend temp(), my
34.             LINE -(mx, my)
35.             _LIMIT 10
36.         WEND
37.         CLS
38.         INPUT "Enter word > "; w$
39.         words(wi).Aname = w$
40.         words(wi).A = Join$(temp(), Comma$)
41.         wi = wi + 1
42.         IF wi > 100 THEN wi = 100: EXIT DO
43.     END IF
44. LOOP UNTIL _KEYDOWN(27)
45.  
46. ' simple playback
47. FOR j = 0 TO wi
48.     CLS
49.     PRINT "This is word "; words(j).Aname
50.     REDIM unpackXY(0) AS LONG
51.     Split2Long words(j).A, Comma$, unpackXY() ' the first data item in an LongAppend Array is at 1 not 0
52.     FOR i = 2 TO UBOUND(unpackXY) STEP 2
53.         IF i = 2 THEN PSET (unpackXY(i - 1), unpackXY(i)) ELSE LINE -(unpackXY(i - 1), unpackXY(i))
54.         _LIMIT 20
55.     NEXT
56.     _DELAY 1
57. NEXT
58.  
59. 'this splits the items separated by delim into an array of LONG type numbers
60. SUB Split2Long (SplitMeString AS STRING, delim AS STRING, loadMeArray() AS LONG) 'modified for this app
61.     DIM curpos AS LONG, arrpos AS LONG, LD AS LONG, dpos AS LONG 'fix use the Lbound the array already has
62.     curpos = 1: arrpos = LBOUND(loadMeArray): LD = LEN(delim)
63.     dpos = INSTR(curpos, SplitMeString, delim)
64.     DO UNTIL dpos = 0
65.         loadMeArray(arrpos) = VAL(MID$(SplitMeString, curpos, dpos - curpos))
66.         arrpos = arrpos + 1
67.         IF arrpos > UBOUND(loadMeArray) THEN REDIM _PRESERVE loadMeArray(LBOUND(loadMeArray) TO UBOUND(loadMeArray) + 1000) AS LONG
68.         curpos = dpos + LD
69.         dpos = INSTR(curpos, SplitMeString, delim)
70.     LOOP
71.     loadMeArray(arrpos) = VAL(MID$(SplitMeString, curpos))
72.     REDIM _PRESERVE loadMeArray(LBOUND(loadMeArray) TO arrpos) AS LONG 'get the ubound correct
73. END SUB
74.  
75. FUNCTION Join$ (numberArray() AS LONG, connect$) 'connect all the array itmes into long string separated by connect$ character
76.     REDIM i AS LONG
77.     FOR i = LBOUND(numberArray) TO UBOUND(numberarray)
78.         IF Join$ = "" THEN Join$ = TS$(numberArray(i)) ELSE Join$ = Join$ + connect$ + TS$(numberArray(i))
79.     NEXT
80. END FUNCTION
81.  
82. ' the first data item in an LongAppend Array is at 1 not 0 assuming a REDIM arr(0) '<< start with 1 item at index 0
83. ' thusly the ubound of the array is the actual significant items it contains
84. SUB LongAppend (arr() AS LONG, addItem AS LONG) ' grow the arr() as you add items to it
85.     REDIM _PRESERVE arr(LBOUND(arr) TO UBOUND(arr) + 1) AS LONG
86.     arr(UBOUND(arr)) = addItem
87. END SUB
88.  
89. FUNCTION TS$ (n AS LONG) ' just convert a long integer to string and remove front and end spaces
90.     TS$ = _TRIM$(STR$(n))
91. END FUNCTION
92.  
93.  

[luke]

That seems like an overly complicated way to store many pieces of data in a string. Leaving the Aname label aside for the moment, this is a much simpler way to do it:

Code: [Select]

DEFLNG A-Z

TYPE t
    s AS STRING
END TYPE
DIM v AS t

FOR i = 10 TO 0 STEP -1
    set v.s, i, i ^ 2
NEXT i

FOR i = 0 TO 10
    PRINT get(v.s, i)
NEXT i

SUB set (array$, index, value&)
    element_size = LEN(value)
    IF LEN(array$) < element_size * (index + 1) THEN
        array$ = array$ + STRING$(element_size * (index + 1) - LEN(array$), CHR$(0))
    END IF
    MID$(array$, index * element_size + 1) = _MK$(LONG, value)
END SUB

FUNCTION get& (array$, index)
    get = _CV(LONG, MID$(array$, index * LEN(get) + 1, LEN(get)))
END FUNCTION
(Change the &s and the 'LONG's to whatever data type you want).

You could rewrite this to use _MEM too, but I don't consider any speed gain to be worth the extra complexity of manual memory management, especially once you start building arrays of UDTs or passing the UDT around as an intermediate value.

[bplus]

That seems like an overly complicated way to store many pieces of data in a string. Leaving the Aname label aside for the moment, this is a much simpler way to do it:

Code: [Select]

DEFLNG A-Z

TYPE t
    s AS STRING
END TYPE
DIM v AS t

FOR i = 10 TO 0 STEP -1
    set v.s, i, i ^ 2
NEXT i

FOR i = 0 TO 10
    PRINT get(v.s, i)
NEXT i

SUB set (array$, index, value&)
    element_size = LEN(value)
    IF LEN(array$) < element_size * (index + 1) THEN
        array$ = array$ + STRING$(element_size * (index + 1) - LEN(array$), CHR$(0))
    END IF
    MID$(array$, index * element_size + 1) = _MK$(LONG, value)
END SUB

FUNCTION get& (array$, index)
    get = _CV(LONG, MID$(array$, index * LEN(get) + 1, LEN(get)))
END FUNCTION
(Change the &s and the 'LONG's to whatever data type you want).

You could rewrite this to use _MEM too, but I don't consider any speed gain to be worth the extra complexity of manual memory management, especially once you start building arrays of UDTs or passing the UDT around as an intermediate value.

Fantastic, this is new, _CV and _MK$, to me. Apparently these control the size of each item according to it's type, so you don't need dividers to tell when one item ends and the next begins, cool!

Thanks @luke can't wait to try it out.

[Dimster]

My gawd you guys - two really clever programs.
@luke - that line of code

array$ = array$ + STRING$(element_size * (index + 1) - LEN(array$), CHR$(0))

It's taking the string array "v" and adding a string numeric value. I'm not sure what the value is but lets say its' 25. So the resultant new string is "v25" or would it be "v 25" with a space between the V and the 25?

Now the resultant array can only be used in that Subroutine (local array) and only used with string values. Is that correct?

@bplus . I see now what you mean by splitting up one long string name into the various names for the arrays I would like my program to develop on the fly. So, in the example I was using, if I forsee the user of the program could manipulate the various files of data into their Mean, Mode, Median, MovingMean, MovingMode, MovingMedian, with periods of 4, 10, 25 and knowing i have 50 files all with the same name but for the event file number then one massive array containing all that info could be used to form the exact array the user would request.

So
 Query$ = "MeanModeMedianMovingMeanMovingModeMovingMedian41025Event1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950"

Then invite the user to chose the Event and Math function to display the data, and using that info create a sub array from Query$ and the file name to access. I'll give it a go. It is dealing with string values ie Dim Shared MovingMedian4 (1 to 300) wouldn't work - has to be Dim Shared MovingMedian4$(1 to 300) and the data it's accessing has to be in quote marks.

[bplus]

@Dimster

My Interpretation of this line:

Code: QB64: [Select]

1. array$ = array$ + STRING$(element_size * (index + 1) - LEN(array$), CHR$(0))

If the new index item exceeds the array size then the above line fills in the difference with CHR$(0) characters probably translates to 0 values with _CV

Now with the array string the right size the next step is to substitute the value converted to ASCII number (base 256?)
plugged in at the index * type size with a MID$() substitution statement (not the MID$ function statement).

I wonder, what would happen for negative indexes?  Well not quite the versatility of an array? and speed comparison?

PS you can only do one type number for this method, because the ASCII conversion will remain the same size, that's the trick you need when using MID$ for putting and getting values, all the items have to be the same size in characters.

[Dimster]

I totally misunderstood that line of Luke's. Looked like a concatenation of string values to me rather than a resizing of the string array. 

[bplus]

@bplus . I see now what you mean by splitting up one long string name into the various names for the arrays I would like my program to develop on the fly. So, in the example I was using, if I forsee the user of the program could manipulate the various files of data into their Mean, Mode, Median, MovingMean, MovingMode, MovingMedian, with periods of 4, 10, 25 and knowing i have 50 files all with the same name but for the event file number then one massive array containing all that info could be used to form the exact array the user would request.

So
 Query$ = "MeanModeMedianMovingMeanMovingModeMovingMedian41025Event1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950"

Then invite the user to chose the Event and Math function to display the data, and using that info create a sub array from Query$ and the file name to access. I'll give it a go. It is dealing with string values ie Dim Shared MovingMedian4 (1 to 300) wouldn't work - has to be Dim Shared MovingMedian4$(1 to 300) and the data it's accessing has to be in quote marks.

LOL man, I am perplexed again!

@Dimster have you worked with TYPE structures? UDT's allow grouping of mixed data types, or just grouping things under one convenient structure could be all same type. Under one variable name you can have all sorts characteristics that make up the object or structure.

So like for data from a file you could have:
Type FileDataType
   Filename as string
   Data as string  ' our string array we are discussing in this thread
   Mean as single
   Average as single
   Highest as single
   Lowest as single
   Range as single
   STD as single
   ...
End Type

' now get ready to load and store from 50 files!
REDIM MyFiles(1 to 50) as FileDataType

' loading procedure on each file to load MyFiles with
open file
get array data string
get stats saved or calc now from array data string

' start queries of MyFiles
'like look at all of one kind of stat find something interesting and see what file it came from

[SMcNeill]

The way I tend to do arrays in types is like this:

Code: [Select]

TYPE a_type
    foo AS STRING * 104
END TYPE

DIM ex AS a_type
DIM array(100) AS LONG
DIM m(1) AS _MEM: m(1)= _MEM(array()): m(0) = _MEM(ex)

FOR i = 0 TO 100
    array(i) = i ‘do whatever with the array.
NEXT

_MEMCOPY m(1), m(1).OFFSET, m(1).SIZE TO m(0), m(0).OFFSET ‘copy the array to the proper position in the TYPE

‘do whatever with the UDT variable such as putting it to a file.



[STxAxTIC]

Seems like you can do away with the line(s)

Code: QB64: [Select]

1. TYPE a_type
2.     foo AS STRING * 104
3. END TYPE

As a_type isn't mentioned subsequently. Is this really arrays in types?

[SMcNeill]

Seems like you can do away with the line(s)

Code: QB64: [Select]

1. TYPE a_type
2.     foo AS STRING * 104
3. END TYPE

As a_type isn't mentioned subsequently. Is this really arrays in types?

If is, if you make ex your type and correct the typo.  :P

[STxAxTIC]

Sly edit. Okay.

[bplus]

Code: QB64: [Select]

1. REDIM b AS _INTEGER64
2. PRINT LEN(a%), LEN(b) '>>>  2   8    hey this is handy!

[STxAxTIC]

This isn't really the answer that's being developed here, but here is an approach using nodes. Following is a demo that ends with a sum calculation over a bunch of numbers with mixed types:

Code: QB64: [Select]

1. ' Version 2020-01-30
2.  
3. OPTION _EXPLICIT
4.  
5. REM $Include: 'SoftArrays-main.bi'
6.  
7. ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
8. ' Begin main program.
9. ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
10.  
11. DO UNTIL _SCREENEXISTS: LOOP
12. _TITLE "Array Demo"
13.  
14. TYPE Person
15.     NickName AS STRING
16.     Age AS DOUBLE
17.     Array1 AS LONG
18.     Array2 AS LONG
19.     ' etc.
20. END TYPE
21.  
22. DIM a AS LONG
23. DIM b AS LONG
24. DIM FellippeHeitor AS Person
25.  
26. ' Create a person.
27. FellippeHeitor.NickName = "Fellippe"
28. FellippeHeitor.Age = 27
29. FellippeHeitor.Array1 = NewTextNode("Friends") ' Define two nodes to build from.
30. FellippeHeitor.Array2 = NewTextNode("Numbers") '
31.  
32. ' Add data by linking nodes to the "east".
33. a = FellippeHeitor.Array1
34. a = LinkEast(a, NewTextNode("Luke"))
35. a = LinkEast(a, NewTextNode("bplus"))
36. a = LinkEast(a, NewTextNode("Ashish"))
37.  
38. a = FellippeHeitor.Array2
39. a = LinkEast(a, NewIntegerNode(1))
40. a = LinkEast(a, NewDoubleNode(3.14))
41. a = LinkEast(a, NewIntegerNode(3))
42.  
43. ' Testing '''''''''''''''''''''''''''''''''''''''''''''''''''
44.  
45. ' Print each array
46. PrintArray (FellippeHeitor.Array1)
47. PRINT
48. PrintArray (FellippeHeitor.Array2)
49. PRINT
50.  
51. ' Sum the array containing numbers.
52. ' However, the first node (as we have it) contains text!
53. ' Must get the next-over address.
54. a = FellippeHeitor.Array2
55. b = Nodes(a).East
56. PRINT SumNumbers(b) ' Prints 7.14, as expected
57.  
58. END '''''''''''''''''''''''''''''''''''''''''''''''''''''''''
59.  
60. SUB PrintArray (x AS LONG)
61.     DIM y AS LONG
62.     PRINT Literal$(Nodes(x).Identity)
63.     y = Nodes(x).East
64.     IF (y <> -1) THEN CALL PrintArray(y)
65. END SUB
66.  
67. FUNCTION SumNumbers (x AS LONG)
68.     DIM TheReturn AS DOUBLE
69.     DIM y AS LONG
70.     TheReturn = LiteralNumber(Nodes(x).Identity)
71.     y = Nodes(x).East
72.     IF (y <> -1) THEN TheReturn = TheReturn + SumNumbers(y)
73.     SumNumbers = TheReturn
74. END FUNCTION
75.  
76. ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
77. ' End main program.
78. ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
79.  
80. REM $Include: 'SoftArrays-main.bm'
81.  

The required files will be on my github in a little while - just showing the method:

 

[bplus]

OK 

I redid original post using Luke's Method for numeric arrays but had a snag or 2, maybe just something I am miscalculating but had to drop drawing the first item in array strings. I made 2 array strings this time to easily distinguish X's from Y's in effort to shake off bug but didn't.

But it is nice not to have to pack and unpack items to and from arrays, just plug in values by index numbers into the "array" string.

The first method still holds for variable length strings in a "array" string.

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "Getting an Array into UDT Mod 1 Luke Method" ' started b+ 2020-01-29
3. ' 2021-01-30   Mod 1 employ Lukes method, dump ALL previous subroutines this is much less complex
4. '  I am getting too many screwups trying x, y, x, y, x, y pairs! So do 2 string arrays 1 for X 1 for Y.
5. '  Still getting some screwy problem from 1st and last elements???  but works fine if I ignore.
6.  
7. CONST Xmax = 1200, Ymax = 700
8. TYPE ArrayType
9.     Aname AS STRING ' here is the name of the array
10.     X AS STRING '    here is the array joined into a long string so it may be stored in a UDT
11.     Y AS STRING '
12. END TYPE
13.  
14. REDIM words(100) AS ArrayType ' record the script positions of handwritten words and save the word and positions into a UDT
15.  
16. SCREEN _NEWIMAGE(Xmax, Ymax, 32)
17. _DELAY .25 'need time for screen to load before attempting to move it.
18. _SCREENMOVE _MIDDLE
19. DIM mx AS INTEGER, my AS INTEGER, mb AS INTEGER, w$, wi AS INTEGER, i AS INTEGER, j AS INTEGER, ai AS INTEGER
20.  
21. _TITLE "To gather data:  Hand write words with mouse and then enter the word, up to 100 words or escape."
22. wi = 0 ' word index for words
23. DO
24.     CLS
25.     WHILE _MOUSEINPUT: WEND
26.     mb = _MOUSEBUTTON(1): mx = _MOUSEX: my = _MOUSEY
27.     IF mb THEN
28.         words(wi).X = "": words(wi).Y = "": ai = 0 ' ai = array index for the elements in X, Y arrays
29.         set words(wi).X, ai, mx: set words(wi).Y, ai, my: ai = ai + 1
30.         PSET (mx, my)
31.         WHILE mb
32.             WHILE _MOUSEINPUT: WEND
33.             mx = _MOUSEX: my = _MOUSEY: mb = _MOUSEBUTTON(1)
34.             set words(wi).X, ai, mx: set words(wi).Y, ai, my: ai = ai + 1
35.             LINE -(mx, my)
36.             _LIMIT 20
37.         WEND
38.         CLS
39.         INPUT "Enter word > "; w$
40.         words(wi).Aname = w$
41.         wi = wi + 1
42.         IF wi > 100 THEN EXIT DO ' wi will always be 1 more than last word
43.     END IF
44. LOOP UNTIL _KEYDOWN(27)
45. wi = wi - 1
46.  
47. ' simple playback
48. FOR j = 0 TO wi
49.     CLS
50.     IF words(j).Aname <> "" THEN
51.         PRINT "This is word "; words(j).Aname
52.         FOR i = 1 TO LEN(words(j).X) / 2 - 1 '<<<< for some reason I have to dump 0 index
53.             IF i = 1 THEN PSET (get%(words(j).X, i), get%(words(j).Y, i)) ELSE LINE -(get%(words(j).X, i), get%(words(j).Y, i))
54.             _LIMIT 30
55.         NEXT
56.         _DELAY 1
57.     END IF
58. NEXT
59.  
60. '              ======================= Luke's Method ========================
61.  
62. SUB set (array$, index AS INTEGER, value AS INTEGER) ' <<<< having big debate with myself between Integer and Long, Integers are shorter
63.     REDIM element_size AS INTEGER
64.     element_size = LEN(value)
65.     IF LEN(array$) < element_size * (index + 1) THEN
66.         array$ = array$ + STRING$(element_size * (index + 1) - LEN(array$), CHR$(0))
67.     END IF
68.     MID$(array$, index * element_size + 1) = _MK$(LONG, value)
69. END SUB
70.  
71. FUNCTION get% (array$, index AS INTEGER)
72.     get% = _CV(INTEGER, MID$(array$, index * 2 + 1, 2))
73. END FUNCTION
74.  
75.  

OH! I missed changing a LONG to INTEGER!  be right back!

[luke]

Line 68 needs to say INTEGER.

I generally just accept the extra space usage of longs in order to get their extra range and prevent overflow, but to reach their own.