public ITrajectory eval(ITrajectory traj1, ITrajectory traj2)
{
if ((_traj1 != traj1) || (_traj2 != traj2))
{
double dt1 = (traj1.MaximumTime - traj1.MinimumTime) / (double)TIME_GRID;
double dt2 = (traj2.MaximumTime - traj2.MinimumTime) / (double)TIME_GRID;
_dt = Math.Min(dt1, dt2);
int w = (int)(WARP_TIME_SECONDS / _dt);
computeDTWArray(traj1, traj2, TIME_GRID, w);
}
Trajectory traj = new Trajectory(traj1.Name + "-" + traj2.Name, 0.0, 0.0, 0.0);
int i = TIME_GRID - 1;
int j = TIME_GRID - 1;
while ((i != 0) || (j != 0))
{
traj.add(_dt * (double)i, traj1.eval(_dt * (double)i) - traj2.eval(_dt * (double)j));
if (_move[i, j] == 'x')
{
i = i - 1;
}
if (_move[i, j] == 'y')
{
j = j - 1;
}
if (_move[i, j] == 'b')
{
i = i - 1; j = j - 1;
}
}
return(traj);
}
public ITrajectory eval(ITrajectoryBundle tb)
{
ITrajectory central = tb.CentralTrajectory;
ITrajectory dev = new Trajectory(tb.Name + SUFFIX, tb.TemporalGranularityThreshold, 0.0, 0.0);
foreach (double t in central.Times)
{
double max = Double.NegativeInfinity;
double centralval = central.eval(t);
foreach (ITrajectory traj in tb.Trajectories)
{
if (traj == central)
{
continue;
}
if (traj.Times.Count == 0)
{
continue;
}
double y = traj.eval(t);
double diff = Math.Abs(y - centralval);
if (diff > max)
{
max = diff;
}
}
dev.add(t, max);
}
return(dev);
}
public ITrajectory eval(ITrajectory traj1, ITrajectory traj2)
{
SortedList <double, double> alltimes = getTimes(traj1, traj2);
ITrajectory sep = new Trajectory(traj1.Name, 0.0, 0.0, 0.0);
foreach (double t in alltimes.Keys)
{
double val = eval(traj1, traj2, t);
sep.add(t, val);
}
return(sep);
}
public ITrajectory eval(ITrajectory orig)
{
double finish = orig.MaximumTime;
double start = orig.MinimumTime;
ITrajectory X = new Trajectory(orig.Name + "-Uniformized(" + _timeStep + ")", 0.0, 0.0, 0.0);
for (double t = start; t <= finish; t += _timeStep)
{
double Xt = orig.eval(t);
X.add(t, Xt);
}
return(X);
}
public ITrajectory eval(ITrajectory orig)
{
ITrajectory smooth = new Trajectory(orig.Name + "-smooth(" + _window + ")", 0.0, 0.0, 0.0);
foreach (double t in orig.Times)
{
double val = 0.0;
double ct = 0.0;
for (double avet = t - _window; avet <= t + _window; avet += _windowstep)
{
val += orig.eval(avet);
ct += 1.0;
}
smooth.add(t, val / ct);
}
return(smooth);
}
public ITrajectory eval(ITrajectoryBundle tb)
{
SortedList <double, double> alltimes = tb.Times;
ITrajectory mean = new Trajectory(tb.Name + SUFFIX, tb.TemporalGranularityThreshold, 0.0, 0.0);
foreach (double t in alltimes.Keys)
{
double val = 0.0;
double ct = 0.0;
foreach (ITrajectory traj in tb.Trajectories)
{
val += traj.eval(t);
ct += 1.0;
}
mean.add(t, val / ct);
}
return(mean);
}
public ITrajectory eval(ITrajectoryBundle tb)
{
ITrajectory mean = tb.MeanTrajectory;
SortedList <double, double> alltimes = tb.Times;
ITrajectory std = new Trajectory(tb.Name + SUFFIX, tb.TemporalGranularityThreshold, 0.0, 0.0);
foreach (double t in alltimes.Keys)
{
double val = 0.0;
double ct = 0.0;
foreach (ITrajectory traj in tb.Trajectories)
{
double y = traj.eval(t);
double ybar = mean.eval(t);
val += (y - ybar) * (y - ybar);
ct += 1.0;
}
std.add(t, Math.Sqrt(val / ct));
}
return(std);
}
public ITrajectory eval(ITrajectoryBundle tb)
{
SortedList <double, double> alltimes = tb.Times;
ITrajectory avesep = new Trajectory(tb.Name + SUFFIX, tb.TemporalGranularityThreshold, 0.0, 0.0);
foreach (double t in alltimes.Keys)
{
double val = 0.0;
double ct = 0.0;
foreach (ITrajectory traj1 in tb.Trajectories)
{
if (traj1.Times.Count == 0)
{
continue;
}
foreach (ITrajectory traj2 in tb.Trajectories)
{
if (traj1 == traj2)
{
continue;
}
if (traj2.Times.Count == 0)
{
continue;
}
val += Math.Abs(traj1.eval(t) - traj2.eval(t));
ct += 1.0;
}
}
avesep.add(t, val / ct);
}
return(avesep);
}
private double ComputeHurstExponent(double timeOfInterest, ITrajectory orig)
{
double finish = timeOfInterest;
double start = Math.Max(finish - _timeWindow, orig.MinimumTime);
int n = 0;
for (double t = start; t <= finish; t += _timeStep)
{
n++;
}
if (n < 1)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "n<1");
return(Double.NaN);
}
int numpoints = 0;
int t2count = INITIAL_T2COUNT;
while (t2count < n)
{
numpoints++;
t2count = (int)((double)t2count * EXPSCALE);
}
if (numpoints < MIN_REG_POINTS)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "numpoints = " + numpoints);
return(Double.NaN);
}
ITrajectory X = new Trajectory("X", 0.0, 0.0, 0.0);
double sigmaX = 0.0;
n = 0;
for (double t = start; t <= finish; t += _timeStep)
{
double Xt = orig.eval(t);
X.add(t, Xt);
sigmaX += Xt;
n++;
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "X:" + X.ToStringLong());
if (n == 0)
{
throw new Exception("Divide by n=0");
}
double m = sigmaX / (double)n;
ITrajectory Y = new Trajectory("Y", 0.0, 0.0, 0.0);
foreach (double t in X.Times)
{
Y.add(t, X.eval(t) - m);
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Y:" + Y.ToStringLong());
ITrajectory Z = new Trajectory("Z", 0.0, 0.0, 0.0);
double sigmaY = 0.0;
foreach (double t in Y.Times)
{
sigmaY += Y.eval(t);
Z.add(t, sigmaY);
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Z:" + Z.ToStringLong());
ITrajectory R = new Trajectory("R", 0.0, 0.0, 0.0);
double Zmax = Double.MinValue;
double Zmin = Double.MaxValue;
foreach (double t in Z.Times)
{
double Zt = Z.eval(t);
Zmax = Math.Max(Zmax, Zt);
Zmin = Math.Min(Zmin, Zt);
R.add(t, Zmax - Zmin);
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "R:" + R.ToStringLong());
ITrajectory U = new Trajectory("U", 0.0, 0.0, 0.0);
sigmaX = 0.0;
int tcounter = 0;
foreach (double t in X.Times)
{
sigmaX += X.eval(t);
tcounter++;
U.add(t, sigmaX / (double)tcounter);
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "U:" + U.ToStringLong());
ITrajectory S = new Trajectory("S", 0.0, 0.0, 0.0);
double sigmaDevXU2 = 0.0;
tcounter = 0;
foreach (double t in X.Times)
{
double DevXU = (X.eval(t) - U.eval(t));
sigmaDevXU2 += (DevXU * DevXU);
tcounter++;
S.add(t, Math.Sqrt(sigmaDevXU2 / (double)tcounter));
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "S:" + S.ToStringLong());
double EPSI = 0.00001;
ITrajectory RoverS = new Trajectory("R/S", 0.0, 0.0, 0.0);
foreach (double t in R.Times)
{
double St = S.eval(t);
double Rt = R.eval(t);
if (St < EPSI)
{
if (Rt < EPSI)
{
RoverS.add(t, 0.0);
}
else
{
// throw new Exception("Divide Rt!=0 by St=0");
}
}
else
{
RoverS.add(t, Rt / St);
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "At t=" + t + ", R=" + Rt + " and S=" + St + " hence R/S=" + Rt / St);
}
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "xxx R/S:" + RoverS.ToStringLong());
double[] xvalues = new double[n];
double[] yvalues = new double[n];
for (int point = 0; point < n; point++)
{
double t = start + (point * _timeStep);
xvalues[point] = (double)point + 1.0;
yvalues[point] = RoverS.eval(t);
SingletonLogger.Instance().InfoLog(typeof(TrajectoryTransformer_Hurst), "t=" + xvalues[point] + " RS=" + yvalues[point]);
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "EXPONENTIALIZED");
double[] xvaluesAve = new double[n];
double[] yvaluesAve = new double[n];
int cutoff = INITIAL_T2COUNT;
double sumX = 0.0;
double sumY = 0.0;
int averaged = 0;
int bins = 0;
for (int point = cutoff; point < n; point++)
{
if (xvalues[point] == 0.0)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Skipping t=" + xvalues[point] + " RS=" + yvalues[point]);
continue;
}
if (yvalues[point] == 0.0)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Skipping t=" + xvalues[point] + " RS=" + yvalues[point]);
continue;
}
sumX += xvalues[point];
sumY += yvalues[point];
averaged++;
if (point == cutoff)
{
xvaluesAve[bins] = sumX / (double)averaged;
yvaluesAve[bins] = sumY / (double)averaged;
SingletonLogger.Instance().InfoLog(typeof(TrajectoryTransformer_Hurst), "_t=" + xvaluesAve[bins] + " _RS=" + yvaluesAve[bins]);
cutoff = (int)((double)cutoff * EXPSCALE);
sumX = 0.0;
sumY = 0.0;
averaged = 0;
bins++;
}
}
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "LOGGED");
double[] xvaluesLog = new double[bins];
double[] yvaluesLog = new double[bins];
t2count = INITIAL_T2COUNT;
for (int point = 0; point < bins; point++)
{
if (xvaluesAve[point] == 0.0)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Skipping t=" + xvaluesAve[point] + " RS=" + yvaluesAve[point]);
continue;
}
xvaluesLog[point] = Math.Log(xvaluesAve[point]) / LOG2;
if (yvaluesAve[point] == 0.0)
{
SingletonLogger.Instance().DebugLog(typeof(TrajectoryTransformer_Hurst), "Skipping t=" + xvaluesAve[point] + " RS=" + yvaluesAve[point]);
continue;
}
yvaluesLog[point] = Math.Log(yvaluesAve[point]) / LOG2;
SingletonLogger.Instance().InfoLog(typeof(TrajectoryTransformer_Hurst), "logt=" + xvaluesLog[point] + " logRS=" + yvaluesLog[point]);
}
double slope, yintercept;
DoLinearRegression(xvaluesLog, yvaluesLog, out slope, out yintercept);
return(slope);
}