unit UVector;
//
//デフォルトの配列プロパティ
//
interface

uses
  SysUtils;

const
  MaxIntegerArrayIndex = (MAXINT div sizeof(integer))-1;
  MaxSingleArrayIndex = (MAXINT div sizeof(single))-1;
  MaxDoubleArrayIndex = (MAXINT div sizeof(double))-1;
  MaxBooleanArrayIndex = (MAXINT div sizeof(boolean))-1;

type
  TIntegerArray = array [0..MaxIntegerArrayIndex] of integer;
  PIntegerArray = ^TIntegerArray;
  TSingleArray  = array [0..MaxSingleArrayIndex] of single;
  PSingleArray  = ^TSingleArray;
  TDoubleArray  = array [0..MaxDoubleArrayIndex] of double;
  PDoubleArray  = ^TDoubleArray;
  TBooleanArray = array [0..MaxBooleanArrayIndex] of boolean;
  PBooleanArray = ^TBooleanArray;

type
  TVector2 = class
  private
    FSize     : array [0..1] of integer;
    function    getSize(i: integer) : integer; virtual; abstract;
  public
    constructor Create;
    constructor Allocate(i, j: integer); virtual; abstract;
    procedure   Reallocate(ACol, ARow: integer); virtual; abstract;
    property    Size[i: integer] : integer read getSize;
    property    Col : integer index 0 read getsize;
    property    Row : integer index 1 read getsize;
  end;
  TVector2I = class(TVector2)
  private
    FItems    : PIntegerArray;
    function    getItems(i, j: integer) : integer;
    procedure   setItems(i, j: integer; v: integer);
    function    getSize(i: integer) : integer; override;
  public
    constructor Allocate(i, j: integer); override;
    procedure   Free;
    procedure   Assign(t: TVector2I);
    procedure   Reallocate(ACol, ARow: integer); override;
    property    Items[i, j: integer] : integer read getItems write setItems; default;
  end;
  TVector2S = class(TVector2)
  private
    FItems    : PSingleArray;
    function    getItems(i, j: integer) : single;
    procedure   setItems(i, j: integer; v: single);
    function    getSize(i: integer) : integer; override;
  public
    constructor Allocate(i, j: integer); override;
    procedure   Free;
    procedure   Assign(t: TVector2S);
    procedure   Reallocate(ACol, ARow: integer); override;
    property    Items[i, j: integer] : single read getItems write setItems; default;
  end;
  TVector2D = class(TVector2)
  private
    FItems    : PDoubleArray;
    function    getItems(i, j: integer) : double;
    procedure   setItems(i, j: integer; v: double);
    function    getSize(i: integer) : integer; override;
  public
    constructor Allocate(i, j: integer); override;
    procedure   Free;
    procedure   Assign(t: TVector2D);
    procedure   Reallocate(ACol, ARow: integer); override;
    property    Items[i, j: integer] : double read getItems write setItems; default;
  end;
  TVector2B = class(TVector2)
  private
    FItems    : PBooleanArray;
    function    getItems(i, j: integer) : boolean;
    procedure   setItems(i, j: integer; v: boolean);
    function    getSize(i: integer) : integer; override;
  public
    constructor Allocate(i, j: integer); override;
    procedure   Free;
    procedure   Assign(t: TVector2B);
    procedure   Reallocate(ACol, ARow: integer); override;
    property    Items[i, j: integer] : boolean read getItems write setItems; default;
  end;

implementation

////////////////////////////////////////////////////////////////

constructor TVector2.create;
begin
  inherited create;
  FSize[0] := 0;
  FSize[1] := 0;
end;

////////////////////////////////////////////////////////////////

constructor TVector2I.Allocate(i, j : integer);
begin
  inherited create;
  FSize[0] := i;
  FSize[1] := j;
  FItems := AllocMem(sizeof(integer)*i*j);
end;

procedure   TVector2I.Free;
begin
  FreeMem(FItems);
  inherited Free;
end;

procedure   TVector2I.Assign(t: TVector2I);
var
  i, j : integer;
begin
  if FSize[0] * FSize[1] <> 0 then
    FreeMem(FItems, sizeof(integer)*FSize[0]*FSize[1]);
  FSize[0] := t.Size[0];
  FSize[1] := t.Size[1];

  FItems := AllocMem(sizeof(integer)*FSize[0]*FSize[1]);
  for i:=0 to FSize[0]-1 do
    for j:=0 to FSize[1]-1 do
      Items[i, j] := t[i, j];
end;

function    TVector2I.getItems(i, j: integer) : integer;
begin
  result := FItems^[i*FSize[1]+j];
end;

procedure   TVector2I.setItems(i, j: integer; v: integer);
begin
  FItems^[i*FSize[1]+j] := v;
end;

function    TVector2I.getSize(i: integer) : integer;
begin
  result := FSize[i];
end;

procedure   TVector2I.Reallocate(ACol, ARow: integer);
var
  i, j : integer;
  ColMin, RowMin : integer;
  V : TVector2I;
begin
  ColMin := Col;
  if ColMin > ACol then
    ColMin := ACol;
  RowMin := Row;
  if RowMin > ARow then
    RowMin := ARow;
  V := TVector2I.Allocate(ACol, ARow);
  for i:=0 to ColMin-1 do
    for j:=0 to RowMin-1 do
      V[i, j] := Items[i, j];
  Assign(V);
  V.Free;
end;

