{ Нормализация данных для поиска минимума функции (не обязательно) }

{---------------------------------------------------------------------------
The control units for mass-spectrometer MI1201-AGM
(c) Copyright	 Aleksandrov O.E., 1998

Модуль управления масс-спектрометром МИ1201-АГМ
(c) Собственность     Александрова О.Е., 1998

   Molecular Physics department	 	620002, Екатеринбург, К-2
   USTU, Ekaterinsburg, K-2, 620002     УГТУ,
   RUSSIA     	   			Кафедра молекулярной физики
   phone 75-48-39                       тел. 75-48-39

   E-mail: aleks@dpt.ustu.ru
----------------------------------------------------------------------------}

unit uDataPre;

interface
   USES uGenFit, QSortMem;

type
  tNormalizeParameter=record
    Origin, Scale:Double;
  end;

  tNormalizeParameters=record
    x,y:tNormalizeParameter;
  end;

procedure NormalizeData(var ND:tNormalizeParameters; var X,Y:tData);
procedure NormalizeVector(var NP:tNormalizeParameter; var V:tData);
procedure SortData(var X,Y:tData); { perform sorting of X and Y by Y }


function  GetUnNormalized(const NP:tNormalizeParameter; const X:Double):Double;

implementation

function  GetUnNormalized;
begin
  GetUnNormalized:=NP.Origin+NP.Scale*X;
end;

procedure NormalizeVector;
  var
    min,max:Double;
    i:word;
begin
{$IfOpt R+}
    If V.Size<3 then RunError(201);
{$EndIf}
  min:=V.Data[1];
  max:=V.Data[1];
  for i:=2 to V.Size do begin
    if max<V.Data[i] then max:=V.Data[i];
    if V.Data[i]<min then min:=V.Data[i];
  end;
{$IfOpt R+}
    If max=min then RunError(201);
{$EndIf}
  max:=max-min;
  for i:=1 to V.Size do begin
    V.Data[i]:=(V.Data[i]-min)/max;
  end;
  NP.Origin:=min;
  NP.Scale:=max;
end;

procedure NormalizeData;
begin
  NormalizeVector(ND.X, X);
  NormalizeVector(ND.Y, Y);
end;

type
  tSorter=object(MemoryQSort)
     PtrToSecondary:^tData;
     constructor Init;
     procedure Sort(var MainA,SecondaryA:tData);
     procedure Swap(i,j:tNumber); virtual;
     function  CompMem(i,j:pointer):shortint; virtual;
  end;

constructor tSorter.Init;
begin
end;

function tSorter.CompMem(i,j:pointer):shortint;
  type tPtrDouble=^Double;
begin
  if      tPtrDouble(i)^>tPtrDouble(j)^ then CompMem:= 1
  else if tPtrDouble(i)^<tPtrDouble(j)^ then CompMem:=-1
					else CompMem:= 0;
end;

procedure tSorter.Swap;
  var tmp:Double;
begin
  with PtrToSecondary^ do begin
    tmp:=Data[i];
    Data[i]:=Data[j];
    Data[j]:=tmp;
  end;
end;

procedure tSorter.Sort;
begin
{$IfOpt R+}
    If MainA.Size<>SecondaryA.Size then RunError(201);
    If MainA.Size<3 then RunError(201);
{$EndIf}
  PtrToSecondary:=@SecondaryA.Data;
  SetArrayParameters(MainA.Size, SizeOf(MainA.Data[1]));
  Inherited Sort(@MainA.Data);
end;

var oSorter:tSorter;

procedure SortData(var X,Y:tData);
begin
{$IfOpt R+}
    If X.Size<>Y.Size then RunError(201);
    If X.Size<3 then RunError(201);
{$EndIf}
  oSorter.Init;
  oSorter.Sort(Y,X);
end;

end.