Recent

Author Topic: Large or huge sets  (Read 7815 times)

marcov

  • Administrator
  • Hero Member
  • *
  • Posts: 10399
  • FPC developer.
Re: Large or huge sets
« Reply #30 on: May 02, 2020, 10:37:23 pm »
Very nice. So my mistakes are

-  typecasting to integer works, but ord() not.
 - And the class operators need visibility modifiers?
-  management operators for initialization
- using ord in declaration works.

Any other obvious things I missed?

howardpc

  • Hero Member
  • *****
  • Posts: 4048
Re: Large or huge sets
« Reply #31 on: May 03, 2020, 11:16:15 am »
@avk
I think your implementation of >< requires xor, not and.

avk

  • Hero Member
  • *****
  • Posts: 651
    • my self-education project
Re: Large or huge sets
« Reply #32 on: May 03, 2020, 11:43:19 am »
@howardpc, yes, thank you, it's a typo, I fixed the code.

Very nice. So my mistakes are

-  typecasting to integer works, but ord() not.
 - And the class operators need visibility modifiers?
-  management operators for initialization
- using ord in declaration works.

Any other obvious things I missed?

It's mostly Ord(). The rest is successfully compiled using FPC 3.2, at least this way:
Code: Pascal  [Select][+][-]
  1. program bigvalueset;
  2. // test to make value type sets.
  3.  
  4. {$define useFPCsyntax}                     // to test in objfpc mode in case there are differences, and because we invoke ord() on enums.
  5. {$define testoperatoroverloading}          // try operator overloading
  6.  
  7. {$ifdef useFPCsyntax}
  8. {$Mode objfpc}
  9. {$else}
  10. {$Mode delphi}
  11. {$endif}
  12. {$modeswitch advancedrecords}
  13. type
  14.     {$ifdef useFPCsyntax}generic {$endif}
  15.      TBigValueSet<T> =  record
  16.                            Type
  17.                             TMySet =  {$ifdef useFPCsyntax}specialize {$endif} TBigValueSet<T>;
  18.                            var
  19.                            data : array[0.. ord(high(T)) div 32] of cardinal;
  20.  
  21.                            procedure xinclude (element:T); inline;
  22.                            procedure xexclude (element:T); inline;
  23.                            function test(element:T) : boolean; inline;
  24.                            {$ifdef testoperatoroverloading}
  25.                            class operator in (A: T; const B: TMySet): boolean;
  26.                            {$endif}
  27.                         end;
  28.  
  29. Type
  30.     TDWordSet = set of 0..31;
  31.     pdwordset = ^TDwordSet;
  32.  
  33.  
  34.  
  35. {$ifdef testoperatoroverloading}
  36. class operator TBigValueSet{$ifndef useFPCsyntax} <T>{$endif}.in (A: T; const B: TMySet): boolean;
  37. begin
  38.   Result := B.test(A);
  39. end;
  40. {$endif}
  41.  
  42. procedure TBigValueSet{$ifndef useFPCsyntax} <T>{$endif}.xinclude(element:T);
  43. begin
  44.   system.include (pdwordset(@data[Integer(element) div 32])^,cardinal(Integer(element) and 31));
  45. end;
  46.  
  47. procedure TBigValueSet{$ifndef useFPCsyntax}<T>{$endif}.xexclude (element:T);
  48. begin
  49.  system.exclude (pdwordset(@data[Integer(element) div 32])^,cardinal(Integer(element) and 31));
  50. end;
  51.  
  52. function TBigValueSet{$ifndef useFPCsyntax}<T>{$endif}.test (element:T):boolean;
  53. begin
  54.   result:=cardinal(Integer(element) and 31) in pdwordset(@data[Integer(element) div 32])^;
  55. end;
  56.  
  57. begin
  58. end.  
  59.  

As for Ord(), it looks like a compiler bug, but I don't have full confidence.

marcov

  • Administrator
  • Hero Member
  • *
  • Posts: 10399
  • FPC developer.
Re: Large or huge sets
« Reply #33 on: May 03, 2020, 04:26:16 pm »
As for Ord(), it looks like a compiler bug, but I don't have full confidence.

It might be that every built-in has to be explicitly fixed for such usage.

PascalDragon

  • Hero Member
  • *****
  • Posts: 4761
  • Compiler Developer
Re: Large or huge sets
« Reply #34 on: May 03, 2020, 05:09:24 pm »
As for Ord(), it looks like a compiler bug, but I don't have full confidence.

