 {
 ****************************************************************************
 CRW32 project
 Copyright (C) by Kuryakin Alexey, Sarov, Russia, 2003, <kouriakine@mail.ru>
 This unit contains API interface to use in DLL plugins for CRW32.
 ****************************************************************************
 }

unit _CrwApi;

{$I _sysdef}

interface

uses SysUtils, Windows, Math, Classes, Graphics;

 ///////////////////////////////////////////////////////////////////////////////
 // Определения констант и типов общего применения.                           //
 ///////////////////////////////////////////////////////////////////////////////
const
 // Константы памяти.
 KiloByte          = 1024;
 MegaByte          = KiloByte*KiloByte;
 GigaByte          = KiloByte*MegaByte;
 // Специальные символы ASCII.
 ASCII_NUL         = char($00);                         // -- Null
 ASCII_SOH         = char($01);                         // ^A Start Of Header
 ASCII_STX         = char($02);                         // ^B Start of TeXt
 ASCII_ETX         = char($03);                         // ^C End of TeXt
 ASCII_EOT         = char($04);                         // ^D End Of Transfer
 ASCII_ENQ         = char($05);                         // ^E ENQuiry
 ASCII_ACK         = char($06);                         // ^F ACKnowledge
 ASCII_BEL         = char($07);                         // ^G Bell
 ASCII_BS          = char($08);                         // ^H Back Space
 ASCII_HT          = char($09);                         // ^I Horizontal Tabulation
 ASCII_LF          = char($0A);                         // ^J Line Feed
 ASCII_VT          = char($0B);                         // ^K Vertical Tabulation
 ASCII_FF          = char($0C);                         // ^L Form Feed
 ASCII_CR          = char($0D);                         // ^M Carriage Return
 ASCII_SO          = char($0E);                         // ^N символ переключения на дополнительный регистр
 ASCII_SI          = char($0F);                         // ^O символ переключения на стандартный регистр
 ASCII_DLE         = char($10);                         // ^P переключение кода
 ASCII_DC1         = char($11);                         // ^Q Data Control 1
 ASCII_DC2         = char($12);                         // ^R Data Control 2
 ASCII_DC3         = char($13);                         // ^S Data Control 3
 ASCII_DC4         = char($14);                         // ^T Data Control 4
 ASCII_NAK         = char($15);                         // ^U NoAcKnowledge
 ASCII_SYN         = char($16);                         // ^V SYNcronize
 ASCII_ETB         = char($17);                         // ^W End Transfer Block
 ASCII_CAN         = char($18);                         // ^X CANcel
 ASCII_EM          = char($19);                         // ^Y End Media
 ASCII_SUB         = char($1A);                         // ^Z SUBstitute
 ASCII_ESC         = char($1B);                         // -- ESCape
 ASCII_FS          = char($1C);                         // -- File Separator
 ASCII_GS          = char($1D);                         // -- Group Separator
 ASCII_RS          = char($1E);                         // -- Record Separator
 ASCII_US          = char($1F);                         // -- Unit Separator
 ASCII_XON         = ASCII_DC1;                         // Uses for RS-232 software flow control
 ASCII_XOFF        = ASCII_DC3;                         // Uses for RS-232 software flow control
 CR                = ASCII_CR;                          // Carriage Return
 LF                = ASCII_LF;                          // Line Feed
 FF                = ASCII_FF;                          // Form Feed
 TAB               = ASCII_HT;                          // Tabulator
 CRLF              = CR+LF;                             // DOS & Win line break
 // Константы диалогов ModalResult.
 mrNone            = 0;
 mrOk              = idOk;
 mrCancel          = idCancel;
 mrAbort           = idAbort;
 mrRetry           = idRetry;
 mrIgnore          = idIgnore;
 mrYes             = idYes;
 mrNo              = idNo;
 mrAll             = mrNo + 1;
 mrNoToAll         = mrAll + 1;
 mrYesToAll        = mrNoToAll + 1;
 // Флаги функции ScanVar.
 svNoCase          = 0;                                 // Регистр Format не преобразуется.
 svUpCase          = $0001;                             // Format преобразуется в верхний регистр.
 svLoCase          = $0002;                             // Format преобразуется в нижний регистр.
 svCaseMask        = svUpCase+svLoCase;                 // Маска для преобразования регистра.
 svLSpace          = $0004;                             // Перед именем должен стоять разделитель.
 svRSpace          = $0008;                             // После имени должен стоять разделитель.
 svSpaces          = svLSpace+svRSpace;                 // До и после имени - разделитель (поиск по полному слову).
 svOrigin          = $0010;                             // Каждое имя ищется с начала строки.
 svAsIs            = 0;                                 // Чтение без преобразований, по порядку.
 svConfig          = svUpCase+svSpaces+svOrigin;        // Стандартный способ разбора ini-файлов.
 // Флаги функции ExtractTextSection.
 efNoCase          = 0;                                 // Регистр не преобразуется.
 efUpCase          = $0001;                             // Символы преобразуются в нижний  регистр.
 efLoCase          = $0002;                             // Символы преобразуются в верхний регистр.
 efCaseMask        = efUpCase+efLoCase;                 // Маска для преобразования регистра.
 efLTrim           = $0004;                             // Удалять незначащие пробелы слева.
 efRTrim           = $0008;                             // Удалять незначащие пробелы справа.
 efTrimMask        = efLTrim+efRTrim;                   // Удалять незначащие пробелы слева и справа.
 efDelCom          = $0010;                             // Удалять комментарии.
 efAsIs            = 0;                                 // Никаких преобразований.
 efConfig          = efUpCase+efLTrim+efRTrim+efDelCom; // Стандартный способ чтения ini-файлов.
 esComments        = [';'];                             // Разделители комментариев в ini-файлах.
 // Стандартные отладочные файлы DebugOut.
 stdfDebug         = 0;                                 // Стандартный файл отладки программы.
 sdtfError         = 1;                                 // Стандартный файл ошибок программы.
 // Наборы символов для синтаксического анализа.
 DirDelimiters     = ['\','/'];                         // Разделители каталогов.
 DosDelimiters     = ['\','/',':'];                     // Разделители каталогов и дисков.
 ScanSpaces        = [' ',Tab,CR,LF,',',';','='];       // Разделители при разборе слов.
 ScanWordDelims    = [CR,';'];                          // Разделители строк форматирования.
 WordSet           = ['_', 'a'..'z', 'A'..'Z','а'..'п', 'р'..'я', 'А'..'П', 'Р'..'Я','0'..'9'];
 // Флаги функции CurveFlags.
 cfInvalid         = $00000001;                         // Кривая не существует.
 cfNoData          = $00000002;                         // В кривой нет точек.
 cfNoComment       = $00000004;                         // В кривой нет комментария.
 cfTooSmall        = $00000008;                         // Кривая имеет мало точек.
 cfNotSortedX      = $00000010;                         // Кривая не отсортирована по x.
 cfNotSortedY      = $00000020;                         // Кривая не отсортирована по y.
 cfDuplicatesX     = $00000040;                         // Кривая содержит точки с одинаковым значением x.
 cfDuplicatesY     = $00000080;                         // Кривая содержит точки с одинаковым значением y.
 cfNotEquiDistantX = $00000100;                         // Кривая имеет непостоянный шаг по x.
 cfNotEquiDistantY = $00000200;                         // Кривая имеет непостоянный шаг по y.
 cfHaveZeroX       = $00000400;                         // Кривая имеет точки с x=0.
 cfHaveZeroY       = $00000800;                         // Кривая имеет точки с y=0.
 cfHavePozitivX    = $00001000;                         // Кривая имеет точки с x>0.
 cfHavePozitivY    = $00002000;                         // Кривая имеет точки с y>0.
 cfHaveNegativX    = $00004000;                         // Кривая имеет точки с x<0.
 cfHaveNegativY    = $00008000;                         // Кривая имеет точки с y<0.
 cfNaNX            = $00010000;                         // Кривая имеет точки с x=NAN.
 cfNaNY            = $00020000;                         // Кривая имеет точки с y=NAN.
 cfInfX            = $00040000;                         // Кривая имеет точки с x=INF.
 cfInfY            = $00080000;                         // Кривая имеет точки с y=INF.
 cfNanXY           = cfNanX+cfNanY;
 cfInfXY           = cfInfX+cfInfY;
 cfNanInf          = cfNanXY+cfInfXY;
 // Флаги функции CurveSort
 sfPrimaryY        = $0001;                             // Основной ключ сортировки - Y, а не Х, как обычно
 sfReversPrimary   = $0002;                             // Сортировка в обратном порядке по основному ключу
 sfReversSecondary = $0004;                             // Сортировка в обратном порядке по дополнительному ключу
 sfPack            = $0008;                             // Упаковка точек с одинаковым значением ключей
 // Флаги событий DaqApi.putev
 evAnalog          = $00000000;                         // Событие направляется в AnalogOutput
 evDigital         = $00000001;                         // Событие направляется в DigitalOutput
 evNormal          = $00000000;                         // Событие обычное, может быть упаковано
 evImportant       = $00000002;                         // Событие важное, упаковка подавляется
 evNoCompress      = $00000000;                         // Событие не упаковывается
 evCompress        = $00000004;                         // Событие упаковывается
 evNoSpectral      = $00000000;                         // Событие не спектральное, добавляется в конец кривой
 evSpectral        = $00000008;                         // Событие спектральное, накапливается в спектре
 // Команды DaqApi.DaqCommand
 Daq_Cmd_Init      = 1;                                 // Команда "Начало работы"
 Daq_Cmd_Free      = 2;                                 // Команда "Завершение работы"
 Daq_Cmd_Poll      = 3;                                 // Команда "Опрос устройства"
 Daq_Cmd_User      = $1000;                             // Начало пользовательских команд
 // Коды методов минимизации
 mNelderMead             = 0;                           // NM  - Нелдер-Мид
 mDavidonFletcherPowell  = 1;                           // DFP - Давидон-Флетчер-Пауэлл
 mBroyden                = 2;                           // B   - Бройден
 mPearson2               = 3;                           // P2  - Пирсон 2
 mPearson3               = 4;                           // P3  - Пирсон 3
 mZoutendijk             = 5;                           // Z   - Заудентайк
 mSteward                = 6;                           // S   - Стюарт
 mFletcherReeves         = 7;                           // FR  - Флетчер-Ривз
 mDavidon2               = 8;                           // D2  - Давидон 2
 // Коды ошибок минимизации, minimization error code
 mecOk             = 0;                                 // Ok,minimum found
 mecBadDim         = 1;                                 // Bad dimension
 mecBadMethod      = 2;                                 // Unknown method
 mecBadArg         = 3;                                 // Invalid argument
 mecBadVal         = 4;                                 // Invalid value
 mecUserBreak      = 5;                                 // User breaks minimization process
 mecFail           = 6;                                 // Convergence not achieved
 mecInfPassed      = 7;                                 // Function value < user-defined infimum
 mecBounds         = 8;                                 // Out of available bounds
 mecInitErr        = 9;                                 // Init error
 mecDoneErr        = 10;                                // Finit error
 mecBadScale       = 11;                                // Invalid scale in GenMinScaled
 mecBadWeight      = 12;                                // Invalid weights in least squares
 mecDLLError       = 13;                                // Error loading DLL
 mecOutOfMem       = 14;                                // Detect out of memory
 // Коды LinearProgrammingBySimplex
 si_Ok               = 0;                               // решение получено, успех
 si_SolutionInfinite = 1;                               // решение неограничено
 si_ConditionsError  = 2;                               // ограничения несовместны, решения нет
 si_OutOfMemory      = -1;                              // Нет памяти для рабочих массивов
 si_InvalidInput     = -2;                              // среди входных данных есть NIL-указатели
 si_InvalidSignum    = -3;                              // ошибка в векторе знаков Signums
 si_InvalidRange     = -4;                              // ошибка размерности входных матриц
 si_Exception        = -5;                              // возникло исключение
 si_Input            = $0001;                           // печать входных данных
 si_Result           = $0002;                           // печать результата
 si_IterBasis        = $0004;                           // печатать базис на каждой итерации
 si_IterFun          = $0008;                           // печатать значение функции на каждой итерации
 si_IterSigm         = $0010;                           // печать симплекс-множителей
 si_Echo             = $8000;                           // вывод на экран сведений о итерации
 // Цветовые константы старого стиля CGA, см. CgaToRgbColor
 Black             = 0;
 Blue              = 1;
 Green             = 2;
 Cyan              = 3;
 Red               = 4;
 Magenta           = 5;
 Brown             = 6;
 LightGray         = 7;
 DarkGray          = 8;
 LightBlue         = 9;
 LightGreen        = 10;
 LightCyan         = 11;
 LightRed          = 12;
 LightMagenta      = 13;
 Yellow            = 14;
 White             = 15;
 // Коды AdamGetStatus. Сокращение от Request Status.
 rs_NotAvail       = 0;                                 // Сеть RS-485 недоступна
 rs_NoRequest      = 1;                                 // Запрос не возбуждался, канал свободен
 rs_WaitQueue      = 2;                                 // Запрос возбужден, но в сеть еще не передан
 rs_WaitAnswer     = 3;                                 // Запрос возбужден, передан в сеть, ожидание ответа
 rs_Answer         = 4;                                 // Пришел ответ на сообщение из сети RS-485
 rs_TimeOut        = 5;                                 // TimeOut : ответ не пришел в назначеннное время
 // Идентификаторы химических элементов таблицы Менделеева.
 ChemEl_H  = 1;    ChemEl_He = 2;     ChemEl_Li = 3;     ChemEl_Be = 4;     ChemEl_B  = 5;
 ChemEl_C  = 6;    ChemEl_N  = 7;     ChemEl_O  = 8;     ChemEl_F  = 9;     ChemEl_Ne = 10;
 ChemEl_Na = 11;   ChemEl_Mg = 12;    ChemEl_Al = 13;    ChemEl_Si = 14;    ChemEl_P  = 15;
 ChemEl_S  = 16;   ChemEl_Cl = 17;    ChemEl_Ar = 18;    ChemEl_K  = 19;    ChemEl_Ca = 20;
 ChemEl_Sc = 21;   ChemEl_Ti = 22;    ChemEl_V  = 23;    ChemEl_Cr = 24;    ChemEl_Mn = 25;
 ChemEl_Fe = 26;   ChemEl_Co = 27;    ChemEl_Ni = 28;    ChemEl_Cu = 29;    ChemEl_Zn = 30;
 ChemEl_Ga = 31;   ChemEl_Ge = 32;    ChemEl_As = 33;    ChemEl_Se = 34;    ChemEl_Br = 35;
 ChemEl_Kr = 36;   ChemEl_Rb = 37;    ChemEl_Sr = 38;    ChemEl_Y  = 39;    ChemEl_Zr = 40;
 ChemEl_Nb = 41;   ChemEl_Mo = 42;    ChemEl_Tc = 43;    ChemEl_Ru = 44;    ChemEl_Rh = 45;
 ChemEl_Pd = 46;   ChemEl_Ag = 47;    ChemEl_Cd = 48;    ChemEl_In = 49;    ChemEl_Sn = 50;
 ChemEl_Sb = 51;   ChemEl_Te = 52;    ChemEl_I  = 53;    ChemEl_Xe = 54;    ChemEl_Cs = 55;
 ChemEl_Ba = 56;   ChemEl_La = 57;    ChemEl_Ce = 58;    ChemEl_Pr = 59;    ChemEl_Nd = 60;
 ChemEl_Pm = 61;   ChemEl_Sm = 62;    ChemEl_Eu = 63;    ChemEl_Gd = 64;    ChemEl_Tb = 65;
 ChemEl_Dy = 66;   ChemEl_Ho = 67;    ChemEl_Er = 68;    ChemEl_Tm = 69;    ChemEl_Yb = 70;
 ChemEl_Lu = 71;   ChemEl_Hf = 72;    ChemEl_Ta = 73;    ChemEl_W  = 74;    ChemEl_Re = 75;
 ChemEl_Os = 76;   ChemEl_Ir = 77;    ChemEl_Pt = 78;    ChemEl_Au = 79;    ChemEl_Hg = 80;
 ChemEl_Tl = 81;   ChemEl_Pb = 82;    ChemEl_Bi = 83;    ChemEl_Po = 84;    ChemEl_At = 85;
 ChemEl_Rn = 86;   ChemEl_Fr = 87;    ChemEl_Ra = 88;    ChemEl_Ac = 89;    ChemEl_Th = 90;
 ChemEl_Pa = 91;   ChemEl_U  = 92;    ChemEl_Np = 93;    ChemEl_Pu = 94;    ChemEl_Am = 95;
 ChemEl_Cm = 96;   ChemEl_Bk = 97;    ChemEl_Cf = 98;    ChemEl_Es = 99;    ChemEl_Fm = 100;
 ChemEl_Md = 101;  ChemEl_No = 102;   ChemEl_Lr = 103;   ChemEl_Ku = 104;   ChemEl_Ns = 105;
 rfa_MinAtomId = ChemEl_H;
 rfa_MaxAtomId = ChemEl_Ns;

type
 // Идентификаторы полей базы данных РФА
 TRfaFieldId=(                                          // Поля базы данных РФА:
  rfa_ATOM_ID,        rfa_ATOM_SYMBOL,                  // Номер и символ элемента
  rfa_ATOM_NAME_RUS,  rfa_ATOM_NAME_ENG,                // Название на русском/английском
  rfa_ATOM_GROUP,     rfa_ATOM_PERIOD,                  // Группа и период
  rfa_ATOM_COLOR,     rfa_CROSS_SECTION,                // Цвет и таблица сечений
  rfa_ATOM_WEIGHT,    rfa_ATOM_DENSITY,                 // Атомный вес и плотность
  rfa_EKAB,  rfa_EL1AB,  rfa_EL2AB,  rfa_EL3AB,         // Энергии абсорбции для K,L1,L2,L3-уровней линий ХРИ
  rfa_EKA,   rfa_IKA,                                   // Линия ХРИ K a1 + a2
  rfa_EKA1,  rfa_IKA1,                                  // Линия ХРИ K a1
  rfa_EKA2,  rfa_IKA2,                                  // Линия ХРИ K a2
  rfa_EKB,   rfa_IKB,                                   // Линия ХРИ K b1 + b2
  rfa_EKB1,  rfa_IKB1,                                  // Линия ХРИ K b1
  rfa_EKB2,  rfa_IKB2,                                  // Линия ХРИ K b2
  rfa_EKB3,  rfa_IKB3,                                  // Линия ХРИ K b3
  rfa_ELA12, rfa_ILA12,                                 // Линия ХРИ L3 a1 + a2
  rfa_ELA1,  rfa_ILA1,                                  // Линия ХРИ L3 a1
  rfa_ELA2,  rfa_ILA2,                                  // Линия ХРИ L3 a2
  rfa_ELB1,  rfa_ILB1,                                  // Линия ХРИ L2 b1
  rfa_ELB2,  rfa_ILB2,                                  // Линия ХРИ L3 b2
  rfa_ELB3,  rfa_ILB3,                                  // Линия ХРИ L1 b3
  rfa_ELB4,  rfa_ILB4,                                  // Линия ХРИ L1 b4
  rfa_ELB5,  rfa_ILB5,                                  // Линия ХРИ L3 b5
  rfa_ELB6,  rfa_ILB6,                                  // Линия ХРИ L3 b6
  rfa_ELB10, rfa_ILB10,                                 // Линия ХРИ L1 b10
  rfa_ELB15, rfa_ILB15,                                 // Линия ХРИ L3 b15
  rfa_ELB17, rfa_ILB17,                                 // Линия ХРИ L2 b17
  rfa_ELG1,  rfa_ILG1,                                  // Линия ХРИ L2 g1
  rfa_ELG2,  rfa_ILG2,                                  // Линия ХРИ L1 g2
  rfa_ELG3,  rfa_ILG3,                                  // Линия ХРИ L1 g3
  rfa_ELG4,  rfa_ILG4,                                  // Линия ХРИ L1 g4
  rfa_ELG4_, rfa_ILG4_,                                 // Линия ХРИ L1 g4_
  rfa_ELG5,  rfa_ILG5,                                  // Линия ХРИ L2 g5
  rfa_ELG6,  rfa_ILG6,                                  // Линия ХРИ L2 g6
  rfa_ELG8,  rfa_ILG8,                                  // Линия ХРИ L2 g6
  rfa_ELG11, rfa_ILG11,                                 // Линия ХРИ L1 g11
  rfa_ELmu,  rfa_ILmu,                                  // Линия ХРИ L2 Mu
  rfa_ELnu,  rfa_ILnu,                                  // Линия ХРИ L2 Nu
  rfa_ELL,   rfa_ILL,                                   // Линия ХРИ L3 L
  rfa_RSRV01, rfa_RSRV02, rfa_RSRV03, rfa_RSRV04,       // Зарезервировано на будущее
  rfa_RSRV05, rfa_RSRV06, rfa_RSRV07, rfa_RSRV08,       // Зарезервировано на будущее
  rfa_RSRV09, rfa_RSRV10, rfa_RSRV11, rfa_RSRV12,       // Зарезервировано на будущее
  rfa_RSRV13, rfa_RSRV14, rfa_RSRV15, rfa_RSRV16,       // Зарезервировано на будущее
  rfa_RSRV17, rfa_RSRV18, rfa_RSRV19, rfa_RSRV20,       // Зарезервировано на будущее
  rfa_RSRV21, rfa_RSRV22, rfa_RSRV23, rfa_RSRV24,       // Зарезервировано на будущее
  rfa_RSRV25, rfa_RSRV26, rfa_RSRV27, rfa_RSRV28,       // Зарезервировано на будущее
  rfa_RSRV29, rfa_RSRV30, rfa_RSRV31, rfa_RSRV32,       // Зарезервировано на будущее
  rfa_RSRV33, rfa_RSRV34, rfa_RSRV35, rfa_RSRV36,       // Зарезервировано на будущее
  rfa_RSRV37, rfa_RSRV38, rfa_RSRV39, rfa_RSRV40,       // Зарезервировано на будущее
  rfa_RSRV41, rfa_RSRV42, rfa_RSRV43, rfa_RSRV44,       // Зарезервировано на будущее
  rfa_RSRV45, rfa_RSRV46, rfa_RSRV47, rfa_RSRV48,       // Зарезервировано на будущее
  rfa_RSRV49, rfa_RSRV50, rfa_RSRV51, rfa_RSRV52,       // Зарезервировано на будущее
  rfa_RSRV53, rfa_RSRV54, rfa_RSRV55, rfa_RSRV56,       // Зарезервировано на будущее
  rfa_RSRV57, rfa_RSRV58, rfa_RSRV59, rfa_RSRV60,       // Зарезервировано на будущее
  rfa_RSRV61, rfa_RSRV62, rfa_RSRV63, rfa_RSRV64,       // Зарезервировано на будущее
  rfa_RSRV65, rfa_RSRV66, rfa_RSRV67, rfa_RSRV68,       // Зарезервировано на будущее
  rfa_RSRV69, rfa_RSRV70, rfa_RSRV71, rfa_RSRV72,       // Зарезервировано на будущее
  rfa_RSRV73, rfa_RSRV74, rfa_RSRV75, rfa_RSRV76,       // Зарезервировано на будущее
  rfa_RSRV77, rfa_RSRV78, rfa_RSRV79, rfa_RSRV80,       // Зарезервировано на будущее
  rfa_RSRV81, rfa_RSRV82, rfa_RSRV83, rfa_RSRV84,       // Зарезервировано на будущее
  rfa_RSRV85, rfa_RSRV86, rfa_RSRV87, rfa_RSRV88,       // Зарезервировано на будущее
  rfa_RSRV89, rfa_RSRV90, rfa_RSRV91, rfa_RSRV92,       // Зарезервировано на будущее
  rfa_RSRV93, rfa_RSRV94, rfa_RSRV95, rfa_RSRV96,       // Зарезервировано на будущее
  rfa_RSRV97, rfa_RSRV98, rfa_RSRV99, rfa_RSRV100,      // Зарезервировано на будущее
  rfa_KEMISSION,   rfa_L31EMISSION, rfa_L32EMISSION,    // Факторы эмиссии линий ХРИ
  rfa_L33EMISSION, rfa_L21EMISSION, rfa_L22EMISSION,    // Факторы эмиссии линий ХРИ
  rfa_ATOMS_MM1,                                        // атомная масса наиболее распространенного изотопа
  rfa_ATOMS_M1,                                         // атомный вес наиболее распространенного изотопа
  rfa_ATOMS_M2,                                         // атомный вес естественной смеси изотопов
  rfa_ATOMS_RHO,                                        // плотность г/куб.см
  rfa_ATOMS_ATRHO,                                      // атомная плотность, 10**22 атом/куб.см
  rfa_ATOMS_VFERMI,                                     // скорость Ферми в единицах скорости Бора
  rfa_ATOMS_LFCTR,                                      // множитель длины экранирования
  rfa_STRAG_S1, rfa_STRAG_S2, rfa_STRAG_S3, rfa_STRAG_S4,   // Коэффициенты для вычисления страгглинга
  rfa_PSTOP_P1, rfa_PSTOP_P2, rfa_PSTOP_P3, rfa_PSTOP_P4,   // Коэффициенты протонного торможения
  rfa_PSTOP_P5, rfa_PSTOP_P6, rfa_PSTOP_P7, rfa_PSTOP_P8,   // Коэффициенты протонного торможения
  rfa_ELEMPOS_X, rfa_ELEMPOS_Y,                         // Положения кнопок для отображения таблицы Менделеева
  rfa_INVALID_FIELD                                     // Такого поля быть не должно
 );
 TRfaFieldIdSet = set of TRfaFieldId;                   // Для наборов полей базы данных
 TRfaCrossSectionFieldId = (                            // Поля таблиц сечений
  rfa_ENERGY,                                           // Энергия в кэв
  rfa_PHOTO,                                            // Сечение фотоэффекта
  rfa_COHER,                                            // Сечение когерентного рассеяния
  rfa_INCOHER,                                          // Сечение некогерентного рассеяния
  rfa_TOTAL                                             // Полное сечение
 );
 TRfaXRayLine = packed record Energy,Height:Double; end;// Описывает линию ХРИ
 // Объект инкапсулирует функции для доступа к базе данных РФА.
 TRfaDataBaseWrap = class(TObject)
  //
  // 0    - Возвращает True, если атомный номер доступен, то есть если он допустим и база данных загружена.
  //
  function  GetAccessible(AtomId:Integer):Boolean;                       virtual; abstract;
  //
  // 1    - Дает доступ к полям базы данных как к числу; нечисловые поля возвращают длину строки/таблицы.
  //
  function  GetAsDouble(AtomId:Integer; FieldId:TRfaFieldId):Double;     virtual; abstract;
  //
  // 2    - Дает доступ к полям базы данных как к строкам; числовые поля преобразуются в строку.
  //
  function  GetAsString(AtomId:Integer; FieldId:TRfaFieldId):ShortString;virtual; abstract;
  //
  // 3    - Возвращает энергию и интенсивность линии ХРИ. Возвращает ноль, если LineId неверное.
  //
  function  GetXRayLine(AtomId:Integer; LineId:TRfaFieldId):TRfaXRayLine;virtual; abstract;
  //
  // 4    - Возвращает химический символ атома.
  //
  function  GetAtomSymbol(AtomId:Integer):ShortString;                   virtual; abstract;
  //
  // 5    - Возвращает символьное имя поля таблицы РФА.
  //
  function  GetFieldName(FieldId:TRfaFieldId):ShortString;               virtual; abstract;
  //
  // 6    - Возвращает название линии ХРИ.
  //
  function  GetLineName(LineId:TRfaFieldId):ShortString;                 virtual; abstract;
  //
  // 7    - Возвращает длину таблицы сечений для данного элемента.
  //
  function  GetCrossSectionTableCount(AtomId:Integer):Integer;           virtual; abstract;
  //
  // 8    - Дает доступ к таблице сечений.
  //
  function  GetCrossSectionTable(AtomId:Integer; aChan:TRfaCrossSectionFieldId;
                                 aIndex:Integer):Double;                 virtual; abstract;
  //
  // 9    - Находит номер атома по его химическому символу или возвращает 0.
  //
  function  FindAtom(const aSymbol:ShortString):Integer;                 virtual; abstract;
  //
  // 10   - Находит линию ХРИ по ее названию или возвращает rfa_INVALID_FIELD.
  //
  function  FindLine(const aLineName:ShortString):TRfaFieldId;           virtual; abstract;
  //
  // 11   - Вычисляет сечение, используя логарифмическую интерполяцию таблицы сечений.
  //
  function  FindCrossSection(AtomID:Integer; CrossId:TRfaCrossSectionFieldId;
                               Energy:Double):Double;                    virtual; abstract;
 public
  property    Accessible[AtomId:Integer]                   : Boolean      read GetAccessible;
  property    AsDouble[AtomId:Integer;FieldId:TRfaFieldId] : Double       read GetAsDouble; default;
  property    AsString[AtomId:Integer;FieldId:TRfaFieldId] : ShortString  read GetAsString;
  property    XRayLine[AtomId:Integer;LineId:TRfaFieldId]  : TRfaXRayLine read GetXRayLine;
  property    AtomSymbol[AtomId:Integer]                   : ShortString  read GetAtomSymbol;
  property    FieldName[FieldId:TRfaFieldId]               : ShortString  read GetFieldName;
  property    LineName[LineId:TRfaFieldId]                 : ShortString  read GetLineName;
  property    CrossSectionTableCount[AtomId:Integer]       : Integer      read GetCrossSectionTableCount;
  property    CrossSectionTable[AtomId:Integer; Chan:TRfaCrossSectionFieldId; aIndex:Integer] : Double  read GetCrossSectionTable;
 end;

const
 rfa_FIRST_FIELD        = Low(TRfaFieldId);             // Первое допустимое поле
 rfa_LAST_FIELD         = Pred(rfa_INVALID_FIELD);      // Последнее допустимое поле
 // Различные наборы, идентифицирующие линии ХРИ.
 rfa_K_Series_Shorten   = [rfa_EKA,             rfa_EKB];
 rfa_K_Series_Perfect   = [rfa_EKA1, rfa_EKA2,  rfa_EKB1, rfa_EKB2, rfa_EKB3];
 rfa_L1_Series_Shorten  = [rfa_ELB3, rfa_ELB4,  rfa_ELB10, rfa_ELG2, rfa_ELG3, rfa_ELG4, rfa_ELG4_, rfa_ELG11];
 rfa_L1_Series_Perfect  = [rfa_ELB3, rfa_ELB4,  rfa_ELB10, rfa_ELG2, rfa_ELG3, rfa_ELG4, rfa_ELG4_, rfa_ELG11];
 rfa_L2_Series_Shorten  = [rfa_ELB1, rfa_ELB17, rfa_ELG1, rfa_ELG5, rfa_ELG6, rfa_ELG8, rfa_ELmu, rfa_ELnu];
 rfa_L2_Series_Perfect  = [rfa_ELB1, rfa_ELB17, rfa_ELG1, rfa_ELG5, rfa_ELG6, rfa_ELG8, rfa_ELmu, rfa_ELnu];
 rfa_L3_Series_Shorten  = [rfa_ELA12,           rfa_ELB2, rfa_ELB5, rfa_ELB6, rfa_ELB15, rfa_ELL];
 rfa_L3_Series_Perfect  = [rfa_ELA1,  rfa_ELA2, rfa_ELB2, rfa_ELB5, rfa_ELB6, rfa_ELB15, rfa_ELL];
 rfa_K_Series           = rfa_K_Series_Shorten  + rfa_K_Series_Perfect;
 rfa_L1_Series          = rfa_L1_Series_Shorten + rfa_L1_Series_Perfect;
 rfa_L2_Series          = rfa_L2_Series_Shorten + rfa_L2_Series_Perfect;
 rfa_L3_Series          = rfa_L3_Series_Shorten + rfa_L3_Series_Perfect;
 rfa_L_Series_Shorten   = rfa_L1_Series_Shorten + rfa_L2_Series_Shorten + rfa_L3_Series_Shorten;
 rfa_L_Series_Perfect   = rfa_L1_Series_Perfect + rfa_L2_Series_Perfect + rfa_L3_Series_Perfect;
 rfa_L_Series           = rfa_L_Series_Shorten + rfa_L_Series_Perfect;
 rfa_All_Series_Shorten = rfa_K_Series_Shorten + rfa_L_Series_Shorten;
 rfa_All_Series_Perfect = rfa_K_Series_Perfect + rfa_L_Series_Perfect;
 rfa_All_Series         = rfa_K_Series + rfa_L_Series;

type
 TCharSet        = set of char;
 TByteSet        = set of byte;
 LongString      = AnsiString;
 PByte           = ^Byte;
 PByteArray      = ^TByteArray;
 TByteArray      = packed array[0..(MaxInt div sizeof(Byte))-1]     of Byte;
 TCharArray      = packed array[0..(MaxInt div sizeof(Char))-1]     of Char;
 PShortInt       = ^ShortInt;
 PShortIntArray  = ^TShortIntArray;
 TShortIntArray  = packed array[0..(MaxInt div sizeof(ShortInt))-1] of ShortInt;
 PBoolean        = ^Boolean;
 PBooleanArray   = ^TBooleanArray;
 TBooleanArray   = packed array[0..(MaxInt div sizeof(Boolean))-1]  of Boolean;
 PWord           = ^Word;
 PWordArray      = ^TWordArray;
 TWordArray      = packed array[0..(MaxInt div sizeof(Word))-1]     of Word;
 PSmallInt       = ^SmallInt;
 PSmallIntArray  = ^TSmallIntArray;
 TSmallIntArray  = packed array[0..(MaxInt div sizeof(SmallInt))-1] of SmallInt;
 PLongWord       = ^LongWord;
 PLongWordArray  = ^TLongWordArray;
 TLongWordArray  = packed array[0..(MaxInt div sizeof(LongWord))-1] of LongWord;
 PDWord          = ^DWord;
 PDWordArray     = ^TDWordArray;
 TDWordArray     = packed array[0..(MaxInt div sizeof(DWord))-1]    of DWord;
 PLongInt        = ^LongInt;
 PLongIntArray   = ^TLongIntArray;
 TLongIntArray   = packed array[0..(MaxInt div sizeof(LongInt))-1]  of LongInt;
 PCardinal       = ^Cardinal;
 PCardinalArray  = ^TCardinalArray;
 TCardinalArray  = packed array[0..(MaxInt div sizeof(Cardinal))-1] of Cardinal;
 PInteger        = ^Integer;
 PIntegerArray   = ^TIntegerArray;
 TIntegerArray   = packed array[0..(MaxInt div sizeof(Integer))-1]  of Integer;
 PInt64          = ^Int64;
 PInt64Array     = ^TInt64Array;
 TInt64Array     = packed array[0..(MaxInt div sizeof(Int64))-1]    of Int64;
 PSingle         = ^Single;
 PSingleArray    = ^TSingleArray;
 TSingleArray    = packed array[0..(MaxInt div sizeof(Single))-1]   of Single;
 PDouble         = ^Double;
 PDoubleArray    = ^TDoubleArray;
 TDoubleArray    = packed array[0..(MaxInt div sizeof(Double))-1]   of Double;
 PComp           = ^Comp;
 PCompArray      = ^TCompArray;
 TCompArray      = packed array[0..(MaxInt div sizeof(Comp))-1]     of Comp;
 PExtended       = ^Extended;
 PExtendedArray  = ^TExtendedArray;
 TExtendedArray  = packed array[0..(MaxInt div sizeof(Extended))-1] of Extended;
 PPointerArray   = ^TPointerArray;
 TPointerArray   = packed array[0..(MaxInt div sizeof(Pointer))-1]  of Pointer;
 // Точки и прямоугольники
 TPoint2I        = packed record x,y : Integer; end;
 TPoint2D        = packed record x,y : Double;  end;
 TPoint3D        = packed record x,y,z : Double; end;
 TRect2I         = packed record a,b : TPoint2I; end;
 TRect2D         = packed record a,b : TPoint2D; end;
 PPoint2IArray   = ^TPoint2IArray;
 TPoint2IArray   = packed array[0..MaxInt div sizeof(TPoint2I)-1] of TPoint2I;
 PPoint2DArray   = ^TPoint2DArray;
 TPoint2DArray   = packed array[0..MaxInt div sizeof(TPoint2D)-1] of TPoint2D;
 PPoint3DArray   = ^TPoint3DArray;
 TPoint3DArray   = packed array[0..MaxInt div sizeof(TPoint3D)-1] of TPoint3D;
 PRect2IArray    = ^TRect2IArray;
 TRect2IArray    = packed array[0..MaxInt div sizeof(TRect2I)-1] of TRect2I;
 PRect2DArray    = ^TRect2DArray;
 TRect2DArray    = packed array[0..MaxInt div sizeof(TRect2D)-1] of TRect2D;
 // Для функций FindZero, FindMin и т.д.
 zmFunType       = function ( x : Double; Custom : Pointer ) : Double;
 // Для функции ForEachFile.
 TForEachFileAction     = procedure ( const FileName    : ShortString;
                                      const FileDetails : TSearchRec;
                                            SubDirLevel : Integer;
                                        var Terminate   : Boolean;
                                            CustomData  : Pointer);
 // Для функции ForEachTexLine.
 TForEachTextLineAction = procedure ( const FileName    : ShortString;
                                      const Line        : ShortString;
                                            Count       : LongInt;
                                        var Terminate   : Boolean;
                                            CustomData  : Pointer);
 // Целевая функция для процедур минимизации
 // n=размерность, x=аргумент, f=значение, g=градиент, Custom=пользовательские данные.
 TMinProblem  = function(n:Integer; var x:array of Double; var f:Double;
                                    var g:array of Double; Custom:Pointer):Integer;
 // Процедура оповещения для процедур минимизации
 TMinReport  = procedure(n:Integer; var x:array of Double; var f:Double;
                                    var g:array of Double; Custom:Pointer;
                                    Count:Integer; const Method,Comment:ShortString);
 // Целевая функция для фитирования
 // t=аргумент, n=размерность параметров,  x=параметры, f=значение, g=градиент по параметрам,
 // Custom=пользовательские данные.
 TFitProblem = function(t:Double; n:Integer; var x:array of Double; var f:Double;
                                             var g:array of Double; Custom:Pointer):Integer;
 // Процедура оповещения для процедур фитирования
 TFitReport=procedure(m:Integer; const t,y,w:array of Double; n:Integer;
                      const x:array of Double; const f:Double; const g:array of Double;
                      Custom:Pointer; Count:Integer; const Method,Comment:ShortString);
 // Функция сравнения для процедур сортировки и поиска.
 // Compare(Data,Key1,Key2) сравнивает ключи Key1,Key2 и возвращает
 // 1 если Key1^ > Key2^; 0 если Key1^ = Key2^; -1 если Key1^ < Key2^.
 // Через Data передаются пользовательские данные.
 TCompareFunction = function(Data,Key1,Key2:Pointer):Integer;
 // Функция ключа для процедур сортировки и поиска.
 // KeyOf(Data,j) возвращает ключ Data[j] с индексом j=0..Count-1 в массиве Data.
 TKeyOfFunction = function(Data:Pointer; i:Integer):Pointer;
 // Процедура перестановки для сортировки массива "на месте".
 // Swap(Data,i,j) меняет местами элементы i,j массива Data.
 TSwapProcedure = procedure(Data:Pointer; i,j:Integer);
 // Процедура для определения ядра оконного сглаживания
 TSmoothKernel = function(x:Double; CustomData:Pointer):Double;
 //
 // Класс TScriptInterpreter применяется для вычисления аналитически заданных
 // выражений и выполнения сценариев на языке Daq Script.
 //
 TScriptInterpreter = class(TObject)
  //
  // 0    - Чтение значения переменной.
  //
  function  GetValue(aName:PChar; var aValue:Double):Boolean;            virtual; abstract;
  //
  // 1    - Запись значения переменной. Создание переменной.
  //
  function  SetValue(aName:PChar; var aValue:Double):Boolean;            virtual; abstract;
  //
  // 2    - Очистка всех переменных.
  //
  procedure Clear;                                                       virtual; abstract;
  //
  // 3    - Вычисляет выражение.
  //
  function  Evaluate(aExpression:PChar):Integer;                         virtual; abstract;
  //
  // 4    - Возвращает текст сценария.
  //
  function  GetScript:LongString;                                        virtual; abstract;
  //
  // 5    - Задает текст сценария.
  //
  procedure SetScript(const aScript:LongString);                         virtual; abstract;
  //
  // 6    - Выполняет сценарий Script.
  //
  function  RunScript:Integer;                                           virtual; abstract;
  //
  // 7    - Возвращает статус последней операции.
  //
  function  Status:Integer;                                              virtual; abstract;
  //
  // 8    - Возвращает расшифровку статуса.
  //
  function  StatusMessage:ShortString;                                   virtual; abstract;
 public
  property  Script : LongString read GetScript write SetScript;
 end;
 //
 // Класс TPolynomWrap используется для построения полиномов методом наименьших
 // квадратов и может использоваться для параметрической аппроксимации гладких
 // данных. Полином задается в следующей форме:
 //  P(x) = P(z) = C[0]+C[1]*z+C[2]*z^2..., где z=(x-Center)/Scale
 // Сдвиг Center и масштаб Scale нужны, чтобы избежать вырожденности базисной
 // системы функций полинома в случае, когда массив данных смещен и растянут
 // по оси абсцисс. Оптимальный выбор состоит в том, чтобы после масштабирования
 // переменная z менялась в интервале [0..1].
 //
 TPolynomWrap = class(TObject)
  //
  // 0    - Возвращает степень полинома.
  //
  function  GetPower:Integer;                                            virtual; abstract;
  //
  // 1    - Задает степень полинома.
  //
  procedure SetPower(aPower:Integer);                                    virtual; abstract;
  //
  // 2    - Возвращает коэффициент полинома.
  //
  function  GetCoeff(aIndex:Integer):Double;                             virtual; abstract;
  //
  // 3    - Задает коэффициент полинома.
  //
  procedure SetCoeff(aIndex:Integer; aValue:Double);                     virtual; abstract;
  //
  // 4    - Возвращает центр (смещение) полинома.
  //
  function  GetCenter:Double;                                            virtual; abstract;
  //
  // 5    - Задает центр (смещение) полинома.
  //
  procedure SetCenter(aCenter:Double);                                   virtual; abstract;
  //
  // 6    - Возвращает масштабный фактор полинома.
  //
  function  GetScale:Double;                                             virtual; abstract;
  //
  // 7    - Задает масштабный фактор полинома.
  //
  procedure SetScale(aScale:Double);                                     virtual; abstract;
  //
  // 8    - Возвращает значение полинома или значение производной с номером
  //        aDerivNum в точке at.
  //
  function  Get(at:Double; aDerivNum:Integer=0):Double;                  virtual; abstract;
  //
  // 9    - Находит методом наименьших квадратов коэффициетны полинома, которые
  //        аппроксимируют выборку (X[i],Y[i]), i=0..NumPoints-1 с единичными весами
  //
  function  Find(const X,Y:array of Double; NumPoints:Integer;
                 Eps:double=1E-14):boolean;                              virtual; abstract;
  //
  // 10   - Находит методом наименьших квадратов коэффициетны полинома, которые
  //        аппроксимируют выборку (X[i],Y[i]), i=0..NumPoints-1 с заданными
  //        весовыми факторами W[i].
  //
  function  FindWeight(const X,Y,W:array of Double; NumPoints:Integer;
                       Eps:double=1E-14):boolean;                        virtual; abstract;
 public
  property  Power:Integer                read GetPower  write SetPower;
  property  Coeff[aIndex:Integer]:Double read GetCoeff  write SetCoeff; default;
  property  Center:Double                read GetCenter write SetCenter;
  property  Scale:Double                 read GetScale  write SetScale;
 end;
 //
 // Классы TLongIntVectorWrap,TDoubleVectorWrap,TLongIntMatrixWrap,TDoubleMatrixWrap
 // реализуют защищенные в смысле ошибок индексации и потоков векторы и матрицы.
 // Lock/UnLock - служит для входа-выхода в потокозащищенную область кода.
 // Origin      - номер первого индекса массива, по умолчанию ноль.
 // Length      - текущая длина вектора.
 // Rows        - текущее число строк матрицы.
 // Cols        - текущее число столбцов матрицы.
 // Exceptions  - разрешение генерации исключений при выходе индекса за диапазон.
 // Пример:
 //  var x:TDoubleVectorWrap; y:TDoubleMatrixWrap; i,j:Integer;
 //  x:=CreateDoubleVector(100);
 //  y:=CreateDoubleMatrix(100,100);
 //  x.Lock;
 //  y.Lock;
 //  try
 //   for i:=0 to x.Length-1 do x[i]:=i;
 //   for i:=0 to y.Rows-1 do for j:=0 to y.Cols-1 do y[i,j]:=x[i]*j;
 //  finally
 //   y.UnLock;
 //   x.UnLock;
 //  end;
 //  x.Free;
 //  y.Free;
 //
 TLongIntVectorWrap = class(TObject)
  procedure Lock;                                                        virtual; abstract;
  procedure UnLock;                                                      virtual; abstract;
  function  GetLength:LongInt;                                           virtual; abstract;
  procedure SetLength(aLength:LongInt);                                  virtual; abstract;
  function  GetOrigin:LongInt;                                           virtual; abstract;
  procedure SetOrigin(aOrigin:LongInt);                                  virtual; abstract;
  function  GetExceptions:Boolean;                                       virtual; abstract;
  procedure SetExceptions(aExcepts:Boolean);                             virtual; abstract;
  function  GetItem(aIndex:LongInt):LongInt;                             virtual; abstract;
  procedure SetItem(aIndex:LongInt; const aValue:LongInt);               virtual; abstract;
  function  GetItemPtr(aIndex:LongInt):PLongInt;                         virtual; abstract;
 public
  property    Length             : LongInt  read GetLength     write SetLength;
  property    Origin             : LongInt  read GetOrigin     write SetOrigin;
  property    Exceptions         : Boolean  read GetExceptions write SetExceptions;
  property    Item[i:LongInt]    : LongInt  read GetItem       write SetItem; default;
  property    ItemPtr[i:LongInt] : PLongInt read GetItemPtr;
 end;
 TDoubleVectorWrap = class(TObject)
  procedure Lock;                                                        virtual; abstract;
  procedure UnLock;                                                      virtual; abstract;
  function  GetLength:LongInt;                                           virtual; abstract;
  procedure SetLength(aLength:LongInt);                                  virtual; abstract;
  function  GetOrigin:LongInt;                                           virtual; abstract;
  procedure SetOrigin(aOrigin:LongInt);                                  virtual; abstract;
  function  GetExceptions:Boolean;                                       virtual; abstract;
  procedure SetExceptions(aExcepts:Boolean);                             virtual; abstract;
  function  GetItem(aIndex:LongInt):Double;                              virtual; abstract;
  procedure SetItem(aIndex:LongInt; const aValue:Double);                virtual; abstract;
  function  GetItemPtr(aIndex:LongInt):PDouble;                          virtual; abstract;
 public
  property    Length             : LongInt read GetLength     write SetLength;
  property    Origin             : LongInt read GetOrigin     write SetOrigin;
  property    Exceptions         : Boolean read GetExceptions write SetExceptions;
  property    Item[i:LongInt]    : Double  read GetItem       write SetItem; default;
  property    ItemPtr[i:LongInt] : PDouble read GetItemPtr;
 end;
 TLongIntMatrixWrap = class(TObject)
  procedure Lock;                                                        virtual; abstract;
  procedure UnLock;                                                      virtual; abstract;
  function  GetRows:LongInt;                                             virtual; abstract;
  procedure SetRows(aRows:LongInt);                                      virtual; abstract;
  function  GetColumns:LongInt;                                          virtual; abstract;
  procedure SetColumns(aColumns:LongInt);                                virtual; abstract;
  function  GetOrigin:LongInt;                                           virtual; abstract;
  procedure SetOrigin(aOrigin:LongInt);                                  virtual; abstract;
  function  GetExceptions:Boolean;                                       virtual; abstract;
  procedure SetExceptions(aExcepts:Boolean);                             virtual; abstract;
  function  GetItem(aRow,aColumn:LongInt):LongInt;                       virtual; abstract;
  procedure SetItem(aRow,aColumn:LongInt; const aValue:LongInt);         virtual; abstract;
  function  GetItemPtr(aRow,aColumn:LongInt):PLongInt;                   virtual; abstract;
 public
  property  Rows                 : LongInt  read GetRows       write SetRows;
  property  Cols                 : LongInt  read GetColumns    write SetColumns;
  property  Origin               : LongInt  read GetOrigin     write SetOrigin;
  property  Exceptions           : Boolean  read GetExceptions write SetExceptions;
  property  Item[r,c:LongInt]    : LongInt  read GetItem       write SetItem; default;
  property  ItemPtr[r,c:LongInt] : PLongInt read GetItemPtr;
 end;
 TDoubleMatrixWrap = class(TObject)
  procedure Lock;                                                        virtual; abstract;
  procedure UnLock;                                                      virtual; abstract;
  function  GetRows:LongInt;                                             virtual; abstract;
  procedure SetRows(aRows:LongInt);                                      virtual; abstract;
  function  GetColumns:LongInt;                                          virtual; abstract;
  procedure SetColumns(aColumns:LongInt);                                virtual; abstract;
  function  GetOrigin:LongInt;                                           virtual; abstract;
  procedure SetOrigin(aOrigin:LongInt);                                  virtual; abstract;
  function  GetExceptions:Boolean;                                       virtual; abstract;
  procedure SetExceptions(aExcepts:Boolean);                             virtual; abstract;
  function  GetItem(aRow,aColumn:LongInt):Double;                        virtual; abstract;
  procedure SetItem(aRow,aColumn:LongInt; const aValue:Double);          virtual; abstract;
  function  GetItemPtr(aRow,aColumn:LongInt):PDouble;                    virtual; abstract;
 public
  property  Rows                 : LongInt  read GetRows       write SetRows;
  property  Cols                 : LongInt  read GetColumns    write SetColumns;
  property  Origin               : LongInt  read GetOrigin     write SetOrigin;
  property  Exceptions           : Boolean  read GetExceptions write SetExceptions;
  property  Item[r,c:LongInt]    : Double   read GetItem       write SetItem; default;
  property  ItemPtr[r,c:LongInt] : PDouble  read GetItemPtr;
 end;
 //
 // Класс TSVDWrap - оболочка для выполнения сингулярного разложения матриц,
 // решения линейных уравнений в смысле наименьших квадратов и т.д.
 // Теория.
 // Сингулярное разложение (singular values decomposition,SVD) матрицы A размера
 // M строк на N столбцов A[M*N] - это разложение на произведение трех матриц
 // U[M*M],W[M*N],V[N*N] вида A=U*W*V', где V' означает "V транспонированное".
 // Столбцы U[M*M], "left singular vectors",  являются собственными векторами A*A'.
 // Столбцы V[N*N], "right singular vectors", являются собственными векторами A'*A.
 // Матрицы U и V унитарные, это значит, U'*U=I(M), V'*V=I(N), где I(N),I(M)
 // обозначает единичную матрицу размера N или M. Матрица W[M*N] - диагональная,
 // так что W[i,j]=0 при i<>j. Диагональные элементы W[i]=W[i,i],i=1..N - это
 // сингулярные числа (singular values) матрицы A. Их квадраты Sqr(W[i]) являются
 // собственными числам матрицы A'*A. Сингулярные числа всегда неотрицательны,
 // то есть W[i]>=0. Сингулярное разложение существует для любых матриц, в том
 // числе вырожденных. Если матрица невырождена, все W[i]>0. Если матрица вырождена,
 // ее ранг равен числу ненулевых W[i]. На практике, где играют роль ошибки вычислений,
 // используется малое число Eps для определения "нулевых" сингулярных чисел.
 // Число Cond(A)=Max(W[i])/Min(W[i]) называется "числом обусловленности".
 // Чем больше значение этого числа, тем матрица ближе к вырожденной, такие
 // матрицы называют плохо обусловленными.
 // Применение в МНК.
 // В методе наименьших квадратов возникают линейные системы A*X=Y, где
 // A[M*N],X[N],Y[M] и M>=N. В точном смысле мы ищем вектор X, минимизирующий
 // сумму квадратов отклонений, или длину вектора невязки R=A*X-Y, то есть
 // ищется минимум квадратичной функции {R'*R}. Что дает сингулярное разложение?
 // Во-первых, |R|=|U'*R|, так как умножение на унитарную матрицу не меняет
 // длину вектора. Возьмем сингулярное разложение A=U*W*V'. Введем новый вектор
 // переменных Z=V'*X и вектор констант D=U'*Y.
 // Имеем: |R|=|U'*(A*X-Y)|=|U'*U*W*V'*X-U'*Y|=|W*Z-D|, так как U'*U=I.
 // Минимизация стала тривиальной, так как W - диагональная матрица.
 // Решение Z=pinv(W,Eps)*D, где pinv(W,Eps) - диагональная "псевдообратная"
 // матрица: pinv(W,Eps)[i]=1/W[i],если W[i]>Eps; pinv(W,Eps)[i]=0,если W[i]<=Eps,
 // где Eps - порог "нулевых" сингулярных чисел. Eps используется для повышения
 // устойчивости решения. Теперь V'*X=pinv(W,Eps)*U'*Y, так что окончательное
 // решение МНК запишется в виде X=V*pinv(W,Eps)*U'*Y.
 // Матрица pinv(A,Eps)=V*pinv(W,Eps)*U' - "псевдообратная" с порогом Eps.
 // Итак, МНК система A*X=Y имеет решение X=pinv(A,Eps)*Y, где "псевдообратная"
 // матрица pinv(A,Eps)=V*pinv(W,Eps)*U' и Eps - малое число для устойчивости.
 // Примечание 1:
 // На практике используют матрицу U[M*N] вместо U[M*M] и вектор W[N] вместо W[M*N].
 // Это обусловлено тем, что W[i,j]=0, при i<>j. Поэтому нет практического смысла
 // хранить недиагональные элементы W[i,j], а также столбцы N..M-1 матрицы U.
 // Класс TSVDWrap поэтому также использует матрицу U[M*N] и вектор W[N].
 // Методы:
 // M,N   - размерность исходной матрицы A[M*N]
 // Eps   - порог "малости" для сингулярных чисел с заданной абсолютной и относительной точностью.
 // Rank  - ранг матрицы, то есть число сингулярных чисел, превышающих пороговое значение Eps.
 // Solve - решение системы линейных уравнений A*X=Y размера M*N в смысле наименьших квадратов, A=U*W*V'.
 // PInv  - вычисление (псевдо) обратной матрицы размера N*M.
 //
 TSVDWrap=class(TObject)
  function  GetM:Integer;                                                virtual; abstract;
  function  GetN:Integer;                                                virtual; abstract;
  function  GetU(i,j:Integer):Double;                                    virtual; abstract;
  function  GetW(i:Integer):Double;                                      virtual; abstract;
  function  GetV(i,j:Integer):Double;                                    virtual; abstract;
  function  Eps(AbsEps:Double=0; RelEps:Double=1E-10):Double;            virtual; abstract;
  function  Rank(AbsEps:Double=0; RelEps:Double=1E-10):Integer;          virtual; abstract;
  function  Solve(X,Y:TDoubleVectorWrap;
                  AbsEps:Double=0; RelEps:Double=1E-10):Boolean;         virtual; abstract;
  function  PInvert(AbsEps:Double=0;
                    RelEps:Double=1E-10):TDoubleMatrixWrap;              virtual; abstract;
 public
  property M               : Integer read GetM;  // Число строк матрицы  A
  property N               : Integer read GetN;  // Число столбцов матрицы A
  property U[i,j:Integer]  : Double  read GetU;  // U[0..M-1,0..N-1] -> A=U*W*V'
  property W[i:Integer]    : Double  read GetW;  // W[0..N-1]        -> A=U*W*V'
  property V[i,j:Integer]  : Double  read GetV;  // V[0..N-1,0..N-1] -> A=U*W*V'
 end;
 //
 // Класс TFifoWrap служит для потокобезопасной передачи данных между потоками
 // через буфер FIFO. Операция передачи данных является атомарной, она либо
 // проходит целиком, либо аннулируется. Это гарантирует корректную передачу
 // потока данных между потоками.
 //
 TFifoWrap = class(TObject)
  procedure   Lock;                                                      virtual; abstract;
  procedure   UnLock;                                                    virtual; abstract;
  procedure   Clear;                                                     virtual; abstract;
  function    GetCount:LongInt;                                          virtual; abstract;
  function    GetSpace:LongInt;                                          virtual; abstract;
  function    GetSize:LongInt;                                           virtual; abstract;
  function    GetName:ShortString;                                       virtual; abstract;
  procedure   SetName(const NewName:ShortString);                        virtual; abstract;
  function    GetTag(i:Integer):LongWord;                                virtual; abstract;
  procedure   SetTag(i:Integer; NewTag:LongWord);                        virtual; abstract;
  function    GetLost:Int64;                                             virtual; abstract;
  procedure   SetLost(N:Int64);                                          virtual; abstract;
  function    Put(Buffer:Pointer; BufferSize:LongInt;
                  TryMode:Boolean=false):LongInt;                        virtual; abstract;
  function    Get(Buffer:Pointer; BufferSize:LongInt):LongInt;           virtual; abstract;
  function    PutText(const S:LongString;
                      TryMode:Boolean=false):Boolean;                    virtual; abstract;
  function    GetText(MaxLen:Integer=MaxInt):LongString;                 virtual; abstract;
 public
  property    Name           : ShortString read GetName  write SetName;  // Имя буфера
  property    Tag[i:Integer] : LongWord    read GetTag   write SetTag;   // Теги для хранения пользовательских данных
  property    Count          : LongInt     read GetCount;                // Сколько байт хранится в буфере
  property    Space          : LongInt     read GetSpace;                // Сколько байт в буфере свободно
  property    Size           : LongInt     read GetSize;                 // Размер буфера
  property    Lost           : Int64       read GetLost  write SetLost;  // Число потерянных байт
 end;
 //
 //
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Определения интерфейсов динамических расширений CRW32.                    //
 // 1) Для чего это надо.                                                     //
 //    Известно, что написать программу на все случаи жизни невозможно, хотя  //
 //    и хочется. Однако можно сделать средства, позволяющие разрабатывать,   //
 //    редактировать, компилировать и тут же, на ходу, вызывать на исполнение //
 //    динамические библиотеки DLL. Если DLL будет уметь общаться программой, //
 //    можно серьезно расширить функциональность программы без модификации, а //
 //    за счет создания внешних динамических расширений или утилит. Если при  //
 //    этом встроить компилятор в программу, программа приобретает новое      //
 //    качество - становится саморасширяемой проблеммно-ориентированной       //
 //    средой разработки. Пакет CRW32, например, содержит интегрированный     //
 //    компилятор Delphi, точнее, его подмножество.                           //
 // 2) Как это реализуется.                                                   //
 //    Создается виртуальный абстрактный интерфейсный класс. Это значит, что  //
 //    он содержит ТОЛЬКО виртуальные абстрактные методы, дающие динамически  //
 //    вызываемой DLL (клиенту) доступ к данным и процедурам сервера, то есть //
 //    программный интерфейс (API). Допустимы также свойства (property), если //
 //    они определяются через виртуальные методы. Фактически абстрактный      //
 //    класс - это просто таблица указателей на функции, общая для сервера и  //
 //    клиента. Практически то же, что COM - интерфейс, только проще.         //
 //    Основная программа (сервер) создает порожденный класс, перекрывающий   //
 //    все абстрактные методы, но клиент не знает, как сервер их реализует.   //
 //    Клиент, то есть DLL, экспортирует функцию вида:                        //
 //      function Plugin(Api:TPluginApi):Integer; StdCall;                    //
 //    Через экземпляр объекта API клиент получает доступ к тем данным и      //
 //    методам, которые сервер считает нужным предоставить. После создания и  //
 //    компиляции утилиты сервер может вызвать клиента, так как способ вызова //
 //    четко зафиксирован. Клиент же может сделать, все, что позволяет данный //
 //    ему сервером интерфейс.                                                //
 // 3) Некоторые договоренности.                                              //
 //    Чтобы обеспечить непротиворечивую расширяемость интерфейса, он должен  //
 //    строиться как дерево интерфейсов, то есть интерфейс может содержать    //
 //    в качестве методов функции для доступа к другим интерфейсам. Дерево    //
 //    интерфейсов может только расти, удалять или менять сигнатуры или       //
 //    порядок ранее объявленных методов запрещено. Поэтому клиент может быть //
 //    уверен, что при обновлении версии сервера его интерфейс будет верным,  //
 //    хотя про новые методы ему ничего не известно.                          //
 //    Клиент возвращает 0, если все нормально, или код ошибки. Все прочие    //
 //    данные клиент передает и получает через функции API.                   //
 ///////////////////////////////////////////////////////////////////////////////
const
 //
 // Идентификатор экспортируемой функции DLL расширения CRW32.
 //
 CRW32_PLUGIN_ID    = 'CRW32_PLUGIN_FUNCTION';
 //
 // Идентификаторы назначения утилиты.
 //
 ForCalculations    = 0; // Для вычислений общего назначения.
 ForDataAnalysis    = 1; // Для анализа экспериментальных данных.
 ForDataAcquisition = 2; // Для системы сбора данных.

type
 ///////////////////////////////////////////////////////////////////////////////
 // Базовый класс интерфейса, служащего для подключения динамических          //
 // расширений пакета CRW32.                                                  //
 ///////////////////////////////////////////////////////////////////////////////
 TPluginApi = class(TObject)
  //
  // 0    - Эту функцию клиент не должен вызывать, ее вызывает только сервер.
  //
  procedure ServerActionsBeforeExecution;                                virtual; abstract;
  //
  // 1    - Эту функцию клиент не должен вызывать, ее вызывает только сервер.
  //
  procedure ServerActionsAfterExecution;                                 virtual; abstract;
 end;
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Динамическая библиотека для расширений CRW32 должна экспортировать        //
 // функцию с такой сигнатурой и именем CRW32_PLUGIN_ID.                      //
 ///////////////////////////////////////////////////////////////////////////////
 TPluginFun = function(Api:TPluginApi):Integer; StdCall;
 //
 // Классы интерфейсов CRW32.
 //
 TCrwApi    = class;            // Корень дерева интерфейсов CRW32 API.
 TSysApi    = class;            // API для функций общего назначения.
 TGuiApi    = class;            // API для создания графического интерфейса.
 TDaqApi    = class;            // API для систем сбора данных.
 TDanApi    = class;            // API для анализа данных.
 //
 // Исключения интерфейсов CRW32.
 //
 ECrwApi    = class(Exception);
 ESysApi    = class(Exception);
 EDaqApi    = class(Exception);
 EDanApi    = class(Exception);
 ///////////////////////////////////////////////////////////////////////////////
 // Класс CrwApi служит корнем дерева интерфейсов CRW API и служит для        //
 // доступа к другим проблеммно - ориентированным интерфейсам.                //
 ///////////////////////////////////////////////////////////////////////////////
 TCrwApi    = class(TPluginApi)
  //
  // 0    - Версия API, содержит дату создания, например, 20030215.
  //
  function  Version:Cardinal;                                            virtual; abstract;
  //
  // 1    - Проблемная ориентация интерфейса.
  //        Это может быть ForCalculations, ForDataAnalysis, ForDataAcquisition.
  //
  function  Target:Cardinal;                                             virtual; abstract;
  //
  // 2    - API для функций общего назначения.
  //
  function  SysApi:TSysApi;                                              virtual; abstract;
  //
  // 3    - API для функций графического интерфейса.
  //
  function  GuiApi:TGuiApi;                                              virtual; abstract;
  //
  // 4    - API для систем сбора данных.
  //
  function  DaqApi:TDaqApi;                                              virtual; abstract;
  //
  // 5    - API для анализа экспериментальных данных.
  //
  function  DanApi:TDanApi;                                              virtual; abstract;
 end;
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Класс TSysApi содержит функции общего назначения. Он доступен при всех    //
 // значениях Target.                                                         //
 ///////////////////////////////////////////////////////////////////////////////
 TSysApi = class(TPluginApi)
  //
  // 0    - Переназначает стандартный ввод на ввод с окна консоли приложения.
  //
  function  RedirectStdIn(var stdIn:Text):boolean;                       virtual; abstract;
  //
  // 1    - Переназначает стандартный вывод на вывод в окно консоли приложения.
  //
  function  RedirectStdOut(var stdOut:Text):boolean;                     virtual; abstract;
  //
  // 2    - Инкремент указателя.
  //
  function  IncPtr(Base:Pointer; ByteOffset:LongInt):Pointer;            virtual; abstract;
  //
  // 3    - Декремент указателя.
  //
  function  DecPtr(Base:Pointer; ByteOffset:LongInt):Pointer;            virtual; abstract;
  //
  // 4    - Перемещение данных с проверкой указателей.
  //
  procedure SafeMove(const Source; var Dest; Count: LongInt);            virtual; abstract;
  //
  // 5    - Заполнение области памяти заданным значением.
  //
  procedure SafeFillChar(var X; Count: LongInt; Value: Byte);            virtual; abstract;
  //
  // 6    - Применяется для выровнивания размер буфера Size по модулю Step.
  //
  function  AdjustBufferSize(Size:LongInt; Step:LongInt):LongInt;        virtual; abstract;
  //
  // 7    - Выделяет блок памяти заданного размера или nil при неудаче.
  //        Блок памяти автоматически заполняется нулями.
  //
  function  Allocate(N:LongInt):Pointer;                                 virtual; abstract;
  //
  // 8    - Освободить блок памяти, выделенный вызовом Allocate.
  //
  procedure Deallocate(var P:Pointer);                                   virtual; abstract;
  //
  // 9    - Узнать размер блока памяти, выделенного вызовом Allocate.
  //
  function  AllocSize(P:Pointer):LongInt;                                virtual; abstract;
  //
  // 10   - Перераспределить память, выделенную вызовом Allocate.
  //        Содержимое блока не меняется, дополнительная память зануляется.
  //
  function  Reallocate(var P:Pointer; N:LongInt):boolean;                virtual; abstract;
  //
  // 11   - Проверка вещественного числа на значение Not A Number.
  //
  function  isNAN(const X: Double): Boolean;                             virtual; abstract;
  //
  // 12   - Проверка вещественного числа на значение Infinity.
  //
  function  isINF(const X: Double): Boolean;                             virtual; abstract;
  //
  // 13   - Возвращает значение Not A Number, "не число".
  //
  function  _NaN: Double;                                                virtual; abstract;
  //
  // 14   - Возвращает значение +Infinity, "плюс бесконечность".
  //
  function  _PlusInf: Double;                                            virtual; abstract;
  //
  // 15   - Возвращает значение -Infinity, "минус бесконечность".
  //
  function  _MinusInf: Double;                                           virtual; abstract;
  //
  // 16   - Поиск нуля функции F(x) на интервале [A,B] с точностью Tol.
  //        Указатель Custom служит для передачи в F(x) пользовательских данных.
  //
  function  FindZero(F:zmFunType;A,B,Tol:Double;Custom:Pointer):Double;  virtual; abstract;
  //
  // 17   - Поиск минимума функции F(x)на интервале [A,B] с точностью Tol.
  //        Указатель Custom служит для передача в F(x) пользовательских данных.
  //
  function  FindMin(F:zmFunType;A,B,Tol:Double;Custom:Pointer):Double;   virtual; abstract;
  //
  // 18   - Поиск интеграла F(x) на интервале [A,B] с заданной абсолютной AbsErr
  //        и относительной RelErr точностью. Возвращает значение интеграла,
  //        а также оценку точности ErrEst, флаг ошибок Flag, который равен 0
  //        при успешном интегрировании, а также счетчик вызовов функции NoFun.
  //        Указатель Custom служит для передача в F(x) пользовательских данных.
  //        
  function  Quanc8(F:zmFunType;A,B,AbsErr,RelErr:Double; var ErrEst:Double;
            var NoFun:Integer; var Flag:Double; Custom:Pointer):Double;  virtual; abstract;
  //
  // 19   - Относительная точность представления вещественных чисел.
  //
  function  MachEps:double;                                              virtual; abstract;
  //
  // 20   - Текущее время в календарном формате.
  //
  function  NativeTimeNow:TSystemTime;                                   virtual; abstract;
  //
  // 21   - Текущее время в миллисекундах от Рождества Христа (01.01.0001-00:00:00).
  //
  function  MSecNow:double;                                              virtual; abstract;
  //
  // 22   - Назначить значение записи календарного времени.
  //
  function  AssignNativeTime(Year:word=1;Month:word=1;Day:word=1;
                             Hour:word=0;Minut:word=0;Sec:word=0;
                             mSec:word=0):TSystemTime;                   virtual; abstract;
  //
  // 23   - Преобразовать время из миллисекунд в календарное.
  //
  function  MSecToNativeTime(mSecond:Double):TSystemTime;                virtual; abstract;
  //
  // 24   - Преобразовать время из календарного в миллисекунды.
  //
  function  NativeTimeToMSec(const T:TSystemTime):double;                virtual; abstract;
  //
  // 25   - Преобразовать время из календарного в миллисекунды.
  //
  function  DateTimeToMSec(Year:Word=1;Month:Word=1;Day:Word=1;
                           Hour:Word=0;Minut:Word=0;Sec:Word=0;
                           mSec:Word=0):Double;                          virtual; abstract;
  //
  // 26   - Преобразовать время из миллисекунд в календарное.
  //
  procedure MSecToDateTime(T:Double;
                           var Year,Month,Day,Hour,Min,Sec,mSec:word);   virtual; abstract;
  //
  // 27   - Получить строку даты по времени в миллисекундах от Рождества Христа.
  //
  function  GetDateStr(ms:Double;Delim:Char='.';YMD_Order:Boolean=false;
                       ShortYear:Boolean=false):ShortString;             virtual; abstract;
  //
  // 28   - Получить строку времени суток по времени в миллисекундах от Рождества Христа.
  //
  function  GetTimeStr(ms:double;Delim:Char=':';
                       ShowMSec:Boolean=false):ShortString;              virtual; abstract;
  //
  // 29   - Длина строки, заверщающейся нулем.
  //
  function  StrLen(Str: PChar): LongInt;                                 virtual; abstract;
  //
  // 30   - Длина строки, но не более MaxLen.
  //
  function  StrLLen(Str: PChar; MaxLen: Integer): LongInt;               virtual; abstract;
  //
  // 31   - Возвращает указатель на ноль, завершающий строку Str.
  //
  function  StrEnd(Str: PChar): PChar;                                   virtual; abstract;
  //
  // 32   - Копирует строку Source в строку Dest и возвращает Dest.
  //
  function  StrCopy(Dest, Source: PChar): PChar;                         virtual; abstract;
  //
  // 33   - Копирует Source в Dest и возвращает StrEnd(Dest).
  //
  function  StrECopy(Dest, Source: PChar): PChar;                        virtual; abstract;
  //
  // 34   - копирует не более MaxLen символов из Source в Dest и возвращает Dest.
  //
  function  StrLCopy(Dest, Source: PChar; MaxLen: LongInt): PChar;       virtual; abstract;
  //
  // 35   - Копирует Pascal-строку Source в строку Dest и возвращает Dest.
  //
  function  StrPCopy(Dest: PChar; const Source: ShortString): PChar;     virtual; abstract;
  //
  // 36   - Добавляет копию Source в конец строки Dest и возвращает Dest.
  //
  function  StrCat(Dest, Source: PChar): PChar;                          virtual; abstract;
  //
  // 37   - Добавляет копию Pascal-строки Source в конец Dest и возвращает Dest.
  //
  function  StrPCat(Dest:PChar; const Source: ShortString): PChar;       virtual; abstract;
  //
  // 38   - Добавляет не более MaxLen - StrLen(Dest) символов из Source в хвост
  //        Dest, возвращает Dest.
  //
  function  StrLCat(Dest, Source: PChar; MaxLen: LongInt): PChar;        virtual; abstract;
  //
  // 39   - Сравнивает Str1 и Str2. Возвращает значение < 0 если Str1 < Str2,
  //        0 если Str1 = Str2, или значение > 0 если Str1 > Str2.
  //
  function  StrComp(Str1, Str2: PChar): Integer;                         virtual; abstract;
  //
  // 40   - Сравнивает Str1 и Str2, в режиме, нечувствительном к регистру символов.
  //
  function  StrIComp(Str1, Str2: PChar): Integer;                        virtual; abstract;
  //
  // 41   - Сравнивает Str1 и Str2, но не более MaxLen символов.
  //
  function  StrLComp(Str1, Str2: PChar; MaxLen: LongInt): Integer;       virtual; abstract;
  //
  // 42   - Сравнивает Str1 и Str2, но не более MaxLen символов, без учета регистра.
  //
  function  StrLIComp(Str1, Str2: PChar; MaxLen: LongInt): Integer;      virtual; abstract;
  //
  // 43   - Возвращает указатель на первое вхождение символа Chr в строку Str.
  //        Возвращает Nil, если в строке нет такого символа.
  //
  function  StrScan(Str: PChar; Chr: Char): PChar;                       virtual; abstract;
  //
  // 44   - Возвращает указатель на последнее вхождение символа Chr в строку Str.
  //        Возвращает Nil, если в строке нет такого символа.
  //
  function  StrRScan(Str: PChar; Chr: Char): PChar;                      virtual; abstract;
  //
  // 45   - Преобразует строку Str к верхнему регистру и возвращает Str.
  //
  function  StrUpper(Str: PChar): PChar;                                 virtual; abstract;
  //
  // 46   - Преобразует строку Str к нижнему регистру и возвращает Str.
  //
  function  StrLower(Str: PChar): PChar;                                 virtual; abstract;
  //
  // 47   - Возвращает указатель на первое вхождение строки Str2 в строку Str1.
  //        Возвращает NIL, если в строке нет вхождения искомой подстроки.
  //
  function  StrPos(Str1, Str2: PChar): PChar;                            virtual; abstract;
  //
  // 48   - Преобразует строку Str с завершающим нулем в Pascal-строку.
  //
  function  StrPas(Str: PChar): ShortString;                             virtual; abstract;
  //
  // 49   - Пропускает ведущие символы, входящие в множество PassChars.
  //        Возвращает указатель на первый символ, не входящий в PassChars.
  //
  function  StrPass(Str:PChar; const PassChars:TCharSet):PChar;          virtual; abstract;
  //
  // 50   - Копирует не более Count символов из Source в Dest и возвращает Dest.
  //        Source и Dest могут перекрываться.
  //
  function  StrMove(Dest, Source: PChar; Count: LongInt): PChar;         virtual; abstract;
  //
  // 51   - Вычисляет число строк текста, то есть число разделителей CRLF плюс 1.
  //        Count задает число символов в тексте. UnixStyle задает разделитель
  //        CR вместо CRLF.
  //
  function  GetTextNumLines(Text:PChar; Count:LongInt=MaxLongInt;
                            UnixStyle:boolean=false):LongInt;            virtual; abstract;
  //
  // 52   - Преобразование к верхнему регистру.
  //
  function  UpCase(c:Char):Char;                                         virtual; abstract;
  //
  // 53   - Преобразование к нижнему регистру.
  //
  function  LoCase(c:Char):Char;                                         virtual; abstract;
  //
  // 54   - Преобразование к нижнему регистру.
  //
  function  LoCaseStr(const S:ShortString):ShortString;                  virtual; abstract;
  //
  // 55   - Преобразование к верхнему регистру.
  //
  function  UpCaseStr(const S:ShortString):ShortString;                  virtual; abstract;
  //
  // 56   - Преобразование кодировки Windows(1251) в кодировку Dos(866).
  //
  function  WinToDos(c:Char):Char;                                       virtual; abstract;
  //
  // 57   - Преобразование кодировки Dos в кодировку Windows.
  //
  function  DosToWin(c:Char):Char;                                       virtual; abstract;
  //
  // 58   - Преобразование кодировки Windows в кодировку Dos.
  //
  function  WinToDosStr(const S:ShortString):ShortString;                virtual; abstract;
  //
  // 59   - Преобразование кодировку Dos в кодировку Windows.
  //
  function  DosToWinStr(const S:ShortString):ShortString;                virtual; abstract;
  //
  // 60   - Преобразование кодировки Windows в кодировку Dos.
  //
  function  WinToDosLongStr(const S:LongString):LongString;              virtual; abstract;
  //
  // 61   - Преобразование кодировки Dos в кодировку Windows.
  //
  function  DosToWinLongStr(const S:LongString):LongString;              virtual; abstract;
  //
  // 62   - Преобразование кодировки Windows в кодировку KOI-8.
  //
  function  WinToKoi(c:Char):Char;                                       virtual; abstract;
  //
  // 63   - Преобразование кодировки KOI-8 в кодировку Windows.
  //
  function  KoiToWin(c:Char):Char;                                       virtual; abstract;
  //
  // 64   - Преобразование кодировки Windows в кодировку KOI-8.
  //
  function  WinToKoiStr(const S:ShortString):ShortString;                virtual; abstract;
  //
  // 65   - Преобразование кодировки KOI-8 в кодировку Windows.
  //
  function  KoiToWinStr(const S:ShortString):ShortString;                virtual; abstract;
  //
  // 66   - Преобразование кодировки Windows в кодировку KOI-8.
  //
  function  WinToKoiLongStr(const S:LongString):LongString;              virtual; abstract;
  //
  // 67   - Преобразование кодировки KOI-8 в кодировку Windows.
  //
  function  KoiToWinLongStr(const S:LongString):LongString;              virtual; abstract;
  //
  // 68   - Защищенная версия функции Format.
  //
  function  Format(const Fmt:LongString;
                   const Args: array of const):LongString;               virtual; abstract;
  //
  // 69   - Создает множество символов, присутствующих в строке S.
  //
  function  Str2CharSet(const S:ShortString):TCharSet;                   virtual; abstract;
  //
  // 70   - Создать строку из символов, присутствующих в множестве S.
  //
  function  CharSet2Str(const S:TCharSet):ShortString;                   virtual; abstract;
  //
  // 71   - Копировать из строки S символы pos..length(S).
  //
  function  RightStr(const S:ShortString; pos:integer):ShortString;      virtual; abstract;
  //
  // 72   - Копировать из строки символы 1..count.
  //
  function  LeftStr(const S:ShortString; count:integer):ShortString;     virtual; abstract;
  //
  // 73   - Вернет строку длиной len, заполненную символами ch.
  //
  function  CharStr(Len:Byte; Ch:Char=' '):ShortString;                  virtual; abstract;
  //
  // 74   - Возвращает строку S, дополненную справа до длины len символами ch.
  //
  function  Pad(const S:ShortString; Len:Byte; Ch:Char=' '):ShortString; virtual; abstract;
  //
  // 75   - Возвращает строку S, дополненную слева до длины len символами ch.
  //
  function  LeftPad(const S:ShortString; Len:Byte;
                    Ch:Char=' '):ShortString;                            virtual; abstract;
  //
  // 76   - Возвращает строку S, дополненную симметрично слева и справа до длины
  //        Width символами Ch, так что исходная строка оказывается в центре.
  //
  function  CenterStr(const S:ShortString; Width:Byte;
                      Ch:Char=' '):ShortString;                          virtual; abstract;
  //
  // 77   - Возвращает строку без пробелов в начале строки. TrimChars определяет,
  //        что считается пробелом.
  //
  function  TrimLeadChars(const S:ShortString;
                          const TrimChars:TCharSet):ShortString;         virtual; abstract;
  //
  // 78   - Возвращает строку без пробелов в конце строки. TrimChars определяет,
  //        что считается пробелом.
  //
  function  TrimTrailChars(const S:ShortString;
                           const TrimChars:TCharSet):ShortString;        virtual; abstract;
  //
  // 79   - Возвращает строку без пробелов в начале и в конце строки.
  //        LeadTrim,TrailTrim определяют, что считается пробелом.
  //
  function  TrimChars(const S:ShortString;
                      const LeadTrim,TrailTrim:TCharSet):ShortString;    virtual; abstract;
  //
  // 80   - Возвращает строку без пробелов в начале строки.
  //        Пробелами считаются символы [#0..' '].
  //
  function  TrimLead(const S:ShortString):ShortString;                   virtual; abstract;
  //
  // 81   - Возвращает строку без пробелов в конце строки.
  //        Пробелами считаются символы [#0..' '].
  //
  function  TrimTrail(const S:ShortString):ShortString;                  virtual; abstract;
  //
  // 82   - Возвращает строку без пробелов в начале и конце строки.
  //        Пробелами считаются символы [#0..' '].
  //
  function  Trim(const S:ShortString):ShortString;                       virtual; abstract;
  //
  // 83   - Функция преобразует строки имен к виду, позволяющему непосредственно
  //        сравнивать их. Например, имена " one " и "One" эквивалентны, хотя их
  //        строковое представление различно. Функция преобразует их в "ONE".
  //        Считается что в именах регистр и пробелы - незначащие.
  //        Текущая реализация - UpcaseStr(Trim(Name)).
  //
  function  UnifyAlias(const Name:ShortString):ShortString;              virtual; abstract;
  //
  // 84   - Преобразует имена файлов к каноническому виду, допускающему
  //        непосредственное сравнение имен файлов как строк. Для этого строка
  //        имени файла преобразуется к полному имени, незначащие пробелы удаляются,
  //        имя преобразуется в верхний регистр. Например, имена файлов
  //        "c:\daq\1110\config\1110.cfg" и "C:\DAQ\1110\DATA\..\CONFIG\1110.CFG"
  //        эквивалентны, хотя имеют разное строковое предстваление. Функция
  //        преобразует их к "C:\DAQ\1110\CONFIG\1110.CFG".
  //        Надо отметить, что для имен файлов Unix это не работает - там имена
  //        файлов чувствительны к регистру.
  //        Текущая реализация - UpcaseStr(Trim(FExpand(Name))).
  //
  function  UnifyFileAlias(const FileName:ShortString):ShortString;      virtual; abstract;
  //
  // 85   - Преобразует любую строку в корректный заголовок секции.
  //        Например, строки 'Section', '[Section', 'Section]', '[Section]'
  //        будут преобразованы в '[SECTION]'.
  //
  function UnifySection(const aSectionName:ShortString):ShortString;     virtual; abstract;
  //
  // 86   - Делает перенос строки InSt, чтобы строка умещалась в поле Margin,
  //        сохраняет результат OutSt, а остаток строки в Overlap.
  //
  procedure WordWrap(const InSt:ShortString; var OutSt, Overlap:ShortString;
                     Margin:Byte; PadToMargin:Boolean);                  virtual; abstract;
  //
  // 87   - Заменяет в строке Str все вхождения подстроки Find на строку Replace.
  //
  function ReplaceString(const Str,Find,Replace:ShortString):ShortString;virtual; abstract;
  //
  // 88   - Делает замену символов форматирования ^L,^R,^C,^N,^B на строки
  //        '^L','^R','^C','^N','^B' или наоборот. Символы форматирования:
  //        ^L - выравнивание по левому краю
  //        ^R - выравнивание по правому краю
  //        ^C - выравнивание по центру
  //        ^N - переход на новую строку
  //
  function ReplaceAlignStr(const Str:ShortString;
                           Invert:Boolean):ShortString;                  virtual; abstract;
  //
  // 89   - Найти в строке S число слов, разделенных пробелами WordDelims.
  //
  function  WordCount(const S:ShortString;
                      const WordDelims:TCharSet):Byte;                   virtual; abstract;
  //
  // 90   - Выделить из строки S слово номер N. Слова разделены пробелами WordDelims.
  //
  function  ExtractWord(N:Byte; const S:ShortString;
                                const WordDelims:TCharSet):ShortString;  virtual; abstract;
  //
  // 91   - Возвращает порядковый номер слова Name в наборе слов, составляющих
  //        строку Str. Слова разделены пробелами WordDelims.
  //        Возвращает ноль, если слово не найдено.
  //
  function  WordIndex(const Name,Str:ShortString;
                      const Delims:TCharSet):Byte;                       virtual; abstract;
  //
  // 92   - Выделяет слово, а затем пытается преобразовать его в целое число.
  //
  function  ExtractInt(N:Byte; const S:ShortString; const WordDelims:TCharSet;
                               var Value:LongInt):boolean;               virtual; abstract;
  //
  // 93   - Выделяет слово, а затем пытается преобразовать его в вещественное число.
  //
  function  ExtractReal(N:Byte; const S:ShortString; const WordDelims:TCharSet;
                                var Value:Double):boolean;               virtual; abstract;
  //
  // 94   - Преобразует байт в строку в двоичной системе счисления.
  //
  function  BinB(x:Byte):ShortString;                                    virtual; abstract;
  //
  // 95   - Преобразует слово в строку в двоичной системе счисления.
  //
  function  BinW(x:Word):ShortString;                                    virtual; abstract;
  //
  // 96   - Преобразует целое число в строку в двоичной системе счисления.
  //
  function  BinL(x:LongWord):ShortString;                                virtual; abstract;
  //
  // 97   - Преобразует байт в строку в восьмиричной системе счисления.
  //
  function  OctB(x:Byte):ShortString;                                    virtual; abstract;
  //
  // 98   - Преобразует слово в строку в восьмиричной системе счисления.
  //
  function  OctW(x:Word):ShortString;                                    virtual; abstract;
  //
  // 99   - Преобразует целое число в строку в восьмиричной системе счисления.
  //
  function  OctL(x:LongInt):ShortString;                                 virtual; abstract;
  //
  // 100  - Преобразует байт в строку в шестнадцатиричной системе счисления.
  //
  function  HexB(x:Byte):ShortString;                                    virtual; abstract;
  //
  // 101  - Преобразует слово в строку в шестнадцатиричной системе счисления.
  //
  function  HexW(x:Word):ShortString;                                    virtual; abstract;
  //
  // 102  - Преобразует целое число в строку в шестнадцатиричной системе счисления.
  //
  function  HexL(x:LongWord):ShortString;                                virtual; abstract;
  //
  // 103  - Преобразует целое число в строку.
  //
  function  Long2Str(L:LongInt):ShortString;                             virtual; abstract;
  //
  // 104  - Преобразует вещественное число в строку в фиксированном формате.
  //
  function  Real2Str(R:Double; Width:Integer=0;
                     Places:Integer=0):ShortString;                      virtual; abstract;
  //
  // 105  - Преобразует целое число в строку.
  //
  function  d2s(d:LongInt; Width:Integer=0):ShortString;                 virtual; abstract;
  //
  // 106  - Преобразует вещественное число в строку в свободном формате.
  //        Параметры задаются в f2sFormat.
  //
  function  f2s(f:Double):ShortString;                                   virtual; abstract;
  //
  // 107  - Задает параметры для функции f2s - ширину и число значащих цифр.
  //
  procedure f2sFormat(Width:Integer=0; Decimals:Integer=14);             virtual; abstract;
  //
  // 108  - Восстанавливает предыдущее значение параметров f2s.
  //
  procedure f2sFormatOld;                                                virtual; abstract;
  //
  // 109  - Преобразует вещественное число в строку в свободном формате.
  //        Аналогично Format('%w.dg',[X]).
  //
  function  FormatG(X:Double; w:integer; d:integer):ShortString;         virtual; abstract;
  //
  // 110  - Преобразует строку "a" в целое число "i".
  //        Если первый символ строки "$", преобразует как шестнадцатиричное.
  //
  function  atoi(a:PChar; var i:LongInt):boolean;                        virtual; abstract;
  //
  // 111  - Преобразует строку "a" в вещественное число "f".
  //        Если первый символ строки "$", преобразует как шестнадцатеричное целое.
  //
  function  atof(a:PChar; var f:double):boolean;                         virtual; abstract;
  //
  // 112  - Преобразует строку в целое число.
  //
  function  Str2Int(const S:ShortString; var I:Integer):Boolean;         virtual; abstract;
  //
  // 113  - Преобразует строку в целое беззнаковое.
  //
  function  Str2Word(const S:ShortString; var I:Word):Boolean;           virtual; abstract;
  //
  // 114  - Преобразует строку в целое число.
  //
  function  Str2Long(const S:ShortString; var I:LongInt):Boolean;        virtual; abstract;
  //
  // 115  - Преобразует строку в вещественное число.
  //
  function  Str2Real(const S:ShortString; var R:Double):Boolean;         virtual; abstract;
  //
  // 116  - Преобразует строку в вещественное число.
  //        Присвоение делает, только если строковые представления старого
  //        и нового значения различны. Это полезно при обработке полей ввода.
  //
  function SmartStr2Real(const S:ShortString; var R:Double):Boolean;     virtual; abstract;
  //
  // 117  - Преобразование строки в целое число в двоичной системе.
  //
  function  StrBin2Long(const S:ShortString; var L:LongInt):Boolean;     virtual; abstract;
  //
  // 118  - Преобразование строки в целое число в восьмеричной системе.
  //
  function  StrOct2Long(const S:ShortString; var L:LongInt):Boolean;     virtual; abstract;
  //
  // 119  - Преобразование строки в целое число в шестнадцатеричной системе.
  //
  function  StrHex2Long(const S:ShortString; var L:LongInt):Boolean;     virtual; abstract;
  //
  // 120  - Форматное чтение переменных с префиксом для идентификации.
  //        Формат состоит из слов,разделенных символом CR или ; типа
  //        prefix1%format1+CR+
  //        prefix2%format2+CR+
  //        ....
  //        prefixN%formatN
  //        Префикс-строка для поиска в тексте (может отсутствовать)
  //        Форматы должны быть одной из указанных строк:
  //        %s - чтение ShortString(Data) после префикса до символа CR или конца строки,
  //             но не более 255 символов
  //        %a - чтение ShortString(Data) после префикса и пробелов слова,содержащего
  //             символы, отличные от пробелов (ScanSpaces), но не более 255 символов
  //        %d - чтение LongInt(Data) после префикса и пробелов
  //        %w - чтение Word
  //        %i - чтение Integer
  //        %b - чтение Boolean (0,1,False,True,Yes,No-по первой букве)
  //        %f - чтение Double(Data) после префикса и пробелов
  //        %c - чтение Char(Data) сразу после префикса
  //        ScanVar возвращает указатель на символ после последней прочтенной
  //        переменной в тексте или nil в случае:
  //         если не найден префикс поиска в тексте ( если он был в формате)
  //         если не найден ни один из форматов %s,%f,%d,%c,%a,%w,%i,%b
  //         в строке формата
  //        пример:
  //         var
  //          Data:record S:ShortString; D:LongInt; F:Double; C:Char end;
  //         const
  //          InputStr='Найти Var1=Cтрока'+CR+
  //                   '      Var2= 100'+CR+
  //                   '      Var3= -3.14'+CR+
  //                   '      Var4=&';
  //          begin
  //           if ScanVar(svAsIs,InputStr,'Var1=%s'+CR+
  //                                      'Var2=%d'+CR+
  //                                      'Var3=%f'+CR+
  //                                      'Var4=%c',Data)=nil then error;
  //         результат:
  //          Data.S='Строка';
  //          Data.D=100;
  //          Data.F:=-3.14;
  //          Data.C='&';
  //        Режим чтения задает способ выделения переменной
  //        svUpCase/svLoCase
  //         Переводят строку формата в верхний/нижний регистр и нужны для того чтобы
  //         переменные читались независимо от регистра, надо только сам текст тоже
  //         привести к этому регистру. Например:
  //          S=StrUpper('SomeVar=1000')
  //          ScanVar(svUpCase,S,'somevar%d'...    - прочитается
  //          ScanVar(svNoCase,S,'somevar%d'...    - не прочитается, разные регистры
  //        svLSpace/svRSpace
  //         Анализируют наличие пробелов слева/справа от выделенного префикса, чтобы
  //         одинаковые фрагменты слов не приводили к ошибочному чтению.
  //         Например, в строке
  //          S='Var10 = 1, Var1 = 10'
  //         фрагмент Var1 - общий для обеих переменных, тогда
  //          ScanVar(0,S,'Var1%s'... прочитает 0, так как воспримет в качестве
  //          префикса вхождение Var1 в строку Var10
  //          ScanVar(svRSpace+svLSpace прочитает правильно, так как выделит только
  //          цельное слово Var1 (так чтобы слева и справа от слова были пробелы)
  //         В то же время в конструкции S='Sin(10)' надо читать
  //         ScanVar(0,'Sin(%f'... , а не ScanVar(svRSpace,'Sin(%f'...
  //         так как значение идет сразу после префикса без пробела
  //        svOrigin
  //         начинает поиск каждого префикса с начала текста, чтобы чтение переменных
  //         не зависело от их порядка, например
  //         если S='Var2 = 1, Var1 = 2', то
  //              ScanVar(0,'Var1%d;Var2%d' - не прочитает так как Var1 - после Var2
  //              ScanVar(svOrigin,'Var1%d;Var2%d'- прочитает
  //         в то же время для жестких конструкций svOrigin не пригоден, например
  //         если S='Var = 1 , 2, 3, 4', то надо читать ScanVar(0,'Var%w;,%w;,%w;,%w
  //         так как при чтении ScanVar(svOrigin,.... вместо 3, 4 будет прочитано
  //         2, 2 - число после ПЕРВОЙ запятой в тексте
  //         Отметим, что пустой префикс не ведет переходу на начало текста то есть
  //         в предыдущем примере можно читать ScanVar(0,'Var%w;%w;%w;%w'....
  //
  function  ScanVar(svMode:word; Str:PChar;
                    const Format:ShortString; var Data):PChar;           virtual; abstract;
  //
  // 121  - Проверяет, содержит ли строка S отличные от пробелов символы.
  //
  function  IsEmptyStr(const S:ShortString):boolean;                     virtual; abstract;
  //
  // 122  - Найти индекс последнего вхождения символа - разделителя из набора
  //        символов Delimiters в строке S. Возвращает ноль, если в строке нет
  //        символов - разделителей.
  //
  function  LastDelimiter(const Delimiters:TCharSet;
                          const S:ShortString):Integer;                  virtual; abstract;
  //
  // 123  - Удалить из имени каталога DirName незначащие пробелы и добавить
  //        обратный слеш "\" в конец строки, если его нет. Используется при
  //        конструировании имен файлов Windows.
  //
  function  AddBackSlash(const DirName:ShortString):ShortString;         virtual; abstract;
  //
  // 124  - Удалить из имени каталога незначащие пробелы, а также обратный слеш
  //        в конце строки. Используется при конструировании имен файлов.
  //
  function  DropBackSlash(const DirName:ShortString):ShortString;        virtual; abstract;
  //
  // 125  - Проверяет, является ли имя файла групповой маской, типа "*.*" или "?.?".
  //
  function  IsWildCard(const FileName:ShortString):boolean;              virtual; abstract;
  //
  // 126  - Проверяет, является ли имя файла относительным или абсолютным.
  //        Абсолютное имя содержит полный путь к файлу, относительное же
  //        предполагает отсчет от какого-то начального каталога, например,
  //        ".\doc\readme.txt".
  //
  function  IsRelativePath(const S:ShortString):boolean;                 virtual; abstract;
  //
  // 127  - Проверяет наличие в имени файла расширения и находит его положение,
  //        то есть положение точки, с которой начинается расширение.
  //
  function  HasExtension(const Name:ShortString;
                         var DotPos:Integer):Boolean;                    virtual; abstract;
  //
  // 128  - Возвращает имя файла с присоединением заданного расширения, если
  //        в имени нет расширения. Если расширение уже есть, то имя файла
  //        не изменяется. Используется для задания расширния по умолчанию.
  //
  function  DefaultExtension(const Name,Ext:ShortString):ShortString;    virtual; abstract;
  //
  // 129  - Возвращает имя файла с присоединенным путем, если исходное имя файла
  //        содержит относительный путь. Абсолютное имя файла не изменяется.
  //        Используется для задания пути по умолчанию.
  //
  function  DefaultPath(const Name,Path:ShortString):ShortString;        virtual; abstract;
  //
  // 130  - Задает расширение имени файла. Если у файла уже есть расширение, оно
  //        будет заменено новым.
  //
  function  ForceExtension(const Name,Ext:ShortString):ShortString;      virtual; abstract;
  //
  // 131  - Задает путь к файлу. Если у файла уже был путь, он будет заменен новым.
  //
  function  ForcePath(const NewPath,Name:ShortString):ShortString;       virtual; abstract;
  //
  // 132  - Удаляет из имени файла путь, оставляя имя и расширение.
  //
  function  ExtractFileNameExt(const FileName: ShortString):ShortString; virtual; abstract;
  //
  // 133  - Выделяет из полного имени файла только имя, без пути и расширения.
  //
  function  ExtractFileName(const FileName: ShortString):ShortString;    virtual; abstract;
  //
  // 134  - Выделяет из полного имени файла расширение, включая точку.
  //
  function  ExtractFileExt(const FileName: ShortString): ShortString;    virtual; abstract;
  //
  // 135  - Выделяет из полного имени файла путь, без имени и расширения.
  //        Обратный слеш в конце пути тоже удаляется.
  //
  function  ExtractFilePath(const FileName: ShortString): ShortString;   virtual; abstract;
  //
  // 136  - Выделяет из полного пути файла имя диска или имя сетевого сервера.
  //
  function  ExtractFileDrive(FileName: ShortString): ShortString;        virtual; abstract;
  //
  // 137  - Выделяет расширение файла из описания фильтра, как это принято
  //        Delphi: 'Text files | *.txt | Data files | *.dat |'.
  //
  function  ExtractFilterExt(const Filter:LongString;
                             Index:Integer):ShortString;                 virtual; abstract;
  //
  // 138  - Преобразует имя файла к канонической форме, удаляя все относительные
  //        ссылки. В результате получается абсолютное имя файла.
  //        Если имя файла пустое, вернет текущий каталог.
  //
  function  FExpand(const Path:ShortString):ShortString;                 virtual; abstract;
  //
  // 139  - Преобразует имя файла Path из абсолютного в относительное, считая
  //        базовым путем путь файла Base.
  //
  function  MakeRelativePath(const Path,Base:ShortString):ShortString;   virtual; abstract;
  //
  // 140  - Возвращает русскую строку Rus или английскую Eng в зависимости от
  //        того, в каком режиме запущена программа.
  //
  function  RusEng(const Rus:LongString='';
                   const Eng:LongString=''):LongString;                  virtual; abstract;
  //
  // 141  - Возвращает строку системной ошибки Windows по коду GetLastError.
  //
  function  SysErrorMessage(ErrorCode: Integer): ShortString;            virtual; abstract;
  //
  // 142  - Возвращает атрибуты файла с именем FileName.
  //        Возвращает -1, если  имя файла недопустимо, или если файл является
  //        групповой маской (*,?), или если файл не существует.
  //
  function  GetFileAttr(const FileName:ShortString):Integer;             virtual; abstract;
  //
  // 143  - Задает атрибуты файла с именем FileName.
  //        Возвращает false, если  имя файла недопустимо, или если файл является
  //        групповой маской (*,?), или если файл не существует.
  //
  function  SetFileAttr(const FileName: ShortString;
                        Attr: Integer):boolean;                          virtual; abstract;
  //
  // 144  - Возвращает размер файла или -1, если файл не существует или ошибка.
  //
  function  GetFileSize(const FileName:ShortString):LongInt;             virtual; abstract;
  //
  // 145  - Возвращает время и дату файла или -1, если файла не существует.
  //        Возвращаемое значение задано в миллисекундах от Рождества Христа,
  //        если ConvertToMSec=true. Иначе время задано в упакованной форме,
  //        которую можно распаковать функцией FileDateToDateTime.
  //
  function  GetFileDate(const FileName:ShortString;
                        ConvertToMsec:Boolean=false):Int64;              virtual; abstract;
  //
  // 146  - Возвращает true, если заданный файл или файлы существуют.
  //        FilePattern задает имя файла или групповую маску, содержащую
  //        шаблон поиска, например "*.*".
  //
  function  FileExists(const FilePattern:ShortString;
                       Attribut:Integer=faAnyFile):Boolean;              virtual; abstract;
  //
  // 147  - Проверяет, существует ли заданный каталог.
  //        Имя каталога не должно быть групповой маской.
  //
  function  DirExists(const DirName: ShortString): Boolean;              virtual; abstract;
  //
  // 148  - Удаляет файл. Возвращает true, если файл не существовал или был
  //        успешно удален с диска.
  //
  function  FileErase(const FileName:ShortString;
                      CheckExistance:boolean=true):boolean;              virtual; abstract;
  //
  // 149  - Копирует файл CopyFrom в файл CopyTo.
  //        Возвращает false при ошибке ввода-вывода, отсутствии файла CopyFrom,
  //        а также при наличии файла CopyTo и флаге FailIfExists=true.
  //
  function  FileCopy(const CopyFrom,CopyTo:ShortString;
                     FailIfExists:boolean=false):boolean;                virtual; abstract;
  //
  // 150  - Перемещает OldFileName в файл NewFileName.
  //        Возвращает false при ошибке ввода-вывода, отсутствии файла OldFileName,
  //        а также при наличии файла NewFileName и флаге FailIfExists=true.
  //
  function  FileRename(const OldFileName,NewFileName:ShortString;
                       FailIfExists:boolean=false):boolean;              virtual; abstract;
  //
  // 151  - Возвращает текущий каталог без обратного слеша в конце.
  //
  function  GetCurrDir: ShortString;                                     virtual; abstract;
  //
  // 152  - Задает текущий каталог. Имя каталога не должно быть групповой маской.
  //
  function  SetCurrDir(const DirName: ShortString): Boolean;             virtual; abstract;
  //
  // 153  - Проверяет наличие и при необходимости создает каталог с заданным
  //        именем DirName. Если родительские каталоги не существуют, они также
  //        создаются. Возвращает true, если каталог существовал или был успешно
  //        создан.
  //
  function  MkDir(const DirName: ShortString): Boolean;                  virtual; abstract;
  //
  // 154  - Удаляет каталог DirName. Каталог должен быть пустым.
  //        Возвращает false, если каталог не существует или не пуст.
  function  RmDir(const DirName: ShortString): Boolean;                  virtual; abstract;
  //
  // 155  - Открывает файл FileName, смещается на Offset байт от начала файла,
  //        читает Count байтов в Buffer.
  //        Возвращает число прочитанных байт или -1 при ошибке.
  //
  function  ReadFileToBuffer(const FileName : ShortString;
                                   Buffer   : Pointer;
                                   Count    : LongInt;
                                   Offset   : LongInt = 0 ):LongInt;     virtual; abstract;
  //
  // 156  - Открывает или создает FileName, смещается на Offset байт от начала
  //        файла, записывает Count байт из Buffer.
  //        Возвращает число записанных байт или -1 при ошибке.
  //        FLAGS может быть OPEN_EXISTING, OPEN_ALWAYS, CREATE_NEW, CREATE_ALWAYS
  //
  function  WriteBufferToFile(const FileName     : ShortString;
                                    Buffer       : Pointer;
                                    Count        : LongInt;
                                    Offset       : LongInt = 0;
                                    FLAGS        : DWORD = OPEN_ALWAYS
                                               ) : LongInt;              virtual; abstract;
  //
  // 157  - Мощный файловый итератор. Для каждого файла, заданного шаблоном
  //        поиска FilePatterns, начиная с каталога RootDir, вызывает процедуру
  //        FileAction, затем вызывает себя рекурсивно для обхода подкаталогов,
  //        максимальный уровень вложенности подкаталогов задается в переменной
  //        MaxSubDirLevels. Указатель CustomData служит для передачи в процедуру
  //        FileAction пользовательских данных. FilePatterns может содержать
  //        список имен файлов или список групповых шаблонов поиска, например,
  //        "*.bmp, config.*, *.wav". Delimiters определяет набор символов,
  //        разделяющих шаблоны поиска в списке FilePatterns.
  //        
  procedure ForEachFile(const RootDir         : ShortString;
                        const FilePatterns    : ShortString;
                              FileAction      : TForEachFileAction;
                              MaxSubDirLevels : Integer = 0;
                              CustomData      : Pointer = nil;
                        const Delimiters      : TCharSet = [' ',';',',',Tab,CR,LF]
                                             );                          virtual; abstract;
  //
  // 158  - Мощный итератор для текстовых файлов. Для каждой строки текстового
  //        файла FileName вызывает процедуру Action. Возвращает 0, если все в
  //        порядке, -1 если файл не существует или IOResult при ошибке.
  //
  function  ForEachTextLine(const FileName   : ShortString;
                                  Action     : TForEachTextLineAction;
                                  CustomData : Pointer = nil
                                           ) : Integer;                  virtual; abstract;
  //
  // 159  - Вывод строки S в отладочный файл номер n. Отладочный файл n надо
  //        открыть процедурой DebugOutOpenFile. Если файл не открыт, ничего
  //        не происходит. Вывод в отладочный файл потокобезопасен и
  //        буферизован, так что вызывать его можно отовсюду.
  //
  procedure DebugOut(n:byte; const S:ShortString);                       virtual; abstract;
  //
  // 160  - Возвращает имя отладочного файла номер n.
  //        Возвращает пустую строку, если отладочный файл не был открыт.
  //
  function  DebugOutGetFile(n:byte):ShortString;                         virtual; abstract;
  //
  // 161  - Возвращает 0 если все OK, или число потерянных байт в отладочном
  //        файле n или -1 если файл не был открыт.
  //
  function  DebugOutGetErrors(n:byte):Int64;                             virtual; abstract;
  //
  // 162  - Открывает отладочный файл номер n. Для каждого отладочного файла
  //        создается буфер FIFO, а также поток для его выталкивания на диск.
  //        FlushPeriod - период выталкивания FIFO на диск в миллисекундах.
  //        Для закрытия отладочного файла надо вызывать DebugOutOpenFile
  //        с пустым именем файла FileName.
  //
  procedure DebugOutOpenFile(n           : byte;
                       const FileName    : ShortString;
                             FifoSize    : Integer = 1024*64;
                             FlushPeriod : Integer = 50;
                             CreateNew   : boolean = true;
                             Hello       : boolean = false);             virtual; abstract;
  //
  // 163  - Выделяет текст секции [SectionName] из ini-файла FileName.
  //        Биты ExtractSectionFlags задают разные флаги алгоритма выделения.
  //        Обычно используются флаги efAsIs или efConfig.
  //
  function  ExtractTextSection(const FileName            : ShortString;
                               const SectionName         : ShortString;
                                     ExtractSectionFlags : Word
                                                       ) : LongString;   virtual; abstract;
  //
  // 164  - Выделяет список слов с заданным индексом WordIndex из секции
  //        [SectionName] из ini-файла FileName.
  //
  //
  function  ExtractWordList(const FileName            : ShortString;
                            const SectionName         : ShortString;
                                  ExtractSectionFlags : word;
                                  WordIndex           : word;
                            const Delimiters          : TCharSet
                                                    ) : LongString;      virtual; abstract;
  //
  // 165  - Выделяет из секции [SectionName] из ini-файла FileName список всех
  //        переменных типа "Prefix = var1, var2, ..".
  //
  function  ExtractEnumWordList(const IniFile             : ShortString;
                                const SectionName         : ShortString;
                                const Prefix              : ShortString;
                                      ExtractSectionFlags : word
                                                        ) : LongString;  virtual; abstract;
  //
  // 166  - Чтение переменных из ini-файла. FileName,SectionName задают имя
  //        файла и секции. Format задает формат чтения - список выражений
  //        вида 'Name%x', разделенных символами CR или ";". Здесь Name - имя
  //        переменной, %x - формат, это одно из выражений
  //         %b - Boolean,
  //         %f - Double,
  //         %d - LongInt,
  //         %w - Word,
  //         %i - Integer,
  //         %s - ShortString, строка символов до конца строки текста,
  //         %a - ShortString, символьная строка, только первое слово.
  //        Запись данных Data должна содержать упакованные (packed) данные
  //        в соответствии с форматом чтения. Например, для чтения данных
  //         [Person]
  //         Age = 34
  //         Height = 182.5
  //         User = Alex, Physics department
  //        можно написать:
  //         var Person : packed record
  //              Age:Integer; Height:Double; Name,Comment:ShortString;
  //             end;
  //         if ReadIniFileVariable(File,'[Person]','Age%i;Height%f;User%a;%s',Data)
  //         then ... Data.Age=34, Data.Height=182.5, Data.Name='ALEX', Data.Comment='PHYSICS DEPARTMENT'
  //         Примечания:
  //         1) Числа могут вводиться в шестнадцатеричном виде типа $F123.
  //         2) Строки всегда преобразуются в верхний регистр. Если это не
  //            подходит, используйте комбинацию ExtractTextSection и ScanVar.
  //
  function ReadIniFileVariable(const FileName    : ShortString;
                               const SectionName : ShortString;
                               const Format      : ShortString;
                                 var Data      ) : Boolean;              virtual; abstract;
  //
  // 167  - Читает имя файла из ini-файла. Возвращается всегда абсолютное (или
  //        полное) имя файла. Если в файле задано относительное имя файла,
  //        то абсолютное имя вычисляется относительно пути StartupPath.
  //
  function ReadIniFilePath(const FileName    : ShortString;
                           const SectionName : ShortString;
                           const Name        : ShortString;
                           const StartupPath : ShortString;
                             var Path        : ShortString ) : Boolean;  virtual; abstract;
  //
  // 168  - Возвращает абсолютное имя EXE-файла текущей выполняемой программы.
  //
  function  ProgName:ShortString;                                        virtual; abstract;
  //
  // 169  - Домашний каталог программы, то есть каталог, где расположен EXE-файл
  //        выполняемой программы. Обычно все пути файлов программы указаны
  //        относительно ее домашнего каталога.
  //
  function  HomeDir:ShortString;                                         virtual; abstract;
  //
  // 170  - Домашний каталог программы, синоним HomeDir.
  //
  function  StartupPath:ShortString;                                     virtual; abstract;
  //
  // 171  - Текущий каталог в момент старта программы. Он не обязательно
  //        совпадает с домашним каталогом программы.
  //
  function  StartAtDir:ShortString;                                      virtual; abstract;
  //
  // 172  - Основной ini-файл программы, в котором содержатся параметры для ее
  //        запуска и настройки. Этот файл получается заменой расширения .EXE
  //        исполняемого файла программы на расширение .INI.
  //
  function  SysIniFile:ShortString;                                      virtual; abstract;
  //
  // 173  - Перейти в домашний каталог программы.
  //
  procedure GoHome;                                                      virtual; abstract;
  //
  // 174  - Каталог, где расположен Windows, например,  C:\Windows.
  //
  function  WindowsDir:ShortString;                                      virtual; abstract;
  //
  // 175  - Каталог системных файлов Windows, например, C:\Windows\System32.
  //
  function  WindowsSystemDir:ShortString;                                virtual; abstract;
  //
  // 176  - Каталог временных файлов Windows.
  //
  function  WindowsTempDir:ShortString;                                  virtual; abstract;
  //
  // 177  - Каталог временных файлов программы. Описывается в SysIniFile,
  //        в секции [System], переменная TempDir.
  //
  function  TempDir:ShortString;                                         virtual; abstract;
  //
  // 178  - Создает имя временного файла, которое гарантированно не совпадает
  //        ни с каким существующим файлом. Имя имеет вид ###NNNN.TMP, где
  //        ### - заданный префикс, NNNN - уникальный номер, .TMP - заданное
  //        расширение.
  //
  function  CreateTempFile(const Template:ShortString='###.TMP'):ShortString;
                                                                         virtual; abstract;
  //
  // 179  - Чтение переменной - строки Name из каталога Key системного реестра Windows.
  //        RootKey задает ключ, например, HKEY_CURRENT_USER.
  //
  function  ReadRegistryString(RootKey:HKEY;
                               const Key,Name:ShortString):ShortString;  virtual; abstract;
  //
  // 180  - Чтение переменной - строки Name из системного реестра Windows,
  //        ключ HKEY_CURRENT_USER,
  //        каталог 'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
  //
  function  GetWindowsShellFolder(const Name:ShortString):ShortString;   virtual; abstract;
  //
  // 181  - Возвращает каталог "Рабочий стол" текущего пользователя  Windows.
  //
  function  GetWindowsShellDesktop:ShortString;                          virtual; abstract;
  //
  // 182  - Возвращает каталог "Программы" текущего пользователя  Windows.
  //
  function  GetWindowsShellPrograms:ShortString;                         virtual; abstract;
  //
  // 183  - Возвращает каталог "Программы\Автозагрузка" текущего пользователя  Windows.
  //
  function  GetWindowsShellStartup:ShortString;                          virtual; abstract;
  //
  // 184  - Возвращает каталог "Старт" текущего пользователя  Windows.
  //
  function  GetWindowsShellStartMenu:ShortString;                        virtual; abstract;
  //
  // 185  - Возвращает каталог "Избранное" текущего пользователя  Windows.
  //
  function  GetWindowsShellFavorites:ShortString;                        virtual; abstract;
  //
  // 186  - Возвращает каталог фонтов Windows.
  //
  function  GetWindowsShellFonts:ShortString;                            virtual; abstract;
  //
  // 187  - Возвращает каталог "История" текущего пользователя Windows.
  //
  function  GetWindowsShellHistory:ShortString;                          virtual; abstract;
  //
  // 188  - Возвращает каталог "Мои документы" текущего пользователя  Windows.
  //
  function  GetWindowsShellPersonal:ShortString;                         virtual; abstract;
  //
  // 189  - Возвращает каталог "Send To"  текущего пользователя Windows.
  //
  function  GetWindowsShellSendTo:ShortString;                           virtual; abstract;
  //
  // 190  - Создает ярлык с именем LinkPath, который ссылается на файл ObjectPath.
  //        Description содержит информационную строку описания файла.
  //        Params содержит параметры командной строки, передаваемой программе.
  //
  procedure CreateFileLink(const ObjectPath, LinkPath, Description,
                           Params: ShortString);                         virtual; abstract;
  //
  // 191  - Задает целочисленную точку.
  //
  function  Point2I(x,y:Integer):TPoint2I;                               virtual; abstract;
  //
  // 192  - Задает вещественную точку.
  //
  function  Point2D(x,y:Double):TPoint2D;                                virtual; abstract;
  //
  // 193  - Задает вещественную трехмерную точку.
  //
  function  Point3D(x,y,z:Double):TPoint3D;                              virtual; abstract;
  //
  // 194  - Задает целочисленный прямоугольник.
  //
  function  Rect2I(const a,b:TPoint2I):TRect2I;                          virtual; abstract;
  //
  // 195  -  Задает вещественный прямоугольник.
  //
  function  Rect2D(const a,b:TPoint2D):TRect2D;                          virtual; abstract;
  //
  // 196  - Сравнивает, равны ли две целочисленные точки.
  //
  function  IsEqualPoint2I(const p1,p2:TPoint2I):Boolean;                virtual; abstract;
  //
  // 197  - Сравнивает, равны ли две вещественные точки.
  //
  function  IsEqualPoint2D(const p1,p2:TPoint2D; AbsEps:Double=0;
                           RelEps:Double=1E-14):Boolean;                 virtual; abstract;
  //
  // 198  - Сравнивает, равны ли два целочисленных прямоугольника.
  //
  function  IsEqualRect2I(const r1,r2:TRect2I):Boolean;                  virtual; abstract;
  //
  // 199  - Сравнивает, равны ли два вещественных прямоугольника.
  //
  function  IsEqualRect2D(const r1,r2:TRect2D; AbsEps:Double=0;
                          RelEps:Double=1E-14):Boolean;                  virtual; abstract;
  //
  // 200  - Определяет, является ли целочисленный прямоугольник пустым.
  //
  function  IsEmptyRect2I(const r:TRect2I):Boolean;                      virtual; abstract;
  //
  // 201  - Определяет, является ли вещественный прямоугольник пустым.
  //
  function  IsEmptyRect2D(const r:TRect2D; AbsEps:Double=0;
                          RelEps:Double=1E-14):Boolean;                  virtual; abstract;
  //
  // 202  - Проверяет, содержит ли целочисленный прямоугольник заданную точку.
  //
  function  Rect2IContainsPoint(const r:TRect2I;
                                const p:TPoint2I):Boolean;               virtual; abstract;
  //
  // 203  - Проверяет, содержит ли вещественный прямоугольник заданную точку.
  //
  function  Rect2DContainsPoint(const r:TRect2D;
                                const p:TPoint2D):Boolean;               virtual; abstract;
  //
  // 204  - Находит пересечение целочисленных прямоугольников.
  //
  function  Rect2IIntersection(const R1,R2:TRect2I):TRect2I;             virtual; abstract;
  //
  // 205  - Находит пересечение вещественных прямоугольников.
  //
  function  Rect2DIntersection(const R1,R2:TRect2D):TRect2D;             virtual; abstract;
  //
  // 206  - Находит объединение целочисленных прямоугольников.
  //
  function  Rect2IUnion(const R1,R2:TRect2I):TRect2I;                    virtual; abstract;
  //
  // 207  - Находит объединение вещественных прямоугольников.
  //
  function  Rect2DUnion(const R1,R2:TRect2D):TRect2D;                    virtual; abstract;
  //
  // 208  - Нормализует целочисленный прямоугольник, если он "вывернут наизнанку".
  //        То есть меняет a.x и b.x если a.x > b.x; меняет a.y и b.y если a.y > b.y.
  //
  function  Rect2IValidate(const r:TRect2I):TRect2I;                     virtual; abstract;
  //
  // 209  - Нормализует вещественный прямоугольник, если он "вывернут наизнанку".
  //        То есть меняет a.x и b.x если a.x > b.x; меняет a.y и b.y если a.y > b.y.
  //
  function  Rect2DValidate(const r:TRect2D):TRect2D;                     virtual; abstract;
  //
  // 210  - Сдвиг целочисленной точки.
  //
  procedure Point2IMove(var p:TPoint2I; dx,dy:Integer);                  virtual; abstract;
  //
  // 211  - Сдвиг вещественной точки.
  //
  procedure Point2DMove(var p:TPoint2D; dx,dy:Double);                   virtual; abstract;
  //
  // 212  - Сдвиг целочисленного прямоугольника.
  //
  procedure Rect2IMove(var r:TRect2I; dx,dy:Integer);                    virtual; abstract;
  //
  // 213  - Сдвиг вещественного прямоугольника.
  //
  procedure Rect2DMove(var r:TRect2D; dx,dy:Double);                     virtual; abstract;
  //
  // 214  - Умножение целочисленной точки.
  //
  procedure Point2IMult(var p:TPoint2I; mx,my:Integer);                  virtual; abstract;
  //
  // 215  - Умножение вещественной точки.
  //
  procedure Point2DMult(var p:TPoint2D; mx,my:Double);                   virtual; abstract;
  //
  // 216  - Умножение целочисленного прямоугольника.
  //
  procedure Rect2IMult(var r:TRect2I; mx,my:Integer);                    virtual; abstract;
  //
  // 217  - Умножение вещественного прямоугольника.
  //
  procedure Rect2DMult(var r:TRect2D; mx,my:Double);                     virtual; abstract;
  //
  // 218  - Симметричное расширение целочисленного прямоугольника.
  //
  procedure Rect2IGrow(var r:TRect2I; dx,dy:Integer);                    virtual; abstract;
  //
  // 219  - Симметричное расширение вещественного прямоугольника.
  //
  procedure Rect2DGrow(var r:TRect2D; dx,dy:double);                     virtual; abstract;
  //
  // 220  - Возвращает размер целочисленного прямоугольника.
  //
  function  Rect2ISize(const r:TRect2I):TPoint2I;                        virtual; abstract;
  //
  // 221  - Возвращает размер вещественного прямоугольника.
  //
  function  Rect2DSize(const r:TRect2D):TPoint2D;                        virtual; abstract;
  //
  // 222  - Возвращает центр целочисленного прямоугольника.
  //
  function  Rect2ICenter(const r:TRect2I):TPoint2I;                      virtual; abstract;
  //
  // 223  - Возвращает центр вещественного прямоугольника.
  //
  function  Rect2DCenter(const r:TRect2D):TPoint2D;                      virtual; abstract;
  //
  // 224  - Создание экземпляра интерпретатора выражений.
  //        Не забудьте удалить его после использования.
  //
  function  CreateScriptInterpreter:TScriptInterpreter;                  virtual; abstract;
  //
  // 225  - Вычисляет 1 SHL BitNumber, то есть число, у которого все биты
  //        кроме заданного равны 0.
  //
  function  GetBitMask(BitNumber:Integer):Integer;                       virtual; abstract;
  //
  // 226  - Вычисляет для числа точность, по заданным абсолютным и относительным
  //        порогам, которую можно использовать при сравнении с другим числом.
  //
  function  Precision(AbsEps,RelEps,Value:Double):Double;                virtual; abstract;
  //
  // 227  - Возвращает максимальное целое число, которое точно представляется
  //        в виде Single. 16.777.216 <-> 24 bit
  //
  function  MaxIntSingle:Single;                                         virtual; abstract;
  //
  // 228  - Возвращает максимальное целое число, которое точно представляется
  //        в виде Double. 9.007.199.254.740.992 <-> 53 bit
  //
  function  MaxIntDouble:Double;                                         virtual; abstract;
  //
  // 229  - Возвращает максимальное целое число, которое точно представляется
  //        в виде Extended. 18.446.744.073.709.551.600 <-> 64 bit
  //
  function  MaxIntExtended:Extended;                                     virtual; abstract;
  //
  // 230  - Сдвиг вещественного числа. Эквивалентно умножению на степень 2:
  //        fscale(X,N) = X * 2 ^ N
  //
  function  fscale(X:Extended; N:integer): Extended;                     virtual; abstract;
  //
  // 231  - Выделение экспоненты и мантиссы числа X.
  //        X = Mantissa * 2 ^ Exponent, 1<=abs(Mantissa)<2
  //
  procedure fxtract(X: Extended; var Mantissa: Extended;
                                 var Exponent: Integer);                 virtual; abstract;
  //
  // 232  - Сжимает число, то есть округляет его так, что в нем остается
  //        только NumberOfSignificantBits значимых двоичных знаков.
  //
  function  fbitcompress(Argument:Extended;
                         NumberOfSignificantBits:integer):Extended;      virtual; abstract;
  //
  // 233  - Сжимает число, то есть округляет его так, что оно представляет
  //        исходное значение с заданной относительной точностью, равной
  //        1/ScaleFactor.
  //
  function  frelcompress(Arument,ScaleFactor:Extended):Extended;         virtual; abstract;
  //
  // 234  - Сжимает число, то есть округляет его так, что оно представляет
  //        исходное значение с заданной абсолютной точностью, равной
  //        1/ScaleFactor.
  //
  function  fabscompress(Argument,ScaleFactor:Extended):Extended;        virtual; abstract;
  //
  // 235  - Вычисляет гамма - функцию. Для целых чисел gamma(n+1) = n!
  //
  function  Gamma(x:Extended):Extended;                                  virtual; abstract;
  //
  // 236  - Вычисляет натуральный логарифм гамма-функции.
  //
  function  GammaLn(x:Extended):Extended;                                virtual; abstract;
  //
  // 237  - Вычисляет неполную гамма - функцию.
  //
  function  GammaInc(x,a:Extended):Extended;                             virtual; abstract;
  //
  // 238  - Вычисляет плотность распределения гамма функции.
  //
  function  GammaDistr(x,a,b:Extended):Extended;                         virtual; abstract;
  //
  // 239  - Вычисляет кумулятивное распределение гамма - функции.
  //
  function  GammaCumDistr(x,a,b:Extended):Extended;                      virtual; abstract;
  //
  // 240  - Вычисляет обратное кумулятивное распределение гамма-функции.
  //
  function  GammaCumDistrInv(p,a,b:Extended):Extended;                   virtual; abstract;
  //
  // 241  - Вычисляет плотность распределения Хи-квадрат с v степенями свободы.
  //
  function  Chi2Distr(x,v:Extended):Extended;                            virtual; abstract;
  //
  // 242  - Вычисляет кумулятивное распределение Хи-квадрат с v степенями свободы.
  //
  function  Chi2CumDistr(x,v:Extended):Extended;                         virtual; abstract;
  //
  // 243  - Вычисляет обратное кумулятивное распределение Хи-квадрат с v степенями свободы.
  //
  function  Chi2CumDistrInv(p,v:Extended):Extended;                      virtual; abstract;
  //
  // 244  - Вычисляет площадь трапеции по отрезком (x1,y1)-(x2,y2).
  //        Полезно для интегрирования методом трапеций, например.
  //
  function  Trapezium(x1,y1,x2,y2:double):double;                        virtual; abstract;
  //
  // 245  - Вычисляет простую и модифицированную функцию Бесселя порядка N.
  //
  function  BesselN(N:integer; X:Double;Modify:boolean=false):Double;    virtual; abstract;
  //
  // 246  - Решает квадратную систему линейных уравнений A*X=Y размера N*N
  //        методом Гаусса с выбором главного диагонального элемента.
  //        Матрица A хранится в одномерном массиве, причем для доступа к
  //        элементам используется правило:
  //          A[i,j] <-> A[i*M+j], i,j=0..N-1
  //        При таком способе хранения матрицу A можно хранить также в двумерном
  //        массиве размерности M, например:
  //         const N=3; M=5;
  //         var A:array[0..M-1,0..M-1] of double; X,Y:array[0..M-1] of double;
  //         if GaussSolverWithPartialPivoting(N,M,A[0,0],X[0],Y[0])=0 then ...
  //        Параметр Eps задает порог для ведущего диагонального элемента,
  //        ниже которого матрица считается вырожденной.
  //        Возвращает значение 0 - Ok.
  //                            1 - Неверная размерность N или M.
  //                            2 - Матрица сингулярна, ведущая диагональ <= Eps.
  //
  function  GaussSolverWithPartialPivoting(N,M:Integer; var A,X,Y:array of Double;
                                           Eps:Double=1E-14):Integer;    virtual; abstract;
  //
  // 247  - Создает экземпляр полинома для аппроксимации данных методом
  //        наименьших квадратов.
  //
  function  CreatePolynom(aPower  : Integer = 1;
                          aCenter : Double  = 0;
                          aScale  : Double  = 1):TPolynomWrap;           virtual; abstract;
  //
  // 248  - Общая процедура минимизации при отсутствии ограничений.
  //        Problem=целевая функция, Report=процедура оповещения, n=размерность,
  //        x[n]=аргумент, f=значение, g[n]=градиент, Custom=пользовательские данные, Count=счетчик вызовов,
  //        MaxCount=ограничение на счетчик вызовов, Method=метод минимизации 0..8, tolx,tolf,tolg=точность по x,f,g,
  //        inf=оценка минимума, Size=начальный симплекс, Step=начальный шаг, EvalTol=точность вычисления функции,
  //        v[]=рабочий массив не менее (n+9)*nv, nv>n, nv=размерность рабочего массива,nv>=n+1.
  //
  function  GenMin(Problem:TMinProblem; Report:TMinReport; n:Integer; var x:array of Double;
                  var f:Double; var g:array of Double; Custom:Pointer; var Count:Integer;
                  MaxCount:Integer; Method:Integer; tolx,tolf,tolg,inf,Size,Step,EvalTol:Double;
                  var v:array of Double; nv:Integer):Integer;            virtual; abstract;
  //
  // 249  - Общая процедура минимизации при отсутствии ограничений.
  //        Добавляется массив фиксации переменных Fix[n].
  //
  function  GenMinFix(Problem:TMinProblem; Report:TMinReport; n:Integer; var x:array of Double;
                  var f:Double; var g:array of Double; Custom:Pointer; var Count:Integer;
                  MaxCount:Integer; Method:Integer; tolx,tolf,tolg,inf,Size,Step,EvalTol:Double;
                  var v:array of Double; nv:Integer;
                  var Fix:array of Boolean):Integer;                     virtual; abstract;
  //
  // 250  - Общая процедура минимизации при отсутствии ограничений.
  //        Добавляется масштабирование функции fscale и диапазон аргумента xLo[n]..xHi[n].
  //
  function  GenMinScaled(Problem:TMinProblem; Report:TMinReport; n:Integer; var x:array of Double;
                  var f:Double; var g:array of Double; Custom:Pointer; var Count:Integer;
                  MaxCount:Integer; Method:Integer; tolx,tolf,tolg,inf,Size,Step,EvalTol:Double;
                  var v:array of Double; nv:Integer; fscale:Double;
                  var xLo,xHi:array of Double):Integer;                  virtual; abstract;
  //
  // 251  - Общая процедура минимизации при отсутствии ограничений.
  //        Используется фиксация и масштабирование.
  //
  function GenMinFixScaled(Problem:TMinProblem; Report:TMinReport; n:Integer; var x:array of Double;
                  var f:Double; var g:array of Double; Custom:Pointer; var Count:Integer;
                  MaxCount:Integer; Method:Integer; tolx,tolf,tolg,inf,Size,Step,EvalTol:Double;
                  var v:array of Double; nv:Integer; var Fix:array of Boolean; fscale:Double;
                  var xLo,xHi:array of Double):Integer;                  virtual; abstract;
  //
  // 252  - Общая процедура фитирования по МНК.
  //        m=число точек, t[m],y[m],w[m]=аргументы,значения,веса фитируемых точек,
  //        Fit=аппроксимирующая функция, Report=процедура отображения, n=размерность,
  //        x[n]=параметры, f=сумма квадратов, g[n]=градиент по параметрам, Custom=данные юзера,
  //        Count=счетчик вызовов, MaxCount=ограничение на счетчик вызовов, Method=метод минимизации 0..8,
  //        tolx,tolf,tolg=точность по x,f,g, inf=оценка минимума, Size=начальный симплекс, Step=начальный шаг,
  //        EvalTol=точность вычисления функции, a[]=рабочий массив не менее (n+10)*(n+1),
  //        Fix[n]=массив фиксации переменных, fscale=масштаб функции, xLo[n],xHi[n]=диапазон параметров
  //
  function  LSQFit(m:Integer; var t,y,w:array of Double; Fit:TFitProblem; Report:TFitReport;
                   n:Integer; var x:array of Double; var f:Double; var g:array of Double;
                   Custom:Pointer; var Count:Integer; MaxCount:Integer; Method:Integer;
                   tolx,tolf,tolg,Inf,Size,Step,EvalTol:Double; var a:array of Double;
                   var Fix:array of Boolean; fscale:Double; var xLo:array of Double;
                   var xHi:array of Double):Integer;                     virtual; abstract;
  //
  // 253  - Находит сумму квадратов отклонений, аргументы как в LSQFit.
  //
  function  LSQFitSumOfSquares(m:Integer; var t,y,w:array of Double; Fit:TFitProblem; n:Integer;
                               var x:array of Double; var f:Double; var g:array of Double;
                               Custom:Pointer):Integer;                  virtual; abstract;
  //
  // 254  - Дает доступ к базе данных РФА (свойства химических элементов и линии ХРИ).
  //
  function  Rfa:TRfaDataBaseWrap;                                        virtual; abstract;
  //
  // 255  - Функция быстрой сортировки массива произвольного типа и метода хранения.
  //        Надо задать функцию "Compare" для сравнения двух элементов массива,
  //        функцию "KeyOf" для получения ключа сортировки для данного индекса.
  //        Кроме того, задается один из следующих методов сортировки:
  //         "SwapData"  - процедура для сортировки массива "на месте".
  //         "Index"     - массив индексов при "индексированной" сортировке.
  //        При задании сортировки "на месте", в массиве Data будет произведена
  //        перестановка элементов, так что будет выполнено условие:
  //           Compare(Data,KeyOf(Data,i),KeyOf(Data,j))<=0, i<=j
  //        Это значит, Data[i] будет отсортирован как Data[i]<=Data[j], i<=j.
  //        Процедура "SwapData" задает способ перестановки двух элементов массива.
  //        Массив индексов "Index" в этом случае должен быть равен nil.
  //          Если массив данных очень велик или доступен только для чтения, лучше
  //        использовать "индексированную" сортировку (при этом "SwapData"=nil).
  //        При "индексированной" сортировке исходный массив данных не меняется.
  //        Вместо этого заполняется массив индексов "Index", сортирующий массив:
  //           Compare(Data,KeyOf(Data,Index[i]),KeyOf(Data,Index[j]))<=0, i<=j
  //        Это значит, что Data[Index[i]] будет отсортирован:
  //           Data[Index[i]]<=Data[Index[j]], i<=j
  //        Параметр "Method" задает алгоритм 0=ShellSort, 1=QuickSort.
  //        ShellSort - "рабочая лошадка" сортировки, простой нерекурсивный алгоритм,
  //        достаточно быстрый для большинства задач, хотя несколько уступающий по
  //        скорости алгоритму Хаара.
  //        smQuickSort - рекурсивная версия быстрой сортировки Хаара. Не следует
  //        использовать ее при очень большой размерности массива из-за опасности
  //        переполнения стека. Используйте в этом случае ShellSort.
  //        Аргументы:
  //           Count    - Размерность массива Data.
  //           Data     - дает доступ к массиву[0..Count-1] данных для сортировки.
  //           Compare  - сравнивает ключи сортировки:Compare(Data,Key1,Key2)=-1/0/+1=LT/EQ/GT.
  //           KeyOf    - KeyOf(Data,j), j=0..N-1 возвращает ключ сортировки j в массиве Data.
  //           SwapData - процедура перестановки элементов при сортировке "на месте".
  //           Index    - указатель на массив индексов: Data[Index[i]] будет отсортирован.
  //           Method   - 0=ShellSort, 1=QuickSort.
  //
  function  Sort(Count:Integer; Data:Pointer; Compare:TCompareFunction;
                 KeyOf:TKeyOfFunction; SwapData:TSwapProcedure;
                 Index:PIntegerArray; Method:Integer=0):Boolean;         virtual; abstract;
  //
  // 256  - Быстрый поиск для процедур интерполяции.
  // 257 -  Быстрый поиск для работы со списками.
  //        Обе функции выполняют быстрый двоичный поиск в массиве, который
  //        был отсортирован "на месте"  (в этом случае Index=nil) или через
  //        "индексированную" сортировку (в этом случае Index<>nil).
  //        QuickFind возвращает индекс i в отсортированном массиве данных
  //        Data[0..Count-1] который удовлетворяет условиям:
  //            i=0        если Key <  Data[0],
  //            i=Count-2  если Key >= Data[Count-1]
  //            Data[i] <= Key < Data[i+1] в ином случае
  //        QuickFind предназначен специально для процедур интерполяции, где
  //        неважно, принадлежит Key массиву данных или нет, а важно только его
  //        положение относительно элементов массива. QuickFind возвращает
  //        фактически индекс интервала x[i]..x[i+1], в который попадает точка.
  //        QuickSearch ищет ключ Key в отсортированном массиве Data[0..Count-1]
  //        и возвращает true/false если ключ найден/не найден, а также индекс
  //        KeyIndex, удовлетворяющий условиям:
  //             KeyIndex=0        если Key<=Data[0],
  //             KeyIndex=Count    если Key>Data[Count-1]
  //             x[KeyIndex-1] < Key <= x[KeyIndex] в иных случаях
  //        Индекс KeyIndex показывает, куда должен быть вставлен элемент Key,
  //        чтобы после вставки массив был по-прежнему отсортирован.
  //        QuickSearch предназначен специально для процедур работы с сортированными
  //        списками, когда перед вставкой элемента надо проверить факт его
  //        существования в списке, а также найти индекс для вставки.
  //
  function  QuickFind(Count:Integer; Data:Pointer; Compare:TCompareFunction;
                      KeyOf:TKeyOfFunction; KeyToSearch:Pointer;
                      Index:PIntegerArray=nil):Integer;                  virtual; abstract;
  function  QuickSearch(Count:Integer; Data:Pointer; Compare:TCompareFunction;
                        KeyOf:TKeyOfFunction; KeyToSearch:Pointer;
                        var KeyIndex:Integer; Index:PIntegerArray=nil;
                        Duplicates:Boolean=false):Boolean;               virtual; abstract;
  //
  // 258  - Найти индекс принадлежности точки в отсортированном массиве.
  //        i:=FindIndex(N,x,at,index) возвращает индекс i в массиве x[0..N-1],
  //        отсортированном как x[i]<=x[i+1], для которого выполнено, условие
  //        x[i]<=at<x[i+1]; при этом i=0, если at<x[0]; i=N-2, если at>x[N-2].
  //        Если задан index<>nil, x[i] заменяется везде на x[index[i]].
  //        Предназначена для процедур интерполяции; это быстрый эквивалент
  //        i:=QuickFind(N,@x,CompareDoubles,KeyOfDoubles,@at,index).
  //
  function  FindDoubleIndex(N:Integer; const x:array of Double; at:Double;
                            Index:PIntegerArray=nil):Integer;            virtual; abstract;
  //
  // 259  - Линейная интерполяция таблично заданной функции y(x) в точке t.
  //        Таблица функции (x[0..N-1],y[0..N-1]) должна быть отсортирована
  //        как x[i]<=x[i+1]. Если это условие не выполнено, результат будет
  //        неверным.
  //
  function  LinearInterpolation(const x,y:array of Double; N:Integer;
                                t:Double):Double;                        virtual; abstract;
  //
  // 260  - Вычислить полином степени N-1, с коэффициентами P[0..N-1], в точке t.
  //        Вычисления идут по схеме Горнера, то есть
  //         P(t)=(..(P[N-1]*t+P[N-2])*t+..+P[1])*t+P[0]
  //
  function  EvaluatePolynomAt(const P:array of Double; N:Integer;
                              t:Double):Double;                          virtual; abstract;
  //
  // 261  - Находит МНК коэффициенты полинома P[0..N-1] степени N-1, который
  //        аппроксимирует таблично заданную функцию y(x)=(x[0..M-1],y[0..M-1]).
  //        Полином вычисляется для масштабированной переменной t=(x-X0)/Scale,
  //        чтобы избежать численной неустойчивости. Потом можно вызывать
  //        EvaluatePolynomAt(P,N,(x-X0)/Scale);
  //
  function  FindLeastSquaresPolynom(var P:array of Double; N:Integer; X0,Scale:Double;
                        const x,y:array of Double; M:Integer):Boolean;   virtual; abstract;
  //
  // 262 - Вычисляет кубический сплайн и его производные в заданной точке t.
  //       Задается массив узлов сплайна x[0..N-1], массивы z[0..N-1],k[0..N-1]
  //       вычисляются процедурой FindSmoothingSpline. Параметр NDeriv=0/1/2/3
  //       задает вычисление значения/1/2/3 производной.
  //
  function  EvaluateSplineAt(N:Integer; const x,z,k:array of Double;
                             t:Double; NDeriv:Integer=0):Double;         virtual; abstract;
  //
  // 263 - Вычисляет коэффициенты k[0..N-1],z[0..N-1] сглаживающего кубического
  //       сплайна, аппроксимирующего функцию y(x), таблично заданную через
  //       массивы x[0..N-1],y[0..N-1], причем x[i] должен быть отсортирован.
  //       Массив p[0..N-1] задает дисперсии точек. Если задать p[i]=0, сплайн
  //       будет проходить точно через точку (x[i],y[i]). Если задать p[i]>0,
  //       получится сглаженное значение с весом 1/p[i]. Если задать все p[i]=0,
  //       получится классический интерполяционный полином. pL,pR,nL,nR задают
  //       левое и правое граничное условие на сплайн, то есть номер и значение
  //       производной на концах.
  //
  function  FindSmoothingSpline(N:Integer; const x,y,p:array of Double;
                                var z,k:array of Double;
                                nL:Integer=2; pL:Double=0;
                                nR:Integer=2; pR:Double=0):Boolean;      virtual; abstract;
  //
  // 264 - Оконное полиномиальное сглаживание.
  // 265 - Оконное интегрирующее сглаживание.
  //       Оконное сглаживание в данной точке t функции y(x), заданной таблицей
  //       (x[0..N-1],y[0..N-1]), отсортированной по x как x[i+1]>=x[i].
  //       Сглаживание на интервале [t-Window..t+Window] окна с шириной Window
  //       вокруг данной точки происходит с ядром w(t)=Kernel((t-Window)/Window).
  //       При полиномиальном сглаживании по точкам окна строится МНК полином
  //       степени Power. При интегральном сглаживании берется интеграл с данной
  //       весовой функцией.
  //
  function  WindowedKernelSmoothing(const x,y:array of Double; N:Integer;
                                    t,Window:Double; Power:Integer; Kernel:TSmoothKernel;
                                    Custom:Pointer=nil):Double;          virtual; abstract;
  function  WindowedIntegrationSmoothing(const x,y:array of Double; N:Integer;
                                         t,Window:Double; Kernel:TSmoothKernel;
                                         Custom:Pointer=nil):Double;     virtual; abstract;
  //
  // 266 - Решение трехдиагональной системы линейных уравнений методом прогонки.
  // 267 - Решение трехдиагональной системы линейных уравнений методом Гаусса.
  // 268 - Решение пятидиагональной системы линейных уравнений методом Гаусса.
  //       Трехдиагональная система относительно x[0..N-1] имеет вид:
  //       a[i]*x[i-1]+b[i]*x[i]+c[i]*x[i+1]=d[i]
  //       Пятидиагональная система относительно x[0..N-1] имеет вид:
  //       a[i]*x[i-2]+b[i]*x[i-1]+c[i]*x[i]+e[i]*x[i+1]+g[i]*x[i+2]=d[i]
  //       Все массивы имеют размерность N и меняются в процессе вычислений.
  //
  procedure Solve3DiagonalSetByProgonka(N:Integer;
                                        var a,b,c,x,d:array of Double);  virtual; abstract;
  procedure Solve3DiagonalSetByGauss(N:Integer;
                                     var a,b,c,x,d:array of Double);     virtual; abstract;
  procedure Solve5DiagonalSetByGauss(N:Integer;
                                     var a,b,c,e,g,x,d:array of Double); virtual; abstract;
  //
  // 269 - Создает экземпляр защищенного целочисленного вектора.
  // 270 - Создает экземпляр защищенного вещественного  вектора.
  // 271 - Создает экземпляр защищенной целочисленной матицы.
  // 272 - Создает экземпляр защищенной вещественной  матрицы.
  //       После использования не забудьте удалить вектор/матрицу.
  //
  function  CreateLongIntVector(aLength:Integer; aOrigin:Integer=0;
                         aExceptions:Boolean=true):TLongIntVectorWrap;   virtual; abstract;
  function  CreateDoubleVector(aLength:Integer; aOrigin:Integer=0;
                         aExceptions:Boolean=true):TDoubleVectorWrap;    virtual; abstract;
  function  CreateLongIntMatrix(aRows,aColumns:Integer; aOrigin:Integer=0;
                         aExceptions:Boolean=true):TLongIntMatrixWrap;   virtual; abstract;
  function  CreateDoubleMatrix(aRows,aColumns:Integer; aOrigin:Integer=0;
                         aExceptions:Boolean=true):TDoubleMatrixWrap;    virtual; abstract;
  //
  // 273  - Решение задач линейного программирования симплексным алгоритмом.
  //        LinearProgrammingBySimplex решает задачу линейного программирования вида:
  //          F = minimum( F(X)=-G(X)= C(1)*X(1)+C(2)*X(2)+...+C(N)*X(N) ) либо
  //          G = maximum( G(X)=-F(X)=-C(1)*X(1)-C(2)*X(2)-...-C(N)*X(N) )
  //        при ограничениях:
  //               A(1,1)*X(1)+A(1,2)*X(2)+....+A(1,N)*X(N) (<=,>=,=) B(1)
  //               ......
  //               A(M,1)*X(1)+A(M,2)*X(2)+....+A(M,N)*X(N) (<=,>=,=) B(M)
  //        а также
  //               X(i) >= 0, i=1..N
  //        B(i) могут иметь любой знак.
  //        Входные данные:
  //        Матрица A(i,j) ограничений передается в MatrCoef[1..M,1..N];
  //        Коэффициенты С(i)            - в векторе Problem[1..N];
  //        Правые части неравенств B(i) - в векторе RightSide[1..M]
  //        Знаки неравенств (<=,>=,=)   - в целом векторе Signums[1..M]:
  //         Signum =+1 соответствует знаку '>='
  //         Signum = 0 соответствует знаку '='
  //         Signum =-1 соответствует знаку '<='
  //        Предполагается, что все матрица MatrCoef и векторы Problem, RightSide имеют
  //        индексацию от 1. Это означает, что свойство Origin этих объектов должно иметь
  //        значение 1.
  //        PrintMode-режим вывода: 0-нет вывода; см.флаги si_XXXX
  //        OutPutFile-файл вывода результата или комментариев.
  //        Можно использовать файл OutPut(экран) или Null(нет вывода).
  //        Результат:
  //        Функция возвращает матрицу,строки которой заполнены векторами решений задачи
  //        или nil, если решения не существует или его не удалось получить.
  //        Если матрица решений содержит более одной сторки, это значит, что
  //        симплекс-задача имеет бесконечное число решений,а множество решений
  //        является выпуклой оболочкой строк матрицы решений. Матрица решений также
  //        индексируется с 1.
  //        Решение ведется с точностью, хранящейся в константе Zero; если решений
  //        много, то это значит, что с точностью Zero все они дают оптимальное решение.
  //        Zero не может быть меньше чем машинная точность MachEps.
  //        В переменной  ErrorCode возвращается код ошибки,смотри константы si_XXXX
  //        Требования к памяти:
  //        Размещение рабочих массивов внутри Simplex требует порядка M*M + 5(2*M+N)
  //        дополнительных ячеек кроме входных данных и решения
  //
  function  LinearProgrammingBySimplex(Problem:TDoubleVectorWrap; MatrCoef:TDoubleMatrixWrap;
                            Signums:TLongIntVectorWrap; RightSide:TDoubleVectorWrap;
                            var ErrorCode:Integer; PrintMode:Word; var OutPutFile:Text;
                            Zero:Double=1E-12):TDoubleMatrixWrap;        virtual; abstract;
  //
  // 274  -  Вычисление сингулярного разложения матрицы. Применяется для решения
  //         линейных уравнений. После использования не забудьте удалить.
  //
  function  CreateSingularDecomposition(A:TDoubleMatrixWrap):TSVDWrap;   virtual; abstract;
  //
  // 275  - Создает буфер FIFO для безопасного обмена данными между потоками.
  //        После использования не забудьте удалить.
  //
  function CreateFifo(aSize:LongInt=1024;
                      const aName:ShortString=''):TFifoWrap;             virtual; abstract;
  //
  // 276  - Возвращает локальное время в микросекундах, считая от старта
  //        программы. Вызов занимает около 2 микросекунд, против 0.2 микросекунд
  //        для вызова msecnow, поэтому, если микросекундное разрешение
  //        не требуется, лучше использовать msecnow. С другой стороны,
  //        время msecnow имеет квант порядка 10 миллисекунд, а время mksecnow
  //        порядка микросекунды. Кроме того, следует учесть, что время mksecnow
  //        зависит от времени старта программы, а у msecnow время глобальное.
  //        Можно повысить точность глобального времени комбинацией вызова
  //        msecnow для фиксации старта и mksecnow для фиксации интервала,
  //        однако следует иметь в виду, что разрядность мантиссы (53) типа
  //        Double, принятого в CRW-DAQ, позволяет определять глобальное время
  //        с точностью порядка 10 микросекунд, не лучше.
  //
  function  MkSecNow:Extended;                                           virtual; abstract;
  //
  // 277  - Атомарная операция Target:=Target+Value, возвращает Target+Value.
  //        Может применяться для синхронизации потоков или процессов.
  //        Например:
  //         const Latch:Integer=0;
  //         if LockedAdd(Latch,1)=1 then DoSomething;
  //         LockedSub(Latch,1);
  //        Процедура  DoSomething защищена от одновременного выполнения более
  //        чем одним потоком, если все потоки используют этот код.
  //        Адрес переменной Target должен быть выровнен по границе 32 бит. 
  //
  function  LockedAdd(var Target: Integer; Value: Integer): Integer;     virtual; abstract;
  //
  // 278  - Атомарная операция if Target=Comp then Target:=Exch, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedCompareExchange(var Target: Integer;
                                  Exch, Comp: Integer): Integer;         virtual; abstract;
  //
  // 279  - Атомарная операция Target:=Target-1, возвращает Target-1.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedDec(var Target: Integer): Integer;                     virtual; abstract;
  //
  // 280  - Атомарная операция Target:=Value, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedExchange(var Target: Integer;
                               Value: Integer): Integer;                 virtual; abstract;
  //
  // 281  - Атомарная операция Target:=Target+Value, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedExchangeAdd(var Target: Integer;
                                   Value: Integer): Integer;             virtual; abstract;
  //
  // 282  - Атомарная операция Target:=Target-1, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedExchangeDec(var Target: Integer): Integer;             virtual; abstract;
  //
  // 283  - Атомарная операция Target:=Target+1, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedExchangeInc(var Target: Integer): Integer;             virtual; abstract;
  //
  // 284  - Атомарная операция Target:=Target-Value, возвращает Target.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedExchangeSub(var Target: Integer;
                                   Value: Integer): Integer;             virtual; abstract;
  //
  // 285  - Атомарная операция Target:=Target+1, возвращает Target+1.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedInc(var Target: Integer): Integer;                     virtual; abstract;
  //
  // 286  - Атомарная операция Target:=Target-Value, возвращает Target-Value.
  //        Может применяться для синхронизации потоков или процессов.
  //
  function  LockedSub(var Target: Integer; Value: Integer): Integer;     virtual; abstract;
  //
  // 287 - Удалить начальную и конечную скобку. Полезна при анализе конфигураций.
  //       Например, RemoveBrackets('[Section]')='Section'.
  //
  function  RemoveBrackets(const s:ShortString;
                           const Brackets:ShortString='[]'):ShortString; virtual; abstract;
  //
  // 288 - Кодировка двоичных данных в MIME, 64-base.
  // В входной строке присутствуют любые символы.
  // В выходной строке присутствуют только символы a..z, A..Z, 0..9, +, /.
  // Применяется для передачи двоичных данных по текстовому каналу связи.
  // Например:
  //  var x,y:double; i,j:integer; s:string;
  //  s:=mime_encode(r2dump(x)+r2dump(y)+i2dump(i)+i2dump(j));
  //  ... send data ...
  //  s:=mime_decode(s);
  //  x:=dump2r(copy(s,1,8));
  //  y:=dump2r(copy(s,9,8));
  //  i:=dump2i(copy(s,17,4));
  //  j:=dump2i(copy(s,21,4));
  //
  function  Mime_Encode(const S:LongString):LongString;                  virtual; abstract;
  //
  // 289 - Декодирование данных, закодированных при помощи Mime_Encode.
  //
  function  Mime_Decode(const S:LongString):LongString;                  virtual; abstract;
  //
  // 290 - Сравнение строк, не чувствительное к регистру.
  //
  function  IsSameText(const S1,S2:LongString):Boolean;                  virtual; abstract;
 end;
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Класс TGuiApi содержит функции для организации графического интерфейса    //
 // пользователя. Он доступен при всех значениях Target. При создании утилит  //
 // обработки данных можно использовать все эти функции без ограничений. При  //
 // создании драйверов CRW-DAQ надо помнить, что драйвер выполняется, как     //
 // правило, в отдельном потоке, поэтому вызов модальных диалогов, например,  //
 // недопустим. Большинство таких функций защищено, в том смысле, что они     //
 // ничего не делают, если вызваны из другого потока, а возвращают mrNone.    //
 ///////////////////////////////////////////////////////////////////////////////
 TGuiApi = class(TPluginApi)
  //
  // 0    - Вывод текста в консольное окно. Работает всегда, даже если не было
  //        вызова RedirectStdOut(..). Вызов потокобезопасен, не дает задержки,
  //        так как фактически выполняется через FIFO. Поэтому может применяться
  //        в Real Time задачах.
  //
  procedure Echo(const Msg:LongString);                                  virtual; abstract;
  //
  // 1    - Модальный диалог для предупреждений.
  //
  function  Warning(const Msg:ShortString):word;                         virtual; abstract;
  //
  // 2    - Модальный диалог для информационных сообщений.
  //
  function  Information(const Msg:ShortString):word;                     virtual; abstract;
  //
  // 3    - Модальный диалог для запросов Yes/No.
  //
  function  YesNo(const Msg:ShortString):word;                           virtual; abstract;
  //
  // 4    - Модальный диалог для запросов Yes/No/Cancel.
  //
  function  YesNoCancel(const Msg:ShortString):word;                     virtual; abstract;
  //
  // 5    - Модальный диалог для сообщений об ошибках.
  //
  function  Error(const Msg:ShortString):word;                           virtual; abstract;
  //
  // 6    - Если выполнено условие, вызывает модальный диалог для сообщений об ошибках.
  //
  function  Trouble(Check:boolean; const Msg:ShortString):Boolean;       virtual; abstract;
  //
  // 7    - Если не выполнено условие, вызывает модальной диалог для сообщений об ошибках.
  //
  function  NoProblem(Check:boolean; const Msg:ShortString):Boolean;     virtual; abstract;
  //
  // 8    - Модальный диалог для выбора элемента списка, заданного текстом ItemList.
  //        Возвращает индекс выбранного пункта (начиная с нуля).
  //        Возвращает -1, если выбор был отменен.
  //
  function  ListBoxMenu(const Caption,Title:ShortString;
                        const ItemList:LongString):Integer;              virtual; abstract;
  //
  // 9    - Модальный диалог для выбора группы элементов списка, заданного текстом ItemList.
  //        Возвращает список выбранных пунктов или список их индексов,
  //        в зависимости от значения GetIndex. Возвращает пустую строку при
  //        отмене выбора.
  //
  function  ListBoxMultiSelection(const Caption,Title:ShortString;
                                  const ItemList : LongString;
                                        Extended : Boolean = false;
                                        GetIndex : Boolean = false
                                               ) : LongString;           virtual; abstract;
  //
  // 10   - Модальный диалог для редактирования текста.
  //
  function  TextEditDialog(const Caption,Title:ShortString;
                           const TextToEdit:LongString):LongString;      virtual; abstract;
  //
  // 11  - Проверяет, доступна ли звуковая подсистема программы.
  //
  function UsesBlaster:Boolean;                                          virtual; abstract;
  //
  // 12   - Инициирует проигрывание списка звуков, заданных списком PlayList.
  //        На самом деле процедура просто помещает список звуков в FIFO и
  //        сразу возвращает управление. Проигрывание звуков выполняется
  //        в отдельном потоке. Список PlayList состоит из имен wav-файлов,
  //        расположенных в каталогах, заданных AddSoundLibrary. Целые числа
  //        автоматически преобразуются в произносимую последовательность
  //        звуков.
  //
  procedure Voice(const PlayList:ShortString);                           virtual; abstract;
  //
  // 13   - Очищает FIFO звуков, отменяя все задания, инициированные командой Voice.
  //
  procedure StopBlaster;                                                 virtual; abstract;
  //
  // 14   - Добавляет в список доступных звуков каталог и его подкаталоги.
  //        Все *.WAV файлы из этих каталогов можно будет произносить.
  //
  procedure AddSoundLibrary(const Path:ShortString;
                                  MaxSubDirs:LongInt=0);                 virtual; abstract;
  //
  // 15   - Вызывает Application.ProcessMessages, для длительных вычислений.
  //
  procedure ApplicationProcessMessages;                                  virtual; abstract;
  //
  // 16   - Вызывает обновление консоли, для длительных вычислений.
  //
  procedure UpdateSystemConsole;                                         virtual; abstract;
  //
  // 17   - Составляет цвет из отдельных компонент R,G,B, лежащих в диапазоне 0..255.
  //
  function  RGB(r,g,b:Integer):TColor;                                   virtual; abstract;
  //
  // 18   - Возвращает английское имя цвета старого стиля CGA.
  //
  function  CgaColorNameEng(CgaColor:Integer):ShortString;               virtual; abstract;
  //
  // 19   - Возвращает русское имя цвета старого стиля CGA.
  //
  function  CgaColorNameRus(CgaColor:Integer):ShortString;               virtual; abstract;
  //
  // 20   - Возвращает цвет старого стиля CGA по имени.
  //
  function  CgaColorByName(const S:ShortString):Integer;                 virtual; abstract;
  //
  // 21   - Преобразует цветовую кодировку старого стиля CGA, принятую в DOS,
  //        в цветовую кодировку RGB, принятую в Windows. CgaColor меняется
  //        в пределах 0=Black...15=White.
  //
  function  CgaToRGBColor(CgaColor:Integer):TColor;                      virtual; abstract;
  //
  // 22   - Вызывает Application.Handle.
  //
  function  ApplicationHandle:THandle;                                   virtual; abstract;
 end;
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Класс TDaqApi содержит функции для создания драйверов для подсистемы      //
 // сбора данных CRW-DAQ. При этом Target должен быть ForDataAcquisition.     //
 // Общие замечания.                                                          //
 // 1) Вызов DLL. В системе CRW-DAQ с устройством Program (на Daq Pascal)     //
 //    можно связать несколько DLL, вызываемых через функции Daq Pascal:      //
 //     DaqDllInit(DllPath)      - загружает DLL с заданным именем файла.     //
 //     DaqDllFree(hDll)         - удаляет загруженную ранее DLL.             //
 //     DaqDllCall(hDll,Command) - вызывает DLL для выполнения данной команды.//
 //    Через Command передается команда, общее указание, что надо делать.     //
 //    Все остальные параметры передаются/принимаются через теги/кривые.      //
 //    Команды, за исключением нескольких, не заданы жестко, они являются     //
 //    предметом договоренности вызывающей программы на Daq Pascal и DLL.     //
 //    Однако несколько команд зарезервированы:                               //
 //     a)При старте CRW-DAQ надо вызывать DLL с командой Daq_Cmd_Init        //
 //       для выполнения инициализирующих действий при старте устройства.     //
 //       Например, инициализация ссылок на кривые и теги, выделение памяти.  //
 //       Если при старте возник код ошибки, работа с DLL должна быть         //
 //       завершена, а опрос должен быть отменен.                             //
 //     b)В процессе опроса DAQ надо вызывать DLL с командой Daq_Cmd_Poll     //
 //       для выполнения полезной работы. Команда опроса вызывается           //
 //       многократно, в цикле опроса устройства. Устройство должно быстро    //
 //       выполнять свои функции, по возможности быстро возвращая управление. //
 //       Если нужны длительные операции, лучше создать для них свой поток,   //
 //       чем задерживать цикл опроса.                                        //
 //     c)При остановке CRW DAQ, надо вызывать DLL с командой Daq_Cmd_Free    //
 //       для выполнения завершающих операций,таких как освобождение памяти   //
 //       и т.д.                                                              //
 //  2) Хранение временных данных. При вызове DaqDllInit создается новый      //
 //     экземпляр API, с которым связан свой собственный сегмент данных.      //
 //     Это надо потому, что одна и та же DLL может обслуживать несколько     //
 //     устройств. Чтобы не путать одноименные переменные, которые относятся  //
 //     к разным устройствам, каждое устройство имеет свой экземпляр API со   //
 //     своим сегментом данных. Сегмент данных сохраняется от вызова к вызову,//
 //     что позволяет хранить в нем долговременные данные.                    //
 //     При вызове DaqDllFree сегмент данных автоматически уничтожается.      //
 //     Но все же лучше уничтожать его явно по команде Daq_Cmd_Free вызовом   //
 //     DaqDataSheet(0), так как сегмент данных может содержать указатели на  //
 //     другие данные,которые надо освободить до уничтожения сегмента данных. //
 //     Выделение, доступ и удаление сегмента данных осуществляется через     //
 //     одну функцию DaqDataSheet(Size). Сегмент данных обычно связан с       //
 //     записью некоторого типа, Size получается через sizeof(..)             //
 //     Пример:                                                               //
 //          type TDataRec:record ... end;                                    //
 //          begin                                                            //
 //           with Daq, TDataRec(DaqDataSheet(sizeof(TDataRec))^) do ...      //
 //          end;                                                             //
 //  3) Теги. Система CRW DAQ содержит базу данных тегов, к которой DLL имеет //
 //     через функции FindTag...sSetTag. Теги являются поименованными         //
 //     переменными системы CRW-DAQ общего пользования с потокобезопасным     //
 //     доступом. Каждый тег имеет имя, ссылку, тип, и значение. Имя служит   //
 //     для идентификаци тега с точки зрения программиста и конфигурационного //
 //     файла (запоминать легче). Однако из соображений эффективности доступ  //
 //     к тегу возможен только по ссылке. Обычно при старте программа DAQ     //
 //     определяет ссылки тегов по имени, а затем использует ссылки для       //
 //     доступа к данным. Тип тега определяет содержимое тега и может быть    //
 //     равен 1(Integer), 2(Double), 3(LongString). Нулевой тип значит, что   //
 //     тег с данным индексом не существует. То же самое означает нулевая     //
 //     ссылка на тег.                                                        //
 //  4) Термопарные таблицы. Система Crw Daq содержит базу данных стандартных //
 //     калибровок - термопар, резистивных датчиков, термодиодов и т.д.       //
 //     Для доступа к базе данных служат функции Thermocouple,Relationsheep.. //
 //  5) Кривые. Система CRW DAQ содержит базу данных кривых, то есть          //
 //     поименованных динамических массивов. Для работы с кривыми есть очень  //
 //     много функций. Часть из них использует для доступа к кривой номер     //
 //     аналогового/цифрового входа/выхода. Эти функции по большей части      //
 //     аналогичны функциям Daq Pascal. Например, основной способ записи      //
 //     в кривую - это помещение в очередь события вызовом putev,putao,putdo. //
 //     При этом автоматически будут обновляться данные в окне.               //
 //     Другая группа функций использует для доступа к кривой ссылку, которую //
 //     можно получить через refAI..refDO, FindObjectRef('Curve',..).         //
 //     При прямой модификации кривой окна надо обновлять вручную, вызовом    //
 //     WinDraw. При использовании функций этой группы надо быть внимательным,//
 //     так как контроль сведен к минимуму (например, можно модифицировать    //
 //     кривую, подключенную к входу).                                        //
 //  6) Устройства. В отличие от DaqPascal, для работы с устройствами CRW DAQ //
 //     в основном используются ссылки, получаемые через вызов функции        //
 //     FindObjectRef('Device',..).                                           //
 ///////////////////////////////////////////////////////////////////////////////
 TDaqApi = class(TPluginApi)
  //
  // 0    - Возвращает команду, переданную в DLL из программы Daq Pascal
  //        при вызове функции DaqDllCall(..,Command).
  //
  function  DaqCommand:Integer;                                          virtual; abstract;
  //
  // 1    - Возвращает указатель области данных драйвера DAQ - системы.
  //        Параметр aSize задает размер области данных. Если он равен нулю,
  //        область данных уничтожается. Если размер области данных изменился,
  //        память перераспределяется. Область данных используется для хранения
  //        данных между вызовами DLL, обычно она связана с записью какого-то
  //        фиксированного типа и используется в таком стиле:
  //          type TDataRec:record ... end;
  //          begin
  //           with Daq, TDataRec(DaqDataSheet(sizeof(TDataRec))^) do ...
  //          end;
  //
  function  DaqDataSheet(aSize:Integer):Pointer;                         virtual; abstract;
  //
  // 2    - Проверяет, загружена ли DAQ - система.
  //
  function  DaqIsLoaded:Boolean;                                         virtual; abstract;
  //
  // 3    - Проверяет, запущена ли на выполнение DAQ - система.
  //
  function  DaqIsStarted:Boolean;                                        virtual; abstract;
  //
  // 4    - Возвращает имя основного конфигурационного файла DAQ.
  //
  function  DaqConfigFile:ShortString;                                   virtual; abstract;
  //
  // 5    - Возвращает каталог для файлов данных загруженной системы DAQ.
  //
  function  DaqDataPath:ShortString;                                     virtual; abstract;
  //
  // 6    - Возвращает каталог для временных файлов загруженной системы DAQ.
  //
  function  DaqTempPath:ShortString;                                     virtual; abstract;
  //
  // 7    - Возвращает ссылку тега по его имени. Сссылка должна быть ненулевой.
  //        Если возвращается ноль, значит тега с таким именем не существует.
  //
  function  FindTag(const Name:ShortString):Integer;                     virtual; abstract;
  //
  // 8    - Возвращает ссылку тега с данным именем, если он существует.
  //        Создает новый тег, если его еще не существует.
  //        Возвращает ноль, если таблица тегов исчерпана или если существует
  //        тег с заданным именем, но другого типа.
  //
  function  CreateTag(const Name:ShortString; Typ:Integer):Integer;      virtual; abstract;
  //
  // 9    - Уничтожает тег, заданный ссылкой tag.
  //
  function  FreeTag(tag:Integer):Boolean;                                virtual; abstract;
  //
  // 10    - Возвращает тип тега, заданного ссылкой tag. Может возвратить:
  //        0 - Тег не существует.
  //        1 - Тег имеет тип Integer    (Integer в Daq Pascal).
  //        2 - Тег имеет тип Double     (Real    в Daq Pascal).
  //        3 - Тег имеет тип LongString (String  в Daq Pascal).
  //
  function  TypeTag(tag:Integer):Integer;                                virtual; abstract;
  //
  // 11   - Возвращает имя тега с заданной ссылкой tag.
  //        Возвращает пустую строку, если тег не существует.
  //
  function  NameTag(tag:Integer):ShortString;                            virtual; abstract;
  //
  // 12   - Возвращает значение тега типа Integer.
  //        Возвращает 0, если тег не существует или тип тега неверен.
  //
  function  iGetTag(tag:Integer):Integer;                                virtual; abstract;
  //
  // 13   - Возвращает значение тега типа Real.
  //        Возвращает 0, если тег не существует или тип тега неверен.
  //
  function  rGetTag(tag:Integer):Double;                                 virtual; abstract;
  //
  // 14   - Возвращает значение тега типа String.
  //        Возвращает пустую строку, если тег не существует или тип тега неверен.
  //
  function  sGetTag(tag:Integer):LongString;                             virtual; abstract;
  //
  // 15   - Задает новое значение тега типа Integer.
  //        Возвращает false, если тег не существует или тип тега неверен.
  //
  function  iSetTag(tag:Integer; i:Integer):Boolean;                     virtual; abstract;
  //
  // 16   - Задает новое значение тега типа Real.
  //        Возвращает false, если тег не существует или тип тега неверен.
  //
  function  rSetTag(tag:Integer; r:Double):Boolean;                      virtual; abstract;
  //
  // 17   - Задает новое значение тега типа String.
  //        Возвращает false, если тег не существует или тип тега неверен.
  //
  function  sSetTag(tag:Integer; const s:LongString):Boolean;            virtual; abstract;
  //
  // 18   - Число загруженных стандартных термопарных таблиц.
  //
  function  ThermoCoupleCount:Integer;                                   virtual; abstract;
  //
  // 19   - Находит индекс от 0 до ThermoCoupleCount-1 стандартной термопарной
  //        таблицы по имени. Возвращает -1, если термопары с таким именем нет.
  //
  function  FindThermoCouple(const CoupleName:ShortString):Integer;      virtual; abstract;
  //
  // 20   - Возвращает имя стандартной термопарной таблицы по индексу.
  //
  function  ThermoCoupleName(CoupleID:Integer):ShortString;              virtual; abstract;
  //
  // 21   - Возвращает диапазон стандартной термопарной таблицы.
  //
  function  ThermoCoupleRange(CoupleID:Integer):TRect2D;                 virtual; abstract;
  //
  // 22   - Возвращает значение прямой или обратной стандартной термопарной
  //        таблицы, в зависимости от Inverted. Для интерполяции используется
  //        сглаживающий сплайн.
  //
  function  ThermoCoupleValue(CoupleID:Integer; Argument:Double;
                              Inverted:Boolean):Double;                  virtual; abstract;
  //
  // 23   - Число загруженных таблиц стандартных калибровок.
  //
  function  RelationshipCount:Integer;                                   virtual; abstract;
  //
  // 24   - Возвращает индекс от 0 до RelationshipCount-1 таблицы стандартных
  //        калибровок по имени. Возвращает -1, если нет такой таблицы.
  //
  function  FindRelationship(const RelationName:ShortString):Integer;    virtual; abstract;
  //
  // 25   - Возвращает имя таблицы стандартных калибровок по индексу.
  //
  function  RelationshipName(RelationID:Integer):ShortString;            virtual; abstract;
  //
  // 26   - Возвращает диапазон стандартной таблицы калибровок.
  //
  function  RelationshipRange(RelationID:Integer):TRect2D;               virtual; abstract;
  //
  // 27   - Возвращает значение прямой или обратной стандартной таблицы
  //        калибровок, в зависимости от Inverted. Для интерполяции используется
  //        сглаживающий сплайн.
  //
  function  RelationshipValue(RelationID:Integer; Argument:Double;
                              Inverted:Boolean):Double;                  virtual; abstract;
  //
  // 28   - Возвращает текущее время по часам DAQ, выраженное в единицах TimeUnits.
  //
  function  Time:Double;                                                 virtual; abstract;
  //
  // 29   - Возвращает единицы измерения времени DAQ в миллисекундах.
  //
  function  TimeUnits:Double;                                            virtual; abstract;
  //
  // 30   - Возвращает число аналоговых входов вызвавшего устройства DAQ.
  //
  function  NumAIs:Integer;                                              virtual; abstract;
  //
  // 31   - Возвращает число цифровых входов вызвавшего устройства DAQ.
  //
  function  NumDIs:Integer;                                              virtual; abstract;
  //
  // 32   - Возвращает число аналоговых выходов вызвавшего устройства DAQ.
  //
  function  NumAOs:Integer;                                              virtual; abstract;
  //
  // 33   - Возвращает число цифровых выходов вызвавшего устройства DAQ.
  //
  function  NumDOs:Integer;                                              virtual; abstract;
  //
  // 34   - Возвращает число калибровок вызвавшего устройства DAQ.
  //
  function  NumCals:Integer;                                             virtual; abstract;
  //
  // 35   - Возвращает ссылку кривой, подключенной к аналоговому входу n.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  RefAI(n:Integer):Integer;                                    virtual; abstract;
  //
  // 36   - Возвращает ссылку кривой, подключенной к цифровому входу n.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  RefDI(n:Integer):Integer;                                    virtual; abstract;
  //
  // 37   - Возвращает ссылку кривой, подключенной к аналоговому выходу n.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  RefAO(n:Integer):Integer;                                    virtual; abstract;
  //
  // 38   - Возвращает ссылку кривой, подключенной к цифровому выходу n.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  RefDO(n:Integer):Integer;                                    virtual; abstract;
  //
  // 39   - Возвращает ссылку калибровки n.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  RefCalibr(n:Integer):Integer;                                virtual; abstract;
  //
  // 40   - Возвращает длину кривой, заданной ссылкой с.
  //
  function  GetCurveLength(c:Integer):Integer;                           virtual; abstract;
  //
  // 41   - Задает новую длину кривой c.
  //
  procedure SetCurveLength(c,aLength:Integer);                           virtual; abstract;
  //
  // 42   - Возвращает точку номер i из кривой, заданной ссылкой c.
  //        Напоминаем, что нумерация точек идет с 0.
  //
  function  GetCurvePoint(c,i:Integer):TPoint2D;                         virtual; abstract;
  //
  // 43   - Задает значение точки номер i на кривой c.
  //
  procedure SetCurvePoint(c,i:Integer; const aPoint:TPoint2D);           virtual; abstract;
  //
  // 44   - Добавляет точку в конец кривой c.
  //
  procedure CurveAddPoint(c:Integer; const aPoint:TPoint2D);             virtual; abstract;
  //
  // 45   - Добавляет aCount точек в конец кривой c.
  //
  procedure CurveAddPoints(c:Integer; const aX,aY:array of Double;
                                            aCount:Integer);             virtual; abstract;
  //
  // 46   - Удаляет точку i из кривой c.
  //
  procedure CurveDeletePoint(c,i:Integer);                               virtual; abstract;
  //
  // 47   - Удаляет aCount точек начиная с i из кривой c.
  //
  procedure CurveDeletePoints(c,i,aCount:Integer);                       virtual; abstract;
  //
  // 48   - Вставляет точку в позицию i кривой c.
  //
  procedure CurveInsertPoint(c,i:Integer; const aPoint:TPoint2D);        virtual; abstract;
  //
  // 49   - Вставляет aCount точек в позицию i кривой c.
  //
  procedure CurveInsertPoints(c,i:Integer; const aX,aY:array of Double;
                              aCount:LongInt);                           virtual; abstract;
  //
  // 50   - Возвращает имя кривой, заданной ссылкой c.
  //
  function  GetCurveName(c:Integer):ShortString;                         virtual; abstract;
  //
  // 51   - Возвращает цвет кривой, заданной ссылкой c.
  //
  function  GetCurveColor(c:Integer):Integer;                            virtual; abstract;
  //
  // 52   - Возвращает стиль кривой, заданной ссылкой c.
  //
  function  GetCurveStyle(c:Integer):Integer;                            virtual; abstract;
  //
  // 53   - Возвращает комментарий кривой, заданной ссылкой c.
  //
  function  GetCurveComment(c:Integer):LongString;                       virtual; abstract;
  //
  // 54   - Задает комментарий кривой, заданной ссылкой c.
  //
  procedure SetCurveComment(c:Integer; const aComment:LongString);       virtual; abstract;
  //
  // 55   - Быстрый поиск индекса ближайшей к t точки кривой c.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveGetIndexAt(c:Integer; t:Double):Integer;                virtual; abstract;
  //
  // 56   - Линейная интерполяция кривой c в точке t.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveInterpolateAt(c:Integer; t:Double):Double;              virtual; abstract;
  //
  // 57   - Сглаживание кривой c в точке t окном шириной Window, а также ядром
  //        типа K(x)=(1-x^k1)^k2. Power - степень полинома или интеграл при Power=-1.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveSmoothAt(c:Integer; t:Double;
                        Window:Double; Power,K1,K2:Integer):Double;      virtual; abstract;
  //
  // 58   - Вычисляет медиану кривой c в интервале точек [i..j].
  //        Возвращает индекс aIndex и значение aValue медианы.
  //        Можно выбирать метод сортировки 0=Shell,1=Quick.
  //
  function  CurveMedianaAt(c,i,j:Integer; var aIndex:Integer; var aValue:Double;
                         SortMethod:Integer=1):Boolean;                  virtual; abstract;
  //
  // 59   - Вычисляет массив флагов типа "кривая отсортирована" и т.д.
  //        Смотрите описание констант cfXXXX.
  //
  function  CurveFlags(c:Integer; AbsEps:Double=0;RelEps:Double=1E-10;
                       Small:Integer=2):LongInt;                         virtual; abstract;
  //
  // 60   - Возвращает минимальный прямоугольник, содержащий все точки кривой c.
  //
  function  GetCurveLimits(c:Integer):TRect2D;                           virtual; abstract;
  //
  // 61   - Возвращает интеграл участка (a,b) кривой c.
  //
  function  GetCurveIntegral(c:Integer; a,b:Double):Double;              virtual; abstract;
  //
  // 62   - Возвращает последнюю точку кривой c.
  //
  function  GetCurveLastPoint(c:Integer):TPoint2D;                       virtual; abstract;
  //
  // 63   - Помещает событие в очередь событий.
  //        w  - тип события, например, evAnalog+evCompress или evDigital.
  //        n  - номер канала, то есть аналогового или цифрового выхода.
  //        t  - время по часам DAQ, см. функцию Time.
  //        d0 - первый элемент данных
  //        d1 - второй элемент данных
  //        Запись данных в кривые через очередь событий является наиболее
  //        предпочтительным способом обновления кривых, так как при этом выполнется
  //        автоматическое обновление графиков, сжатие данных и другие
  //        предусмотренные диспетчером событий действия.
  //
  function  PutEv(w,n:Integer; t,d0:Double; d1:Double=0):Boolean;        virtual; abstract;
  //
  // 64   - Помещает аналоговое событие в очередь событий.
  //        Эквивалент PutEv(evAnalog+evCompress,n,t,d,0).
  //        Запись данных в кривые через очередь событий является наиболее
  //        предпочтительным способом обновления кривых, так как при этом выполнется
  //        автоматическое обновление графиков, сжатие данных и другие
  //        предусмотренные диспетчером событий действия.
  //
  function  PutAO(n:Integer; t,d:Double):Boolean;                        virtual; abstract;
  //
  // 65   - Помещает цифровое событие в очередь событий.
  //        Эквивалент PutEv(evDigital,n,t,d,0).
  //        Запись данных в кривые через очередь событий является наиболее
  //        предпочтительным способом обновления кривых, так как при этом выполнется
  //        автоматическое обновление графиков, сжатие данных и другие
  //        предусмотренные диспетчером событий действия.
  //
  function  PutDO(n:Integer; t,d:Double):Boolean;                        virtual; abstract;
  //
  // 66   - Возвращает данные аналогового входа n в момент времени t с применением сглаживания.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai(n:Integer;t:Double):Double;                            virtual; abstract;
  //
  // 67   - Возвращает число точек кривой с аналогового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai_n(n:Integer):Integer;                                  virtual; abstract;
  //
  // 68   - Возвращает координату X последней точки кривой с аналогового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai_xn(n:Integer):Double;                                  virtual; abstract;
  //
  // 69   - Возвращает координату Y последней точки кривой с аналогового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai_yn(n:Integer):Double;                                  virtual; abstract;
  //
  // 70   - Возвращает координату X[i] кривой с аналогового входа n.
  //        Нумерация точек начинается с 1, как в Daq Pascal.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai_xi(n,i:Integer):Double;                                virtual; abstract;
  //
  // 71   - Возвращает координату Y[i] кривой с аналогового входа n.
  //        Нумерация точек начинается с 1, как в Daq Pascal.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getai_yi(n,i:Integer):Double;                                virtual; abstract;
  //
  // 72   - Возвращает данные цифрового входа n в момент времени t.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi(n:Integer;t:Double):Double;                            virtual; abstract;
  //
  // 73   - Возвращает число точек кривой с цифрового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi_n(n:Integer):Integer;                                  virtual; abstract;
  //
  // 74   - Возвращает координату X последней точки кривой с цифрового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi_xn(n:Integer):Double;                                  virtual; abstract;
  //
  // 75   - Возвращает координату Y последней точки кривой с цифрового входа n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi_yn(n:Integer):Double;                                  virtual; abstract;
  //
  // 76   - Возвращает координату X[i] кривой с цифрового входа n.
  //        Нумерация точек начинается с 1, как в Daq Pascal.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi_xi(n,i:Integer):Double;                                virtual; abstract;
  //
  // 77   - Возвращает координату Y[i] кривой с цифрового входа n.
  //        Нумерация точек начинается с 1, как в Daq Pascal.
  //        Аналог одноименной функции DaqPascal.
  //
  function  getdi_yi(n,i:Integer):Double;                                virtual; abstract;
  //
  // 78   - Преобразует величину t по калибровке номер n, используя параметр d.
  //        Аналог одноименной функции DaqPascal.
  //
  function  calibr(n:Integer; t,d:Double):Double;                        virtual; abstract;
  //
  // 79   - Фиксирует ошибку с кодом n.
  //        Аналог одноименной функции DaqPascal.
  //
  function  fixerror(n:Integer):Boolean;                                 virtual; abstract;
  //
  // 80   - Возвращает число, в битах которого закодирована карта подключения
  //        аналоговых входов i..i+n-1. Наличие бита в числе означает, что
  //        на соответствующем входе подключена кривая.
  //        Аналог одноименной функции DaqPascal.
  //
  function  aimap(i,n:Integer):Integer;                                  virtual; abstract;
  //
  // 81   - Возвращает число, в битах которого закодирована карта подключения
  //        цифровых входов i..i+n-1. Наличие бита в числе означает, что
  //        на соответствующем входе подключена кривая.
  //        Аналог одноименной функции DaqPascal.
  //
  function  dimap(i,n:Integer):Integer;                                  virtual; abstract;
  //
  // 82   - Возвращает число, в битах которого закодирована карта подключения
  //        аналоговых выходов i..i+n-1. Наличие бита в числе означает, что
  //        на соответствующем выходе подключена кривая.
  //        Аналог одноименной функции DaqPascal.
  //
  function  aomap(i,n:Integer):Integer;                                  virtual; abstract;
  //
  // 83   - Возвращает число, в битах которого закодирована карта подключения
  //        цифровых выходов i..i+n-1. Наличие бита в числе означает, что
  //        на соответствующем выходе подключена кривая.
  //        Аналог одноименной функции DaqPascal.
  //
  function  domap(i,n:Integer):Integer;                                  virtual; abstract;
  //
  // 84   - Конструирует число, в битах которого закодирован входной цифровой
  //        сигнал на входах i..i+n-1. Наличие бита в числе означает, что
  //        на соответствующем входе соответствующий бит числа установлен.
  //        Аналог одноименной функции DaqPascal.
  //
  function  diword(i,n:Integer):Integer;                                 virtual; abstract;
  //
  // 85   - Возвращает код при нажатии кнопки мыши на сенсоре.
  //        0 - ничего не нажато.
  //        1 - нажата левая кнопка.
  //        2 - нажата правая кнопка.
  //        3 - нажата средняя кнопка.
  //        Аналог одноименной функции DaqPascal.
  //
  function  ClickButton:Integer;                                         virtual; abstract;
  //
  // 86   - Возвращает имя нажатого сенсора.
  //        Аналог одноименной функции DaqPascal.
  //
  function  ClickSensor:ShortString;                                     virtual; abstract;
  //
  // 87   - Возвращает ссылку нажатого тега.
  //        Аналог одноименной функции DaqPascal.
  //
  function  ClickTag:Integer;                                            virtual; abstract;
  //
  // 88   - Посылает звуковое сообщение. Отличается рядом деталей от GuiApi.Voice.
  //        Например, звук DaqApi.Voice можно запретить кнопкой на панели DAQ.
  //        Аналог одноименной функции DaqPascal.
  //
  function  Voice(const msg:ShortString):Boolean;                        virtual; abstract;
  //
  // 89   - Находит и перерисовывает окно, имеющее заголовок Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  WinDraw(const Caption:ShortString):Boolean;                  virtual; abstract;
  //
  // 90   - Находит и разворачивает окно, имеющее заголовок Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  WinShow(const Caption:ShortString):Boolean;                  virtual; abstract;
  //
  // 91   - Находит и сворачивает окно, имеющее заголовок Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  WinHide(const Caption:ShortString):Boolean;                  virtual; abstract;
  //
  // 92   - Находит и активизирует окно, имеющее заголовок Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  WinSelect(const Caption:ShortString):Boolean;                virtual; abstract;
  //
  // 93   - Читает из конфигурации переменную. Возможны варианты строки s:
  //         s = Var         - чтение переменной Var из секции устройства.
  //         s = Sec Var     - чтение переменной Var из секции Sec конфигурации DAQ.
  //         s = Cfg Sec Var - чтение переменной Var из секции Sec файла Cfg.
  //        Аналог одноименной функции DaqPascal.
  //
  function  ReadIni(const s:ShortString):ShortString;                    virtual; abstract;
  //
  // 94   - Чтение байта из порта ввода-вывода процессора. Будьте осторожны!
  //
  function  GetPortB(Address:Word):Byte;                                 virtual; abstract;
  //
  // 95   - Запись байта в порт ввода-вывода процессора. Будьте осторожны!
  //
  procedure SetPortB(Address:Word; Value:Byte);                          virtual; abstract;
  //
  // 96   - Чтение слова из порта ввода-вывода процессора. Будьте осторожны!
  //
  function  GetPortW(Address:Word):Word;                                 virtual; abstract;
  //
  // 97   - Запись слова в порт ввода-вывода процессора. Будьте осторожны!
  //
  procedure SetPortW(Address:Word; Value:Word);                          virtual; abstract;
  //
  // 98   - Чтение двойного слова из порта ввода-вывода процессора. Будьте осторожны!
  //
  function  GetPortL(Address:Word):LongWord;                             virtual; abstract;
  //
  // 99   - Запись двойного слова в порт ввода-вывода процессора. Будьте осторожны!
  //
  procedure SetPortL(Address:Word; Value:LongWord);                      virtual; abstract;
  //
  // 100  -  Регистрирует в DAQ системе новый код ошибки с текстом сообщения s.
  //        Аналог одноименной функции DaqPascal.
  //
  function  RegisterErr(const s:ShortString):Integer;                    virtual; abstract;
  //
  // 101  - Счетчик ошибок с кодом n.
  //         n = -2       : все ошибки всех устройств
  //         n = -1       : все ошибки данного устройства
  //         n = 0..255   : ошибки устройства с кодом n
  //         n = 256..511 : ошибки всех устройств с кодом n-256
  //        Аналог одноименной функции DaqPascal.
  //
  function  GetErrCount(n:Integer):Double;                               virtual; abstract;
  //
  // 102  - Возвращает счетчик вызовов программы DAQ PASCAL, с которой связана DLL.
  //        Аналог одноименной функции DaqPascal.
  //
  function  RunCount:Double;                                             virtual; abstract;
  //
  // 103  - Поиск объекта типа What с именем Name в базе данных CRW DAQ.
  //        Тип What может иметь значение:
  //        TAG    - возвращает ссылку на тег, аналогично вызову FindTag.
  //        CURVE  - возвращает ссылку на кривую с данным именем.
  //        DEVICE - возвращает ссылку на устройство DAQ с данным именем.
  //                 Если задано пустое имя, возвращает текущее устройство.
  //        Если возвращается ноль, объект не найден.
  //        Полученную ссылку надо использовать по назначению, например,
  //        ссылку на кривую - только в функциях работы с кривыми и т.д.
  //        Так как функция связана с поиском в базе данных, рекомендуется
  //        вызывать ее один раз в начале программы, а полученную ссылку
  //        запоминать для дальнейшего использования.
  //
  function  FindObjectRef(const What,Name:ShortString):Integer;          virtual; abstract;
  //
  // 104  - Возвращает имя устройства по его ссылке.
  //
  function  DeviceName(d:Integer):ShortString;                           virtual; abstract;
  //
  // 105  - Возвращает название модели устройства по его ссылке.
  //
  function  DeviceModel(d:Integer):ShortString;                          virtual; abstract;
  //
  // 106  - Возвращает название семейства устройства по его ссылке.
  //
  function  DeviceFamily(d:Integer):ShortString;                         virtual; abstract;
  //
  // 107  - Вызов метода Action устройства, заданного ссылкой d, см.FindObjectRef.
  //        Вызов отсрочен, всвязи с тем, что выполняется в основном потоке VCL.
  //
  function  DeviceAction(d:Integer):Boolean;                             virtual; abstract;
  //
  // 108  - Вызов метода Clear устройства, заданного ссылкой d, см.FindObjectRef.
  //        Вызов отсрочен, всвязи с тем, что выполняется в основном потоке VCL.
  //
  function  DeviceClear(d:Integer):Boolean;                              virtual; abstract;
  //
  // 109  - Вызов метода ClearDevice устройства, заданного ссылкой d, см.FindObjectRef.
  //        Вызов отсрочен, всвязи с тем, что выполняется в основном потоке VCL.
  //
  function  DeviceClearDevice(d:Integer):Boolean;                        virtual; abstract;
  //
  // 110  - Вызов метода Start устройства, заданного ссылкой d, см.FindObjectRef.
  //        Вызов отсрочен, всвязи с тем, что выполняется в основном потоке VCL.
  //
  function  DeviceStart(d:Integer):Boolean;                              virtual; abstract;
  //
  // 111  - Вызов метода Stop устройства, заданного ссылкой d, см.FindObjectRef.
  //        Вызов отсрочен, всвязи с тем, что выполняется в основном потоке VCL.
  //
  function  DeviceStop(d:Integer):Boolean;                               virtual; abstract;
  //
  // 112  - Вызов метода HandleMessage устройства, заданного ссылкой d, см.FindObjectRef.
  //
  function  DeviceMessage(d:Integer; const msg:ShortString):Double;      virtual; abstract;
  //
  // 113  - Сохранение списка кривых в файл *.CRW.
  //        arglist =  fname winname wintitle winlable curvelist
  //         fname     - имя файла, можно относительно основного конфигфайла и без расширения
  //         winname   - имя окна под которым оно попадет в crw-архив
  //         wintitle  - заголовок в верхней части окна
  //         winlable  - метка в нижней части окна
  //         curvelist - список сохраняемых кривых
  //        Например:
  //        SaveCrw('..\data\pressure.crw, Pressures, ^CP(t)^N^L{P}, ^R{t}^N^Ct, p1,p2,p3,p4,p5');
  //        Аналог одноименной функции DaqPascal.
  //
  function  SaveCrw(const ArgList:ShortString):Boolean;                  virtual; abstract;
  //
  // 114  - Возвращает текущий маркер спектрометрического окна с заголовком Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  SpecMarker(const Caption:ShortString):Double;                virtual; abstract;
  //
  // 115  - Возвращает левый маркер спектрометрического окна с заголовком Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  SpecMarkerL(const Caption:ShortString):Double;               virtual; abstract;
  //
  // 116  - Возвращает правый маркер спектрометрического окна с заголовком Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  SpecMarkerR(const Caption:ShortString):Double;               virtual; abstract;
  //
  // 117  - Возвращает левую границу ROI спектрометрического окна с заголовком Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  SpecRoiL(const Caption:ShortString):Double;                  virtual; abstract;
  //
  // 118  - Возвращает правую границу ROI спектрометрического окна с заголовком Caption.
  //        Аналог одноименной функции DaqPascal.
  //
  function  SpecRoiR(const Caption:ShortString):Double;                  virtual; abstract;
  //
  // 119  - Вычисляет выражение Expression, используя общий калькулятор.
  //        Аналог функции global() DaqPascal.
  //
  function  GlobalCalc(const Expression:ShortString):Double;             virtual; abstract;
  //
  // 120    - Открывает порт aPortNum последовательной связи COM.
  //          aParity   = (NOPARITY,ODDPARITY,EVENPARITY,MARKPARITY,SPACEPARITY).
  //          aDataBits = 5..8.
  //          aStopBits = (ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS).
  //          Будьте внимательны. Функции Uartxxx работают с портом напрямую.
  //          Это полезно при написании драйверов RS-232, однако недопустимо
  //          работать с портом напрямую, если на порт подключены устройства
  //          семейства ADAM, работающие по логике RS-485, типа серии IC-7000.
  //          Прямая работа с портом в этом случае нарушает логику опроса.
  //
  function  UartOpen(aPortNum:Integer; aBaudrate:Integer=9600; aParity:Integer=NOPARITY;
                     aDataBits:Integer=8; aStopBits:Integer=ONESTOPBIT; aXonXoff:Boolean=false;
                     aFifoSize:Integer=4096;aDcbFlags:LongInt=0):Boolean;virtual; abstract;
  //
  // 121  - Открывает порт, используя конфигурационный файл CRW-DAQ.
  //
  function  UartOpenConfig(const Section:ShortString='[SerialPort-COM1]'
                           ):Integer;                                    virtual; abstract;
  //
  // 122  - Закрывает порт с данным номером.
  //
  procedure UartClose(aPortNum:Integer);                                 virtual; abstract;
  //
  // 123  - Проверяет, не был ли уже открыт порт с данным номером.
  //
  function  UartActive(aPortNum:Integer):Boolean;                        virtual; abstract;
  //
  // 124  - Записывает данные в буфер передатчика для последующей передачи.
  //        Возвращает число реально записанных в передачик символов.
  //
  function  UartWriteBuf(aPortNum:Integer; const Data:PChar;
                         Count:Cardinal):Cardinal;                       virtual; abstract;
  //
  // 125  - Читает принятые данные из буфера приемника. Возвращает число прочитанных символов.
  //
  function  UartReadBuf(aPortNum:Integer; var Data:PChar;
                        MaxCount:Cardinal):Cardinal;                     virtual; abstract;
  //
  // 126  - Записывает строку данных в буфер передатчика для последующей передачи.
  //
  function  UartWriteStr(aPortNum:Integer;
                         const Data:ShortString):Boolean;                virtual; abstract;
  //
  // 127  - Читает строку данных из буфера приемника.
  //
  function  UartReadStr(aPortNum:Integer;
                        MaxCount:Byte=255):ShortString;                  virtual; abstract;
  //
  // 128  - Очищает приемник и его буфер.
  //
  procedure UartRxClear(aPortNum:Integer);                               virtual; abstract;
  //
  // 129  - Очищает передатчик и его буфер.
  //
  procedure UartTxClear(aPortNum:Integer);                               virtual; abstract;
  //
  // 130  - Возвращает число символов в буфере приемника.
  //
  function  UartRxCount(aPortNum:Integer):Integer;                       virtual; abstract;
  //
  // 131  - Возвращает число символов в буфере передатчика.
  //
  function  UartTxCount(aPortNum:Integer):Integer;                       virtual; abstract;
  //
  // 132  - Возвращает свободное пространство в буфере приемника.
  //
  function  UartRxSpace(aPortNum:Integer):Integer;                       virtual; abstract;
  //
  // 133  - Возвращает свободное пространство в буфере передатчика.
  //
  function  UartTxSpace(aPortNum:Integer):Integer;                       virtual; abstract;
  //
  // 133 - Находит контрольную сумму строки, то есть сумму всех байтов без учета переполнения.
  //       Эта и 4 следующие функции ориентированы на работу с модулями серии ADAM,IC-700 и т.д.
  //
  function  UartFindCheckSum(Data:PChar; Length:Integer):Byte;           virtual; abstract;
  //
  // 134  - Добавляет в конец строки контрольную сумму в виде HEX - строки.
  //
  function  UartCatCheckSum(const DataStr:ShortString):ShortString;      virtual; abstract;
  //
  // 135  - Добавляет в конец строки перед символом CR контрольную сумму в виде HEX - строки.
  //
  function  UartCatCheckSumCR(const DataStr:ShortString;
                              CR:Char=ASCII_CR):ShortString;             virtual; abstract;
  //
  // 136  - Делает проверку контрольной суммы и выделение исходной строки без контрольной суммы.
  //        Если сумма не совпала, возвращается пустая строка.
  //
  function  UartTruncCheckSum(const DataStr:ShortString):ShortString;    virtual; abstract;
  //
  // 137  - Делает проверку контрольной суммы и выделение исходной строки без контрольной суммы.
  //        Если сумма не совпала, возвращается пустая строка. Если в конце строки CR, он подавляется.
  //
  function  UartTruncCheckSumCR(const DataStr:ShortString;
                                CR:Char=ASCII_CR):ShortString;           virtual; abstract;
  //
  // 138  - Получить ссылку на устройство Adam_Slot. Указывается имя устройства.
  //        Если имя пустое, используется ссылка Adam_Slot в секции описания
  //        устройства program, из которого вызвана DLL.
  //        Группа функций типа AdamXXX специально создана для обслуживания
  //        устройств в сети RS-485 типа ADAM-4000,IC-7000,IC-87000 и т.д.
  //        Для работы в сети RS-485 используется специальная дисциплина опроса
  //        устройств - они должны опрашиваться последовательно, а не асинхронно,
  //        так как все устройства используют один канал связи. Устройство типа
  //        Adam_Slot служит для того, чтобы через него программа получила
  //        корректный доступ к RS-485. Эти устройства обеспечивают корректный
  //        опрос, добавление/проверку/удаление контрольных сумм и разделителей,
  //        так что можно посылать/принимать сообщения, не заботясь о суммах.
  //
  function  AdamFindSlot(const aSlotDeviceName:ShortString=''):Integer;  virtual; abstract;
  //
  // 139  - Возвращает статус устройства Adam_Slot в сети RS-485.
  //        rs_NotAvail   = Сеть RS-485 недоступна. Скорее всего, неверная ссылка Adam_Slot.
  //        rs_NoRequest  = Запрос не был возбужден. Можно вызывать AdamSendRequest.
  //        rs_WaitQueue  = Запрос возбужден и ожидает очереди. Значит, запрос передан в устройство
  //                        Adam_Slot, но еще не передан в сеть из-за того, что она была занята. Ждите.
  //        rs_WaitAnswer = Запрос возбужден и передан по линии связи, ожидается ответ.
  //        rs_Answer     = Принят ответ на запрос. Вызывайте AdamGetAnswer.
  //        rs_TimeOut    = Ошибка TimeOut. Ответ на запрос не был принят в течение установленного времени.
  //        Если статус был Answer или TimeOut, то после вызова функции статус
  //        автоматически сбрасывается в rs_NoRequest, чтобы исключить возможность
  //        ошибочной повторной обработки уже обработанных запросов.
  //
  function  AdamGetStatus(aSlot:Integer):Integer;                        virtual; abstract;
  //
  // 140  - Посылает запрос в сеть RS-485. Запрос передается устройству AdamSlot,
  //        которое обеспечивает синхронизацию с другими устройствами. Указывается
  //        также время ожидания в миллисекундах, после которого регистрируется
  //        "TimeOut". Функцию надо вызывать, когда AdamGetStatus=rs_NoRequest.
  //        Запросы посылаются простые, без контрольных сумм и разделителя CR.
  //        Устройство AdamDevice само их прибавит, как надо.
  //
  function  AdamSendRequest(aSlot:Integer; aRequest:ShortString;
                            aTimeOut:Integer):Boolean;                   virtual; abstract;
  //
  // 141  - Возвращает данные последнего посланного запроса.
  //
  function  AdamGetRequest(aSlot:Integer):ShortString;                   virtual; abstract;
  //
  // 142  - Возвращает время посылки последнего запроса в миллисекундах.
  //
  function  AdamGetRequestTime(aSlot:Integer):Double;                    virtual; abstract;
  //
  // 143  - Возвращает ответ от устройства в сети RS-485 на посланный запрос.
  //        В ответе уже проверены и удалены контрольная сумма и разделитель CR.
  //        Вызывается, когда AdamGetStatus=rs_Answer.
  //
  function  AdamGetAnswer(aSlot:Integer):ShortString;                    virtual; abstract;
  //
  // 144  - Возвращает номер порта, к которому подключен AdamSlot.
  //
  function  AdamGetPort(aSlot:Integer):Integer;                          virtual; abstract;
  //
  // 145  - Возвращает в виде 2-х символьной HEX-строки адрес устройства
  //        AdamSlot в сети RS-485. Используется при формировании сообщений.
  //
  function  AdamGetAddress(aSlot:Integer):ShortString;                   virtual; abstract;
  //
  // 146  - Возвращает признак испльзования контрольных сумм в AdamSlot.
  //        Добавление/анализ/удаление контрольных сумм и разделителя CR
  //        происходит автоматически, так что при посылке сообщения формируются
  //        так, будто контрольные суммы не используются.
  //
  function  AdamGetUsesCheckSum(aSlot:Integer):Boolean;                  virtual; abstract;
  //
  // 147  - Точный аналог Daq Pascal функции clickparams. Смотри документацию по CRW-DAQ.
  //
  function  ClickParams(const Args:ShortString):LongString;              virtual; abstract;
  //
  // 148  - Точный аналог Daq Pascal функции add3d. Смотри документацию по CRW-DAQ.
  //
  function  Add3D(x,y,z:Double):Boolean;                                 virtual; abstract;
  //
  // 149  - Точный аналог Daq Pascal функции plot3d. Смотри документацию по CRW-DAQ.
  //
  function  Plot3D(Nx,Ny:Integer; x1,y1,x2,y2:Double;
                   const opt:ShortString):Boolean;                       virtual; abstract;
  //
  // 150  - Точный аналог Daq Pascal функции edit. Смотри документацию по CRW-DAQ.
  //
  function  Edit(const s:LongString):LongString;                         virtual; abstract;
  //
  // 151  - Точный аналог Daq Pascal функции editstate. Смотри документацию по CRW-DAQ.
  //
  function  EditState:Integer;                                           virtual; abstract;
  //
  // 152  - Точный аналог Daq Pascal функции devsend. Смотри документацию по CRW-DAQ.
  //
  function  DevSend(d:Integer; const msg:LongString):Double;             virtual; abstract;
  //
  // 153 - Точный аналог Daq Pascal функции daqfileref. Смотри документацию по CRW-DAQ.
  //
  function  FileRef(const FileName : LongString;
                    const DefExt   : LongString='';
                    const BaseFile : LongString='*'):LongString;         virtual; abstract;
 public
  property  CurveLength[c:Integer]   : Integer     read GetCurveLength   write SetCurveLength;
  property  CurvePoint[c,i:Integer]  : TPoint2D    read GetCurvePoint    write SetCurvePoint;
  property  CurveName[c:Integer]     : ShortString read GetCurveName;
  property  CurveColor[c:Integer]    : Integer     read GetCurveColor;
  property  CurveStyle[c:Integer]    : Integer     read GetCurveStyle;
  property  CurveComment[c:Integer]  : LongString  read GetCurveComment  write SetCurveComment;
  property  CurveLimits[c:Integer]   : TRect2D     read GetCurveLimits;
  property  CurveLastPoint[c:Integer]: TPoint2D    read GetCurveLastPoint;
 public
  property  PortB[Address:Word]      : Byte        read GetPortB         write SetPortB;
  property  PortW[Address:Word]      : Word        read GetPortW         write SetPortW;
  property  PortL[Address:Word]      : LongWord    read GetPortL         write SetPortL;
 end;
 //
 ///////////////////////////////////////////////////////////////////////////////
 // Класс TDanApi содержит интерфейс для создания утилит анализа данных.      //
 // Перед вызовом утилиты анализа данных пользователь вводит в диалоговом     //
 // окне аргументы, для доступа к ним есть GetArguments,GetArgumentAsXX.      //
 // Интерфейс дает доступ к трем окнам:                                       //
 // 1) Окно - источник, активное окно с кривыми в момент вызова утилиты.      //
 //    Оно служит источником данных, которые надо обрабатывать.               //
 // 2) Окно - приемник, вновь созданное окно для помещения в него результата. //
 // 3) Окно - буфер обмена, служит для того, чтобы задавать дополнительную    //
 //    кривую в качестве аргумента. Например, для сложения кривых одна        //
 //    берется из окна - источника, другая копируется в буфер обмена.         //
 // Для доступа к кривым и окнам интерфейс использует целочисленные ссылки.   //
 // Будем обозначать ссылки для доступа к кривым буквой c, к окнам - w, а     //
 // к точкам кривой - i. При этом:                                            //
 //   w > 0 - идентифицирует окно - источник                                  //
 //   w < 0 - идентифицирует окно - приемник                                  //
 //   w = 0 - идентифицирует окно - буфер обмена                              //
 //   c > 0 - идентифицирует кривую с номером "+c"  в окне источника          //
 //   c < 0 - идентифицирует кривую с номером "-c" в окне приемника           //
 //   c = 0 - идентифицирует кривую, скопированную в буфер обмена             //
 // Нумерация кривых в окне начинается с 1, при этом абсолютное значение      //
 // ссылки дает номер кривой в окне, а знак-ссылку на окно (+1 = источник,    //
 // -1 = приемник, 0 = буфер обмена). В буфере обмена доступна одна кривая,   //
 // та, которая была вставлена туда последней, что вроде бы логично.          //
 // При такой нумерации ссылка кривой может служить одновременно и  ссылкой   //
 // для доступа к окну, которому она принадлежит.                             //
 // Нумерация точек кривых начинается с 0 .                                   //
 // Значения, связанные с буфером обмена, можно только читать, но не писать.  //
 // Например, вызов:                                                          //
 //  WindowCaption[+1]:='Source' - задаст имя окна источника                  //
 //  WindowCaption[-1]:='Target' - задаст имя окна приемника                  //
 //  WindowCaption[0]:='Clipbrd' - ничего не сделает                          //
 // Дополнительную информацию можно получить, изучая примеры меющихся утилит. //
 ///////////////////////////////////////////////////////////////////////////////
 //
 TDanApi = class(TPluginApi)
  //
  // 0    - Возвращает список аргументов вызова, которые пользователь редактирует
  //        перед вызовом утилиты в диалоговом окне. Сам список аргументов и его
  //        начальное состояние описывается в секциях [Arguments.Rus] и
  //        [Arguments.Eng] в комментариях текста программы.
  //
  function  GetArguments:LongString;                                     virtual; abstract;
  //
  // 1    - Возвращает аргумент вызова по имени в виде строки или пустую строку
  //        если аргумента с таким именем нет.
  //
  function  GetArgumentAsString(const aName:ShortString):ShortString;    virtual; abstract;
  //
  // 2    - Возвращает аргумент вызова по имени в виде целого числа.
  //
  function  GetArgumentAsInteger(const aName:ShortString;
                                 var aValue:Integer):boolean;             virtual; abstract;
  //
  // 3    - Возвращает аргумент вызова по имени в виде вещественного числа.
  //
  function  GetArgumentAsDouble(const aName:ShortString;
                                 var aValue:Double):boolean;              virtual; abstract;
  //
  // 4    - Проверяет, существует ли окно, заданное ссылкой w.
  //
  function  WindowExists(w:Integer):Boolean;                             virtual; abstract;
  //
  // 5    - Проверяет, существует ли кривая, заданная ссылкой c.
  //
  function  CurveExists(c:Integer):Boolean;                              virtual; abstract;
  //
  // 6    - Возвращает заголовок окна, заданного ссылкой w.
  //
  function  GetWindowCaption(w:Integer):ShortString;                     virtual; abstract;
  //
  // 7    - Задает заголовок окна, заданного ссылкой w.
  //
  procedure SetWindowCaption(w:Integer;const aCaption:ShortString);      virtual; abstract;
  //
  // 8    - Возвращает верхний комментарий окна, заданного ссылкой w.
  //
  function  GetWindowTitle(w:Integer):ShortString;                       virtual; abstract;
  //
  // 9    - Задает верхний комментарий окна, заданного ссылкой w.
  //
  procedure SetWindowTitle(w:Integer;const aTitle:ShortString);          virtual; abstract;
  //
  // 10   - Возвращает нижний комментарий окна, заданного ссылкой w.
  //
  function  GetWindowLegend(w:Integer):ShortString;                      virtual; abstract;
  //
  // 11   - Задает нижний комментарий окна, заданного ссылкой w.
  //
  procedure SetWindowLegend(w:Integer;const aLegend:ShortString);        virtual; abstract;
  //
  // 12   - Возвращает прямоугольник ROI - "область интересов" окна w.
  //        Прямоугольник содержит значения NAN, если ROI не задано.
  //
  function  GetWindowRoi(w:Integer):TRect2D;                             virtual; abstract;
  //
  // 13   - Задает прямоугольник ROI - "область интересов" окна w.
  //        Для отмены области интересов надо задать NAN.
  //
  procedure SetWindowRoi(w:Integer; const aRoi:TRect2D);                 virtual; abstract;
  //
  // 14   - Возвращает текст комментария окна, заданного ссылкой w.
  //
  function  GetWindowComment(w:Integer):LongString;                      virtual; abstract;
  //
  // 15   - Задает текст комментария окна, заданного ссылкой w.
  //
  procedure SetWindowComment(w:Integer;const aComment:LongString);       virtual; abstract;
  //
  // 16   - Возвращает ссылку выделенной кривой в окне w или 0, если не выбрана.
  //        Абсолютное значение ссылки дает номер кривой в окне.
  //        Для окна буфера обмена всегда возвращается 0.
  //
  function  GetSelectedCurve(w:Integer):Integer;                         virtual; abstract;
  //
  // 17   - Выделяет кривую с в окне w. Можно использовать как ссылку,
  //        так и номер кривой, так как c берется по модулю.
  //
  procedure SetSelectedCurve(w,c:Integer);                               virtual; abstract;
  //
  // 18   - Возвращает текущее число кривых в окне, заданном ссылкой w.
  //
  function  GetCurvesCount(w:Integer):Integer;                           virtual; abstract;
  //
  // 19   - Задает число кривых в окне, заданном ссылкой w.
  //        При необходимости уничтожает лишние кривые или создает новые пустые
  //        кривые, в зависимости от того, сколько кривых уже было в окне.
  //        Поэтому функцию можно использовать для создания кривых вместо
  //        CurveCreate, а также для удаления кривых. Например, вызов типа
  //        CurveCount[-1]:=0; удалит все кривые в окне приемника.
  //
  procedure SetCurvesCount(w,aCount:Integer);                            virtual; abstract;
  //
  // 20   - Возвращает длину кривой c.
  //
  function  GetCurveLength(c:Integer):Integer;                           virtual; abstract;
  //
  // 21   - Задает новую длину кривой c.
  //
  procedure SetCurveLength(c,aLength:Integer);                           virtual; abstract;
  //
  // 22   - Возвращает точку номер i из кривой, заданной ссылкой c.
  //        Напоминаем, что нумерация точек идет с 0, а кривых с 1.
  //
  function  GetCurvePoint(c,i:Integer):TPoint2D;                         virtual; abstract;
  //
  // 23   - Задает значение точки номер i на кривой c.
  //
  procedure SetCurvePoint(c,i:Integer; const aPoint:TPoint2D);           virtual; abstract;
  //
  // 24   - Добавляет точку в конец кривой c.
  //
  procedure CurveAddPoint(c:Integer; const aPoint:TPoint2D);             virtual; abstract;
  //
  // 25   - Добавляет aCount точек в конец кривой c.
  //
  procedure CurveAddPoints(c:Integer; const aX,aY:array of Double;
                                            aCount:Integer);             virtual; abstract;
  //
  // 26   - Удаляет точку i из кривой c.
  //
  procedure CurveDeletePoint(c,i:Integer);                               virtual; abstract;
  //
  // 27   - Удаляет aCount точек начиная с i из кривой c.
  //
  procedure CurveDeletePoints(c,i,aCount:Integer);                       virtual; abstract;
  //
  // 28   - Вставляет точку в позицию i кривой c.
  //
  procedure CurveInsertPoint(c,i:Integer; const aPoint:TPoint2D);        virtual; abstract;
  //
  // 29   - Вставляет aCount точек в позицию i кривой c.
  //
  procedure CurveInsertPoints(c,i:Integer; const aX,aY:array of Double;
                              aCount:LongInt);                           virtual; abstract;
  //
  // 30   - Возвращает имя кривой, заданной ссылкой c.
  //
  function  GetCurveName(c:Integer):ShortString;                         virtual; abstract;
  //
  // 31   - Задает имя кривой, заданной ссылкой c.
  //
  procedure SetCurveName(c:Integer; const aName:ShortString);            virtual; abstract;
  //
  // 32   - Возвращает цвет кривой, заданной ссылкой c.
  //
  function  GetCurveColor(c:Integer):Integer;                            virtual; abstract;
  //
  // 33   - Задает цвет кривой, заданной ссылкой c.
  //
  procedure SetCurveColor(c:Integer; aColor:Integer);                    virtual; abstract;
  //
  // 34   - Возвращает стиль кривой, заданной ссылкой c.
  //
  function  GetCurveStyle(c:Integer):Integer;                            virtual; abstract;
  //
  // 35   - Задает стиль кривой, заданной ссылкой c.
  //
  procedure SetCurveStyle(c:Integer; aStyle:Integer);                    virtual; abstract;
  //
  // 36   - Возвращает комментарий кривой, заданной ссылкой c.
  //
  function  GetCurveComment(c:Integer):LongString;                       virtual; abstract;
  //
  // 37   - Задает комментарий кривой, заданной ссылкой c.
  //
  procedure SetCurveComment(c:Integer; const aComment:LongString);       virtual; abstract;
  //
  // 38   - Быстрый поиск индекса ближайшей к t точки кривой c.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveGetIndexAt(c:Integer; t:Double):Integer;                virtual; abstract;
  //
  // 39   - Линейная интерполяция кривой c в точке t.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveInterpolateAt(c:Integer; t:Double):Double;              virtual; abstract;
  //
  // 40   - Сглаживание кривой c в точке t окном шириной Window, а также ядром
  //        типа K(x)=(1-x^k1)^k2. Power - степень полинома или интеграл при Power=-1.
  //        Точки кривой должны быть отсортированы в порядке возрастания по оси X.
  //
  function  CurveSmoothAt(c:Integer; t:Double;
                        Window:Double; Power,K1,K2:Integer):Double;      virtual; abstract;
  //
  // 41   - Вычисляет медиану кривой c в интервале точек [i..j].
  //        Возвращает индекс aIndex и значение aValue медианы.
  //        Можно выбирать метод сортировки 0=Shell,1=Quick.
  //
  function  CurveMedianaAt(c,i,j:Integer; var aIndex:Integer; var aValue:Double;
                         SortMethod:Integer=1):Boolean;                  virtual; abstract;
  //
  // 42   - Вычисляет массив флагов типа "кривая отсортирована" и т.д.
  //        Смотрите описание констант cfXXXX.
  //
  function  CurveFlags(c:Integer; AbsEps:Double=0;RelEps:Double=1E-10;
                       Small:Integer=2):LongInt;                         virtual; abstract;
  //
  // 43   - Копирование всех данных из кривой c2 в кривую c1.
  //
  procedure CurveAssign(c1,c2:Integer);                                  virtual; abstract;
  //
  // 44   - Добавление к кривой c1 точек из кривой c2.
  //
  procedure CurveCatenate(c1,c2:Integer);                                virtual; abstract;
  //
  // 45  - Создание в окне w кривой с заданным именем, цветом, стилем, комментарием.
  //       Возвращает ссылку на кривую.
  //
  function  CreateCurve(w:Integer; const aName:ShortString='';
                        aColor:Integer=0;  aStyle:Integer=0;
                        aComment:LongString=''):Integer;                 virtual; abstract;
  //
  // 46  - Сортирует кривую c, используя флаги Flags, смотри константы sfXXXX.
  //       Если указана упаковка, абсолютная и относительная точность определяют
  //       сжатие кривой. При этом точки, у которых ключ сортировки одинаков
  //       в пределах точности, объединяются в одну среднюю точку.
  //       Можно выбирать метод сортировки 0=Shell,1=Quick.
  //
  procedure CurveSort(c:Integer; Flags:Integer=0; AbsEps:Double=0;
                      RelEps:Double=1E-10; Method:Integer=0);            virtual; abstract;
  //
  // 47   - Возвращает минимальный прямоугольник, содержащий все точки кривой c.
  //
  function  GetCurveLimits(c:Integer):TRect2D;                           virtual; abstract;
  //
  // 48   - Интегрирует кривую c методом трапеций, возвращает первообразную.
  //
  procedure CurveIntegrate(c:Integer; AFreeConst:Double=0);              virtual; abstract;
  //
  // 49   - Дифференциирует кривую c, возвращает производную.
  //
  procedure CurveDifferentiate(c:Integer);                               virtual; abstract;
  //
  // 50   - Применяет к кривой c пороговый медианный фильтр.
  //
  procedure CurveMedianFiltr(c:Integer; Width:Integer=1;
                             AbsEps:Double=0; RelEps:Double=1E-10);      virtual; abstract;
  //
  // 51   - Возвращает интеграл участка (a,b) кривой c.
  //
  function  GetCurveIntegral(c:Integer; a,b:Double):Double;              virtual; abstract;
  //
  // 52   - Возвращает последнюю точку кривой c.
  //
  function  GetCurveLastPoint(c:Integer):TPoint2D;                       virtual; abstract;
 public
  property  WindowCaption[w:Integer] : ShortString read GetWindowCaption write SetWindowCaption;
  property  WindowTitle[w:Integer]   : ShortString read GetWindowTitle   write SetWindowTitle;
  property  WindowLegend[w:Integer]  : ShortString read GetWindowLegend  write SetWindowLegend;
  property  WindowRoi[w:Integer]     : TRect2D     read GetWindowRoi     write SetWindowRoi;
  property  WindowComment[w:Integer] : LongString  read GetWindowComment write SetWindowComment;
  property  SelectedCurve[w:Integer] : Integer     read GetSelectedCurve write SetSelectedCurve;
  property  CurvesCount[w:Integer]   : Integer     read GetCurvesCount   write SetCurvesCount;
  property  CurveLength[c:Integer]   : Integer     read GetCurveLength   write SetCurveLength;
  property  CurvePoint[c,i:Integer]  : TPoint2D    read GetCurvePoint    write SetCurvePoint;
  property  CurveName[c:Integer]     : ShortString read GetCurveName     write SetCurveName;
  property  CurveColor[c:Integer]    : Integer     read GetCurveColor    write SetCurveColor;
  property  CurveStyle[c:Integer]    : Integer     read GetCurveStyle    write SetCurveStyle;
  property  CurveComment[c:Integer]  : LongString  read GetCurveComment  write SetCurveComment;
  property  CurveLimits[c:Integer]   : TRect2D     read GetCurveLimits;
  property  CurveLastPoint[c:Integer]: TPoint2D    read GetCurveLastPoint;
 end;
 //
 // Пример функций сравнения, ключа и перестановки для поиска/сортировки.
 //
