public void TestEquality()
{
TimeInterval interval1 = new TimeInterval(new JulianDate(1.0), new JulianDate(2.0));
TimeInterval interval2 = new TimeInterval(new JulianDate(1.0), new JulianDate(2.0));
Assert.AreEqual(interval1, interval2);
Assert.AreEqual(interval2, interval1);
Assert.IsTrue(interval1.Equals(interval2));
Assert.IsTrue(interval2.Equals(interval1));
Assert.IsTrue(interval1 == interval2);
Assert.IsTrue(interval2 == interval1);
Assert.IsFalse(interval1 != interval2);
Assert.IsFalse(interval2 != interval1);
interval2 = new TimeInterval(new JulianDate(1.0), new JulianDate(3.0));
Assert.AreNotEqual(interval1, interval2);
Assert.AreNotEqual(interval2, interval1);
Assert.IsFalse(interval1.Equals(interval2));
Assert.IsFalse(interval2.Equals(interval1));
Assert.IsFalse(interval1 == interval2);
Assert.IsFalse(interval2 == interval1);
Assert.IsTrue(interval1 != interval2);
Assert.IsTrue(interval2 != interval1);
Assert.AreNotEqual(interval1, 5);
}
public void Add(string[] cbttPcodeList, DateTime t1, DateTime t2,
HydrometHost svr = HydrometHost.PN, TimeInterval interval = TimeInterval.Monthly, int back=0)
{
// make cbttPcodeList unique.
List<string> lst = new List<string>(cbttPcodeList);
cbttPcodeList = lst.Distinct().ToArray();
//minT = t1;
//maxT = t2;
m_interval = interval;
string query = String.Join(",",cbttPcodeList);
if (query.Length >0)
{
DataTable m_table = new DataTable();
if (interval == TimeInterval.Monthly)
{
m_table = HydrometDataUtility.MPollTable(svr, query, t1, t2);
}
else if (interval == TimeInterval.Daily)
{
m_table = HydrometDataUtility.ArchiveTable(svr, query, t1, t2,back);
}
else if (interval == TimeInterval.Irregular)
{
m_table = HydrometDataUtility.DayFilesTable(svr, query, t1, t2,back);
}
m_table.ExtendedProperties.Add("interval", interval.ToString());
s_counter++;
m_table.TableName = svr.ToString()+"_"+interval.ToString() + s_counter;
m_dataSet.Tables.Add(m_table);
}
}
public List<PVTableRow> AverageSessionLengthChart(string gameShort, TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate)
{
GameMonitoringConfig game = Games.Instance.GetMonitoredGames().Where(x => x.ShortTitle == gameShort).FirstOrDefault();
List<PVTableRow> DataTableInfo = GetAverageSessionLengthTable(interval, region, startDate, endDate, game);
return DataTableInfo;
}
public JsonResult PrivateVsPublic(string game, AWSRegion region, TimeInterval interval, string start, string end)
{
DateTime st = Convert.ToDateTime(start);
DateTime et = Convert.ToDateTime(end);
return JsonResult(GameSessionsModel.Instance.GetPrivateSessionTimeSeries(game, interval, st, et));
}
public List<PVTimeSeries> GetAverageSessionLength(TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate, string gameShortName)
{
List<PVTimeSeries> timeSeriesData = new List<PVTimeSeries>();
DataTable queryResults = new DataTable();
GameMonitoringConfig game = Games.Instance.GetMonitoredGames().Where(x => x.ShortTitle == gameShortName).FirstOrDefault();
string query = String.Format(
@"select DATE(RecordCreated) as RecordTimeStamp,
SessionTypeFriendly as SeriesName,
round(avg(minute(timediff(RecordLastUpdateTime, RecordCreated)))) * 60 * 1000 as AverageSessionLength
from {0}
WHERE GameId = '{1}'
AND DATE(RecordCreated) BETWEEN '{2}' and '{3}'
AND minute(timediff(RecordLastUpdateTime, RecordCreated)) > 1
group by DATE(RecordCreated), SessionTypeFriendly
order by RecordCreated asc;",
"GameSessionMeta", game.Id, startDate.ToString("yyyy-MM-dd HH:mm:ss"), endDate.ToString("yyyy-MM-dd HH:mm:ss"));
try
{
queryResults = DBManager.Instance.Query(Datastore.Monitoring, query);
timeSeriesData = Charts.Instance.ProcessedTimeSeries(queryResults, interval, startDate, endDate, "RecordTimestamp");
}
catch (Exception ex)
{
Logger.Instance.Exception(ex.Message, ex.StackTrace);
}
return timeSeriesData;
}
public JsonResult UsersOnlineBySessionType(string game, AWSRegion region, TimeInterval interval, string start, string end)
{
DateTime st = Convert.ToDateTime(start);
DateTime et = Convert.ToDateTime(end);
return JsonResult(GameSessionsModel.Instance.UsersOnlineBySessionType(game, interval, region, st, et));
}
public JsonResult SessionLengthGraphData(string game, AWSRegion region, TimeInterval interval, string start, string end)
{
DateTime st = Convert.ToDateTime(start);
DateTime et = Convert.ToDateTime(end);
return JsonResult(GameSessionsModel.Instance.GetAverageSessionLength(interval, region, st, et, game));
}
public void SetCathedraModificator(Cathedra cathedra, TimeInterval interval)
{
foreach (var dataProvider in _dataProviders)
{
dataProvider.SetCathedraModificator(cathedra, interval);
}
}
public DataTableSeries(DataTable tbl, TimeInterval interval, string dateColumn, string valueColumnName)
{
this.data = tbl;
this.TimeInterval = interval;
this.dateColumn = dateColumn;
this.valueColumnName = valueColumnName;
}
public void SetProfessorModificator(Person professor, TimeInterval interval)
{
foreach (var dataProvider in _dataProviders)
{
dataProvider.SetPersonModificator(professor, interval);
}
}
public void SetFacultyModificator(TimeInterval interval)
{
foreach (var dataProvider in _dataProviders)
{
dataProvider.SetFacultyModificator(interval);
}
}
public void PassToIso8601Interval()
{
//Since ToIso8601Interval is just a simple wrapper around two calls to
//CesiumFormattingHelper.ToIso8601, this test is just a smoke screen.
string expectedBasicInterval = "19800801T000000Z/20720703T000000Z";
string expectedExtendedInterval = "1980-08-01T00:00:00Z/2072-07-03T00:00:00Z";
string expectedCompactInterval = "19800801T00Z/20720703T00Z";
JulianDate start = new GregorianDate(1980, 08, 01).ToJulianDate();
JulianDate stop = new GregorianDate(2072, 07, 03).ToJulianDate();
string basicInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Basic);
Assert.AreEqual(expectedBasicInterval, basicInterval);
string extendedInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Extended);
Assert.AreEqual(expectedExtendedInterval, extendedInterval);
string compactInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Compact);
Assert.AreEqual(expectedCompactInterval, compactInterval);
TimeInterval interval = new TimeInterval(start, stop);
basicInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Basic);
Assert.AreEqual(expectedBasicInterval, basicInterval);
extendedInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Extended);
Assert.AreEqual(expectedExtendedInterval, extendedInterval);
compactInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Compact);
Assert.AreEqual(expectedCompactInterval, compactInterval);
}
public ActionResult Create(string name, int poolId)
{
try
{
Pool p = db.PoolSet.Find(poolId);
int max = p.Division.Pools.Max(x => x.Teams.Count);
if (p.Teams.Count == max)
{
db.FinalsLinkSet.Add(new FinalsLink() { Division = p.Division, PoolPlacement = max + 1, Finalstage = max + 1 });
}
Team t = db.TeamSet.Add(new Team() { Name = name, Pool = p });
// Add time intervals and default them to the tournament's time intervals
foreach (TimeInterval ti in p.Division.Tournament.TimeIntervals)
{
TimeInterval timeinterval = new TimeInterval() { Team = t, StartTime = ti.StartTime, EndTime = ti.EndTime };
db.TimeIntervalSet.Add(timeinterval);
t.TimeIntervals.Add(timeinterval);
}
//Clear the schedule
sm.DeleteSchedule(p.Division.Tournament.Id, db);
db.SaveChanges();
return Json(new { status = "success", message = "New team added", id = t.Id }, JsonRequestBehavior.AllowGet);
}
catch (Exception ex)
{
return Json(new { status = "error", message = "New team not added", details = ex.Message }, JsonRequestBehavior.AllowGet);
}
}
public ConstantSeries(string name, string parameter, double value, TimeInterval interval)
{
m_value = value;
this.Name = name;
this.Parameter = parameter;
this.TimeInterval = interval;
}
public static Series ReadCorpsDataFile(string url, TimeInterval interval, params string[] headers)
{
string units = headers[headers.Length - 1];
if( units == "n (ft)") // hack for Banks Lake.
units = "(ft)";
Series rval = new Series(units, interval);
rval.HasFlags = true;
string fileName = FileUtility.GetTempFileName(".txt");
Web.GetTextFile(url, fileName, true);
int[] widths = new int[] { 9, 5, 9, 9, 9, 9, 9, 9, 9, 9, 9,9,9 };
var tf = new FixedWidthTextFile(fileName, widths);
int col, row;
tf.FindIndexToRange(headers, out row, out col);
if (row < 0 || col < 0)
{
Logger.WriteLine("Error: no index found for headers '" + String.Join("','", headers) + "'");
return rval;
}
rval.Name = String.Join(" ", headers, 0, headers.Length - 1);
ReadDataIntoSeries(tf, rval, row + headers.Length, col);
return rval;
}
/// <summary>
/// Lookup hydromet Series.
/// name is interval_cbtt_pcode
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override ParserResult Lookup(string name, TimeInterval defaultInterval)
{
var interval = defaultInterval;
TimeSeriesName tn = new TimeSeriesName(name);
if( tn.HasInterval)
{
interval = tn.GetTimeInterval();
}
if (tn.Valid)
{
Logger.WriteLine("Hydromet Lookup " + tn.siteid + "," + tn.pcode);
var s = new Series();
if (interval == TimeInterval.Monthly)
{
s = new HydrometMonthlySeries(tn.siteid, tn.pcode,svr);
}
else if (interval == TimeInterval.Irregular)
{
s = new HydrometInstantSeries(tn.siteid, tn.pcode,svr);
}
else if (interval == TimeInterval.Daily)
{
s = new HydrometDailySeries(tn.siteid, tn.pcode,svr);
}
return new ParserResult(s);
}
else
{
return base.Lookup(name,interval);
}
}
/// <summary>
/// </summary>
/// <param name="stationID">example: 13245000</param>
/// <param name="ipcoType">Q,Qin,HW,Qx,S</param>
/// <param name="numDays">how many days back</param>
/// <returns></returns>
public static Series GetIdahoPowerData(string stationID, string ipcoType, int numDays, TimeInterval interval)
{
string xmlFileName = GetIdahoPowerXmlFile(stationID, interval, numDays);
var s = ParseXmlData(xmlFileName, stationID, ipcoType, interval);
return s;
}
public void MomentTest() {
DateTime moment = ClockProxy.Clock.Now;
TimeInterval timeInterval = new TimeInterval(moment);
Assert.AreEqual(timeInterval.Start, moment);
Assert.AreEqual(timeInterval.End, moment);
Assert.IsTrue(timeInterval.IsMoment);
Assert.IsTrue(timeInterval.IsDegenerate);
}
public void TestCalculateDuration()
{
JulianDate start = new JulianDate(2451545.0);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(Duration.FromDays(1.5), interval.ToDuration());
}
public void TestRetainValue()
{
JulianDate start = new JulianDate(DateTime.UtcNow);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(start, interval.Start);
Assert.AreEqual(stop, interval.Stop);
}
public void TestIsEmpty()
{
TimeInterval interval = new TimeInterval(new JulianDate(1.0), new JulianDate(1.0));
Assert.IsTrue(interval.IsEmpty);
interval = new TimeInterval(new JulianDate(5.0), new JulianDate(4.0));
Assert.IsTrue(interval.IsEmpty);
}
public void TimeInterval_GetHashCode()
{
var ti = new TimeInterval<string>(null, TimeSpan.FromSeconds(123.45));
Assert.True(ti.GetHashCode() != 0);
Assert.Equal(ti.GetHashCode(), ti.GetHashCode());
var t2 = new TimeInterval<string>("", TimeSpan.FromSeconds(123.45));
Assert.NotEqual(ti.GetHashCode(), t2.GetHashCode());
}
public void DefaultTest() {
TimeInterval timeInterval = new TimeInterval();
Assert.AreNotEqual(timeInterval, TimeInterval.Anytime);
Assert.AreEqual(timeInterval.GetRelation(TimeInterval.Anytime), PeriodRelation.ExactMatch);
Assert.IsTrue(timeInterval.IsAnytime);
Assert.IsTrue(timeInterval.IsClosed);
Assert.IsFalse(timeInterval.IsOpen);
Assert.IsFalse(timeInterval.IsMoment);
Assert.IsFalse(timeInterval.IsReadOnly);
}
/// <summary>
/// Function that averages a series based on a defined Time-Interval
/// </summary>
/// <param name="s">Input Series</param>
/// <param name="tInterval">Averaging Time-Interval</param>
/// <returns></returns>
public static Series Average(Series s, TimeInterval tInterval)
{
Series rval = s.Clone();
if (s.Count == 0)
return rval;
// Define starting date of averaging process
DateTime t = new DateTime(s[0].DateTime.Year, s[0].DateTime.Month, s[0].DateTime.Day,
s[0].DateTime.Hour, 0, 0);
// Find which averaging process to accomplish
if (tInterval == TimeInterval.Daily)
{
// Define series time-interval
rval.TimeInterval = TimeInterval.Daily;
// Loop through the dates
while (t < s[s.Count - 1].DateTime.Date)
{
// Get the series subset based on the averaging time-interval
Series sTemp = s.Subset(t, t.AddDays(1));
// Average the values of the subset
DoAverage(rval, t, sTemp);
// Increment DateTime by averaging time-interval
t = t.AddDays(1);
}
}
// Ditto on the other processes below
else if (tInterval == TimeInterval.Monthly)
{
rval.TimeInterval = TimeInterval.Monthly;
while (t < s[s.Count - 1].DateTime.Date)
{
Series sTemp = s.Subset(t, t.AddMonths(1));
DoAverage(rval, t, sTemp);
t = t.AddMonths(1);
}
}
else if (tInterval == TimeInterval.Hourly)
{
rval.TimeInterval = TimeInterval.Hourly;
while (t < s.MaxDateTime)
{
Series sTemp = Math.Subset(s, new DateRange(t, t.AddHours(1)), false);
DoAverage(rval, t, sTemp);
t = t.AddHours(1);
}
}
else
{ throw new Exception("Time Interval " + tInterval.ToString() + " not supported!"); }
return rval;
}
public void HasEndTest() {
TimeInterval timeInterval1 = new TimeInterval(TimeSpec.MinPeriodTime, ClockProxy.Clock.Now);
Assert.IsFalse(timeInterval1.HasStart);
Assert.IsTrue(timeInterval1.HasEnd);
TimeInterval timeInterval2 = new TimeInterval(TimeSpec.MinPeriodTime, TimeSpec.MaxPeriodTime);
Assert.IsFalse(timeInterval2.HasEnd);
TimeInterval timeInterval3 = new TimeInterval(
TimeSpec.MinPeriodTime, TimeSpec.MaxPeriodTime, IntervalEdge.Open, IntervalEdge.Open);
Assert.IsTrue(timeInterval3.HasEnd);
}
public HDBSeries(int sdi,TimeInterval interval, HDBServer server )
{
m_sdi = sdi;
m_server = server;
this.TimeInterval = TimeSeries.TimeInterval.Daily;
Source = "hdb"; // need icon for HDB
Provider = "HDBSeries";
ConnectionString = "server=" + m_server
+ ";sdi=" + m_sdi
+ ";TimeInterval="+interval.ToString()
+";LastUpdate=" + DateTime.Now.ToString(DateTimeFormatInstantaneous);
Init();
}
public List<PVTableRow> GetAverageSessionLengthTable(TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate, GameMonitoringConfig game)
{
#region Validation
if (!interval.IsSupportedInterval(TimeInterval.Minute, TimeInterval.Year))
{
throw new Exception(String.Format("Chart data only supports an interval between {0} and {1}", TimeInterval.Day, TimeInterval.Year));
}
if (startDate == DateTime.MinValue || endDate == DateTime.MinValue || (startDate >= endDate))
{
throw new Exception("StartDate and EndDate cannot be null, and StartDate must come before EndDate");
}
if (String.IsNullOrEmpty(game.Id))
{
throw new Exception("GameID cannot be empty or null");
}
#endregion
List<PVTableRow> dataTableData = new List<PVTableRow>();
DataTable queryResults = new DataTable();
startDate = startDate.RoundDown(interval);
endDate = endDate.RoundDown(interval);
string query = String.Format(
@"select DATE(RecordCreated) as RecordTimeStamp,
SessionTypeFriendly as SeriesName,
round(avg(minute(timediff(RecordLastUpdateTime, RecordCreated)))) as AverageSessionLength
from {0}
WHERE GameId = '{1}'
AND DATE(RecordCreated) BETWEEN '{2}' and '{3}'
AND minute(timediff(RecordLastUpdateTime, RecordCreated)) > 1
group by DATE(RecordCreated), SessionTypeFriendly
order by RecordCreated asc;",
"GameSessionMeta", game.Id, startDate.ToString("yyyy-MM-dd HH:mm:ss"), endDate.ToString("yyyy-MM-dd HH:mm:ss"));
try
{
queryResults = DBManager.Instance.Query(Datastore.Monitoring, query);
dataTableData = Charts.Instance.ProcessedSessionLengthData(queryResults, interval, startDate, endDate, "RecordTimestamp");
}
catch (Exception ex)
{
Logger.Instance.Exception(ex.Message, ex.StackTrace);
}
return dataTableData;
}
/// <summary>
/// Initializes a new instance of the <see cref="Event"/> struct.
/// </summary>
/// <param name="category">
/// Typically the object that was interacted with (e.g. button)
/// </param>
/// <param name="action">
/// The type of interaction (e.g. click)
/// </param>
/// <param name="from">
/// The inclusive start of the period that we're interested in.
/// </param>
/// <param name="to">
/// The exclusive end of the period that we're interested in.
/// </param>
/// <param name="timeInterval">
/// The accuracy at which we want the data. For example, setting this to TimeInterval.OneDay means there won't
/// be any keys at the fifteen minute or one hour levels, so if the <paramref name="from"/> DateTime is for the
/// middle of a day, it'll include the entire day.
/// </param>
public Event(
string category,
string action,
DateTime from,
DateTime to,
TimeInterval timeInterval = TimeInterval.FifteenMinutes)
{
this._category = category;
this._action = action;
this._from = from;
this._to = to;
this._redisKeys = null;
this._timeInterval = timeInterval;
}
public static Series GetIdahoPowerData(string stationID, string ipcoType, TimeInterval interval, DateTime t1, DateTime t2)
{
if( t1 > DateTime.Now)
return new Series();
var ts = TimeSpan.FromTicks( DateTime.Now.Ticks- t1.Ticks );
string xmlFileName = GetIdahoPowerXmlFile(stationID, interval, ts.Days);
var s = ParseXmlData(xmlFileName, stationID, ipcoType, interval);
s.Trim(t1, t2);
return s;
}
public List<PVTimeSeries> AverageSessionLength(string gameShort, TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate)
{
//List<OnlineBySessionTypeSeries> retVal = new List<OnlineBySessionTypeSeries>();
//need to format this data in the appropriate way as to feed it directly into high charts
List<PVTimeSeries> TimeSeriesChart = GetAverageSessionLength(interval, region, startDate, endDate, gameShort);
//this is the datetime format with TimeZone encoded in thatjavascript understands
// the Z means UTC
// and also JS Date has a method to JSON that turns the datetime into this string.
// f**k yeah
string IEFTFormatForJSON = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
return TimeSeriesChart;
}
public void Update(TimeInterval gt)
{
}
public static void Main(string[] args)
{
var times = new TimeInterval[] { new TimeInterval(30, 75), new TimeInterval(0, 50), new TimeInterval(60, 150) };
Console.WriteLine(GetRequiredRoomAmount(times));
}
public async Task InsertOrMergeAsync(IEnumerable <IFeedCandle> candles, string asset, TimeInterval interval, PriceType priceType)
{
foreach (var candle in candles)
{
await this.InsertOrMergeAsync(candle, asset, interval, priceType);
}
}
/// <inheritdoc />
public void Update(TimeInterval messagesTimeInterval, TimeInterval messagesOriginatingTimeInterval)
{
throw new NotImplementedException();
}
/// <summary> /// Maximum acceptable error for a benchmark (by default, BenchmarkDotNet continue iterations until the actual error is less than the specified error). /// Doesn't have a default value. /// <remarks>If <see cref="AccuracyMode.MaxRelativeError"/> is also provided, the smallest value is used as stop criteria.</remarks> /// </summary> public static Job WithMaxAbsoluteError(this Job job, TimeInterval value) => job.WithCore(j => j.Accuracy.MaxAbsoluteError = value);
public void UpdateMainInterval(TimeInterval ti, CameraTimeInfo[] tmpList)
{
main = ti;
UpdateAll(tmpList);
}
/// <summary>
/// Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value.
/// </summary>
/// <param name="other">An object to compare to the current TimeInterval<T> value.</param>
/// <returns>true if both TimeInterval<T> values have the same Value and Interval; otherwise, false.</returns>
public bool Equals(TimeInterval <T> other)
{
return(other.Interval.Equals(Interval) && EqualityComparer <T> .Default.Equals(Value, other.Value));
}
private void GetHistory(TimeInterval interval, TimeSpan span, DateTime now)
{
var entry = _context.TimeEvents.OrderBy(e => e.Created, SortOrder.Desc).FirstOrDefault(e => e.Type == interval);
_lastCheck.Add(interval, new CheckHolder(entry?.Created ?? now, span));
}
public QuantityConstraintModel()
{
ForTimeInterval = new TimeInterval();
Quantity = 0;
ComparisonOperator = ComparisonOperator.Equals;
}
public CsvFormatter(TimeInterval interval, bool printFlags)
: base(interval, printFlags)
{
}
public static void AddAvarageTimeInterval(this AvarageTimeInterval targetTimeInterval, TimeInterval newTimeInterval)
{
var prevDuration = targetTimeInterval.AvarageDuration * targetTimeInterval.Count;
targetTimeInterval.Count++;
targetTimeInterval.AvarageDuration = (prevDuration + newTimeInterval.Duration) / targetTimeInterval.Count;
}
private NowUntil(TimeInterval timeInterval) => _timeInterval = timeInterval;
public string FormatTimeInterval(TimeInterval interval)
{
return(String.Format("({0}) - ({1})", FormatDateTime(interval.Start), FormatDateTime(interval.End.AddTicks(1))));
}
private DateTime GetEndDate(DateTime now, TimeInterval interval, int numberOfCandleSticks)
{
switch (interval)
{
case TimeInterval.Minutes_1:
return(now.AddDays(-5));
break;
case TimeInterval.Minutes_3:
return(now.AddDays(-5));
break;
case TimeInterval.Minutes_5:
return(now.AddDays(-5));
break;
case TimeInterval.Minutes_15:
return(now.AddDays(-5));
break;
case TimeInterval.Minutes_30:
return(now.AddDays(-5));
break;
case TimeInterval.Hours_1:
return(now.AddDays(-10));
break;
case TimeInterval.Hours_2:
return(now.AddDays(-10));
break;
case TimeInterval.Hours_4:
return(now.AddDays(-50));
break;
case TimeInterval.Hours_6:
return(now.AddDays(-50));
break;
case TimeInterval.Hours_8:
return(now.AddDays(-50));
break;
case TimeInterval.Hours_12:
return(now.AddDays(-50));
break;
case TimeInterval.Days_1:
return(now.AddDays(-100));
break;
case TimeInterval.Days_3:
return(now.AddDays(-300));
break;
case TimeInterval.Weeks_1:
return(now.AddDays(-700));
break;
case TimeInterval.Months_1:
return(now.AddMonths(-100));
break;
default:
throw new ArgumentOutOfRangeException(nameof(interval), interval, null);
}
}
public void Initialize()
{
main = new TimeInterval(DateTime.Now, DateTime.Now.AddMinutes(10));
}
public Task <IEnumerable <IFeedCandle> > GetCandlesAsync(string asset, TimeInterval interval, PriceType priceType, DateTime from, DateTime to)
{
throw new NotImplementedException();
}
public void Initialize(DateTime startTime, DateTime endTime)
{
main = new TimeInterval(startTime, endTime);
}
public Task <IFeedCandle> GetCandleAsync(string asset, TimeInterval interval, PriceType priceType, DateTime dateTime)
{
throw new NotImplementedException();
}
public MinIterationTimeAttribute(double milliseconds) : base(Job.Default.WithMinIterationTime(TimeInterval.FromMilliseconds(milliseconds)))
{
}
/// <summary>
/// Expand simplified query
/// BOII MX,MN,MM
/// is translated to
/// BOII MX, BOII MN, BOII MM
///
/// GREY
/// is translated to
/// GREY GH, GREY Q
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public static string ExpandQuery(string query, TimeInterval db)
{
var rval = new List <string>();
string title = "";
var idx = query.IndexOf("#");
if (idx >= 0)
{
title = query.Substring(idx);
query = query.Substring(0, idx);
}
query = query.Trim();
if (CbttOnly(query))
{
string[] pcodes = GetParameters(query, db);
if (pcodes.Length > 0)
{
query = query + " " + String.Join(",", pcodes);
// return query;
}
}
string[] pairs = query.Split(',');
string cbtt = "";
var pc = "";
for (int i = 0; i < pairs.Length; i++)
{
string s = pairs[i];
s = s.Replace(": ", ":");
var tokens = s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (i == 0 && tokens.Length != 2)
{
Logger.WriteLine("query syntax Error: first pair must have cbtt and pcode");
return(query);
}
if (tokens.Length == 2)
{
cbtt = tokens[0];
pc = tokens[1];
}
else if (tokens.Length == 1)
{
pc = tokens[0];
}
else if (tokens.Length == 0)
{
continue;
}
rval.Add(cbtt + " " + pc);
}
string r = String.Join(",", rval.ToArray());
if (r.Trim() != query.Trim())
{
Logger.WriteLine("query expanded to '" + r + "'");
}
return(r + title);
}
private void PrintHtmlInventory(string siteID, TimeInterval interval, bool ui)
{
var parms = db.GetParameters(siteID, interval);
var desc = db.GetSiteDescription(siteID);
WriteLine("<!DOCTYPE html>");
WriteLine("<html>");
DataTable tbl = new DataTable();
tbl.Columns.Add("parameter");
tbl.Columns.Add("available records");
tbl.Columns.Add("description");
int firstYear = DateTime.Now.Year;
int minYr = 0, maxYr = 0;
int min = 0, max = 0;
for (int i = 0; i < parms.Length; i++)
{
string por = db.GetPeriodOfRecord(siteID, parms[i], interval, out minYr, out maxYr);
if (i == 0)
{
min = minYr;
max = maxYr;
}
if (minYr < min)
{
min = minYr;
}
if (maxYr > max)
{
max = maxYr;
}
if (ui)
{
var cb = " <input type=\"checkbox\" name=\"pcode\" value=\"" + parms[i] + "\" id=\"" + parms[i] + "\">" + parms[i].ToUpper();
tbl.Rows.Add(cb, db.GetParameterDescription(parms[i], interval), por);
}
else
{
tbl.Rows.Add(parms[i], db.GetParameterDescription(parms[i], interval), por);
}
}
if (ui)
{
string cgiTag = "";
if (CgiUtility.IsRemoteRequest())
{
cgiTag = ".pl";
}
if (interval == TimeInterval.Daily)
{
WriteLine("<form name=\"Form\" action=\"/pn-bin/daily" + cgiTag + "\" method=\"get\" >");
}
else
{
WriteLine("<form name=\"Form\" action=\"/pn-bin/instant" + cgiTag + "\" method=\"get\" >");
}
WriteLine("<input name=station type=\"hidden\" value=\"" + siteID + "\">");
WriteLine("<input name=format type=\"hidden\" value=\"html\">");
WriteTimeSelector(siteID, min, max);
}
var s = DataTableOutput.ToHTML(tbl, false, desc);
WriteLine(s);
WriteLine("<p><input type=\"submit\" value=\"Retrieve Daily Data\">");
if (ui)
{
WriteLine("</form>");
}
//WriteLine("<\\html>");
}
public void SetWorkingHours(TimeInterval hours)
{
throw new NotImplementedException();
}
/// <summary> /// Minimum time of a single iteration. Unlike Run.IterationTime, this characteristic specifies only the lower limit. In case of need, BenchmarkDotNet can increase this value. /// The default value is 500 milliseconds. /// </summary> public static Job WithMinIterationTime(this Job job, TimeInterval value) => job.WithCore(j => j.Accuracy.MinIterationTime = value);
public void SetAnnualLeave(TimeInterval period)
{
throw new NotImplementedException();
}
/// <summary> /// Desired time of execution of an iteration. Used by Pilot stage to estimate the number of invocations per iteration. /// The default value is 500 milliseconds. /// </summary> public static Job WithIterationTime(this Job job, TimeInterval time) => job.WithCore(j => j.Run.IterationTime = time);
public void RunActions(TimeInterval gt)
{
}
public BlockingConstraintModel()
{
ForTimeInterval = new TimeInterval();
ForPeriodicTimeInterval = new PeriodicTimeIntervalModel();
}
private static bool InCache(DataTable tbl, string key, DateTime t1, DateTime t2, TimeInterval interval)
{
int idx = tbl.Columns.IndexOf(key);
if (idx < 0)
{
return(false);
}
if (tbl.Rows.Count == 0)
{
return(false);
}
DateTime tMin = (DateTime)tbl.Rows[0][0];
DateTime tMax = (DateTime)tbl.Rows[tbl.Rows.Count - 1][0];
if (interval == TimeInterval.Monthly)
{
tMin = tMin.FirstOfMonth();
tMax = tMax.EndOfMonth();
}
if (interval == TimeInterval.Irregular)
{ // hydromet/agrimet data comes in once per hour..
// loosen tolerence to corespond
tMin = tMin.AddHours(-1);
tMax = tMax.AddHours(1);
}
return((t1 >= tMin && t1 <= tMax) &&
(t2 >= tMin && t2 <= tMax));
}
/// <summary>
/// Receiver for the combined VAD signal and audio data.
/// </summary>
/// <param name="data">A message containing the combined VAD signal and audio data.</param>
/// <param name="e">The message envelope</param>
/// <returns>The <see cref="Task"/> representing the asynchronous operation.</returns>
protected override async Task ReceiveAsync(ValueTuple <AudioBuffer, bool> data, Envelope e)
{
byte[] audioData = data.Item1.Data;
bool hasSpeech = data.Item2;
this.lastAudioOriginatingTime = e.OriginatingTime;
// Throw if a fatal error has occurred in the OnConversationError event handler
if (this.fatalError)
{
if (this.conversationError != null)
{
var error = this.conversationError;
this.conversationError = null;
throw error;
}
// Stop processing until the pipeline terminates
return;
}
if (hasSpeech || this.lastAudioContainedSpeech)
{
// Send the audio data to the cloud
await this.speechRecognitionClient.SendAudioAsync(audioData, this.cancellationTokenSource.Token);
// Add audio to the current utterance queue so we can reconstruct it in the recognition result later
this.currentQueue.Enqueue(data.DeepClone(this.In.Recycler));
}
// If this is the last audio packet containing speech
if (!hasSpeech && this.lastAudioContainedSpeech)
{
this.lastVADSpeechEndTime = e.OriginatingTime;
this.lastVADSpeechTimeInterval = new TimeInterval(this.lastVADSpeechStartTime, this.lastVADSpeechEndTime);
// Allocate a buffer large enough to hold the buffered audio
BufferWriter bw = new BufferWriter(this.currentQueue.Sum(b => b.Item1.Length));
// Get the audio associated with the recognized text from the current queue.
ValueTuple <AudioBuffer, bool> buffer;
while (this.currentQueue.TryDequeue(out buffer))
{
bw.Write(buffer.Item1.Data);
// We are done with this buffer so enqueue it for recycling
this.In.Recycle(buffer);
}
// Save the buffered audio
this.lastAudioBuffer = bw.Buffer;
// Call EndAudio to signal that this is the last packet
await this.speechRecognitionClient.SendEndAudioAsync(this.cancellationTokenSource.Token);
}
else if (hasSpeech && !this.lastAudioContainedSpeech)
{
// If this is the first audio packet containing speech
this.lastVADSpeechStartTime = e.OriginatingTime;
// Also post a null partial recognition result
this.lastPartialResult = string.Empty;
this.OutputResult(this.BuildPartialSpeechRecognitionResult(this.lastPartialResult), e.OriginatingTime);
}
// Remember last audio state.
this.lastAudioContainedSpeech = hasSpeech;
}
public RecentDataFormatter(TimeInterval interval, bool printFlags) : base(interval, printFlags)
{
}