It might be that every built-in has to be explicitly fixed for such usage.

Correct. I have done that in revision 45232 now.

Mogens Lundholm

  • New Member
  • *
  • Posts: 23
Re: Large or huge sets
« Reply #35 on: May 04, 2020, 09:49:09 am »
Large or huge sets are often requested.

Waiting for the final solution, I made a TBigSet with 1024 elements. Made even a little test program. A few lines from the test program:
Code: Pascal  [Select][+][-]
  1. s1:=[1,3,5,7,9];
  2. s2:=[1,4,5,7,9,11];
  3.  
  4.   s3:=s1><s2;
  5.  
  6.   s:=BigSetToStr(s3);
  7.   if s<>'[3,4,11]' then
  8.     begin
  9.     writeln('Error test 3:',s,'- Should be [3,4,11]');
  10.     readln;
  11.     end;              
  12.  

The most strange thing: TBigset runs much faster than the built-in 256-set in a performance test (union of two sets 10000000 times) Can this be true?

« Last Edit: May 04, 2020, 04:55:54 pm by Mogens Lundholm »

strmckr

  • New member
  • *
  • Posts: 6
Re: Large or huge sets
« Reply #36 on: September 07, 2022, 10:24:55 am »
Sorry for the necro post but there really isn't much discussion on large sets one of my projects needs to be able to reach a range of 1 -> 46,666 sets. 

function Equals(constref ALeft, ARight: T): Boolean;

i believe this function is missing coding for the hashtable variation Thaddy has posted
  operator =  and <>

both cannot be overloaded directly producing errors sitting the above as inherently defined yet its missing the ability to produce results

a work around was to build a function  that did >< then checked for values   to replicate the comparison function of  =, <>

when testing my code below for with identical sets it yields no results same with
  (w2 = w1 )  or (w2 <> w1)   both compile but have no result.

the version below seems to fix the problem posted by PascalDragon
 that
   W3: = w1 + w2   would modify w2  every time its called.
         {fixed by cloning the first value then merging with the new}

same problem seem to happen with ><,+,- operators. {at least on testing} similar fix applied..   

I'm a hobbyist: if this code is "bloated"  point out how to make it better 
   not bad for a 10 min fix :P
 
