Скачать DynArray 1.0 - Dynamic Array Object with Disk Swap

Скачать файл (5,12 Кб)

This unit implements an array and vector which can grow in size as required during the execution of the program. The number of observations (rows) is almost unlimmited because of the use of list and a swapfile that is created on disk. It's written with the object Orientated Filosofie in mind and requires Borland Pascal v7.0 (OOP-requirement) and runs in DOS Protected Mode (Needs the DLL for the DPMI)

If anyone use this unit or makes desendents of the objects, I would greatly appreciate if they mention my name for writing this piece of source. If you make your own version of this objects, I would appreciate it, if you send it to me for further development of the unit.


Before using one of the described objects you need to call the function SwapFile_Init which returns True if the creation of a swapfile was succesfull.
Swapfile_Done should be called at the end of the program so that everything is cleaned up properly.

TDynArray implements an array with a fixed number of columns, maximum 100, and an unlimited number of rows (As long as there is enough space on the harddisk)

        Array : PDynArray;
    Usage : Before using the array, you have to initialise it by making
            an instance of the object
            And when you are finished using the array, you deinitialise it
            by the statement :
            The two most important methods are the Put and Get method for
            accessing the array.
                    W := Array^.Get(X,Y);
            With  Var W = Real; X,Y : Word;
            Put places the real W in the array on the place X,Y (X = Row,
            Y = Column). And Get retrieves the real at place X,Y.
            Y ranges from 0 to 99, X from 0..???
            If one use the get method with X and Y parameter which are greater
            than the greatest one you used with put, you get a run-time error
                Suppose this code:
                    W := Random(1);
                    W := Array^.Get(3,3); -> Runtime error 203
                    W := Array^.Get(1,1); -> Runtime Error 203
                    W := Array^.Get(0,1); -> Returns 0 in W
                        See the techincal reference for an explanation of
                        the last line.

When you do not need the data in the array anymore, but you don't want to use the Destructor Done (Because you need an array in an other part of your program and want to keep the name), you can use the Clear method:


It is strongly recomended using Clear or Done as soon as you don't need the data or array anymore because of the rather strong memory requirements of the object.

TDynFrame is a descendent of TDynArray. Besides the functionality of TDynArray, it implements names for variables (Columns) and observation (Rows) and opne can assign a code (Char-type) to each variable.


The methods Init, Done, Put, Get and Clear are used in the same way as with TDynArray. The Put method is extended so that the first time you assign a value to a row it recevies the Observation name: Obsxxx (xxx is the row number)

Procedure Put_VarNaam(Y : Word; T : String;C : Char);
            Sets the variable name of column Y to string Y to the variable
            code to character C
           Procedure Put_ObsNaam(X : Word; T : String);
            Sets the observation name of row X to string T
           Function Get_VarNaam(Y : Word) : String;
            Retrieves the Variable name of column Y
           Function Get_ObsNaam(X : Word) : String;
            Retrieves the Observation name of row X
           Function Code(Y : Word) : Char;
            Retrieves the Code of variable (column) Y

TDynArray2 is another descendent of TDynArray. If you want to use more than 100 columns, you can swap the X and Y when you call the Put and Get method. But what if you want to allocate a matrix of 200 columns and 200 rows? TDynArray2 can allocate a fixed numer of rows (ranging from 1 to ?? , as long as there is enough memory) and unlimited number of columns.

The only difference with TDynArray is that you have the precise the number of rows you want to use when you allocate the object.


        Var Array : PDynArray;

        Array^.Put(100,120,W); -> Ok, no error
        Array^.Put(310,120,W); -> No error shall be generated, but it is
                                  likely that another data shall be over-

TDynVector implements a vector with unlimited observation. It is very symilar to TDynArray but the Put and Get methods only accepts the X parameter.

Technical documentation

The implementation is based on small one-dimensional arrays with 50 elements, which are combined in list for every variable / Column.

The definition is :

PObs = ^TObs;
        TObs = Record
            Id : Byte;
            Obs : Array[0..49] Of Real;
            Next : PObs;
        Id = Number that represent position. Id * 50 -> Starting row
        Obs = One dimensional array of values
        Next = Points to the a position in memory where another structure
              with data is placed. (Nil of it is the last one)

When you supply an X to the Put methods, it checks of the corresponding Id (X Div 50) exists.
If not, it creates the rows with that Id and fills them with zeros.

Suppose Var Vect : PDynVect;
                Vect^.Put(20,8); -> Creates vector observations 0..49 and
                                    puts at 20 the value 8.
                Vect^.Put(30,9); Puts in the same datastructure (Has also Id
                                 0) the value 9 on position 30
                Vect^.Put(101,7); -> Creates vector observations 100..149.
                                     The range 50..99 doesn't exist and
                Writeln(Vect^.Get(80)); Gives a runtime error but
                Writeln(Vect^.Get(15)); Gives zero because of the initial
                                        filling with zero.

Before it creates the datastructure TObs, it checks if there is enough memory available. If not, it enlarges the Swapfile with 0.5 Mb.