function  CompareDoubles(Data,Key1,Key2:Pointer):Integer;
function  KeyOfDoubles(Data:Pointer; KeyIndex:Integer):Pointer;
procedure SwapDoubles(Data:Pointer; i,j:Integer);
 //
 // Dump/undump routines to be used with MIME
 // For example:
 //  var x,y:double; i,j:integer; s:string;
 //  s:=mime_encode(r2dump(x)+r2dump(y)+i2dump(i)+i2dump(j));
 //  s:=mime_decode(s);
 //  x:=dump2r(copy(s,1,8));
 //  y:=dump2r(copy(s,9,8));
 //  i:=dump2i(copy(s,17,4));
 //  j:=dump2i(copy(s,21,4));
 //
function c2dump(const x:Char):LongString;
function b2dump(const x:Boolean):LongString;
function i2dump(const x:Integer):LongString;
function r2dump(const x:Double):LongString;
function x2dump(var x; Size:Integer):LongString;
function dump2c(const x:LongString):Char;
function dump2b(const x:LongString):Boolean;
function dump2i(const x:LongString):Integer;
function dump2r(const x:LongString):Double;

procedure ResetFpu;
procedure FpuSetExceptions(TurnOn : Boolean);
function  PatchBug_cwChop(OnOff:Boolean):Boolean;