Code: Pascal  [Select][+][-]
  1.  {$mode objfpc}{$inline on}
  2.  
  3.     { A simple way to implement large or huge sets.
  4.      (c) 2019 Thaddy de Koning. No license and not
  5.      re-licensable: free for all to use.
  6.      Copyright holds:
  7.      You can not claim license nor copyrigths
  8.          }
  9.          {* added by strmck 2022}
  10.     unit largesets;
  11.     { Operator      Action
  12.       ---------------------------------------------
  13.       +             Union
  14.       -             Difference
  15.       *             Intersection
  16.       ><        Symmetric difference
  17.       <=        Contains
  18.           >=        Left hand side set is a superset of the one on the right *
  19.        =             equality:  use function  equality( which does (><) and evaultes if its empty)*
  20.        <>        inequality:  use function inequality( which does (><) and evaulates if its not empty)*
  21.       include2   Include an element in the set
  22.       exclude2   Exclude an element from the set
  23.       in         Check if an single element is in a set
  24.    
  25.    notes: Twordset can be modifed for Tdwordset/Tqwordset
  26.    include & exclude renamed to allow for inherinted function include/exclude to function normally
  27.    }
  28.     interface
  29.     uses
  30.       generics.collections;
  31.      
  32.     type
  33.       TWordSet  = specialize TSortedHashSet<word >;
  34.            
  35.       { union }
  36.       operator + (const a,b:TWordset):TWordSet;  
  37.      
  38.       { difference }
  39.       operator - (const a,b:Twordset ):TWordSet;  
  40.      
  41.       { intersection }
  42.       operator * (const a,b:TwordSet ):TWordSet;  
  43.      
  44.       { symmetric difference }
  45.       operator >< (const a,b:TWordSet ):TWordSet;
  46.    
  47.       { contains }
  48.       operator <= (const a,b:TWordSet ):Boolean;
  49.  
  50.         { Left hand side set is a superset of the one on the right }
  51.       operator >= (const a,b:TWordSet ):Boolean;  
  52.                  
  53.       { in }
  54.       operator in (const a:word; const b:TWordset ):Boolean;  
  55.      
  56.       { include }
  57.       procedure include2(const a:TWordSet; const b:Word);  
  58.      
  59.       { exclude }
  60.       procedure exclude2(const a:TWordSet;const  b:Word);    
  61.      
  62.          function Equality(const A,B:TWordSet):Boolean;
  63.          function inEquality(const A,B:TWordSet):Boolean;
  64.          
  65.     implementation
  66.  Var
  67.   D: TwordSet;
  68.  
  69.       { union }
  70.       operator + (const a,b:Twordset):TWordSet;
  71.       begin
  72.           d.Free;
  73.           D := TWordSet.Create;
  74.             D.unionWith(A);
  75.                 D.unionWith(B);      
  76.         Result := D;           
  77.       end;      
  78.          
  79.       { difference }
  80.       operator -(const a,b:Twordset):TWordSet;
  81.       begin
  82.            d.Free;
  83.             D := TWordSet.Create;
  84.             D.unionWith(A);
  85.                 D.ExceptWith(B);        
  86.         result:=D;
  87.       end;    
  88.          
  89.       { intersection }
  90.       operator *(const a,b:TwordSet):TWordSet;
  91.       begin
  92.           d.Free;
  93.           D := TWordSet.Create;
  94.           D.unionWith(a);
  95.           D.IntersectWith(b);      
  96.         Result := D;
  97.       end;        
  98.      
  99.       { symmetric difference }
  100.       operator ><(const a,b:TWordSet):TWordSet;
  101.       begin
  102.           d.Free;
  103.           D := TWordSet.Create;
  104.           D.unionWith(a);
  105.           D.SymmetricExceptWith(b);      
  106.         Result := D;
  107.       end;        
  108.      
  109.       { contains }
  110.       operator <=(const a,b:TWordSet):Boolean;
  111.       var
  112.         c:word;
  113.       begin
  114.         Result := true;
  115.         for c in a do
  116.         if not b.contains(c) then
  117.         begin
  118.           Result := False;
  119.           break;
  120.         end;
  121.       end;    
  122.          
  123.       { Left hand side set is a superset of the one on the right }
  124.       operator >=(const a,b:TWordSet):Boolean;
  125.       var
  126.         c:word;
  127.       begin
  128.         Result := true;
  129.         for c in b do
  130.         if not a.contains(c) then
  131.         begin
  132.           Result := False;
  133.           break;
  134.         end;
  135.       end;     
  136.  
  137.          
  138.  {equality} { first checks if either set has diffrent values}
  139.  Function Equality(const A, B: TWordSet): Boolean;
  140. var
  141.   c:word;
  142. begin
  143. d.Free;
  144. Result := true;
  145. D := TWordSet.Create;
  146. D.unionWith(a);
  147. D.SymmetricExceptWith(b);              
  148.   for c in D do
  149.      begin  
  150.     result:= False;
  151.       break;   
  152.         end;    
  153. end;
  154.  
  155.  Function inEquality(const A, B: TWordSet): Boolean;
  156. var
  157.   c:word;
  158. begin
  159. d.Free;
  160. Result := false;
  161. D := TWordSet.Create;
  162. D.unionWith(a);
  163. D.SymmetricExceptWith(b);            
  164.   for c in D do
  165.      begin  
  166.     result:= True;
  167.       break;   
  168.         end;    
  169. end;   
  170.        
  171.       { in }
  172.       operator in (const a:word;const b:TWordset):Boolean;
  173.       begin
  174.         Result := b.Contains(a);
  175.       end;
  176.      
  177.       { include }
  178.       procedure include2(const a:TWordSet;const b:Word);
  179.       begin
  180.         a.Add(b);
  181.       end;    
  182.          
  183.       { exclude }
  184.       procedure exclude2(const a:TWordSet;const b:Word);
  185.       begin
  186.         a.Remove(b);
  187.       end;    
  188.      
  189.   {counting function}    
  190. function GetCount(const aSet: TWordSet): SizeInt;
  191.   begin
  192.     Exit(aSet.Count);  
  193.     end;
  194.        
  195. end.

