1. Possible feature for new Euphoria-version
- Posted by Tommy Carlier <tommy.carlier at pandora.be> Jan 08, 2004
- 402 views
Sequences are really easy to use, but there is no way you can create an index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be nice if such a thing existed? In the current version of Euphoria, you can do: sequence seq seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} integer a a = seq[2][2] My suggestion for a new feature: allow the index to be a sequence. That way you could do something like this: sequence seq seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} integer a a = seq[ {2, 2} ] And now for the exciting part: sequence seq seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} sequence b b = {2, 2} integer a a = seq[b] This way you can also pass and return multiple indices to and from procedures and functions. -- Tommy Carlier tommy online: http://users.pandora.be/tommycarlier
2. Re: Possible feature for new Euphoria-version
- Posted by "Euman" <euman at bellsouth.net> Jan 08, 2004
- 405 views
Ouch, to much confusion...Im an old timer in euphoria Euman ----- Original Message ----- From: "Tommy Carlier" <tommy.carlier at pandora.be> To: "Euphoria Mailing List" <EUforum at topica.com> Subject: Possible feature for new Euphoria-version > > > Sequences are really easy to use, but there is no way you can create an > index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be > nice if such a thing existed? > > In the current version of Euphoria, you can do: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[2][2] > > My suggestion for a new feature: allow the index to be a sequence. That > way you could do something like this: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[ {2, 2} ] > > And now for the exciting part: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > sequence b > b = {2, 2} > integer a > a = seq[b] > > This way you can also pass and return multiple indices to and from > procedures and functions. > > -- > > Tommy Carlier > tommy online: http://users.pandora.be/tommycarlier > > > > TOPICA - Start your own email discussion group. FREE! > >
3. Re: Possible feature for new Euphoria-version
- Posted by "Kat" <gertie at visionsix.com> Jan 08, 2004
- 392 views
On 8 Jan 2004, at 14:38, Euman wrote: > > > Ouch, to much confusion...Im an old timer in euphoria > > Euman > > ----- Original Message ----- > From: "Tommy Carlier" <tommy.carlier at pandora.be> > To: "Euphoria Mailing List" <EUforum at topica.com> > Subject: Possible feature for new Euphoria-version > > > > Sequences are really easy to use, but there is no way you can create an > > index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be > > nice if such a thing existed? > > > > In the current version of Euphoria, you can do: > > sequence seq > > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > > integer a > > a = seq[2][2] > > > > My suggestion for a new feature: allow the index to be a sequence. That > > way you could do something like this: > > sequence seq > > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > > integer a > > a = seq[ {2, 2} ] > > > > And now for the exciting part: > > sequence seq > > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > > sequence b > > b = {2, 2} > > integer a > > a = seq[b] > > > > This way you can also pass and return multiple indices to and from > > procedures and functions. You can do this in strtok: param = {2} db = {"this is a test1","this is test2 a"} result = gettok(db,param,"") And this: string = {"Red,Skelton,45,London,England", "Lucy,Ball,56,Barre,North Dakota", "Fred,Astaire,45,Alberta,Canada", "Pierre,du Pont,56,Paris,France"} string = sorttok(string,{3,-2},',') string = {"Red,Skelton,45,London,England", "Fred,Astaire,45,Alberta,Canada", "Pierre,du Pont,56,Paris,France", "Lucy,Ball,56,Barre,North Dakota"} You see, it did a ascending sort on (fictitious) age field, then sorted the two last name fields in decending order. And this gets you a seq in reply: string = {"Red,Skelton,45,London,England", "Lucy,Ball,56,Barre,North Dakota", "Fred,Astaire,45,Alberta,Canada", "Pierre,du Pont,56,Paris,France"} string = sortntok(string,{3,-2},',') string = {1,3,4,2} Eu should be as versatile as possible, no? Kat
4. Re: Possible feature for new Euphoria-version
- Posted by "Derek Parnell" <ddparnell at bigpond.com> Jan 08, 2004
- 398 views
----- Original Message ----- From: "Tommy Carlier" <tommy.carlier at pandora.be> To: "Euphoria Mailing List" <EUforum at topica.com> Subject: Possible feature for new Euphoria-version > > > Sequences are really easy to use, but there is no way you can create an > index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be > nice if such a thing existed? > > In the current version of Euphoria, you can do: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[2][2] > > My suggestion for a new feature: allow the index to be a sequence. That > way you could do something like this: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[ {2, 2} ] > > And now for the exciting part: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > sequence b > b = {2, 2} > integer a > a = seq[b] > > This way you can also pass and return multiple indices to and from > procedures and functions. > Tommy, this idea has been suggested before (about 2 or 3 years ago). I was not accepted then because (I think) it was too hard to incorporate into Euphoria's code, but now that RDS is rewritting the parser they might consider it. I certainly like the idea. And as an extention, I hope one could also do this ... seq[b] = 123 which would change the sequence to ... {{1, 2, 3}, {4, 123, 6}, {7, 8, 9}} This would make a lot of my code much simplier to write and read, and make the app run faster. -- Derek
5. Re: Possible feature for new Euphoria-version
- Posted by Pete Lomax <petelomax at blueyonder.co.uk> Jan 09, 2004
- 439 views
On Thu, 08 Jan 2004 19:54:28 +0100, Tommy Carlier <tommy.carlier at pandora.be> wrote: >Sequences are really easy to use, but there is no way you can create an >index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be >nice if such a thing existed? My apologies if you already knew how to code such, but this might just (possibly) be all you are after: function getqx(sequence q, sequence i) if length(i)=1 then return q[i[1]] end if return getqx(q[i[1]],i[2..length(i)]) end function function setqx(sequence q, sequence i, object val) if length(i)=1 then q[i[1]]=val return q end if q[i[1]]=setqx(q[i[1]],i[2..length(i)],val) return q end function sequence s s = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} integer a ? getqx(s,{2,2}) -- prints 5 s=setqx(s,{2,2},123) ?s -- prints {{1, 2, 3}, {4, 123, 6}, {7, 8, 9}} if getc(0) then end if abort(0) I'm not (too) worried about having to code get() like this, but set() will probably impose serious COW (copy-on-write) overhead unnecessarily when used with large sequences. Of course I believe indexing using sequences should be part of a new improved Euphoria, btw, but that's not going to be here for a while yet, so maybe in the meantime the above will be of some use. Regards, Pete
6. Re: Possible feature for new Euphoria-version
- Posted by Robert Craig <rds at RapidEuphoria.com> Jan 09, 2004
- 407 views
Tommy Carlier wrote: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > sequence b > b = {2, 2} > integer a > a = seq[b] > > This way you can also pass and return multiple indices to and from > procedures and functions. There are at least three logical ways that you might define subscripting of a sequence with a sequence. 1. Your way (above). The sequence used as a subscript would contain a series of subscripts to be applied. This fills a logical gap in subscripting, since currently the number of levels of subscripting is fixed at compile-time. You could use this for reading and writing. 2. sequence s s = {100, 200, 300, 400, 500} s[{1,5,3}] is {100, 500, 300} The subscript would let you randomly select a bunch of elements for reading or writing. 3. sequence s s[1] = 7 s["Tommy"] = 99 s["Carlier"] = 0 s["Carlier"] += 1 ? s["Tommy"] * s["Carlier"] The Euphoria implementer might set up a hash table internally. Whenever you assigned to a previously nonexistent element, the implementation would create a new element for you. This would be good for symbol tables, databases etc. Which approach is best? If you choose one, you'll eliminate the possibility of doing the others. Regards, Rob Craig Rapid Deployment Software http://www.RapidEuphoria.com
7. Re: Possible feature for new Euphoria-version
- Posted by "PeterBlonner" <peter at blonner.com> Jan 09, 2004
- 405 views
While it is true that there are alternative meanings that could be applied to subscripting through sequences, in my opinion the first is by far the most attractive. The ability to access various levels of a sequence at run-time could be quite a powerful tool, however as with Pete Lomax suggestion implementing it with Euphoria (as it is currently works) would impose a hefty overhead. So for me, implementing this as part of the language would be a significant improvement that would enable a lot of code to be written more generically with reasonable efficiency. Whereas the other alternative applications could just as well be implemented though library functions. Regards, Peter Blonner ----- Original Message ----- From: "Robert Craig" <rds at RapidEuphoria.com> To: <EUforum at topica.com> Sent: Friday, January 09, 2004 3:29 PM Subject: Re: Possible feature for new Euphoria-version > > > Tommy Carlier wrote: > > sequence seq > > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > > sequence b > > b = {2, 2} > > integer a > > a = seq[b] > > > > This way you can also pass and return multiple indices to and from > > procedures and functions. > > There are at least three logical ways that you might define > subscripting of a sequence with a sequence. > > 1. Your way (above). The sequence used as a subscript would > contain a series of subscripts to be applied. This > fills a logical gap in subscripting, since currently > the number of levels of subscripting is fixed at > compile-time. You could use this for reading and writing. > > 2. sequence s > s = {100, 200, 300, 400, 500} > s[{1,5,3}] is {100, 500, 300} > The subscript would let you randomly select a bunch of > elements for reading or writing. > > 3. sequence s > s[1] = 7 > s["Tommy"] = 99 > s["Carlier"] = 0 > s["Carlier"] += 1 > ? s["Tommy"] * s["Carlier"] > > The Euphoria implementer might set up a hash table internally. > Whenever you assigned to a previously nonexistent > element, the implementation would create a new > element for you. This would be good for symbol tables, > databases etc. > > Which approach is best? If you choose one, you'll > eliminate the possibility of doing the others. > > Regards, > Rob Craig > Rapid Deployment Software > http://www.RapidEuphoria.com > > > > TOPICA - Start your own email discussion group. FREE! > >
8. Re: Possible feature for new Euphoria-version
- Posted by "Juergen Luethje" <j.lue at gmx.de> Jan 09, 2004
- 410 views
Derek wrote: >> -----Original Message----- >> From: Robert Craig >> Sent: Friday, 9 January 2004 3:30 PM >> >> >> Tommy Carlier wrote: >>> sequence seq >>> seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} >>> sequence b >>> b = {2, 2} >>> integer a >>> a = seq[b] >>> >>> This way you can also pass and return multiple indices to and from >>> procedures and functions. >> >> There are at least three logical ways that you might define >> subscripting of a sequence with a sequence. >> >> 1. Your way (above). The sequence used as a subscript would >> contain a series of subscripts to be applied. This >> fills a logical gap in subscripting, since currently >> the number of levels of subscripting is fixed at >> compile-time. You could use this for reading and writing. I vote for this way. >> 2. sequence s >> s = {100, 200, 300, 400, 500} >> s[{1,5,3}] is {100, 500, 300} >> The subscript would let you randomly select a bunch of >> elements for reading or writing. > > Or as alternative ... > > s = {100, 200, 300, 400, 500} > s[1,5,3] is {100, 500, 300} > >> 3. sequence s >> s[1] = 7 >> s["Tommy"] = 99 >> s["Carlier"] = 0 >> s["Carlier"] += 1 >> ? s["Tommy"] * s["Carlier"] >> >> The Euphoria implementer might set up a hash table internally. >> Whenever you assigned to a previously nonexistent >> element, the implementation would create a new >> element for you. This would be good for symbol tables, >> databases etc. > > Or as alternative ... > > s."Tommy" = 99 > >> Which approach is best? If you choose one, you'll >> eliminate the possibility of doing the others. > > Well at least any of them will be an improvement, and the "eliminated" ones > are still possible through slower methods. I vote for using your alternatives for 2. and 3. Well, 2. is not important for me, but implementing 1. and 3. directly into Euphoria would be a *considerable* enhancement. Regards, Juergen -- /"\ ASCII ribbon campain | |\ _,,,---,,_ \ / against HTML in | /,`.-'`' -. ;-;;,_ X e-mail and news, | |,4- ) )-,_..;\ ( `'-' / \ and unneeded MIME | '---''(_/--' `-'\_)
9. Re: Possible feature for new Euphoria-version
- Posted by "Derek Parnell" <ddparnell at bigpond.com> Jan 09, 2004
- 397 views
----- Original Message ----- From: "Andy Serpa" <ac at onehorseshy.com> To: <EUforum at topica.com> Subject: RE: Possible feature for new Euphoria-version > > > Robert Craig wrote: > > > > > > Tommy Carlier wrote: > > > sequence seq > > > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > > > sequence b > > > b = {2, 2} > > > integer a > > > a = seq[b] > > > > > > This way you can also pass and return multiple indices to and from > > > procedures and functions. > > > > There are at least three logical ways that you might define > > subscripting of a sequence with a sequence. > > > > 1. Your way (above). The sequence used as a subscript would > > contain a series of subscripts to be applied. This > > fills a logical gap in subscripting, since currently > > the number of levels of subscripting is fixed at > > compile-time. You could use this for reading and writing. > > > > 2. sequence s > > s = {100, 200, 300, 400, 500} > > s[{1,5,3}] is {100, 500, 300} > > The subscript would let you randomly select a bunch of > > elements for reading or writing. > > > > 3. sequence s > > s[1] = 7 > > s["Tommy"] = 99 > > s["Carlier"] = 0 > > s["Carlier"] += 1 > > ? s["Tommy"] * s["Carlier"] > > > > The Euphoria implementer might set up a hash table internally. > > Whenever you assigned to a previously nonexistent > > element, the implementation would create a new > > element for you. This would be good for symbol tables, > > databases etc. > > > > Which approach is best? If you choose one, you'll > > eliminate the possibility of doing the others. > > > > Can't #1 and #2 be combined? > > sequence s > > s = {{1,2,3},{4,5,6},{7,8,9}} > > object x > > > -- Like #2 > > x = s[{1,3}] > > -- Now x = {{1,2,3},{7,8,9}} Okay, so because the reference was {1,3} you have plucked out the 1st and 3rd elements. > x = s[{1,2}] > > -- Same as x = s[1..2], x = {{1,2,3},{4,5,6}} > > -- Like #1 > > x = s[{{1,2}}] > > -- Now x = 2, depth of subscripting sequence = depth of retrieved > element > > > -- Like #1 & #2 both > > x = s[{{1,2},{3,1}}] > > -- Now x = {2,7} > > x = s[{{1,2},3}] > > -- Now x = {2,{7,8,9}} > > > Logical, consistent, no? > I'm not sure if this solves the issue, Andy. I was thinking that the syntax ... SEQ[ seq ] would only ever refer to a single element. The depth of that element is the length of 'seq'. This is because at run time it is a trivial matter to have the length of a sequence represent the depth you wish to fetch from. It may be harder to do use the depth dynamically. If, for example, we didn't know until runtime, that we wanted something 3 levels deep, it is trival to build a reference sequence thus ... refseq = {index1, index2, index3} but to do a depth reference sequence we would need to do ... refseq = {index1, index2, index3} for i = 1 to length(refseq) do refseq = {refseq} end for Why bother? And ... SEQ[ a,b, ... ,z ] would refer to one or more elements, depending on the number of items in the square-bracket-enclosed list. We could even do SEQ[ a, b..c, {d,e,f}, $ ] which would create a new sequence whose 1st element would be SEQ[a], 2nd would be SEQ[b..c], 3rd would be SEQ[{d,e,f}], and 4th would be SEQ[length(SEQ)]. -- Derek
10. Re: Possible feature for new Euphoria-version
- Posted by "Carl R. White" <euphoria at cyreksoft.yorks.com> Jan 09, 2004
- 396 views
Tommy Carlier wrote: > Options for seq[seq]: > > 1. s[{a, b, c}] = s[a][b][c] -- recursive indices > 2. s[{a, b, c}] = { s[a], s[b], s[c] } -- direct indices > 3. s["abc"] = s[VALUES][ find("abc", s[KEYS]) ] -- associative list 1: Simpler than you might think: -- Get 's' from somewhere, then... params = {a, b, c} t = s for i = 1 to length(params) do t = t[params[i]] end for -- t is now s[a][b][c] 2: Not much difference in coding terms: -- Get 's' from somewhere, then... params = {a, b, c} t = repeat(0, length(params)) for i = 1 to length(params) do t[i] = s[params[i]] end for -- t is now {s[a],s[b],s[c]} 3: Pretty much speaks for itself :) Carl -- [ Carl R White == aka () = The Domain of Cyrek = ] [ Cyrek the Illogical /\ www.cyreksoft.yorks.com ]
11. Re: Possible feature for new Euphoria-version
- Posted by "Derek Parnell" <ddparnell at bigpond.com> Jan 09, 2004
- 388 views
----- Original Message ----- From: "Carl W." <euphoria at cyreksoft.yorks.com> To: <EUforum at topica.com> Subject: Re: Possible feature for new Euphoria-version > > > Tommy Carlier wrote: > > > Options for seq[seq]: > > > > 1. s[{a, b, c}] = s[a][b][c] -- recursive indices > > 2. s[{a, b, c}] = { s[a], s[b], s[c] } -- direct indices > > 3. s["abc"] = s[VALUES][ find("abc", s[KEYS]) ] -- associative list > > 1: Simpler than you might think: > > -- Get 's' from somewhere, then... > params = {a, b, c} > t = s > for i = 1 to length(params) do > t = t[params[i]] > end for > -- t is now s[a][b][c] Yes, this is almost exactly how I coded it in my support library. The hard part was putting it as a SET operation. S[{a,b,c}] = d This needs recursion I think. Well that's how I've got it coded. Here is code from my 'basic.e' library -- Returns an element from source. Index is a list of subscripts -- Example: rc = seqfetch({"abc","def"}, {2,1}) -- --> rc is 'd' -- Example: rc = seqfetch({"abc","def"}, {1,2}) -- --> rc is 'b' ---------------------------------------- global function seqfetch(object piSource, object piIndex) ---------------------------------------- -- fetch from piSource using index sequence piIndex for i=1 to length(piIndex) do if atom(piSource) then exit end if piSource = piSource[piIndex[i]] end for return piSource end function -- Returns an updated sequence. Index is a list of subscripts -- Example: rc = seqstore({"abc","def"}, {2,1}, 'q') -- --> rc is {"abc","qef"} -- Example: rc = seqstore({"abc","def"}, {1,2}, 'q') -- --> rc is {"aqc","def"} ---------------------------------------- global function seqstore(object piSource, object piIndex, object piValue) ---------------------------------------- -- store piValue in piSource using index sequence piIndex integer lLen if atom(piSource) then return piValue end if if atom(piIndex) then piSource[piIndex] = piValue else lLen = length(piIndex) if lLen > 1 then piSource[piIndex[1]] = seqstore(piSource[piIndex[1]], piIndex[2..lLen], piValue) else piSource[piIndex[1]] = piValue end if end if return piSource end function > 2: Not much difference in coding terms: > > -- Get 's' from somewhere, then... > params = {a, b, c} > t = repeat(0, length(params)) > for i = 1 to length(params) do > t[i] = s[params[i]] > end for > -- t is now {s[a],s[b],s[c]} Again my code is very similar, just more validation checking and an 'exclude/include' tweak... ---------------------------------------- global function subset(sequence piSource, sequence piIndex, integer pFlag) ---------------------------------------- -- Pickout from a sequence, all the elements identified in the Index sequence -- If Flag = true then include all the elements, otherwise exclude them. sequence lResult integer lSub integer lUsed -- If excluding elements, rejig the index sequence. if pFlag = 0 then -- Init to a null set lResult = {} -- Examine each possible element subscript for i = 1 to length(piSource) do -- If subscript not in original list, then include it. if find(i, piIndex) = 0 then lResult &= i end if end for -- Replace original list with new list. piIndex = lResult end if lResult = repeat(0, length(piIndex)) lUsed = 0 -- for each subscript in the index sequence: for i = 1 to length(piIndex) do lSub = piIndex[i] -- if the subscript in valid for the source seq, if lSub >= 1 and lSub <= length(piSource) then -- collect the element lUsed += 1 lResult[lUsed] = piSource[lSub] end if end for return lResult[1 .. lUsed] end function > 3: Pretty much speaks for itself :) Hmmmm.... My associative array library is way to big to copy into this reply. -- Derek
12. Re: Possible feature for new Euphoria-version
- Posted by "Hayden McKay" <hmck1 at dodo.com.au> Jan 09, 2004
- 403 views
What exactly do you mean? In the second example; sequence seq seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} integer a a = seq[ {2, 2} ] to me it reads, "an embeded sequence", eg 'variable a' returns {{2,2}}, where example 1, 'a' would return 'integer 5'. n.b. You can do what was done in your example by doing the following, sequence seq, b, a seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} b = [2][ 2] a = b ----- Original Message ----- From: "Tommy Carlier" <tommy.carlier at pandora.be> To: "Euphoria Mailing List" <EUforum at topica.com> Sent: Friday, January 09, 2004 5:54 AM Subject: Possible feature for new Euphoria-version > > > Sequences are really easy to use, but there is no way you can create an > index to a sub-, sub-, sub-sequence of a given sequence. Wouldn't it be > nice if such a thing existed? > > In the current version of Euphoria, you can do: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[2][2] > > My suggestion for a new feature: allow the index to be a sequence. That > way you could do something like this: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > integer a > a = seq[ {2, 2} ] > > And now for the exciting part: > sequence seq > seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} > sequence b > b = {2, 2} > integer a > a = seq[b] > > This way you can also pass and return multiple indices to and from > procedures and functions. > > -- > > Tommy Carlier > tommy online: http://users.pandora.be/tommycarlier > > > > TOPICA - Start your own email discussion group. FREE! > > > -- > Incoming mail is certified Virus Free. > Checked by AVG anti-virus system (http://www.grisoft.com). > Version: 6.0.558 / Virus Database: 350 - Release Date: 4/01/04 > --- --
13. Re: Possible feature for new Euphoria-version
- Posted by Pete Lomax <petelomax at blueyonder.co.uk> Jan 09, 2004
- 403 views
On Sat, 10 Jan 2004 02:33:53 +1100, Hayden McKay <hmck1 at dodo.com.au> wrote: >n.b. You can do what was done in your example by doing the following, > >sequence seq, b, a >seq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} Sorry to tell you this, but it gives a syntax error: >b = [2][ 2] ^ expected to see an expression, not '[' Pete
14. Re: Possible feature for new Euphoria-version
- Posted by "Mike Nelson" <MichaelANelson at worldnet.att.net> Jan 09, 2004
- 400 views
I vote for the first alternative, with this addition: seq={{1,2,3},{4,5,6},{7,8,9}} a={2,{2,3}} b=seq[a] -- b is {5,6} thus a sequence subscript would provide both single elements and slices. Thus in the general case a={w,x,y,z} seq[a] will have exactly the same effect as seq[w][x][y][z] -- Mike Nelson
15. Re: Possible feature for new Euphoria-version
- Posted by Pete Lomax <petelomax at blueyonder.co.uk> Jan 09, 2004
- 402 views
On Fri, 9 Jan 2004 12:23:43 +0000, Tommy Carlier <tommy.carlier at pandora.be> wrote: >Options for seq[seq]: > >1. s[{a, b, c}] = s[a][b][c] -- recursive indices >2. s[{a, b, c}] = { s[a], s[b], s[c] } -- direct indices >3. s["abc"] = s[VALUES][ find("abc", s[KEYS]) ] -- associative list > >I think that 2 and 3 are so easy and fast to do in Euphoria, There is (nearly) the same copy on write overhead for 2 as for 1. I do agree that anyone using (large) associative arrays and wondering why it is a tad slow ought not to give up their day job. Pete PS As I don't personally see that 1 necessarily wins over 2, and 3 would be darn handy (despite being unlikely to be specially fast if hand-coded in optimised assembly), I have to abstain on this one.
16. Re: Possible feature for new Euphoria-version
- Posted by Pete Lomax <petelomax at blueyonder.co.uk> Jan 09, 2004
- 400 views
On Fri, 9 Jan 2004 11:20:28 +0000, Matt Lewis <matthewwalkerlewis at yahoo.com> wrote: > > >> From: Robert Craig [mailto:rds at RapidEuphoria.com] >> >> There are at least three logical ways that you might define >> subscripting of a sequence with a sequence. >> >> 1. Your way (above). The sequence used as a subscript would >> contain a series of subscripts to be applied. This >> fills a logical gap in subscripting, since currently >> the number of levels of subscripting is fixed at >> compile-time. You could use this for reading and writing. >> >> 2. sequence s >> s = {100, 200, 300, 400, 500} >> s[{1,5,3}] is {100, 500, 300} >> The subscript would let you randomly select a bunch of >> elements for reading or writing. > >I think 1 and 2 could be combined in this way: > >s = {{1,2,3},{4,5,6},{7,8,9,{10,11,12}}} > >s[{2,2}] is 5 >s[{{2},{1}}] is {{4,5,6},{1,2,3}} >s[{{2},{3,{2},{3,1}}] is {{4,5,6},8,10} {3,1} would give you a subscript error on the 9, surely? > >In other words, each 1d sequence refers to an element. To get really >fancy, we could do slices, too: > >s[{2,2}..{2,3}] is {5,6} >s[{{2,1},{1,1}}..{{2,2},{1,3}}] is {{4,5},{1,2,3}} s[{{2,1}..{2,2},{1,1}..{1.3}}] ?? >s[{{2},{3,{2},{3,1}}..{{3},{3,{4},{3,2}}}] is either: > >{{{4,5,6},{8,10}},{8,9,{10,11,12}},{10,11}} >...or... >{{4,5,6},{8,10},8,9,{10,11,12},10,11} erm, pass Definitely needs sugar, of the syntactic variety that is. Perhaps {[1..2],[3..4]} which could be stored internally as {{-inf,1,2},{-inf,3,4}} to represent (a pair of) slices? Pete.
17. Re: Possible feature for new Euphoria-version
- Posted by "Lucius L. Hilley III" <L3Euphoria at bellsouth.net> Jan 09, 2004
- 410 views
Ok, My 2 cents. 1. s[{a, b, c}] = s[a][b][c] -- recursive indices 2. s[a, b, c] = { s[a], s[b], s[c] } -- direct indices Now, we extend this easily by allowing this to mean. s = { {1,2,3,}, {4,5,6}, {7 8,9} } s[{1, 2}] = 2 s[1, 2] = {{1,2,3,}, {4, 5, 6}} s[{1, 2}, {2, 3}] = {2, 6} I don't want to allow slicing as of yet. because... I see some logic problems with it. PROBLEM: s = { {1,2,3,}, {4,5,6}, {7 8,9} } 1. s[{1, 2}..{2, 3}] = {{2,3}, {5, 6}}? -- slice from the 2 to the 6. That's neither vertical nor horizontal. I guess it could be implemented as: s = { {1,2,3,}, {4,5,6}, {7 8,9} } 1. s[{1, 2}..3] = {2, 3} -- but then that will forever limit us to the current horizontal form of indexing. I would still like to see some form of vertical indexing. s[?] = {s[1][2], s[2][2], s[3][2]} Lucius L. Hilley III - Unkmar