implementation

function CompareDoubles(Data,Key1,Key2:Pointer):Integer;
begin
 if Double(Key1^)<Double(Key2^) then Result:=-1 else
 if Double(Key1^)>Double(Key2^) then Result:=+1 else Result:= 0;
end;

function KeyOfDoubles(Data:Pointer; KeyIndex:Integer):Pointer;
begin
 Result:=@TDoubleArray(Data^)[KeyIndex];
end;

procedure SwapDoubles(Data:Pointer; i,j:Integer);
var dummy:Double;
begin
 dummy:=TDoubleArray(Data^)[i];
 TDoubleArray(Data^)[i]:=TDoubleArray(Data^)[j];
 TDoubleArray(Data^)[j]:=dummy;
end;

function c2dump(const x:Char):LongString;
begin
 SetString(Result,PChar(@x),sizeof(x));
end;

function b2dump(const x:Boolean):LongString;
begin
 SetString(Result,PChar(@x),sizeof(x));
end;

function i2dump(const x:Integer):LongString;
begin
 SetString(Result,PChar(@x),sizeof(x));
end;

function r2dump(const x:Double):LongString;
begin
 SetString(Result,PChar(@x),sizeof(x));
end;

function x2dump(var x; Size:Integer):LongString;
begin
 SetString(Result,PChar(@x),Size);