Test program
Code: Pascal  [Select][+][-]
  1.     program tsets;
  2.     // {$include largesets.pas}// attempt to fix sets above 256 size limit.
  3.  
  4.       uses crt,windows,Largesets;
  5.     var
  6.       w1,w2,w3: TWordSet;        
  7.           n:word;
  8.                   ch:char;
  9.     begin
  10.         Clrscr;
  11.  
  12.       gotoxy(2,1);
  13. w1 := TWordSet.Create;
  14. w2 := TWordSet.Create;
  15.  
  16.          for n in [1..2] do
  17.           include2(w1,n);
  18.          for n in [3..5] do
  19.           include2(w2,n);
  20.  
  21. W3:=w1+w2; // equals [1,2,3,4,5]
  22.    write('w3:');
  23.      for n in w3 do write(' ',n);
  24.         {  write(' w1:');   for n in w1 do write(n);
  25.           write(' w2:');   for n in w2 do write(n); }
  26.  
  27. w1.Free;
  28. w2.Free;
  29.  
  30. gotoxy(2,2);
  31. w1 := TWordSet.Create;
  32. w2 := TWordSet.Create;
  33.          for n in [1..3] do
  34.           include2(w1,n);
  35.          for n in [3] do
  36.           include2(w2,n);
  37.  
  38.    W3:=w1-w2;     // equals [1,2]
  39.     write('w3:');
  40.      for n in w3 do write(n);
  41.         {  write(' w1:');   for n in w1 do write(n);
  42.           write(' w2:');   for n in w2 do write(n);}
  43. w1.Free;
  44. w2.Free;
  45.  
  46. gotoxy(2,3);
  47.  
  48. w1 := TWordSet.Create;
  49. w2 := TWordSet.Create;
  50.          for n in [2..5] do
  51.           include2(w1,n);
  52.          for n in [1..3,5..6] do
  53.           include2(w2,n);
  54.  
  55.    W3:=w2-w1;     // equals [1,6]
  56.    write('w3:');
  57.      for n in w3 do write(n);
  58.          { write(' w1:');   for n in w1 do write(n);
  59.           write(' w2:');   for n in w2 do write(n);}
  60.          
  61. w1.Free;
  62. w2.Free;
  63. gotoxy(2,4);
  64. w1 := TWordSet.Create;
  65. w2 := TWordSet.Create;
  66.          for n in [1..3] do
  67.           include2(w1,n);
  68.          for n in [3,4,6] do
  69.           include2(w2,n);
  70.  
  71.    W3:=w1*w2; // equals [3]
  72.     write('w3:');
  73.      for n in w3 do write(n);
  74.          { write(' w1:');   for n in w1 do write(n);
  75.           write(' w2:');   for n in w2 do write(n);}
  76.  
  77. gotoxy(2,5);
  78. w1.Free;
  79. w2.Free;
  80. w1 := TWordSet.Create;
  81. w2 := TWordSet.Create;
  82.          for n in [1..3] do
  83.           include2(w1,n);
  84.          for n in [3,4,6] do
  85.           include2(w2,n);
  86.  
  87.    W3:=w1 >< w2; // equals [1,2,4,6]
  88.    write('w3:');
  89.      for n in w3 do write(n);
  90.          { write(' w1:');   for n in w1 do write(n);
  91.           write(' w2:');   for n in w2 do write(n);}
  92.  
  93.  gotoxy(2,6);
  94.  w1.Free;
  95.  w2.Free;
  96. w1 := TWordSet.Create;
  97. w2 := TWordSet.Create;
  98.          for n in [1..7] do
  99.           include2(w1,n);
  100.          for n in [1,2] do
  101.           include2(w2,n);
  102.     if (w2<=w1) then write('must work on 1 and 2');
  103.  
  104.  
  105.  gotoxy(2,7);
  106.  w1.Free;
  107.  w2.Free;
  108.   w1 := TWordSet.Create;
  109.   w2 := TWordSet.Create;
  110.          for n in [9] do
  111.           include2(w1,n);
  112.          for n in [8,9] do
  113.           include2(w2,n);
  114.         if (w2>=w1) then write('can rest on 9');
  115.  
  116. gotoxy(2,7);
  117. w1.Free;
  118. w2.Free;
  119.  w1:= TWordSet.Create;
  120.  w2 := TWordSet.Create;
  121.          for n in [1..4] do
  122.           include2(w1,n);
  123.          for n in [1..4] do
  124.           include2(w2,n);
  125.       if Equality(w1,w2) then write(' 1..4 in both sets');
  126.  
  127.  
  128. gotoxy(2,8);
  129. w1.Free;
  130. w2.Free;
  131.  w1:= TWordSet.Create;
  132.  w2 := TWordSet.Create;
  133.          for n in [1..3] do
  134.           include2(w1,n);
  135.          for n in [1..4] do
  136.           include2(w2,n);
  137.       if inEquality(w1,w2) then write(' 4 not in both sets');
  138.  
  139.          writeln(' press esc to exit');
  140.          ch:=readkey;
  141.         if (ch=#27) then exit;
  142.  
  143.     end.


« Last Edit: September 08, 2022, 08:08:13 am by strmckr »

jamie

  • Hero Member
  • *****
  • Posts: 4931
Re: Large or huge sets
« Reply #37 on: September 07, 2022, 06:44:14 pm »
Did you do a leakage test on that code?

I see many Creates with no free's and some maybe not needed.

Many that Class is just what it is, all CLASS>
The only true wisdom is knowing you know nothing

strmckr

  • New member
  • *
  • Posts: 6
Re: Large or huge sets
« Reply #38 on: September 08, 2022, 08:42:27 am »
updated: 
   less memory tied up in newer code.

i will note that freeing D at the end of any of the operator function has a nasty effect of pointing nothing.
  so it cannot be freed until the next call is made.


Arioch

  • Sr. Member
  • ****
  • Posts: 414
Re: Large or huge sets
« Reply #39 on: September 12, 2022, 06:12:52 pm »
I would think that doing all those operators on class is futile endevour, there would be really lots of memory micro-management.

Would i need it - i'd perhaps just stick with TBits - https://www.freepascal.org/docs-html/rtl/classes/tbits.html
Yes, it would need extension with LessOrEqual AKA Subset comparisons.

But more verbose code would not feel that bad to me.

If you, however, want to do expressions, then you IMHO better stick with advanced records instead.

Some problem is that only recent Delphi versions (10.4+) added true constructors and destructors to the records - https://docwiki.embarcadero.com/RADStudio/Sydney/en/Custom_Managed_Records
And FPC did not yet - https://www.freepascal.org/docs-html/ref/refse63.html

So, unless FPC can do operators over interfaces, not classes, i think the only reliable way of coding would be

1. Making interface-based wrapper over storage class, be it TBits, Delphi 2 old TBitSet ot FPC's TSortedHashlist. For the sake of ARC compiler magic - it needs to get converted to interfaces.

2. Making advanced record on top of that interface, like that

Code: Pascal  [Select][+][-]
  1.  type
  2.       TCustomWordSet  = specialize TSortedHashSet<word >;
  3.       iWordSet = interface .... end; // repeating all the needed functions of TWordSet;  
  4.       TWordSet  = class (TCustomWordSet, iWordSet) end;  
  5.  
  6. // in Delphi this would require TWordSet implement three basis methods of IUnknown. In FPC i heard IUnknown is optional not mandatory.
  7. // anyway, ARC mechanic, if not given by FPC for granted, would need to be implemented
  8.            
  9.      RWordSet = record
  10.         private
  11.            DataStorage: iWordSet;
  12.            function GetDataStorage: iWordSet; inline;
  13.            ....
  14.         public
  15.            property Bits: iWordSet read GetDataStorage;
  16.            property Bit[const index: integer]: boolean read GetBit write SetBit; default;
  17.        
  18.            operator + (const a,b:RWordset):RWordSet;  
  19.            ....
  20.      end;
  21.  
  22. function RWordSet.GetDataStorage: iWordSet;
  23. begin
  24.    if nil = DataStorage then
  25.       DataStorage := TWordSet.Create;
  26.   Result := DataStorage;
  27. end;
  28.  
  29. operator RWordSet.+(const a,b:RWordset):RWordSet;  
  30. begin
  31.     Result.Bits.UnionWith(a);
  32.     Result.Bits.UnionWith(b);
  33. end;
  34.  

But i expect this to be rather slow unless FPC would implement "compound assignment" like C's +=, /= and other.
In other terms, binary commands rather than ternary.

some hypothetical code
Code: Pascal  [Select][+][-]
  1.  setA := setA + setB;

would then posibly get optimized to a hypothetical

Code: Pascal  [Select][+][-]
  1. operator RWordSet.:+(const b:RWordset):RWordSet;
  2. begin
  3.    Resut := Self;
  4.    Self.Bits.UnionWith(b.Bits);
  5. end;
  6.  

or another hypothetical operator
Code: Pascal  [Select][+][-]
  1. operator RWordSet.AddAndDestroy(const b:RWordset):RWordSet;
  2. begin
  3.    if (b.DataStorage = nil) and (Self.DataStorage = nil) then exit;
  4.  
  5.    Resut.DataStorage := Self.DataStorage;
  6.    Self.DataStorage := nil;
  7.  
  8.    if b.DataStorage <> nil then
  9.       Result.Bits.UnionWith(b.DataStorage);
  10. end;
  11.  


But i would not hold my breath for FPC to ether have such complexity.
« Last Edit: September 12, 2022, 06:18:05 pm by Arioch »

PascalDragon

  • Hero Member
  • *****
  • Posts: 4761
  • Compiler Developer
Re: Large or huge sets
« Reply #40 on: September 13, 2022, 09:22:59 am »
Some problem is that only recent Delphi versions (10.4+) added true constructors and destructors to the records - https://docwiki.embarcadero.com/RADStudio/Sydney/en/Custom_Managed_Records
And FPC did not yet - https://www.freepascal.org/docs-html/ref/refse63.html

FPC supports management operators since 3.2.0. We just added them before Delphi did, thus they are not compatible in the way they are declared.

Arioch

  • Sr. Member
  • ****
  • Posts: 414
Re: Large or huge sets
« Reply #41 on: September 13, 2022, 09:31:08 pm »
Then it should be made part of documentation. Curently i did not find it in online docs.

If they work then interface-based work-aronund is not requied, of course.

But then, can FPC have operators on interface types?

Delphi actually did a bad job there. The class operators were probably borrowed for C# with its GC objects. That should had been translated to interfaces, not classes in Object Pascal.
Same goes with TEncoding - they apy belong to intefaces, not classes.
I wish FPC could fix Delphi mistakes :-)


