public void TrajectoryBundleCollapser_CentralDTW_Test()
{
TrajectoryBundle tb = new TrajectoryBundle("test trajectory");
Trajectory t1 = new Trajectory("test trajectory", 0.0, 0.0, 0.0);
double v = 1.0;
for (double t = 0; t <= 3600; t += 10)
{
t1.add(t, v);
v *= -1.0;
}
Console.WriteLine("t1 = " + t1.GetHashCode());
Trajectory t2 = new Trajectory("test trajectory", 0.0, 0.0, 0.0);
v = 2.0;
for (double t = 0; t <= 3600; t += 10)
{
t2.add(t + 23.0, v);
v *= -1.0;
}
Console.WriteLine("t2 = " + t2.GetHashCode());
Trajectory t3 = new Trajectory("test trajectory", 0.0, 0.0, 0.0);
v = 0.1;
for (double t = 0; t <= 3600; t += 10)
{
t3.add(t + 36.0, v);
v *= -1.0;
}
Console.WriteLine("t3 = " + t3.GetHashCode());
tb.addTrajectory(t1);
tb.addTrajectory(t2);
tb.addTrajectory(t3);
ITrajectory central = tb.CentralTrajectory;
for (double t = 0; t <= 3600; t += 10)
{
Assert.AreEqual(central.eval(t), t1.eval(t));
Assert.AreNotEqual(central.eval(t), t2.eval(t));
Assert.AreNotEqual(central.eval(t), t3.eval(t));
}
ITrajectory dev = tb.CentralDevTrajectory;
for (double t = 0; t <= 3600; t += 10)
{
Console.WriteLine("t=" + t + " dev=" + dev.eval(t));
}
}
public double eval(ITrajectory traj1, ITrajectory traj2, double t)
{
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);
}
int index1 = (int)(t / _dt);
int i = TIME_GRID - 1;
int j = TIME_GRID - 1;
while (i > index1)
{
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(traj1.eval(_dt * (double)i) - traj2.eval(_dt * (double)j));
}
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);
}
private void PresentCenter(ITrajectory center, ITrajectory dev)
{
string header = "# Trajectory " + center.Name + TrajectoryBundleCollapser_CentralDTW.SUFFIX;
this.AppendToPresentation(header);
header = "# time center dev";
this.AppendToPresentation(header);
int count = 0;
double step = (center.MaximumTime - center.MinimumTime) / STEPS;
for (double x = center.MinimumTime; x <= center.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double ctr = center.eval(x);
double delta = dev.eval(x);
string str = "" + x + "\t" + ctr + "\t" + delta;
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
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);
}
private void PresentMean(ITrajectory mean, ITrajectory std)
{
string header = "# Trajectory " + mean.Name + "";
this.AppendToPresentation(header);
header = "# time mean std";
this.AppendToPresentation(header);
int count = 0;
double step = (mean.MaximumTime - mean.MinimumTime) / STEPS;
for (double x = mean.MinimumTime; x <= mean.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double y = mean.eval(x);
double bar = std.eval(x);
string str = "" + x + "\t" + y + "\t" + bar;
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
private void Present(ITrajectory traj)
{
string header = "# Trajectory " + traj.Name + "";
this.AppendToPresentation(header);
header = "# time value";
this.AppendToPresentation(header);
int count = 0;
double step = (traj.MaximumTime - traj.MinimumTime) / STEPS;
for (double x = traj.MinimumTime; x <= traj.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double y = traj.eval(x);
string str = "" + x + "\t" + y + "";
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
public void TrajectoryBundleTest()
{
TrajectoryBundle tb = new TrajectoryBundle("test trajectory");
Trajectory t1 = new Trajectory("test trajectory", 0.0, 0.0, 0.0);
t1.add(0.0, 2.0);
t1.add(2.0, 0.0);
Assert.AreEqual(t1.Times.Count, 2);
Trajectory t2 = new Trajectory("test trajectory", 0.0, 0.0, 0.0);
t2.add(-1.0, 4.0);
t2.add(0.0, 4.0);
t2.add(1.0, 3.0);
t2.add(2.0, 2.0);
t2.add(3.0, 4.0);
Assert.AreEqual(t2.Times.Count, 5);
tb.addTrajectory(t1);
tb.addTrajectory(t2);
Assert.AreEqual(tb.Trajectories.Contains(t1), true);
Assert.AreEqual(tb.Trajectories.Contains(t2), true);
Assert.AreEqual(tb.Times.Count, 5);
ITrajectory t12mean = tb.MeanTrajectory;
Assert.AreEqual(t1.eval(-1.0), 2.0);
Assert.AreEqual(t2.eval(-1.0), 4.0);
Assert.AreEqual(t1.eval(3.0), 0.0);
Assert.AreEqual(t2.eval(3.0), 4.0);
Assert.AreEqual(t12mean.eval(-1.0), 3.0);
Assert.AreEqual(t12mean.eval(0.0), 3.0);
Assert.AreEqual(t12mean.eval(1.0), 2.0);
Assert.AreEqual(t12mean.eval(2.0), 1.0);
Assert.AreEqual(t12mean.eval(0.0), 3.0);
Assert.AreEqual(t12mean.eval(3.0), 2.0);
Assert.AreEqual(t12mean.Times.Count, 5);
Assert.AreEqual(t12mean.MinimumTime, -1.0);
Assert.AreEqual(t12mean.MaximumTime, 3.0);
ITrajectory t12std = tb.StdTrajectory;
Assert.AreEqual(t12std.eval(0.0), t12std.eval(1.0));
Assert.AreEqual(t12std.eval(1.0), t12std.eval(2.0));
Assert.AreEqual(t12std.eval(2.0), t12std.eval(0.0));
Assert.AreEqual(t12std.eval(-1.0), 1.0);
Assert.AreEqual(t12std.eval(3.0), 2.0);
Assert.AreEqual(t12std.Times.Count, 5);
Assert.AreEqual(t12std.MinimumTime, -1.0);
Assert.AreEqual(t12std.MaximumTime, 3.0);
}
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);
}
private double [] TrajectoryToArray(ITrajectory traj1, int n)
{
double [] val = new double [n];
int i = 0;
for (double t = traj1.MinimumTime; t < traj1.MaximumTime; t += _dt)
{
val[i] = traj1.eval(t);
i++;
if (i >= n)
{
break;
}
}
return(val);
}
private void Present(ITrajectory traj, int i, int n)
{
double step = (traj.MaximumTime - traj.MinimumTime) / STEPS;
for (double x = traj.MinimumTime; x <= traj.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double y = traj.eval(x);
string str = "" + x + "\t" + y + "\n";
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
}
}
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)
{
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 double eval(ITrajectory traj1, ITrajectory traj2, double t)
{
return(Math.Abs(traj1.eval(t) - traj2.eval(t)));
}
private void WriteTrajectories(int popi, ISimulationBundle simb, ISimulationResultsBundle resb)
{
string trajname = TRAJ_FILE_PREFIX + "." + popi + ".Validation";
string trajpath = Path.Combine(_trajdir, trajname);
TextWriter trajWriter = File.CreateText(trajpath);
foreach (IAgentEvaluationBundle aeb in resb.getAgentEvaluationBundles())
{
trajWriter.WriteLine("# AgentEvaluation: " + aeb.Name);
trajWriter.Write("# BlauPoint-Coordinates \t ");
trajWriter.Write("mean \t std \t count");
trajWriter.WriteLine("");
IBlauSpaceLattice bsl = simb.getLattice(theActualDistribution, aeb);
IBlauSpaceEvaluation meanEval = aeb.MeanEvaluation(bsl);
IBlauSpaceEvaluation stdEval = aeb.StdEvaluation(bsl);
IBlauSpaceEvaluation ctEval = aeb.AssignmentCounts(bsl);
foreach (IBlauPoint bp in meanEval.AssignedLatticePoints)
{
for (int c = 0; c < bp.Space.Dimension; c++)
{
trajWriter.Write("" + bp.Space.getAxis(c).Name + "=" + bp.getCoordinate(c).ToString("#0.000") + "\t");
}
trajWriter.Write("" + meanEval.eval(bp).ToString("#0.000") + "\t");
trajWriter.Write("" + stdEval.eval(bp).ToString("#0.000") + "\t");
trajWriter.Write("" + ctEval.eval(bp).ToString("#0.000") + "\t");
trajWriter.WriteLine("");
}
}
double NUMTICKS = 100.0;
foreach (ITrajectoryBundle tb in resb.getTrajectoryBundles())
{
trajWriter.WriteLine("# TrajectoryBundle: " + tb.Name);
trajWriter.WriteLine("# time \t mean \t std \t center \t dev");
ITrajectory meanTraj = tb.MeanTrajectory;
ITrajectory stdTraj = tb.StdTrajectory;
ITrajectory centerTraj = tb.CentralTrajectory;
ITrajectory devTraj = tb.CentralDevTrajectory;
double mint = tb.MinimumTime;
double maxt = tb.MaximumTime;
double stept = (maxt - mint) / NUMTICKS;
for (double t = mint; t < maxt; t += stept)
{
trajWriter.Write("" + t.ToString("#0.000") + "\t");
trajWriter.Write("" + meanTraj.eval(t).ToString("#0.000") + "\t");
trajWriter.Write("" + stdTraj.eval(t).ToString("#0.000") + "\t");
trajWriter.Write("" + centerTraj.eval(t).ToString("#0.000") + "\t");
trajWriter.Write("" + devTraj.eval(t).ToString("#0.000") + "\t");
trajWriter.WriteLine("");
}
}
trajWriter.Flush();
trajWriter.Close();
}
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);
}
