Изображение квадрата Дюрера

ООО АВТОМАТИКА плюс

Rambler's Top100

Рейтинг@Mail.ru

Справочная система




unit Matrix;

interface

uses Windows, SysUtils, Classes, Math, ComObj, Variants;

var
  {Определяет, нужно ли оповещать пользователя об ошибках (рекомендуется)}
  MatrixShowErrorMessages: Boolean = True;

const
  MaxArrayCount = 1000000; // Максимальное число массивов в рабочей области
  MaxElemCount  = $effffff; // 251658239 элементов (изменять нельзя!)

{Конвертирует строку в число. В качестве разделителя может стоять как
 точка, так и запятая}
function AnyStrToFloat(S: string): Extended;

{Конвертирует число в строку фиксированного формата (23 символа). В качестве
 разделителя ставится точка}
function FloatToStrExp(Value: Extended): string;

{Конвертирует число в строку. Длина строки переменная. В качестве разделителя
 ставится точка}
function FloatToStrGen(Value: Extended): string;

{Передает Матлабу команду Str}
procedure SendMatlabCommand(Str: string);

type    {Объявляем все необходимые типы}
  RealArray  = array[0..MaxElemCount] of Real;
  PRealArray = ^RealArray;
  PDoubleArray = ^RealArray;

  {Используется для указания измерения массива}
  TDim = (dimRows, dimCols);

  {Псевдонимы для стандартных числовых типов}
  TStandartType =
     // В первой строке порядок элементов должен быть фиксированным. Это нужно
     // для правильной работы функции GetElemType
    (stReal, stByte, stShortint, stWord, stShort, stDword, stInteger,
     stSmallint, stLongint, stCardinal, stLongword, stInt64, stDouble, stReal48,
     stSingle, stExtended, stComp, stCurrency);

  {Описание массива}
  TMatrixData = record
    NameArray: string;
    Rows, Cols, Address, Hash: Integer;
  end;

  TNameArray = array[1..32] of Char;
  TRealFunc = function(const Value: Real): Real;
  TRealFunc2 = function(const Value1, Value2: Real): Real;
  TExtendFunc = function(const Value: Extended): Extended;

  {Класс "Список массивов". Для каждого массива хранит самую необходимую
   информацию: Имя, Ардес, Число строк, Число столбцов. Используется
   исключительно в классе TWorkspace, поэтому вам не нужно знать его
   подробностей}
  TMatrixList = class(TObject)
  private
    FList: array of ^TMatrixData;
    FCount: Integer;
    FCapacity: Integer;
    FData: ^TMatrixData;
    FLastIndexes: array[1..10] of Integer;
    function GetItemsName(Index: Integer): string;
    procedure SetItemsName(Index: Integer; const Value: string);
    function GetItemsCols(Index: Integer): Integer;
    procedure SetItemsCols(Index: Integer; const Value: Integer);
    function GetItemsRows(Index: Integer): Integer;
    procedure SetItemsRows(Index: Integer; const Value: Integer);
    function GetItemsAddr(Index: Integer): Integer;
    procedure SetItemsAddr(Index: Integer; const Value: Integer);
    procedure Grow;
    procedure SetCapacity(NewCapacity: Integer);
  public
    {Деструктор}
    destructor Destroy(); override;

    {Добавляет элемент в список}
    function Add(Item: TMatrixData): Integer;

    {Фактически не удаляет, а устанавливает префикс $ у строк и обнуляет числа}
    procedure Delete(Index: Integer);

    {Используется для удаления элементов, начиная с конца}
    procedure DeleteFull(Index: Integer);

    {Полностью очищает список и обнуляет длину массива указателей}
    procedure Clear;

    {Возвращает число элементов списка}
    function Count: Integer;

    {Осуществляет поиск массива с заданным именем. Выполняет индексацию
     10 массивов для ускорения поиска}
    function FindName(const ArrayName: string): Integer;

    {Возвращает индекс массива (в переменной Idx) OldName. Если массив не
     найден, то возвращается индекс первого удаленного массива (удаленные
     массивы помечены символом '$') или -1, если ничего не было найдено}
    function FindOldName(const OldName: string; var Idx: Integer): Boolean;

    {Определяет, существует ли массив, заданный индексом Idx}
    function ArrayExistsForIndex(const Idx: Integer): Boolean;

    {Устанавливает значение Index в первую ячейку массива FLastIndexes}
    procedure SetIndex(Index: Integer);

    {Следующие свойства обеспечивают быстрый доступ к нужному полю}
    property ItemsName[Index: Integer]: string read GetItemsName write SetItemsName; default;
    property ItemsRows[Index: Integer]: Integer read GetItemsRows write SetItemsRows;
    property ItemsCols[Index: Integer]: Integer read GetItemsCols write SetItemsCols;
    property ItemsAddr[Index: Integer]: Integer read GetItemsAddr write SetItemsAddr;
  end;
  {Класс TMatrixList закончен}

  {Класс TWorkspace. Основной класс системы Matrix. Вы можете использовать
   только функции, которые объявлены в разделе PUBLIC, и их назначение
   вы должны знать и должны уметь ими пользоваться}
  TWorkspace = class(TObject)
  private
    FArrayList: TMatrixList;      // Список массивов данной рабочей области
    FRefList: TList;              // Список массивов, переданных по ссылке
    FWorkspaceList: TList;        // Список дочерних рабочих областей
    FParentWorkspace: TWorkspace; // Если не NIL, то родитель - раб. область
    FUniqueNameCounter: Int64;    // Счетчик уникальных имен
    FElemCount: Integer;          // Число элементов в рабочей области
    FName: string;                // Имя рабочей области
    FSelf: TWorkspace;            // Ссылка на рабочую область
    FMStream: TMemoryStream;      // Поток памяти для работы с файлами

    {Процедуры и функции, осуществляющие доступ к отдельному элементу массива}
    function GetElem(const Name: string; Row, Col: Integer): Real;
    procedure SetElem(const Name: string; Row, Col: Integer; const Value: Real);
    function GetElemI(Idx, Row, Col: Integer): Real;
    procedure SetElemI(Idx, Row, Col: Integer; const Value: Real);
    function GetElemFast(Adr, Row, Col, ColCount: Integer): Real;
    procedure SetElemFast(Adr, Row, Col, ColCount: Integer; const Value: Real);

    {Определяет, является ли массив с индексом Index переданным по ссылке}
    function FIsRef(Index: Integer): Boolean;

    {Извлекает ссылку на массив}
    function FGetRef(Name: string): TMatrixData;

    {Устанавливает ссылку на массив}
    procedure FSetRef(Ref: TMatrixData);

    {Удаляет ссылку на массив}
    procedure FDelRef(Name: string);

    {Записывает указанный массив в двоичный файл. Если AddToEnd=True,
     то массив запишется в конец файла, иначе процедура будет проверять
     файл на наличие в нем массива NameAr}
    procedure FSaveArrayToBinFile(const FileName: string; ArIdx: Integer;
      AddToEnd: Boolean = True);

    {Сохраняет рабочую область в текстовом файле}
    procedure FSaveToTextFile(FileName: string);

    {Сохраняет указанный массив в текстовый файл}
    procedure FSaveArrayToTextFile(const FileName: string; Name: string);

    {Загружает рабочую область из текстового файла}
    procedure FLoadFromTextFile(const FileName: string);

    {Загружает указанный массив из текстового файла}
    procedure FLoadArrayFromTextFile(const FileName: string; Name: string);

    {Очищает временные рабочие области и генерирует исключение}
    procedure FDoError(Msg: string);
  public
    {Имя рабочей области}
    property wsName: string read FName;

    {Ссылка на данную рабочую область (типизированный Self)}
    property SelfWS: TWorkSpace read FSelf;

    {Ссылка на родительскую рабочую область}
    property ParentWS: TWorkSpace read FParentWorkspace;

    {Создает рабочую область с именем Name. Если ParentWorkspace задан, то
     созданная рабочая область считается временной, и будет автоматически
     уничтожаться при уничтожении ParentWorkspace}
    constructor Create(const Name: string; ParentWorkspace: TWorkspace = nil);

    {Уничтожает рабочую область}
    destructor Destroy; override;

    {Генерирует исключение (происходит очистка стэка и вывод текст. сообщения)
     Временные рабочие области каскадно уничтожаются до тех пор, пока не будет
     найдена основная рабочая область, у которой ParentWorkspace=nil}
    procedure DoError(Msg: string);

    {Ищет массив "Name" в рабочей области и возвращает его индекс. Если массива
     нет, то функция вернет значение -1}
    function Find(const Name: string): Integer;

    {Определяет, существует ли указанный массив}
    function ArrayExists(const Name: string): Boolean; overload;

    {Определяет, существует ли массив с указанным индексом}
    function ArrayExists(Idx: Integer): Boolean; overload;

    {Создает массив "Name" размером Rows х Cols. Забивает массив нулями, если
     параметр Init=True. Возвращает индекс созданного массива. Если массив
     является вектором, то выделяется дополнительная память, позволяющая быстро
     изменить размер вектора при помощи функции Resize}
    function NewArray(const Name: string; Rows, Cols: Integer;
      Init: Boolean = False): Integer; overload;

    {Создание нового вектора-строки (Name=StartValue:Step:FinishValue)}
    function NewArray(const Name: string;
      StartValue, FinishValue: Real; Step: Extended): Integer; overload;

    {Полная очистка рабочей области}
    procedure Clear; overload;

    {Удаление массива "Name" из рабочей области}
    function Clear(const Name: string): Integer; overload;

    {Свойства - для чтения и записи элемента массива по имени и индексу}
    property Elem[const Name: string; Row, Col: Integer]: Real read GetElem write SetElem;
    property ElemI[Idx, Row, Col: Integer]: Real read GetElemI write SetElemI;

    {Самый быстрый способ доступа к элементу массива. Необходимо дополнительно
     указывать адрес начала массива и число столбцов в массиве}
    property ElemFast[Adr, Row, Col, ColCount: Integer]: Real read GetElemFast write SetElemFast;

    {Устанавливает новое значение Value элемента массива, заданного именем.
     При AutoSize=True размеры массива изменяются автоматически
     При AutoCreate=True массив создается, если он раньше не существовал}
    procedure SetEl(const Name: string; const Value: Real; Row, Col: Integer;
      AutoSize: Boolean = False; AutoCreate: Boolean = False); overload;

    {Устанавливает новое значение элемента массива, заданного индексом
     При AutoSize=True размеры массива изменяются автоматически}
    procedure SetEl(Idx: Integer; const Value: Real; Row, Col: Integer;
      AutoSize: Boolean = False); overload;

    {Копирует массив SourAr в массив DestAr в пределах данной рабочей области}
    function CopyArray(const SourAr, DestAr: string): Integer; overload;

    {Копирует массив SourAr в DestAr из рабочей области SourWS}
    function CopyArray(SourWS: TWorkspace; const SourAr, DestAr: string):
      Integer; overload;

    {Копирует ссылку на массив из указанной рабочей области. Т.е., фактически
     вы будете работать с массивом SourAr, который находится в рабочей области
     SourWS. Массив, переданный по ссылке, должен использоваться только для
     чтения}
    function CopyRef(SourWS: TWorkspace; const SourAr, DestAr: string): Integer;

    {Перемещает массив в указанную рабочую область. Массив SourAr в рабочей
     области DestWS будет иметь имя DestAr}
    procedure MoveArray(DestWS: TWorkspace; const SourAr, DestAr: string);

    {Загрузка массива в подпрограмму из родительской рабочей области.
     Передача массива может происходить по ссылке (ByRef=True) или с помощью
     копирования (ByRef=False). Переданный по ссылке массив должен использоваться
     только для чтения}
    function LoadArray(const SourAr, DestAr: string; ByRef: Boolean = True): Integer;

    {Возвращает результат работы подпрограммы (массив) в родительскую рабочую
     область. Происходит перемещение массива, поэтому после работы данной
     функции массив SourAr будет удален из данной рабочей области}
    procedure ReturnArray(const SourAr, DestAr: string);

    {Переименовывает массив}
    function RenameArray(const SourAr, DestAr: string): Integer;

    {Транспонирует матрицу (замена строк матрицы ее столбцами)}
    function Transpose(const SourAr: string; DestAr: string): string;

    {Добавляет строки массива SourAr2 к массиву SourAr1. В результате получается
     массив DestAr. Разрешается в качестве одного из входных массивов указывать
     выходной массив DestAr. Это позволяет организовать добавление строк к
     массиву DestAr в цикле, причем до начала цикла массив DestAr может
     не существовать}
    function AddRows(const SourAr1, SourAr2: string; DestAr: string): string;

    {Добавляет столбцы к массиву}
    function AddCols(const SourAr1, SourAr2: string; DestAr: string): string;

    {Вставляет строки массива RowsAr перед строкой Row массива DestAr}
    function InsertRows(const RowsAr: string; DestAr: string; Row: Integer): string;

    {Вставляет столбцы массива ColsAr перед столбцом Col массива DestAr}
    function InsertCols(const ColsAr: string; DestAr: string; Col: Integer): string;

    {Копирует или вырезает в массив DestAr строки из массива SourAr}
    function CopyCutRows(SourAr, DestAr: string;
      RowNumber, Rows: Integer; Cut: Boolean = False): string;

    {Копирует или вырезает в массив DestAr столбцы из массива SourAr}
    function CopyCutCols(SourAr, DestAr: string;
      ColNumber, Cols: Integer; Cut: Boolean = False): string;

    {Копирует указанную часть массива SourAr в массив DestAr}
    function CopySubmatrix(SourAr, DestAr: string;
      FirstRow, Rows, FirstCol, Cols: Integer): string;

    {Вставляет массив SourAr внутрь массива DestAr}
    function PasteSubmatrix(SourAr, DestAr: string;
      FirstPastRow, FirstPastCol: Integer): string;

    {Изменяет размеры массива (исходный массив рассматривается в виде вектора)}
    function Resize(const Name: string; Rows, Cols: Integer): Integer;

    {Изменяет размеры матрицы, сохраняя внутреннюю структуру}
    function ResizeMatrix(const Name: string; Rows, Cols: Integer): Integer;

    {Вычисляет математические функции с одним параметром.
     Пример. Пусть есть массив A = [1 2 3 4 5];
     Выполним возведение в квадрат: CalcFunc('A', 'A', fncSqr);
     Получим массив A = [1 4 9 16 25]
     Вместо fncSqr можно указывать другие функции, в том числе и свои.
     Функция CalcFunc прогоняет последовательно каждый элемент массива SourAr
     через заданную функцию}
    function CalcFunc(const SourAr: string; DestAr: string; Func: TRealFunc): string; overload;
    function CalcFunc(const SourAr: string; DestAr: string; Func: TExtendFunc): string; overload;

    {Функция, в отличие от предыдущей, использует два входных массива.
     Пусть есть входные массивы A и B. Их можно сложить следующим образом:
     CalcFunc2('A', 'B', 'C', fncSum);
     Вместо названия массива вы можете указать числовое значение. Если вы
     укажите переменную типа, отличного от строкового и вещественного, то
     правильность работы функции не гарантируется. Функция сможет работать
     только если оба массива имеют одинаковый размер, или любой из них
     содержит только один элемент}
    function CalcFunc2(const SourArray1, SourArray2: Variant; DestAr: string;
      Func: TRealFunc2): string;

    {Перемножает массивы по правилу матричного умножения}
    function MulMatrix(const Matrix1, Matrix2: string; MatResult: string): string;

    {Заполняет массив случайными числами от 0 до 1. Если размеры не указаны,
     то используется имеющийся массив. В противном случае будет создан
     новый массив c размерами Rows x Cols}
    function RandomAr(const Name: string; Rows: Integer = 0; Cols: Integer = 0): string;

    {Заполняет массив диапазоном чисел с шагом Step}
    function FillAr(const Name: string; BaseValue: Real; Step: Extended): string;

    {Создает массив и заполняет диапазоном чисел. Первое число - BaseValue, а
     остальные получаются путем прибавления значения Step}
    function NewFillAr(const Name: string; Rows, Cols: Integer;
      const BaseValue: Real; Step: Extended): string; overload;

    {Создает массив (вектор) и заполняет диапазоном чисел. Первое число - BaseValue,
     последнее - LastValue. Шаг расчитывается в зависимости от количества элементов}
    function NewFillAr(const Name: string; const FirstValue, LastValue: Real;
      ElemCount: Integer): string; overload;

    {Создает массив, все элементы которого - нули}
    function NewZeros(const Name: string; Rows, Cols: Integer): string;

    {Создает массив, все элементы которого - единицы}
    function NewOnes(const Name: string; Rows, Cols: Integer): string;

    {Определяет, равны ли массивы между собой или нет. Результат может быть
     записан в массив ResArray (это "1" или "0")}
    function IsEqual(const Array1, Array2: string; ResArray: string = ''): Boolean;

    {Если массив состоит из одного элемента, то функция вернет True}
    function IsSingle(const Name: String): Boolean; overload;
    function IsSingle(Idx: Integer): Boolean; overload;

    {Определяет, является ли матрица квадратной}
    function IsSquare(const Name: String): Boolean; overload;
    function IsSquare(Idx: Integer): Boolean; overload;

    {Определяет, одинаковые ли размеры у массивов или нет}
    function SizeEqual(const Array1, Array2: string): Boolean; overload;
    function SizeEqual(Idx1, Idx2: Integer): Boolean; overload;

    {Определяет минимальные элементы (и при необходимости их индексы) в
     строках или столбцах матрицы SourAr}
    procedure GetMin(SourAr, MinElems, Indexes: string; Dim: TDim = dimCols);

    {Определяет максимальные элементы (и при необходимости их индексы) в
     строках или столбцах матрицы SourAr}
    procedure GetMax(SourAr, MaxElems, Indexes: string; Dim: TDim = dimCols);

    {Возвращает величину наименьшего и наибольшего элемента массива Name}
    procedure GetMinMax(Name: string; var MinVal, MaxVal: Real); overload;

    {Возвращает наибольшие и наименьшие элементы каждой строки или столбца}
    function GetMinMax(SourAr, DestAr: string; Dim: TDim = dimRows): string; overload;

    {Возвращает минимальный или максимальный элемент указанной строки
     или столбца массива Name}
    function GetMinOrMax(Name: string; Num: Integer; Dim: TDim;
      ReturnMax: Boolean; var Index: Integer): Real;

    {Возвращает средние арифметические значения для столбцов или для строк
     матрицы SourAr}
    function GetMean(SourAr, DestAr: string; Dim: TDim = dimCols): string;

    {Умножение элементов строк или столбцов матрицы}
    function CalcProd(SourAr, DestAr: string; Dim: TDim = dimRows): string;

    {Суммирует строки массива между собой}
    function SumRows(SourAr, DestAr: string): string;

    {Суммирует столбцы массива между собой}
    function SumCols(SourAr, DestAr: string): string;

    {Загружает массив из строки, например SLoad('A=[1 2 3; 4 5 6]');}
    function SLoad(const Str: string): string; overload;

    {Создает массив Name с элементами Values, например SLoad('A', '[1 2 3]');}
    function SLoad(const Name, Values: string): string; overload;

    {Создает массив Name с элементом Value, например SLoad('A', 100);}
    function SLoad(const Name: string; const Value: Real): string; overload;

    {Возвращает размеры указанного массива и его индекс - при желании}
    function GetSize(const Name: string; var Rows, Cols: Integer): Integer; overload;

    {Возвращает размеры указанного массива и его индекс - при желании}
    function GetSize(Idx: Integer; var Rows, Cols: Integer): Integer; overload;

    {Возвращает число элементов массива}
    function GetSize(const Name: string): Integer; overload;
    function GetSize(Idx: Integer): Integer; overload;

    {Возвращает индекс массива. Генерирует исключение, если массива нет}
    function GetIndex(const Name: string): Integer;

    {Возвращает адрес массива по имени в формате Integer}
    function GetAddress(const Name: string): Integer; overload;

    {Возвращает адрес массива по индексу в формате Integer}
    function GetAddress(Idx: Integer): Integer; overload;

    {Возвращает адрес начала строки RowNum}
    function GetRowAddress(const Name: string; RowNum: Integer = 1): Pointer; overload;

    {Возвращает адрес начала строки RowNum}
    function GetRowAddress(Idx: Integer; RowNum: Integer = 1): Pointer; overload;

    {Возвращает имя массива по его индексу}
    function GetName(Idx: Integer): string; overload;

    {Возвращает число строк}
    function GetRows(const Name: string): Integer; overload;

    {Возвращает число строк}
    function GetRows(Idx: Integer): Integer; overload;

    {Возвращает число столбцов}
    function GetCols(const Name: string): Integer; overload;

    {Возвращает число столбцов}
    function GetCols(Idx: Integer): Integer; overload;

    {Возвращает список массивов данной рабочей области}
    procedure GetNameList(List: TStrings);

    {Возвращает количество массивов}
    function GetArrayCount(): Integer;

    {Возвращает число строк в списке массивов FArrayList}
    function GetArrayListSize(): Integer;

    {Возвращает общее число элементов в рабочей области}
    property GetElemCount: Integer read FElemCount;

    {Проверяет, правильно ли имя выходного массива. Если имя не задано,
     то может изменить его на "ans"}
    function CheckResAr(var Name: string; DoANS: Boolean = True): string;

    {Определяет, правильно ли задано имя массива. Имя может иметь длину до 32
     символов. Первым символом должна быть буква латинского алфавита. Далее
     могуть стоять следующие символы: ['A'..'Z', 'a'..'z', '0'..'9', '_']}
    function IsTrueName(const Name: string): Boolean;

    {Сохраняет массив в текстовоую строку}
    function SaveArrayToString(const Name: string): string;

    {Загружает массив из текстовой строки}
    function LoadArrayFromString(Str: string): string;

    {Сохраняет элементы массива в строку. В качестве разделителя строк
     служит конструкция #13#10}
    function SaveArrayToValues(const Name: string): string;

    {Сохраняет массив в ascii-файл}
    procedure SaveToAscii(const FileName, Name: string; Fixed: Boolean = False);

    {Загружает массив из ascii-файла}
    procedure LoadFromAscii(const FileName: string; ArName: string = '');

    {Сохраняет рабочую область или массив в текстовый файл}
    procedure SaveToTextFile(const FileName: string; ArName: string = '');

    {Загружает рабочую область или массив из текстового файла}
    procedure LoadFromTextFile(const FileName: string; ArName: string = '');

    {Сохраняет рабочую область или массив в двоичный файл}
    procedure SaveToBinFile(const FileName: string; ArName: string = '');

    {Считывает рабочую область или массив из двоичного файла}
    procedure LoadFromBinFile(const FileName: string; NameAr: string = '');

    {Копирует массив в указанную область памяти}
    procedure SaveArrayToMemory(ArrayName: string; ArrayAddress: Pointer;
      ElemType: TStandartType);

    {Загружает массив из указанной области памяти}
    procedure LoadArrayFromMemory(ArrayName: string; ArrayAddress: Pointer;
      RowCount, ColCount: Integer; ElemType: TStandartType);

    {Сохраняет массив в поток (дочерний от TStream)}
    procedure SaveArrayToStream(ArrayName: string; Stream: TStream;
      ElemType: TStandartType; StartByte: Integer = 0);

    {Загружает массив из потока (дочернего от TStream)}
    procedure LoadArrayFromStream(ArrayName: string; Stream: TStream;
      Rows, Cols: Integer; ElemType: TStandartType; StartByte: DWORD = 0);

    {Передает указанный массив в Матлаб (в основную рабочую область)}
    procedure PutArrayToMatlab(const Name: string);

    {Считывает указанный массив из основной рабочей области Матлаба
     при ошибке чтения вернет False}
    function LoadArrayFromMatlab(const Name: string): Boolean;

    {Передача среде MATLAB команды Str}
    procedure SendMatlabCommand(Str: string);

    {Примеров работы данной функции сейчас нет, однако она поможет вам в том
     случае, если вы хотите, чтобы ваша подпрограмма поддерживала одновременно
     и передачу массива, заданного именем и массива, заданного строкой чисел.
     Здесь InputArray - имя массива, переданного в подпрограмму,
     TempArray - имя временного массива. Логика работы функции такова, что если
     InputArray - строка чисел, то будет автоматически создан массив TempArray, в
     который загрузятся элементы строки InputArray. Далее строке InputArray будет
     присвоено имя временного массива TempArray.
     Таким образом, после работы данной функции вы можете считать InputArray
     именем входного массива и работать с ним как ни в чем не бывало}
    function HandInput(var InputArray: string; var TempArray: string): Integer;

    {Генерация уникального имени массива}
    function GenName(Str: string = ''): string;

    {Возвращает тип элементов массива, закодированный в виде числа}
    function GetElemType(const Name: string): TStandartType;
  end;


var
  {Здесь объявлена рабочая область Base. Вы не должны создавать или уничтожать ее.
   Как только вы подключите данный модуль к своему проекту, вам сразу становится
   доступной рабочая область Base. Переменная объявлена исключительно для вашего
   удобства}
  Base: TWorkspace;


// Следующие функции используются для передачи в функцию CalcFunc2

function fncSum(const Value1, Value2: Real): Real;   // Сложение
function fncSub(const Value1, Value2: Real): Real;   // Вычитание
function fncMul(const Value1, Value2: Real): Real;   // Умножение
function fncDiv(const Value1, Value2: Real): Real;   // Деление
function fncPower(const Value1, Value2: Real): Real; // Возведение в степень

function fncEQ(const Value1, Value2: Real): Real; // Равно
function fncNE(const Value1, Value2: Real): Real; // Не равно
function fncLT(const Value1, Value2: Real): Real; // Меньше
function fncGT(const Value1, Value2: Real): Real; // Больше
function fncLE(const Value1, Value2: Real): Real; // Меньше или равно
function fncGE(const Value1, Value2: Real): Real; // Больше или равно

function fncAnd(const Value1, Value2: Real): Real; // И
function fncOr(const Value1, Value2: Real): Real; // Или
function fncXor(const Value1, Value2: Real): Real; // Xor

// Следующие функции используются для передачи в функцию CalcFunc

function fncNot(const Value: Real): Real; // Not

function fncNone(const Value: Real): Real; // Result := Value
function fncSin(const Value: Real): Real;
function fncCos(const Value: Real): Real;
function fncRound(const Value: Real): Real;
function fncTrunc(const Value: Real): Real;
function fncInt(const Value: Real): Real;
function fncFrac(const Value: Real): Real;
function fncSqrt(const Value: Real): Real;
function fncSqr(const Value: Real): Real;
function fncAbs(const Value: Real): Real;
function fncExp(const Value: Real): Real;

// Следующие переменные используются для передачи в функцию CalcFunc
var
         fncTan: TExtendFunc = Tan;
         fncCotan: TExtendFunc = Cotan;
         fncArcsin: TExtendFunc = Arcsin;
         fncArccos: TExtendFunc = Arccos;
         fncSecant: TExtendFunc = Secant;
         fncCosecant: TExtendFunc = Cosecant;
         fncLog10: TExtendFunc = Log10;
         fncLog2: TExtendFunc = Log2;
         fncLnXP1: TExtendFunc = LnXP1;
         fncCosh: TExtendFunc = Cosh;
         fncSinh: TExtendFunc = Sinh;
         fncTanh: TExtendFunc = Tanh;
         fncCotH: TExtendFunc = CotH;
         fncSecH: TExtendFunc = SecH;
         fncCscH: TExtendFunc = CscH;
         fncArcCot: TExtendFunc = ArcCot;
         fncArcSec: TExtendFunc = ArcSec;
         fncArcCsc: TExtendFunc = ArcCsc;
         fncArcCosh: TExtendFunc = ArcCosh;
         fncArcSinh: TExtendFunc = ArcSinh;
         fncArcTanh: TExtendFunc = ArcTanh;
         fncArcCotH: TExtendFunc = ArcCotH;
         fncArcSecH: TExtendFunc = ArcSecH;
         fncArcCscH: TExtendFunc = ArcCscH;

const
  // Числовые константы
  matrixPi = Pi;
  matrixExp = 2.7182818284590455;
  matrixEps = 1.0842021724855E-19;

  // Текстовые константы
  matBaseWorkspace = 'Основная рабочая область';
  matWrongIndex = 'Массив с указанным индексом не существует';
  matWrongCapacity = 'Превышено максимально допустимое число массивов в рабочей области';
  matArrayNotFound = 'Указанный массив отсутствует в рабочей области';
  matBadCoords = 'Указаны недопустимые координаты элемента';
  matBadRow = 'Указанной строки не существует';
  matBadCol = 'Указанного столбца не существует';
  matBadRowCol = 'Указанного столбца/строки не существует';
  matBadSize = 'Размеры массива заданы неверно';
  matBadInputData = 'Недопустимые входные данные';
  matErrorCreateArray = 'Невозможно создать массив с указанными размерами';
  matIsNotVektor = 'Массив не является вектором';
  matDivsionByZero = 'Деление на ноль';
  matBadOperation = 'Заданная операция не поддерживается';
  matCalcFuncError = 'Произошла ошибка при расчете функции';
  matErrorLoadingArray = 'Ошибка при попытке загрузить массив';
  matErrorPast = 'Невозможно вставить массив сам в себя';
  matInvalidFloat = '"%s" не является правильным дробным числом';
  matOutOfMemory = 'Недостаточно памяти для выполнения операции';
  matBadName = 'Указано недопустимое имя массива';
  matDirNotFound = 'Указанная директория не найдена';
  matBadType = 'Указанный тип не поддерживается';
  matArraysNotAgree = 'Размеры массивов не согласованы';
  matBadParams = 'Недопустимые параметры создания массива';
  matBadFileFormat = 'Неправильный формат файла ';
  matFileNotFound = 'Файл не найден';
  matBinaryHeader = 'Matrix binaries. Version 2.0. '; // 30 байт
  matWorkspaceError = 'Рабочая область задана ошибочно';
  matReturnError = 'Попытка возврата массива, переданного по ссылке';
  matCalcLimit =
    'Генератор имен массивов достиг последнего возможного значения.' +
    'Теперь он будет обнулен. При плохой организации вычислений это может привести' +
    'к ошибкам. Вы хотите продолжить работу программы?';
Логинов Дмитрий © 2005-2015