end;

procedure SafeMove(const Source; var Dest; Count: LongInt);
begin
 if (Count>0) and (@Source<>nil) and (@Dest<>nil) then Move(Source,Dest,Count);
end;

function dump2b(const x:LongString):Boolean;
begin
 Result:=false;
 SafeMove(x[1],Result,min(sizeof(Result),Length(x)));
end;

function dump2c(const x:LongString):Char;
begin
 Result:=#0;
 SafeMove(x[1],Result,min(sizeof(Result),Length(x)));
end;

function dump2i(const x:LongString):Integer;
begin
 Result:=0;
 SafeMove(x[1],Result,min(sizeof(Result),Length(x)));
end;

function dump2r(const x:LongString):Double;
begin
 Result:=0;
 SafeMove(x[1],Result,min(sizeof(Result),Length(x)));
end;

procedure ResetFpu;
begin
 FpuSetExceptions(false);
 PatchBug_cwChop(true);
end;

const
 MaskAllIntr        = $133F;
 Saved8087CW : word = $133F;

function IncPtr(Base:Pointer; ByteOffset:LongInt):Pointer; register;
asm
 ADD EAX,EDX
end;

procedure FpuSetExceptions(TurnOn : Boolean);
begin
 if TurnOn then Set8087CW(Saved8087CW) else Set8087CW(MaskAllIntr);