---------

Frankly, online docs on operators is truly patchy...
I tried to find management there, but failed.

The table of operators does not link to specific declarations and descriptions.
The chapter with descriptions doe not have table of "all existing operators"...

What is "><" ? It is "symmetric difference".
Oookay.... what does it mean? Well, i can try to guess, but i want to read in authorized docs, if i guessed right or wrong!
Also, how should i then use such an operator from the app code? Crickets.

Inc operator - how is it different from Inc procedure? both mentioned, differene not spelled out. It was sounding like explicitteasing, actually.

Enumeration operator... Can i have > 1 enumerators, for different data types in for-in loops? The type parameter suggests so, but it was not spelled out and no examples given.

enumerating mulkti-dimansinal array - the end elementtype can be enumerated, de facto flattening the array. Great feature! But would i wont only enumerae 1st dimension -  can i? or not? Crickets...

PascalDragon

  • Hero Member
  • *****
  • Posts: 4761
  • Compiler Developer
Re: Large or huge sets
« Reply #42 on: September 14, 2022, 09:28:19 am »
Then it should be made part of documentation. Curently i did not find it in online docs.

No one found the time to document them. You may want to report a bug to get them documented.

But then, can FPC have operators on interface types?

You can have global operators that operate on interface types just like you can for class types. However they won't be picked up for specializations.