////////////////////////////////////////////////////////////////

constructor TVector2S.Allocate(i, j : integer);
begin
  inherited create;
  FSize[0] := i;
  FSize[1] := j;
  FItems := AllocMem(sizeof(double)*i*j);
end;

procedure   TVector2S.Free;
begin
  FreeMem(FItems);
  inherited Free;
end;

procedure   TVector2S.Assign(t: TVector2S);
var
  i, j : integer;
begin
  if FSize[0] * FSize[1] <> 0 then
    FreeMem(FItems, sizeof(double)*FSize[0]*FSize[1]);
  FSize[0] := t.Size[0];
  FSize[1] := t.Size[1];

  FItems := AllocMem(sizeof(double)*FSize[0]*FSize[1]);
  for i:=0 to FSize[0]-1 do
    for j:=0 to FSize[1]-1 do
      Items[i, j] := t[i, j];
end;

function    TVector2S.getItems(i, j: integer) : single;
begin
  result := FItems^[i*FSize[1]+j];
end;

procedure   TVector2S.setItems(i, j: integer; v: single);
begin
  FItems^[i*FSize[1]+j] := v;
end;

function    TVector2S.getSize(i: integer) : integer;
begin
  result := FSize[i];
end;

procedure   TVector2S.Reallocate(ACol, ARow: integer);
var
  i, j : integer;
  ColMin, RowMin : integer;
  V : TVector2S;
begin
  ColMin := Col;
  if ColMin > ACol then
    ColMin := ACol;
  RowMin := Row;
  if RowMin > ARow then
    RowMin := ARow;
  V := TVector2S.Allocate(ACol, ARow);
  for i:=0 to ColMin-1 do
    for j:=0 to RowMin-1 do
      V[i, j] := Items[i, j];
  Assign(V);
  V.Free;
end;

////////////////////////////////////////////////////////////////

constructor TVector2D.Allocate(i, j : integer);
begin
  inherited create;
  FSize[0] := i;
  FSize[1] := j;
  FItems := AllocMem(sizeof(double)*i*j);
end;

procedure   TVector2D.Free;
begin
  FreeMem(FItems);
  inherited Free;
end;

procedure   TVector2D.Assign(t: TVector2D);
var
  i, j : integer;
begin
  if FSize[0] * FSize[1] <> 0 then
    FreeMem(FItems, sizeof(double)*FSize[0]*FSize[1]);
  FSize[0] := t.Size[0];
  FSize[1] := t.Size[1];

  FItems := AllocMem(sizeof(double)*FSize[0]*FSize[1]);
  for i:=0 to FSize[0]-1 do
    for j:=0 to FSize[1]-1 do
      Items[i, j] := t[i, j];
end;

function    TVector2D.getItems(i, j: integer) : double;
begin
  result := FItems^[i*FSize[1]+j];
end;

procedure   TVector2D.setItems(i, j: integer; v: double);
begin
  FItems^[i*FSize[1]+j] := v;
end;

function    TVector2D.getSize(i: integer) : integer;
begin
  result := FSize[i];
end;

procedure   TVector2D.Reallocate(ACol, ARow: integer);
var
  i, j : integer;
  ColMin, RowMin : integer;
  V : TVector2D;
begin
  ColMin := Col;
  if ColMin > ACol then
    ColMin := ACol;
  RowMin := Row;
  if RowMin > ARow then
    RowMin := ARow;
  V := TVector2D.Allocate(ACol, ARow);
  for i:=0 to ColMin-1 do
    for j:=0 to RowMin-1 do
      V[i, j] := Items[i, j];
  Assign(V);
  V.Free;
end;

////////////////////////////////////////////////////////////////

constructor TVector2B.Allocate(i, j : integer);
begin
  inherited create;
  FSize[0] := i;
  FSize[1] := j;
  FItems := AllocMem(sizeof(boolean)*i*j);
end;

procedure   TVector2B.Free;
begin
  FreeMem(FItems);
  inherited Free;
end;

procedure   TVector2B.Assign(t: TVector2B);
var
  i, j : integer;
begin
  if FSize[0] * FSize[1] <> 0 then
    FreeMem(FItems, sizeof(boolean)*FSize[0]*FSize[1]);
  FSize[0] := t.Size[0];
  FSize[1] := t.Size[1];

  FItems := AllocMem(sizeof(boolean)*FSize[0]*FSize[1]);
  for i:=0 to FSize[0]-1 do
    for j:=0 to FSize[1]-1 do
      Items[i, j] := t[i, j];
end;

function    TVector2B.getItems(i, j: integer) : boolean;
begin
  result := FItems^[i*FSize[1]+j];
end;

procedure   TVector2B.setItems(i, j: integer; v: boolean);
begin
  FItems^[i*FSize[1]+j] := v;
end;

function    TVector2B.getSize(i: integer) : integer;
begin
  result := FSize[i];
end;

procedure   TVector2B.Reallocate(ACol, ARow: integer);
var
  i, j : integer;
  ColMin, RowMin : integer;
  V : TVector2B;
begin
  ColMin := Col;
  if ColMin > ACol then
    ColMin := ACol;
  RowMin := Row;
  if RowMin > ARow then
    RowMin := ARow;
  V := TVector2B.Allocate(ACol, ARow);
  for i:=0 to ColMin-1 do
    for j:=0 to RowMin-1 do
      V[i, j] := Items[i, j];
  Assign(V);
  V.Free;
end;

end.