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;