Oxygen Basic
Programming => Problems & Solutions => Topic started by: Arnold on June 30, 2019, 11:21:10 PM
-
Hi Charles,
at Rosettacode I found an example dealing with array concatentation. The OxygenBasic solution seems not to work any more with the latest version. I also experimented a little bit and noticed this difference:
'Array concatenation
uses console
string s1[4] = {"The", "quick", "brown", "fox"}
string s2[5] = {"jumped", "over", "the", "lazy", "dog"}
int n1=countof(s1)
int n2=countof(s2)
int n=n1+n2
sys a=getmemory n * sizeof(string) 'ok
'sys a=getmemory(countof(s1)+countof(s2)) * sizeof(string) 'not ok
'sys a=getmemory (n1+n2) * sizeof(string) 'not ok
string s3 at a
int x
for x=1 to n1
s3[x]=s1[x]
next
for x=1 to n2
s3[x+n1]=s2[x]
next
printl s3[1] " " s3[2] " "s3[3] " "s3[4] " "s3[5] " "s3[6] " "s3[6] " "s3[7] " "s3[8] " " s3[9]
freememory a
===================================================
string t1[4] = {"The", "quick", "brown", "fox"}
string t2[5] = {"jumped", "over", "the", "lazy", "dog"}
int nn=countof(t1)+countof(t2)
sys addr=getmemory nn * sizeof(string)
string t3 at addr
int x
for x=1 to countof(t1)
t3[x]=t1[x]
next
for x=1 to countof(t2)
t3[x+countof(t1)]=t2[x]
next
printl t3[1] " " t3[2] " "t3[3] " "t3[4] " "t3[5] " "t3[6] " "t3[6] " "t3[7] " "t3[8] " " t3[9]
freememory addr
printl "Enter ..."
waitkey()
getmemory using an expression in parantheses seems not to work? It is not a big problem, but I feel obliged to report the behaviour, because O2 terminates without an error message. (though the issue can be spotted quickly)
Roland
-
Hi Roland,
getmemory is a normal function (with optional enclosing brackets), so this won't work:
sys a=getmemory(countof(s1)+countof(s2)) * sizeof(string)
but this will:
sys a=getmemory( (countof(s1)+countof(s2)) * sizeof(string) )
-
Concatenating with redim is very efficient, but strings in the new array will remain cross-linked to the originals. This could be a useful feature to be exploited :)
s3_buffer = s1_buffer + s2_buffer
uses console
redim string s1(4)
s1={"The", "quick", "brown", "fox"}
redim string s2(5)
s2={"jumped", "over", "the", "lazy", "dog"}
'
'FAST CONCATENATION BUT STRINGS REMAIN LINKED
redim string s3(0)
s3_buffer = s1_buffer + s2_buffer
@s3 = strptr s3_buffer
'
int i
for i=1 to 9
print s3[i] " "
next
printl
s1[4]="bear" 'ALSO AFFECTS S3
for i=1 to 9
print s3[i] " "
next
printl
printl "Enter ..." : waitkey()
-
Thank you Charles. I knew that I missed something. Pay attention to the brackets. (Shame on me).
-
Hi Charles,
is it possible to apply the s3_buffer approach in a similar way with e.g. floats? This is the task of Rosetta Code solved with a previous version of O2, which does not work this way any more:
'CREATE DYNAMIC ARRAY SPACES USING STRINGS
string sa=nuls 5* sizeof float
string sb=sa
'MAP ARRAY VARIABLES ONTO STRINGS
float a at *sa
float b at *sb
'ASSIGN SOME VALUES
a<=10,20,30,40,50
b<=60,70,80,90,00
'ADD ARRAY B TO A BY STRING CONCATENATION
sa+=sb
'TEST
print a[7] 'result should be 70
This is what I have achieved so far (shameful little):
redim float aa[5]
redim float bb[5]
aa = {10,20,30,40,50}
bb = {60,70,80,90,00}
print aa[4] + ", " + bb[2]
Adding two arrays like cc=aa+bb would be a tempting option, but it is also ok to assign the values individually.
Roland
-
Yes, it will work more cleanly with floats and integers,since we are no longer dealing with string pointers.
cc_buffer = aa_buffer + bb_buffer
This is more efficient than transferring elements individually
-
Hi Charles,
it took some time until I found my mistake: despite the type float of cc I must apply strptr for cc_buffer. So this code will show the correct results:
redim float aa(5)
redim float bb(5)
aa = {10,20,30,40.5,50}
bb = {60,70.5,80,90,00}
'print aa[4] + ", " + bb[2]
redim float cc(0)
cc_buffer = aa_buffer + bb_buffer
@cc = strptr cc_buffer 'strptr
print cc[4] + ", " + cc[7]
Redim makes concatenation very effective.
I would like to ask two questions. Can the code of the RosettaCode example above be solved with the latest version of Oxygen too? And could redim be used with type any or with structs? FBSL offers a solution for concatenation of mixed arrays (int, string, single). If this is possible with O2 in some way then this will offer a lot of interesting aspects.
Roland
-
I found this solution for the task of RosettaCode:
'CREATE DYNAMIC ARRAY SPACES USING STRINGS
string sa=nuls 5* sizeof float
string sb=nuls 5* sizeof float
'MAP ARRAY VARIABLES ONTO STRINGS
float a at *sa
float b at *sb
'ASSIGN SOME VALUES
a = {10,20,30,40,50}
b = {60,70,80,90,00}
'print a[5] ", " b[4]
'ADD ARRAY B and A to C BY STRING CONCATENATION
string sc
sc=sa+sb
float c at *sc
'TEST
print c[7] 'result 70
Most probably there are more and better ways to do concatenation (besides using redim). But I think it is nice that there are alternatives to solve a task.
-
Hi Roland,
That is how redim works in o2.
The current redim macro (from oxsc\lang.inc):
def redim
#ifndef %2_buffer
dim string %2_buffer = ""
dim %1 byref %2
#endif
scope
int _qb_ = %3
int _le_ = len %2_buffer
int _qn_ = _le_ / sizeof(%1)
#if match "%4","clear"
int _i_
for _i_=1 to _qn_
#if typecodeof(%2)>=0x200
#ifdef %1.destructor
%2[_i_].destructor
#endif
#elseif typecodeof(%2)>=0xa0
%2[_i_]=""
#else
%2[_i_]=0
#endif
next
#endif
#if typecodeof(%2)>=0xa0
if _qb_<_qn_
_qb_=_qn_ 'disallow reduction
endif
#endif
if _qb_ > _qn_
%2_buffer += nuls( sizeof(%1) * (_qb_ - _qn_))
elseif _qb_ < _qn_
%2_buffer = left( %2_buffer, sizeof(%1) * _qb_ )
endif
@%2=strptr(%2_buffer)
end scope
end def
Redim will support both primitives and UDTs.
Concatenation the buffers works well for direct types, but for strings and other pointered types, it requires that the underlying data is non-volatile, and the data is used as read-only.
-
Thank you, Charles, for the code of redim. In any case, it is worthwhile to learn more about the possible use of this macro.
-
Hi Charles,
I am looking for a way to reset some structures in an array. At the moment I do this by resetting the values in the fields of the corresponding structures. Is there a more general way to achieve this without specifying the fields? I assume the solution is included in the redim macro, but it seems I am not able to find it.
Roland
string cr=chr(13,10)
string pr
type info
char name[40]
int age
end type
'print hex(typecodeof info)
int countof_staff=6
redim info staff[countof_staff]
int i
for i = 1 to 5
staff[i].name = "Officer " + str(i)
staff[i].age = 40-i
pr += i ": " + staff[i].name + ": " + staff[i].age +cr
next
pr += i ": " + staff[countof_staff].name + ": " + staff[countof_staff].age +cr
int used_mem = countof_staff*sizeof(info)
pr += "Used memory: " + used_mem +cr +cr
'print sizeof(info) + cr
staff[4].name = "" : staff[4].age = 0
staff[5].name = "" : staff[5].age = 0
for i = 1 to countof_staff
pr += i ": " + staff[i].name + ": " + staff[i].age +cr
next
used_mem = countof_staff*sizeof(info)
pr += "Used memory: " + used_mem +cr
print pr
-
Hi Roland,
Resetting individual fields is good enough, and safe for non-flat structures. You can make the UDT into a class with a destructor, for clearing individual members.
The current redim clear option looks for a destructor and, it it exists, invokes it for each member of the dynamic array.
redim typ v(10) clear
-
Thank you, Charles. I wondered about the clear option, but I have not found an example of it yet, and I am not brave enough to test this.
I tried another approach and added an additional member dta in type info. Would this be applicable? If there are side-effects I will delete the values individually, although using a type with e.g. 10 members it would be interesting to do this with a single statement.
Roland
$ filename "test.exe"
'uses rtl32
'uses rtl64
string cr=chr(13,10)
string pr
type info
char name[40]
sys age 'test for 64-bit
=
char dta[sizeof(info)]
end type
'print sizeof info
'print hex(typecodeof info)
int countof_staff=6
redim info staff[countof_staff]
int i
for i = 1 to 5
staff[i].name = "Officer " + str(i)
staff[i].age = 40-i
pr += i ": " + staff[i].name + ": " + staff[i].age +cr
next
pr += i ": " + staff[countof_staff].name + ": " + staff[countof_staff].age +cr
int used_mem = countof_staff*sizeof(info)
pr += "Used memory: " + used_mem +cr +cr
staff[4].dta=nuls sizeof(info)
staff[5].dta=nuls sizeof(info)
'staff[4].name = "New Officer" : staff[4].age = 22
for i = 1 to countof_staff
pr += i ": " + staff[i].name + ": " + staff[i].age +cr
next
used_mem = countof_staff*sizeof(info)
pr += "Used memory: " + used_mem +cr
print pr
-
instead of:
staff[4].dta=nuls sizeof(info)
this code avoids the string intermediary, and could be applied to any flat structure:
sub clear(sys p, int n)
byte b at (p)
while n>0
b=0 : @b++ : n--
wend
end sub
in assembler:
sub clear(sys p, int n)
mov ecx,n
mov rsi,p
(
dec ecx : jl exit
mov byte [rsi],0
inc rsi
repeat
)
end sub
clear @staff[4], sizeof(info)
-
Wow! This is impressive. I will not need an extra dta member and will get the expected result. Thank you again for this little helpful routine.
-
I'll add it to inc\generics.inc :)