end;

function PatchBug_cwChop(OnOff:Boolean):Boolean;
type
 TPatch = packed record
  cwChop    : Word;
  Dummy     : Word;
  two2neg32 : Double;
 end;
const
 cwChops : packed array[Boolean] of Word = ($1F3F, $1F32);
var
 Patch:^TPatch;
begin
 Result:=false;
 Patch:=IncPtr(@Default8087CW,$30);
 try
  if Patch.cwChop=cwChops[OnOff] then
  if Patch.two2neg32=((1.0/$10000) / $10000) then begin
   Patch.cwChop:=cwChops[not OnOff];
   Result:=true;
  end else begin
   if Default8087CW=0 then              // 00 This stuff uses
   if HeapAllocFlags=0 then             // 04 only to link
   if DebugHook=0 then                  // 08 variables & functions
   if JITEnable=0 then                  // 0C to give known cwChop
   if NoErrMsg then                     // 10 offset
   if VarDispProc=nil then              // 14
   if DispCallByIDProc=nil then         // 18
   if LibModuleList=nil then            // 1C
   if ModuleUnloadList=nil then         // 20, MemoryManager 24
   if trunc(Random)=0 then;             // 30 cwChop, 34 two2neg32
  end;
 except
  Result:=false;
 end;
end;

begin

 Saved8087CW := Default8087CW;
 if isLibrary then begin
  HeapAllocFlags := GMEM_MOVEABLE + GMEM_ZEROINIT;
  ResetFpu;
 end;

end.
