Solved

# ultra huge array of Bits (Boolean)

Posted on 2006-11-28

i Want to create a bit array , size [1...1E6, 1...1E6] or even a little bit bigger. .-))

I used a TList Object and a Bool-Pointer

max. array size is only 1E5x1E5 . Any Hint thow o blow up my record size?

the function TBitplane.Init_BitArray should run with stepx=1E6.. and function stepy=1E6...

------------------

some trial code

------------------

type

TPointBoolZ = record

// x : Integer; { x index = 0...n, removed, changed to lin. Address }

// y : Integer; { y index = 0...m, removed, changed to lin. Address }

Z : Boolean;

end;

TPointBoolZPtr =^TPointBoolZ;

{ 2D Array of Bool to calc the area of any arbitray gemomatical layouts }

TBitPlane = Class

BitArray : TList;

constructor Create;

private

Upp : FPoint;

Low : FPoint;

deltax : Real;

deltay : Real;

stepX : Integer;

stepY : Integer;

{ Function for discrete geometric (DG) problems }

public

function Init_BitArray : Boolean;

function AddTRect(MyRect : TRect) : Boolean;

function AddTFRect(MyFRect : TFRect) : Boolean;

function AddTCircle(MyRect : TRect) : Boolean;

function AddFCircle(MyFRect : TFRect) : Boolean;

function AddTThickline(MyLine: TThickline): Boolean;

function GetTIndex (MyPoint :FPoint): TPoint;

function GetFPoint (MyPoint :TPoint): FPoint;

function VirtualPoint(I: Integer): TPoint;

function AssignSize(UpperCorner, LowerCorner : FPoint; Sx, Sy : Integer) : Boolean;

function SetBitArray (x,y : Integer; Value : Boolean) : Boolean;

function GetBitArea: real;

function GetFalseCount : Integer;

function GetBitArray(x, y: Integer): Boolean;

end;

{ Calculate from the 1D Array of Bool to 2d Array A[X;Y] }

function TBitplane.VirtualPoint(I : Integer): TPoint;

var V : TPoint;

x,y : Word;

begin

// procedure DivMod(Dividend: Integer; Divisor: Word; var Result, Remainder: Word);

DivMod(i, stepx,y,x);

V.x :=x;

V.y :=y;

result := v;

end;

function TBitplane.Init_BitArray : Boolean;

var x, y : Integer;

SinglePoint : TPointBoolZPtr;

begin

BitArray.Clear;

try

begin

for y:=0 to stepy do

for x := 0 to stepx do

begin

new(SinglePoint);

// SinglePoint^.x := x; { version 1 only }

// SinglePoint^.y := y; { version 1 only }

SinglePoint^.Z := false;

BitArray.Add(SinglePoint);

end;

result := true;

end;

except

result := false;

end;

end;