Frankly, online docs on operators is truly patchy...
I tried to find management there, but failed.

The table of operators does not link to specific declarations and descriptions.
The chapter with descriptions doe not have table of "all existing operators"...

What is "><" ? It is "symmetric difference".
Oookay.... what does it mean? Well, i can try to guess, but i want to read in authorized docs, if i guessed right or wrong!
Also, how should i then use such an operator from the app code? Crickets.

Inc operator - how is it different from Inc procedure? both mentioned, differene not spelled out. It was sounding like explicitteasing, actually.

Enumeration operator... Can i have > 1 enumerators, for different data types in for-in loops? The type parameter suggests so, but it was not spelled out and no examples given.

enumerating mulkti-dimansinal array - the end elementtype can be enumerated, de facto flattening the array. Great feature! But would i wont only enumerae 1st dimension -  can i? or not? Crickets...

Then file bugs for the problems you found.

BrunoK

  • Sr. Member
  • ****
  • Posts: 364
  • Retired programmer
Re: Large or huge sets
« Reply #43 on: September 14, 2022, 10:23:32 am »
...
What is "><" ? It is "symmetric difference".
Oookay.... what does it mean? Well, i can try to guess, but i want to read in authorized docs, if i guessed right or wrong!
...
Copy paste Symmetric difference to your browser and presto, you have the reply in ~10 seconds.

Arioch

  • Sr. Member
  • ****
  • Posts: 414
Re: Large or huge sets
« Reply #44 on: September 14, 2022, 08:50:02 pm »
Copy paste Symmetric difference to your browser and presto, you have the reply in ~10 seconds.

It would be that very guesswork that i said is not enough.

Google does not describe this concept as applied to specific FPC types, does not give authoritative (meaning, FPC would be obliged to support it) FPC code examples.

 

TinyPortal © 2005-2018