How to Create an Array of 2,000,000 doubles in Delphi 1: Delphi1LargeArray.ZIP

Also, see example below in "Open Array; Slice Function."

I don't particularly like Borland's solution, How can I resize an array?, (sorry Joe) since it requires turning off all range checking:  FAQ 1830D

Also look at Borland's Tech Info Report, Dynamically Allocating Arrays:
TI 1093D

Dr. Dobb's Journal on huge arrays in Turbo Pascal: ftp://garbo.uwasa.fi/pc/turbopas/ddj8803.zip

Dr. Dobb's Journal on virtual arrays in Turbo Pascal: ftp://garbo.uwasa.fi/pc/turbopas/ddj8810.zip

   How to create a Bitmap from numeric data? (D5)
Shows how to read a TXT file into a TStringList.  Parses each line in TStringList and forms a dynamic matrix of real values to be displayed in a bitmap.

// Delphi 3 Example of 2-Dimensional Dynamic Array
CONST
ArrayMaxCount = 65536;

TYPE
pDoubleArray = ^TDoubleArray;
TDoubleArray = ARRAY[0..ArrayMaxCount-1] OF DOUBLE;
pMatrix = ^TMatrix;
TMatrix = ARRAY[0..ArrayMaxCount-1] OF pDoubleArray;

procedure TForm1.Button1Click(Sender: TObject);
  CONST
    iCountMax = 500; // columns
    jCountMax = 1000; // rows
  VAR
    i : 0..iCountMax-1;
    j : 0..jCountMax-1;
    k : INTEGER;

    // Let's make Matrix 1000 rows of 500 columns =
    // 500,000 elements = 4,000,000 bytes
    Matrix: pMatrix;

    Sum : DOUBLE;
begin
  // Allocate the pointers to each row
  GetMem(Matrix, jCountMax*SizeOf(pMatrix));
  TRY

    // Allocate each row of DOUBLEs
    FOR j := 0 TO jCountMax-1 DO
      GetMem(Matrix[j], iCountMax*SizeOf(DOUBLE));

    TRY
      // Assign value to each Matrix element
      k := 1;
      FOR j := 0 TO jCountMax - 1 DO
      BEGIN
        FOR i := 0 TO iCountMax -1 DO
        BEGIN
          Matrix[j]^[i] := k;
          INC(k);
        END;
      END;

      // Add up all values in Matrix. The sum of 1..N = N*(N+1)/2, so
      // the sum should be (iCountMax*jCountMax)*(iCountMax*jCountMax + 1) / 2,
      // or in this case SUM(1..500,000) = 125,000,250,000.
      Sum := 0;
      FOR j := 0 TO jCountMax - 1 DO
        FOR i := 0 TO iCountMax -1 DO
          Sum := Sum + Matrix[j]^[i];

      Button1.Caption := FloatToStr(Sum);

    FINALLY
      // Free each row of DOUBLEs
      FOR j := jCountMax-1 DOWNTO 0 DO
        FreeMem(Matrix[j]);

    END
  FINALLY
    // Free array of pointers
    FreeMem(Matrix)
  END
end;

Simple Slice Example:

CONST
  PointMaxCount = 25;

VAR
  Points : ARRAY[0..PointMaxCount-1] OF TPoint;
begin
  Points[ 0] := Point( 20, 40);
  Points[ 1] := Point( 30,400);
  Points[ 2] := Point( 40,450);
  Points[ 3] := Point(600,460);
...
  PointCount := 14; // or some other value < PointMaxCount
...
  Bitmap.Canvas.Polyline(Slice(Points, PointCount));

Example defining open array function, dynamic allocation of array, and Slice:

// Calculate median intensity of RGB array
FUNCTION RGBMedian(RGB: ARRAY OF TRGBTriple): TRGBTriple;
  TYPE
    pIntegerArray = ^TIntegerArray;
    TIntegerArray = ARRAY[0..MaxPixelCount-1] OF INTEGER;
  VAR
    Count           : INTEGER;
    i                    : INTEGER;
    MedianIndex: INTEGER;
    MedianValue: INTEGER;
    pIntensity     : pIntegerArray;
BEGIN
  Count := High(RGB) - Low(RGB) + 1;

  // Allocate temporary integer array for intensity values
  GetMem(pIntensity, Count*SizeOf(Integer));

  TRY
    FOR i := Low(RGB) to High(RGB) DO
    BEGIN
      pIntensity^[i] := RGBIntensity(RGB[i]);
    END;

    MedianValue := MedianInteger( Slice(pIntensity^, Count) );

    MedianIndex := Low(RGB);
    WHILE (MedianIndex < High(RGB)) AND (pIntensity^[MedianIndex] <> MedianValue) DO
    BEGIN
      INC (MedianIndex)
    END

  FINALLY
    FreeMem(pIntensity)
  END;

  RESULT := RGB[MedianIndex]
END {RGBMedian};

The above RGBMedian function is called by the following:

RowLast := BitmapIn.Scanline[j-1];

AssignRGBTriple(rowOut[i],
RGBMedian([RowLast[i-1], RowLast[i], RowLast[i+1],
RowIn[i-1], RowIn[i], RowIn[i+1],
RowNext[i-1], RowNext[i+1], RowNext[i+1] ]) );

An Open Array function called by the above example:

FUNCTION MedianInteger (x: ARRAY OF INTEGER): INTEGER;
   VAR
    i        : INTEGER;
    j        : INTEGER;
    Middle   : INTEGER;
    Temporary: INTEGER;
BEGIN
  // Use truncated selection sort to find median

  Middle := (High(x)+1) DIV 2;

  FOR i := 0 TO Middle DO
  BEGIN
    FOR j := 1 TO High(x)-i DO
    BEGIN
      IF x[j] > x[j-1]
      THEN BEGIN
        Temporary := x[j];
        x[j] := x[j-1];
        x[j-1] := Temporary
      END
    END

  END;

  IF Odd(High(x))
  THEN BEGIN
    // When High(x) is Odd, there are an even number of elements in array.
    // Define median as average of two middle values.
    RESULT := (x[middle] + x[middle-1]) DIV 2
  END
  ELSE BEGIN
    // When High(x) is Even, there are an odd number of elements in array.
    // Median is the middle value.
    RESULT := x[middle]
  END
END {MedianInteger};

Also see:   Joselito G. Real UseNet Post about "Initializing n-dimensional array-type constants or static arrays"