|
Справочная система
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 =
'Генератор имен массивов достиг последнего возможного значения.' +
'Теперь он будет обнулен. При плохой организации вычислений это может привести' +
'к ошибкам. Вы хотите продолжить работу программы?';
|
