//Копирует значение из списка мгновенных значений по указанной позиции
public EditMom CopyValueFrom(IReadMean list, //список значений
int i) //Позиция
{
list.CurNum = i;
_mean.CopyValueFrom(list);
return(this);
}
//Запись значения в рекордсет клона
protected void PutCloneRec(IReadMean mom, //Значение
DaoRec rec, //Рекордсет
bool isCutTable, //Запись в таблицу срезов
DateTime d) //Время среза
{
rec.AddNew();
rec.Put("SignalId", IdInClone);
if (isCutTable)
{
rec.Put("CutTime", d);
}
rec.Put("Time", mom.Time);
if (mom.Error != null)
{
rec.Put("ErrNum", mom.Error.Number);
}
if (DataType.IsReal())
{
rec.Put("RealValue", mom.Real);
}
else if (DataType == DataType.String)
{
rec.Put("StrValue", mom.String);
}
else if (DataType == DataType.Time)
{
rec.Put("TimeValue", mom.Date);
}
rec.Update();
}
//Запись значения в клон
protected override int PutClone(IReadMean mom, //Рекордсет срезов клона
bool onlyCut) //Добавляет только 10-минутные срезы, но не само значение
{
bool isReal = DataType.IsReal();
var rec = isReal ? ClonerConnect.CloneRec : ClonerConnect.CloneStrRec;
var recCut = isReal ? ClonerConnect.CloneCutRec : ClonerConnect.CloneStrCutRec;
int nwrite = 0;
if (_prevMom.Time >= Connect.PeriodBegin)
{
var d1 = ClonerConnect.RemoveMinultes(mom.Time);
var d = ClonerConnect.RemoveMinultes(_prevMom.Time).AddMinutes(10);
while (d <= d1)
{
if (d != mom.Time)
{
PutCloneRec(_prevMom, recCut, true, d);
nwrite++;
}
d = d.AddMinutes(10);
}
}
if (!onlyCut)
{
PutCloneRec(mom, rec, false, mom.Time);
nwrite++;
}
_prevMom.CopyAllFrom(BufMom);
return(nwrite);
}
//Копирует время, ошибку и значение из другого IMean, возвращает себя
public EditMom CopyAllFrom(IReadMean mom)
{
_mean.CopyValueFrom(mom);
Time = mom.Time;
Error = mom.Error;
return(this);
}
//5 - Мгновенные
public IReadMean Aperture_rr(FunData data, DataType dataType, params IReadMean[] par)
{
var res = MFactory.NewList(dataType);
var list = par[0];
var dif = par[1];
if (list.Count == 0)
{
return(res);
}
var prev = data.ParamsValues[0];
list.CurNum = 0;
if (prev == null)
{
res.AddMom(list);
}
IReadMean m = prev ?? list.ToMean();
for (list.CurNum = 0; list.CurNum < list.Count; list.CurNum++)
{
if (Math.Abs(list.Real - m.Real) >= dif.Real)
{
res.AddMom(m = list.ToMean());
}
}
data.ParamsValues[0] = m;
return(res);
}
private void AddUniformMom(IReadMean fromList, MomList toList, int i, DateTime t)
{
if (i < fromList.Count && fromList.TimeI(i) == t)
{
return;
}
toList.AddMom(fromList.ToMomI(i == 0 ? 0 : i - 1, t));
}
//Запись значения в клон, для UniformCloneSignal переопределяется
//Чтение одной строчки значений из рекордсета, и запись ее в клон
protected virtual int PutClone(IReadMean mom, //Рекордсет срезов клона
bool onlyCut) //Добавляет только 10-минутные срезы, но не само значение
{
var rec = DataType.IsReal() ? ClonerConnect.CloneRec : ClonerConnect.CloneStrRec;
PutCloneRec(mom, rec, false, mom.Time);
return(1);
}
//Копирует время, ошибку и значение из списка мгновенных значений по указанной позиции
public EditMom CopyAllFrom(IReadMean list, //список значений
int i) //Позиция
{
list.CurNum = i;
_mean.CopyValueFrom(list);
Time = list.TimeI(i);
Error = list.ErrorI(i);
return(this);
}
//Вычисление значения
public IReadMean Generate(SubRows row)
{
IReadMean mean = null;
while (_condition.Generate(row).Boolean)
{
mean = _prog.Generate(row);
}
return(mean ?? _elseProg.Generate(row));
}
public void CertainNP_rrrrr(IReadMean[] par)
{
var parv = new IReadMean[par.Length - 3];
for (int i = 0; i < parv.Length; i++)
{
parv[i] = par[i + 3];
}
ScalarRes.Error = par[0].Error.Add(par[1].Error).Add(par[2].Error);
ScalarRes.Real = Certain(parv, par[0], par[1].Real, par[2].Real);
}
public void CertainP_rrrr(IReadMean[] par)
{
var parv = new IReadMean[par.Length - 2];
for (int i = 0; i < parv.Length; i++)
{
parv[i] = par[i + 2];
}
ScalarRes.Error = par[0].Error.Add(par[1].Error);
ScalarRes.Real = Certain(parv, par[0], double.MaxValue, par[1].Real);
}
public void Certain_rrr(IReadMean[] par)
{
var parv = new IReadMean[par.Length - 1];
for (int i = 0; i < parv.Length; i++)
{
parv[i] = par[i + 1];
}
ScalarRes.Error = par[0].Error;
ScalarRes.Real = Certain(parv, par[0], double.MaxValue, double.MaxValue);
}
//Вычислить значение
public IVal Calculate(DataType resultType, IEnumerable <IVal> par, FunData funData)
{
var arr = par.ToArray();
var fs = (CalcFunctions)Functions;
var args = new IReadMean[arr.Length - 1];
for (int i = 1; i < arr.Length; i++)
{
args[i] = (IReadMean)arr[i];
}
return(fs.CalcScalar(resultType, args, false, (moms, flags) => _fun(arr[0], moms)));
}
public void Max_uu(IReadMean[] par)
{
IReadMean mv = par[0];
for (int i = 1; i < par.Length; ++i)
{
if (mv.ValueLess(par[i]))
{
mv = par[i];
}
}
ScalarRes.CopyValueFrom(mv);
}
private double Certain(IEnumerable <IReadMean> par, IReadMean pn, double dn, double dp)
{
//Аппаратная недостоверность и сравнение с нормативным
var dpar = (from p in par where (p.Error == null || p.Error.Quality != ErrQuality.Error) && Math.Abs(p.Real - pn.Real) <= dn select p.Real).ToList();
if (dpar.Count == 0)
{
return(pn.Real);
}
//Сравнение друг с другом
while (dpar.Count > 2)
{
double m = dpar.Average();
int k = 0;
for (int i = 1; i < dpar.Count; i++)
{
if (Math.Abs(m - dpar[i]) > Math.Abs(m - dpar[k]))
{
k = i;
}
}
if (Math.Abs(m - dpar[k]) > dp)
{
dpar.RemoveAt(k);
}
else
{
break;
}
}
if (dpar.Count == 2 && Math.Abs(dpar[1] - dpar[0]) > 2 * dp)
{
return(pn.Real);
}
return(dpar.Average());
}
internal override void CopyValueFrom(IReadMean mean)
{
Real = mean.Real;
}
//Добавление значений как будто в список
public virtual void AddMom(IReadMean mom)
{
CopyAllFrom(mom);
}
public void AddMom(DateTime time, IReadMean mean)
{
CopyAllFrom(mean);
Time = time;
}
//Записать значение в рекордсет
public static void PutMean(this IRecordAdd rec, string field, IReadMean mean)
{
mean.ValueToRec(rec, field);
}
internal override void CopyValueFrom(IReadMean mean)
{
}
internal override void CopyValueFrom(IReadMean mean)
{
Boolean = mean.Boolean;
}
public void AddMom(IReadMean mom, MomErr err)
{
CopyAllFrom(mom);
Error = err;
}
//На входе количество параметров функции
public FunData(int parsCount)
{
ParamsValues = new IReadMean[parsCount];
}
//Добавить мгновенное значение
public void AddMom(IReadMean mom)
{
CopyValueFrom(mom);
Time = mom.Time;
Error = mom.Error;
}
public void AddMom(DateTime time, IReadMean mean, MomErr err)
{
CopyValueFrom(mean);
Time = time;
Error = err;
}
//Записать значение
public void PutValue(IReadMean value)
{
InValue = InSignal.OutValue;
}
internal override void CopyValueFrom(IReadMean mean)
{
String = mean.String;
}
//Копирует значение из другого мгновенного значения, возвращает себя
public EditMom CopyValueFrom(IReadMean mean)
{
_mean.CopyValueFrom(mean);
return(this);
}
//Вычисление скалярной функции для списков мгновенных значений
internal IReadMean CalcScalar(DataType dataType, //Возвращаемый тип данных
IReadMean[] par, //Список аргументов
bool isComplex, //При вычислении используются флаги значений аргументов
Action <IReadMean[], bool[]> action) //Действие, выполняющее вычисление для одного момента времени
{
SetScalarDataType(dataType);
var mpar = new IReadMean[par.Length];
var cpar = new bool[par.Length];
bool isMom = !isComplex;
for (int i = 0; i < par.Length; i++)
{
var mean = par[i] as Mean;
if (mean != null)
{
mpar[i] = mean;
}
else
{
isMom = false;
if (par[i].Count == 0 && !isComplex)
{
return(MFactory.NewList(dataType));
}
}
}
if (isMom) //Одно значение
{
DateTime t = Static.MinDate;
foreach (var mean in mpar)
{
if (mean.Time > t)
{
t = mean.Time;
}
}
if (t == Static.MinDate)
{
t = PeriodBegin;
}
CalcScalarFun(mpar, () => action(mpar, cpar));
return(ScalarRes.ToMom(t));
}
//Список значений
var rlist = MFactory.NewList(dataType);
while (true)
{
DateTime ctime = Static.MaxDate;
foreach (var list in par)
{
if (list.NextTime < ctime)
{
ctime = list.NextTime;
}
}
if (ctime == Static.MaxDate)
{
break;
}
for (int i = 0; i < par.Length; i++)
{
var list = par[i];
cpar[i] = list.NextTime == ctime;
if (cpar[i])
{
list.CurNum++;
}
mpar[i] = list.ToMean();
}
CalcScalarFun(mpar, () => action(mpar, cpar));
rlist.AddMom(ScalarRes.ToMom(ctime));
}
return(rlist);
}
internal override void CopyValueFrom(IReadMean mean)
{
Integer = mean.Integer;
}
