public NumericalSeriesPair[] Derive(NumericalDataType datatype, int timeInteval)
{
if (timeInteval == 0)
{
timeInteval = 1;
}
DateTime[] mDateTimeVector = DateTimes;
double[] mDataValueVector = Value;
List <NumericalSeriesPair> list = new List <NumericalSeriesPair>();
int startYear = mDateTimeVector.Min().Year;
int year = mDateTimeVector.Max().Year - mDateTimeVector.Min().Year + 1;
int index = 0;
DateTime start = mDateTimeVector.Min();
for (int i = 0; i < year; i++)
{
for (int j = 0; j < 12; j++)
{
int daysInMonth = DateTime.DaysInMonth(startYear + i, j + 1);
double s = (double)daysInMonth / (double)timeInteval;
//int seg =(int)Math.Ceiling( s);
int seg = 6;
for (int c = 0; c < seg - 1; c++)
{
double sum = 0;
DateTime now = start.AddDays(index);
for (int t = 0; t < timeInteval; t++)
{
sum += mDataValueVector[index];
index++;
}
double ave = Math.Round(sum / timeInteval, 3);
NumericalSeriesPair np = new NumericalSeriesPair(now, ave);
list.Add(np);
}
double sum1 = 0;
DateTime now1 = start.AddDays(index);
for (int c = (seg - 1) * timeInteval; c < daysInMonth; c++)
{
sum1 += mDataValueVector[c];
index++;
}
if (datatype == NumericalDataType.Average)
{
double ave1 = Math.Round(sum1 / (daysInMonth - (seg - 1) * timeInteval), 3);
list.Add(new NumericalSeriesPair(now1, ave1));
}
else if (datatype == NumericalDataType.Cumulative)
{
list.Add(new NumericalSeriesPair(now1, sum1));
}
}
}
return(list.ToArray());
}
public NumericalTimeSeries DeriveTS(NumericalDataType datatype, TimeUnits outseriesTimeUnit)
{
var derivedParis = Derive(datatype, outseriesTimeUnit);
var values = from dp in derivedParis select dp.Value;
var times = from dp in derivedParis select dp.DateTime;
var ts = new NumericalTimeSeries(values.ToArray(), times.ToArray());
return(ts);
}
public Derive()
{
Name = "Derive";
Category = "Math";
Description = "Derive time series from existing data cube";
Version = "1.0.0.0";
Derived = "Derived";
this.Author = "Yong Tian";
mNumericalDataType = Core.NumericalDataType.Average;
mTimeUnit = TimeUnits.Month;
}
public ZonalStatisticsAsTable()
{
Name = "Zonal Statistics As Table";
Category = "Tempo-Spatial Analysis";
Description = "Zonal As Table";
Version = "1.0.0.0";
this.Author = "Yong Tian";
Output = "zonal";
mNumericalDataType = Core.NumericalDataType.Average;
mTimeUnit = TimeUnits.Month;
NoDataValue = -999;
BaseTimeStep = 0;
}
public static float[] GetMonthlyMean(DataCube <float> source, NumericalDataType datatype)
{
var mean_mon = new float[12];
var mon = Derieve(source, datatype, TimeUnits.Month);
int nmon = mon.DateTimes.Length;
int nyear = nmon / 12;
for (int j = 0; j < 12; j++)
{
for (int i = 0; i < nyear; i++)
{
mean_mon[j] += mon[0, 12 * i + j, 0];
}
}
for (int j = 0; j < 12; j++)
{
mean_mon[j] /= nyear;
}
return(mean_mon);
}
/// <summary>
/// Provide quick summerization on specified cells.. Add an offeset when reading. Return 3D array: [subset zone][var][step]
/// </summary>
/// <param name="filename"></param>
/// <param name="intevals"></param>
/// <param name="step"></param>
/// <param name="varNames"></param>
/// <param name="subindex"></param>
/// <param name="offset"></param>
/// <param name="statFlag"></param>
/// <returns></returns>
public float[][][] Summerize(string filename, int[] intevals, ref int step, ref string[] varNames, int[][] subindex, float [] offset, NumericalDataType statFlag = NumericalDataType.Average)
{
step = 0;
int feaNum = 0;
FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs);
int varnum = br.ReadInt32();
int nzone = subindex.Length;
varNames = new string[varnum];
float[][][] stat = new float[nzone][][];
for (int i = 0; i < nzone; i++)
{
stat[i] = new float[varnum][];
}
for (int i = 0; i < varnum; i++)
{
int varname_len = br.ReadInt32();
varNames[i] = new string(br.ReadChars(varname_len)).Trim();
feaNum = br.ReadInt32();
for (int z = 0; z < nzone; z++)
{
stat[z][i] = new float[intevals.Length];
}
}
float[][] matrix = new float[varnum][];
for (int i = 0; i < varnum; i++)
{
matrix[i] = new float[feaNum];
}
for (int i = 0; i < intevals.Length; i++)
{
MatrixExtension <float> .Set(matrix, 0);
for (int d = 0; d < intevals[i]; d++)
{
for (int s = 0; s < feaNum; s++)
{
for (int v = 0; v < varnum; v++)
{
matrix[v][s] += (br.ReadSingle() + offset[s]);
}
}
step++;
}
for (int z = 0; z < nzone; z++)
{
for (int v = 0; v < varnum; v++)
{
float temp = 0;
foreach (var id in subindex[z])
{
temp += matrix[v][id];
}
if (statFlag == NumericalDataType.Average)
{
stat[z][v][i] = temp / subindex[z].Length / intevals[i];
}
else if (statFlag == NumericalDataType.Cumulative)
{
stat[z][v][i] = temp / subindex[z].Length;
}
}
}
}
br.Close();
fs.Close();
return(stat);
}
public static DataCube <float> Derieve(DataCube <float> source, NumericalDataType datatype, TimeUnits outseriesTimeUnit)
{
var sourcePairs = source.ToPairs();
DataCube <float> result = null;
if (datatype == NumericalDataType.Average || datatype == NumericalDataType.Cumulative)
{
if (outseriesTimeUnit == TimeUnits.Week)
{
if (datatype == NumericalDataType.Average)
{
var derivedValues = sourcePairs.GroupBy(t => new
{
Year = t.DateTime.Year,
Week = CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(t.DateTime, CalendarWeekRule.FirstDay, DayOfWeek.Monday)
}).Select(group =>
new TimeSeriesPair <float>(DateTimeHelper.GetBy(group.Key.Year, group.Key.Week), group.Sum(s => s.Value) / group.Count()));
result = DataCube <float> .FromPairs(derivedValues);
}
else if (datatype == NumericalDataType.Cumulative)
{
var derivedValues = sourcePairs.GroupBy(t => new
{
Year = t.DateTime.Year,
Week = CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(t.DateTime, CalendarWeekRule.FirstDay, DayOfWeek.Monday)
}).Select(group =>
new TimeSeriesPair <float>(DateTimeHelper.GetBy(group.Key.Year, group.Key.Week), group.Sum(s => s.Value)));
result = DataCube <float> .FromPairs(derivedValues);
}
}
else if (outseriesTimeUnit == TimeUnits.Month)
{
if (datatype == NumericalDataType.Average)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year, t.DateTime.Month }).Select(group =>
new TimeSeriesPair <float>(new DateTime(group.Key.Year, group.Key.Month, 1), group.Sum(s => s.Value) / group.Count()));
result = DataCube <float> .FromPairs(derivedValues);
}
else if (datatype == NumericalDataType.Cumulative)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year, t.DateTime.Month }).Select(group =>
new TimeSeriesPair <float>(new DateTime(group.Key.Year, group.Key.Month, 1), group.Sum(s => s.Value)));
result = DataCube <float> .FromPairs(derivedValues);
}
}
else if (outseriesTimeUnit == TimeUnits.CommanYear)
{
if (datatype == NumericalDataType.Average)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year }).Select(group =>
new TimeSeriesPair <float>(new DateTime(group.Key.Year, 1, 1), group.Sum(s => s.Value) / group.Count()));
result = DataCube <float> .FromPairs(derivedValues);
}
else if (datatype == NumericalDataType.Cumulative)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year }).Select(group =>
new TimeSeriesPair <float>(new DateTime(group.Key.Year, 1, 1), group.Sum(s => s.Value)));
result = DataCube <float> .FromPairs(derivedValues);
}
}
else if (outseriesTimeUnit == TimeUnits.Day)
{
result = source;
}
}
return(result);
}
public NumericalSeriesPair[] Derive(NumericalDataType datatype, TimeUnits outseriesTimeUnit)
{
INumericalSeriesPair[] sourcePairs = SeriesPairs;
NumericalSeriesPair[] derivedParis = null;
DateTime[] mDateTimeVector = DateTimes;
double[] mDataValueVector = Value;
if (datatype == NumericalDataType.Average || datatype == NumericalDataType.Cumulative)
{
if (outseriesTimeUnit == TimeUnits.Week)
{
int startIndex = 0;
DateTime start = mDateTimeVector[0];
foreach (DateTime t in mDateTimeVector)
{
if (t.DayOfWeek == DayOfWeek.Monday)
{
start = t;
break;
}
startIndex++;
}
int weekCount = (mDateTimeVector.Length - startIndex + 1) / 7;
if (weekCount > 0)
{
derivedParis = new NumericalSeriesPair[weekCount];
for (int w = 0; w < weekCount; w++)
{
double weekSum = 0;
double max = startIndex + (w + 1) * 7 > mDateTimeVector.Length ? mDateTimeVector.Length : startIndex + (w + 1) * 7;
for (int j = startIndex + w * 7; j < max; j++)
{
weekSum += mDataValueVector[j];
}
if (datatype == NumericalDataType.Average)
{
derivedParis[w] = new NumericalSeriesPair(start.AddDays(w * 7), Math.Round(weekSum / 7, 4));
}
else if (datatype == NumericalDataType.Cumulative)
{
derivedParis[w] = new NumericalSeriesPair(start.AddDays(w * 7), weekSum);
}
}
}
}
else if (outseriesTimeUnit == TimeUnits.Month)
{
if (datatype == NumericalDataType.Average)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year, t.DateTime.Month }).Select(group =>
new NumericalSeriesPair(new DateTime(group.Key.Year, group.Key.Month, 1), Math.Round(group.Sum(s => s.Value) / group.Count(), 4)));
derivedParis = derivedValues.ToArray();
}
else if (datatype == NumericalDataType.Cumulative)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year, t.DateTime.Month }).Select(group =>
new NumericalSeriesPair(new DateTime(group.Key.Year, group.Key.Month, 1), group.Sum(s => s.Value)));
derivedParis = derivedValues.ToArray();
}
}
else if (outseriesTimeUnit == TimeUnits.CommanYear)
{
if (datatype == NumericalDataType.Average)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year }).Select(group =>
new NumericalSeriesPair(new DateTime(group.Key.Year, 1, 1), Math.Round(group.Sum(s => s.Value) / group.Count(), 4)));
derivedParis = derivedValues.ToArray();
}
else if (datatype == NumericalDataType.Cumulative)
{
var derivedValues = sourcePairs.GroupBy(t => new { t.DateTime.Year }).Select(group =>
new NumericalSeriesPair(new DateTime(group.Key.Year, 1, 1), group.Sum(s => s.Value)));
derivedParis = derivedValues.ToArray();
}
}
else if (outseriesTimeUnit == TimeUnits.FiveDays)
{
derivedParis = Derive(datatype, 5);
}
else if (outseriesTimeUnit == TimeUnits.Day)
{
derivedParis = (NumericalSeriesPair[])sourcePairs;
}
}
return(derivedParis);
}
