public virtual void TestBasicPhaseAsMR2009()
{
GeneralTimingSpecification gts = new GeneralTimingSpecification(IntervalFactory.CreateLowHigh <PlatformDate>(DateUtil.GetDate
(1969, 11, 31), DateUtil.GetDate(1969, 11, 31)), PeriodicIntervalTime.CreatePhase(IntervalFactory.CreateLowHigh <PlatformDate
>(DateUtil.GetDate(1969, 11, 31), DateUtil.GetDate(1969, 11, 31))));
string result = new GtsBoundedPivlFormatter().Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl
(this.result, null, "name", "GTS.BOUNDEDPIVL", null, null, false, SpecificationVersion.R02_04_02, null, null, null, false
), new GTSImpl(gts));
AssertXml("result", "<name specializationType=\"GTS.BOUNDEDPIVL\" xsi:type=\"SXPR_TS\">" + "<comp specializationType=\"IVL_TS.FULLDATE\" xsi:type=\"IVL_TS\">"
+ "<low value=\"19691231\"/>" + "<high value=\"19691231\"/></comp>" + "<comp operator=\"I\" specializationType=\"PIVL_TS.DATETIME\" xsi:type=\"PIVL_TS\">"
+ "<phase><low value=\"19691231\"/><high value=\"19691231\"/></phase></comp></name>", result);
Assert.IsTrue(this.result.IsValid());
}
public virtual void TestBasicFreqAsCeRx()
{
GeneralTimingSpecification gts = new GeneralTimingSpecification(IntervalFactory.CreateLowWidth <PlatformDate>(DateUtil.GetDate
(1969, 11, 31), new DateDiff(CreateQuantity("3", Ca.Infoway.Messagebuilder.Domainvalue.Basic.DefaultTimeUnit.DAY))), PeriodicIntervalTime
.CreateFrequency(3, CreateQuantity("3", Ca.Infoway.Messagebuilder.Domainvalue.Basic.DefaultTimeUnit.DAY)));
string result = new GtsBoundedPivlFormatter().Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl
(this.result, null, "name", "GTS.BOUNDEDPIVL", null, null, false, SpecificationVersion.V01R04_3, null, null, null, false
), new GTSImpl(gts));
AssertXml("result", "<name xsi:type=\"SXPR_TS\">" + "<comp operator=\"I\" xsi:type=\"IVL_TS\">" + "<low value=\"19691231\"/>"
+ "<width unit=\"d\" value=\"3\"/></comp>" + "<comp xsi:type=\"PIVL_TS\">" + "<frequency><numerator value=\"3\"/>" + "<denominator unit=\"d\" value=\"3\"/>"
+ "</frequency></comp></name>", result);
Assert.IsTrue(this.result.IsValid());
}
private SenderValueHolder PopulateSender()
{
SenderValueHolder sender = new SenderValueHolder();
sender.SetTelecom(new TelecommunicationAddress(Ca.Infoway.Messagebuilder.Domainvalue.Basic.URLScheme.HTTP, "192.168.2.2")
);
sender.SetDeviceId(new Identifier("1.1.4", "ext4"));
sender.SetDeviceManufacturerModelName("1.0");
sender.SetDeviceSoftwareName("MBT Pharmacy");
sender.SetDeviceDesc("Configuration information");
sender.SetDeviceName("Sending Application Name");
sender.SetDeviceExistenceTime(IntervalFactory.CreateLow <PlatformDate>(new PlatformDate()));
sender.SetDeviceAgentAgentOrganizationId(new Identifier("1.1.5", "ext5"));
return(sender);
}
public virtual void TestFormatValueNonNullWithValidTime()
{
PlatformDate lowDate = new DateWithPattern(DateUtil.GetDate(2006, 11, 25), "yyyyMMdd");
PlatformDate highDate = new DateWithPattern(DateUtil.GetDate(2014, 3, 12), "yyyyMMdd");
Interval <PlatformDate> validTime = IntervalFactory.CreateLowHigh(lowDate, highDate);
EnR2PropertyFormatter formatter = new EnR2PropertyFormatter();
TrivialName trivialName = new TrivialName("something");
trivialName.ValidTime = validTime;
string result = formatter.Format(GetContext("name", "TN"), new TNImpl(trivialName));
Assert.IsTrue(this.result.IsValid());
AssertXml("something in text node", "<name>something<validTime><low value=\"20061225\"/><high value=\"20140412\"/></validTime></name>"
, result, true);
}
private TriggerEvent <ImmunizationQueryParameters> CreateControlActEvent()
{
TriggerEvent <ImmunizationQueryParameters> controlActEvent = new TriggerEvent <ImmunizationQueryParameters>();
controlActEvent.Code = HL7TriggerEventCode.IMMUNIZATION_QUERY;
controlActEvent.Id = new Identifier(Guid.NewGuid().ToString());
controlActEvent.EffectiveTime = IntervalFactory.CreateLow(new PlatformDate());
controlActEvent.RecordTargetPatient1 = this.CreateRecordTarget();
controlActEvent.Author = this.CreateAuthor_1();
controlActEvent.DataEntryLocationServiceDeliveryLocation = this.CreateServiceLocation2();
return(controlActEvent);
}
public async Task <ICollection <BollingerBandsDataPoint> > BollingerBands(ExchangeEnum exchange, SymbolCodeEnum symbolCode, IntervalKey intervalKey, Epoch from, int dataPoints, CandleTypeEnum candleType, int period, MovingAverageTypeEnum maType, double stdDevUp, double stdDevDown)
{
var maTypeConverted = maType.ToTaLib();
var periodOffset = period - 1;
var fromOffset = IntervalFactory.GetInterval(intervalKey, from, periodOffset * -1);
var aggValues = await MarketRepository.GetTradeAggregates(exchange, symbolCode, intervalKey, fromOffset.From, periodOffset + dataPoints);
var values = aggValues.GetValues(candleType);
int outBegIdx, outNbElement;
var upperBandValues = new double[dataPoints];
var middleBandValues = new double[dataPoints];
var lowerBandValues = new double[dataPoints];
var retCode = Bbands(0, values.Length - 1, values, period, stdDevUp, stdDevDown, maTypeConverted, out outBegIdx, out outNbElement, upperBandValues, middleBandValues, lowerBandValues);
var validUpperBandValues = upperBandValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validMiddleBandValues = middleBandValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validLowerBandValues = lowerBandValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validAggValues = aggValues.Skip(aggValues.Count - dataPoints).Take(dataPoints).ToArray();
if (retCode == RetCode.Success)
{
var dp = new List <BollingerBandsDataPoint>();
for (var i = 0; i < validAggValues.Length; i++)
{
var agg = validAggValues[i];
dp.Add(new BollingerBandsDataPoint
{
Epoch = agg.Epoch,
Upper = upperBandValues[i],
Middle = middleBandValues[i],
Lower = lowerBandValues[i]
});
}
return(dp);
}
throw new Exception("Unable to calculate Bollinger Bands - " + retCode);
}
public async Task <ICollection <StochasticDataPoint> > Stochastic(ExchangeEnum exchange, SymbolCodeEnum symbolCode, IntervalKey intervalKey, Epoch from, int dataPoints, MovingAverageTypeEnum kMaType, int kFastPeriod, int kSlowPeriod, MovingAverageTypeEnum dMaType, int dSlowPeriod)
{
var dMaTypeConverted = dMaType.ToTaLib();
var kMaTypeConverted = kMaType.ToTaLib();
var periodOffset = kSlowPeriod + 1;
var fromOffset = IntervalFactory.GetInterval(intervalKey, from, periodOffset * -1);
var aggValues = await MarketRepository.GetTradeAggregates(exchange, symbolCode, intervalKey, fromOffset.From, periodOffset + dataPoints);
var highPoints = aggValues.GetValues(CandleTypeEnum.High);
var lowPoints = aggValues.GetValues(CandleTypeEnum.Low);
var closePoints = aggValues.GetValues(CandleTypeEnum.Close);
int outBegIdx, outNbElement;
var kValues = new double[dataPoints];
var dValues = new double[dataPoints];
var retCode = Stoch(0, closePoints.Length - 1, highPoints, lowPoints, closePoints, kFastPeriod, kSlowPeriod, kMaTypeConverted, dSlowPeriod, dMaTypeConverted, out outBegIdx, out outNbElement, kValues, dValues);
var validKValues = kValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validDValues = dValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validAggValues = aggValues.Skip(aggValues.Count - dataPoints).Take(dataPoints).ToArray();
if (retCode == RetCode.Success)
{
var dp = new List <StochasticDataPoint>();
for (var i = 0; i < validAggValues.Length; i++)
{
var agg = validAggValues[i];
dp.Add(new StochasticDataPoint
{
Epoch = agg.Epoch,
D = validKValues[i],
K = validDValues[i],
});
}
return(dp);
}
throw new Exception("Unable to calculate Stochastic - " + retCode);
}
public virtual void TestBasicAbstract()
{
Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(ParseDate("2006-12-25"), ParseDate("2007-01-02"
));
IVLImpl <QTY <PlatformDate>, Interval <PlatformDate> > hl7DataType = new IVLImpl <QTY <PlatformDate>, Interval <PlatformDate> >(interval
);
hl7DataType.DataType = StandardDataType.IVL_FULL_DATE;
string result = this.formatter.Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl(this.result
, null, "name", "IVL<TS.FULLDATEWITHTIME>", Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.POPULATED, null, false, SpecificationVersion
.R02_04_03, null, null, null, false), hl7DataType);
Assert.IsTrue(this.result.IsValid());
AssertXml("result", "<name specializationType=\"IVL_TS.FULLDATE\" xsi:type=\"IVL_TS\"><low value=\"20061225\"/><high value=\"20070102\"/></name>"
, result);
}
public virtual void TestEivlTsFull()
{
PhysicalQuantity low = new PhysicalQuantity(new BigDecimal("120"), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive
.CENTIMETRE);
PhysicalQuantity high = new PhysicalQuantity(new BigDecimal("170"), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive
.CENTIMETRE);
Interval <PhysicalQuantity> ivl = IntervalFactory.CreateLowHigh(low, high);
TimingEvent timingEvent = Ca.Infoway.Messagebuilder.Domainvalue.Basic.TimingEvent.ACM;
EventRelatedPeriodicIntervalTime @event = new EventRelatedPeriodicIntervalTime(ivl, timingEvent);
string result = new EivlTsR2PropertyFormatter().Format(CreateContext("EIVL<TS>"), new EIVLImpl <EventRelatedPeriodicIntervalTime
>(@event));
Assert.IsTrue(this.result.IsValid());
AssertXml("xml output", "<eventRelatedPeriod><event code=\"ACM\" codeSystem=\"2.16.840.1.113883.5.139\" codeSystemName=\"TimingEvent\" displayName=\"Acm\"/><offset><low unit=\"cm\" value=\"120\"/><high unit=\"cm\" value=\"170\"/></offset></eventRelatedPeriod>"
, result, true);
}
public virtual void TestFullPivl()
{
PlatformDate lowDate = DateUtil.GetDate(1999, 0, 23);
PlatformDate lowDateWithPattern = new DateWithPattern(lowDate, "yyyyMMdd");
PlatformDate highDate = DateUtil.GetDate(2013, 4, 7);
PlatformDate highDateWithPattern = new DateWithPattern(highDate, "yyyyMMdd");
Interval <PlatformDate> phase = IntervalFactory.CreateLowHigh(lowDateWithPattern, highDateWithPattern);
PhysicalQuantity period = new PhysicalQuantity(new BigDecimal(11), Ca.Infoway.Messagebuilder.Domainvalue.Basic.DefaultTimeUnit
.DAY);
PeriodicIntervalTimeR2 pivl = new PeriodicIntervalTimeR2(phase, period, CalendarCycle.DAY_OF_THE_MONTH, true, null, null);
string result = new PivlTsR2PropertyFormatter().Format(GetContext("periodicInterval", "PIVL<TS>"), new PIVL_R2Impl(pivl));
Assert.IsTrue(this.result.IsValid());
AssertXml("result", "<periodicInterval alignment=\"D\" institutionSpecified=\"true\"><phase><low value=\"19990123\"/><high value=\"20130507\"/></phase><period unit=\"d\" value=\"11\"/></periodicInterval>"
, result);
}
public virtual void TestBasicAbstract()
{
TimeZoneInfo timeZone = TimeZoneUtil.GetTimeZone("America/Toronto");
Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(DateUtil.GetDate(2006, 11, 25, 11, 12, 13,
0, timeZone), DateUtil.GetDate(2007, 0, 2, 10, 11, 12, 0, timeZone));
IVLImpl <QTY <PlatformDate>, Interval <PlatformDate> > hl7DataType = new IVLImpl <QTY <PlatformDate>, Interval <PlatformDate> >(interval
);
hl7DataType.DataType = StandardDataType.IVL_FULL_DATE_TIME;
string result = new IvlTsPropertyFormatter().Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl
(this.result, null, "name", "IVL<TS.FULLDATEWITHTIME>", Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.POPULATED, null,
false, SpecificationVersion.V02R02, timeZone, timeZone, null, false), hl7DataType);
Assert.IsTrue(this.result.IsValid());
AssertXml("result", "<name specializationType=\"IVL_TS.FULLDATETIME\" xsi:type=\"IVL_TS\"><low value=\"20061225111213.0000-0500\"/><high value=\"20070102101112.0000-0500\"/></name>"
, result);
}
public virtual void TestBasicPartTime()
{
TimeZoneInfo timeZone = TimeZoneUtil.GetTimeZone("America/Toronto");
PlatformDate lowDate = new DateWithPattern(DateUtil.GetDate(2006, 11, 25, 11, 12, 13, 0, timeZone), "yyyyMMddHHZZZZZ");
PlatformDate highDate = new DateWithPattern(DateUtil.GetDate(2007, 0, 2, 10, 11, 12, 0, timeZone), "yyyyMMddHHZZZZZ");
Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(lowDate, highDate);
DateInterval dateInterval = new DateInterval(interval);
IVL_TSImpl hl7DataType = new IVL_TSImpl(dateInterval);
hl7DataType.DataType = StandardDataType.IVL_TS;
string result = new IvlTsR2PropertyFormatter().Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl
(this.result, null, "name", "IVL<TS>", Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.POPULATED, null, false, SpecificationVersion
.V02R02, timeZone, timeZone, null, false), hl7DataType);
Assert.IsTrue(this.result.IsValid());
AssertXml("result", "<name><low value=\"2006122511-0500\"/><high value=\"2007010210-0500\"/></name>", result);
}
public static List <Interval <TPoint> > Exclude <TPoint>(
this Interval <TPoint> interval,
HashSet <TPoint> pointSet,
IComparer <TPoint> comparer)
where TPoint : notnull
{
var orderedExclusions = pointSet
.OrderBy(
key => key,
comparer: comparer)
.Where(
p => interval.Contains(
point: p,
comparer: comparer));
var lowerBound = interval.LowerBound;
var upperBound = interval.UpperBound;
var intervalList = new List <IInterval <TPoint> >();
foreach (var exclude in orderedExclusions)
{
intervalList.Add(
item: IntervalFactory
.Build(
lowerBound: lowerBound,
upperBound: new OpenUpperBound <TPoint>(
point: exclude),
comparer: comparer));
lowerBound = new OpenLowerBound <TPoint>(
point: exclude);
}
intervalList
.Add(
item: IntervalFactory
.Build(
lowerBound: lowerBound,
upperBound: upperBound,
comparer: Comparer <TPoint> .Default));
return(intervalList
.OfType <Interval <TPoint> >()
.ToList());
}
public async Task <ICollection <MacdDataPoint> > Macd(ExchangeEnum exchange, SymbolCodeEnum symbolCode, IntervalKey intervalKey, Epoch from, int dataPoints, CandleTypeEnum candleType, int fastEmaPeriod, int slowEmaPeriod, int signalPeriod)
{
var periodOffset = (slowEmaPeriod + signalPeriod) - 2;
var fromOffset = IntervalFactory.GetInterval(intervalKey, from, periodOffset * -1);
var aggValues = await MarketRepository.GetTradeAggregates(exchange, symbolCode, intervalKey, fromOffset.From, periodOffset + dataPoints);
var values = aggValues.GetValues(candleType);
int outBegIdx, outNbElement;
var macdValues = new double[dataPoints];
var signalValues = new double[dataPoints];
var histogramValues = new double[dataPoints];
var retCode = TicTacTec.TA.Library.Core.Macd(0, values.Length - 1, values, fastEmaPeriod, slowEmaPeriod, signalPeriod, out outBegIdx, out outNbElement, macdValues, signalValues, histogramValues);
var validMacdValues = macdValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validSignalValues = signalValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validHistogramValues = histogramValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validAggValues = aggValues.Skip(aggValues.Count - dataPoints).Take(dataPoints).ToArray();
if (retCode == RetCode.Success)
{
var dp = new List <MacdDataPoint>();
for (var i = 0; i < validAggValues.Length; i++)
{
var agg = validAggValues[i];
dp.Add(new MacdDataPoint
{
Epoch = agg.Epoch,
Macd = validMacdValues[i],
Signal = validSignalValues[i],
Histogram = validHistogramValues[i]
});
}
return(dp);
}
throw new Exception("Unable to calculate MACD - " + retCode);
}
protected override string FormatNonNullValue(FormatContext context, UncertainRange <PlatformDate> value, int indentLevel)
{
// convert URG to an IVL and use IVL formatter
Interval <PlatformDate> convertedInterval = IntervalFactory.CreateFromUncertainRange(value);
IVLImpl <TS, Interval <PlatformDate> > convertedHl7Interval = new IVLImpl <TS, Interval <PlatformDate> >(convertedInterval);
FormatContext ivlContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl(context.Type.Replace
("URG", "IVL"), context.IsSpecializationType(), context);
string xml = this.formatter.Format(ivlContext, convertedHl7Interval, indentLevel);
xml = ChangeAnyIvlRemnants(xml);
// inclusive attributes not allowed for URG<TS>
if (value.LowInclusive != null || value.HighInclusive != null)
{
context.GetModelToXmlResult().AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, "High/Low inclusive fields should not be set; these attributes are not allowed for "
+ context.Type + " types", context.GetPropertyPath()));
}
return(xml);
}
public static IInterval <TPoint> Intersect <TPoint>(
this Interval <TPoint> leftInterval,
Interval <TPoint> rightInterval,
IComparer <TPoint> comparer)
where TPoint : notnull
{
var lowerBoundComparer = new LowerBoundComparer <TPoint>(comparer);
var upperBoundComparer = new UpperBoundComparer <TPoint>(comparer);
return(IntervalFactory.Build(
lowerBound: lowerBoundComparer.Compare(leftInterval.LowerBound, rightInterval.LowerBound) >= 0
? leftInterval.LowerBound
: rightInterval.LowerBound,
upperBound: upperBoundComparer.Compare(leftInterval.UpperBound, rightInterval.UpperBound) <= 0
? leftInterval.UpperBound
: rightInterval.UpperBound,
comparer: comparer));
}
public void IntersectWithOpenIntervalIsOpenInterval(
int lowerBoundaryPoint,
int upperBoundaryPoint)
{
var leftInterval = IntervalFactory.Build(
new LowerOpenBoundary <int, IntComparer>(lowerBoundaryPoint),
new UpperOpenBoundary <int, IntComparer>(upperBoundaryPoint),
pointComparer: new IntComparer());
InfinityInterval <int, IntComparer> rightInterval = default;
var intersection = leftInterval.Intersect(
rightInterval,
pointComparer: new IntComparer());
Assert.Equal(
expected: leftInterval,
actual: intersection);
}
public virtual void TestIvlTs()
{
XmlToModelResult result = new XmlToModelResult();
XmlNode node = CreateNode("<ivl><low value=\"20120503\"/><high value=\"20120708\"/></ivl>");
ParseContext context = ParseContextImpl.Create("IVLTSCDAR1", null, SpecificationVersion.R02_04_03, null, null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel
.MANDATORY, Cardinality.Create("1"), null, true);
BareANY parseResult = this.parser.Parse(context, Arrays.AsList(node), result);
PlatformDate dateLow = DateUtil.GetDate(2012, 4, 3);
DateWithPattern dateWithPatternLow = new DateWithPattern(dateLow, "yyyyMMdd");
PlatformDate dateHigh = DateUtil.GetDate(2012, 6, 8);
DateWithPattern dateWithPatternHigh = new DateWithPattern(dateHigh, "yyyyMMdd");
Interval <PlatformDate> expectedIvl = IntervalFactory.CreateLowHigh((PlatformDate)dateWithPatternLow, (PlatformDate)dateWithPatternHigh
);
Assert.IsTrue(result.IsValid());
Assert.IsTrue(parseResult is IVLTSCDAR1);
DateInterval ivl = (DateInterval)parseResult.BareValue;
Assert.AreEqual(expectedIvl, ivl.Interval);
}
public virtual void TestIvlTs()
{
ModelToXmlResult result = new ModelToXmlResult();
PlatformDate dateLow = DateUtil.GetDate(2012, 4, 3);
DateWithPattern dateWithPatternLow = new DateWithPattern(dateLow, "yyyyMMdd");
PlatformDate dateHigh = DateUtil.GetDate(2012, 6, 8);
DateWithPattern dateWithPatternHigh = new DateWithPattern(dateHigh, "yyyyMMdd");
Interval <PlatformDate> ivlTs = IntervalFactory.CreateLowHigh((PlatformDate)dateWithPatternLow, (PlatformDate)dateWithPatternHigh
);
DateInterval dateInterval = new DateInterval(ivlTs);
BareANY dataType = new IVLTSCDAR1Impl(dateInterval);
FormatContext formatContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl(result, string.Empty
, "ivl", "IVLTSCDAR1", null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.MANDATORY, Cardinality.Create("1"), false, SpecificationVersion
.R02_04_03, null, null, null, null, true);
string xml = this.formatter.Format(formatContext, dataType);
Assert.IsTrue(result.IsValid());
string expected = "<ivl><low value=\"20120503\"/><high value=\"20120708\"/></ivl>";
AssertXml("pivl output", expected, xml, true);
}
public virtual void TestParseFull()
{
TimeZoneInfo timeZone = TimeZoneUtil.GetTimeZone("America/Toronto");
Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(DateUtil.GetDate(2006, 11, 25, 11, 12, 13,
0, timeZone), DateUtil.GetDate(2007, 0, 2, 10, 11, 12, 0, timeZone));
XmlNode node = CreateNode("<something code=\"BARNEY\" codeSystem=\"1.2.3.4.5\" codeSystemName=\"aCsName\" codeSystemVersion=\"aCsVersion\" displayName=\"aDisplayName\" value=\"1.2\" operator=\"P\">"
+ " some freeform text" + " <originalText>some original text</originalText>" + " <qualifier inverted=\"true\"><name code=\"cm\" codeSystem=\"1.2.3.4\"/><value code=\"normal\" codeSystem=\"2.16.840.1.113883.5.14\"/></qualifier>"
+ " <qualifier inverted=\"true\"><name code=\"M\" codeSystem=\"2.16.840.1.113883.5.1\"/><value code=\"ACT\" codeSystem=\"2.16.840.1.113883.5.6\"/></qualifier>"
+ " <translation code=\"M\" codeSystem=\"2.16.840.1.113883.5.1\" />" + " <translation code=\"F\" codeSystem=\"2.16.840.1.113883.5.1\" />"
+ " <validTime><low value=\"20061225121213.0000-0400\"/><high value=\"20070102111112.0000-0400\"/></validTime>" + "</something>"
);
HXIT <MockCharacters> ce = (HXIT <MockCharacters>) this.parser.Parse(ParseContextImpl.Create("HXIT<CE>", typeof(MockCharacters
), SpecificationVersion.V02R02, null, null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.OPTIONAL, null, null, false),
node, this.xmlResult);
Assert.IsFalse(this.xmlResult.IsValid());
Assert.AreEqual(4, this.xmlResult.GetHl7Errors().Count, "error message count");
Assert.IsNotNull(ce.Value, "main enum found");
Assert.AreEqual("BARNEY", ce.Value.GetCodeValue(), "main code");
Assert.AreEqual("1.2.3.4.5", ce.Value.GetCodeSystem(), "main code");
Assert.AreEqual("aCsName", ce.Value.CodeSystemName);
Assert.AreEqual("aCsVersion", ce.Value.CodeSystemVersion);
Assert.AreEqual("aDisplayName", ce.Value.DisplayName);
Assert.IsNull(ce.Value.Operator);
Assert.IsNull(ce.Value.Value);
Assert.IsNull(ce.Value.SimpleValue);
Assert.AreEqual("some original text", ce.Value.OriginalText.Content);
Assert.AreEqual(2, ce.Value.Translation.Count);
Assert.AreEqual(Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.MALE.CodeValue, ce.Value.Translation[0
].Code.CodeValue);
Assert.AreEqual(Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.MALE.CodeSystem, ce.Value.Translation[
0].Code.CodeSystem);
Assert.AreEqual(Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.FEMALE.CodeValue, ce.Value.Translation
[1].Code.CodeValue);
Assert.AreEqual(Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.FEMALE.CodeSystem, ce.Value.Translation
[1].Code.CodeSystem);
Assert.AreEqual(0, ce.Value.Qualifier.Count);
Assert.AreEqual(interval.Low, ce.Value.ValidTime.Low);
Assert.AreEqual(interval.High, ce.Value.ValidTime.High);
}
public async Task <ICollection <MovingAverageDataPoint> > Ema(ExchangeEnum exchange, SymbolCodeEnum symbolCode, IntervalKey intervalKey, Epoch from, int dataPoints, CandleTypeEnum candleType, int period)
{
var periodOffset = period - 1;
var fromOffset = IntervalFactory.GetInterval(intervalKey, from, periodOffset * -1);
var aggValues = await MarketRepository.GetTradeAggregates(exchange, symbolCode, intervalKey, fromOffset.From, periodOffset + dataPoints);
var values = aggValues.GetValues(candleType);
int outBegIdx, outNbElement;
var smaValues = new double[dataPoints];
var retCode = TicTacTec.TA.Library.Core.Ema(0, values.Length - 1, values, period, out outBegIdx, out outNbElement, smaValues);
var validSmaValues = smaValues.Skip(outNbElement - dataPoints).Take(dataPoints).ToArray();
var validAggValues = aggValues.Skip(aggValues.Count - dataPoints).Take(dataPoints).ToArray();
if (retCode == RetCode.Success)
{
var dp = new List <MovingAverageDataPoint>();
for (var i = 0; i < validAggValues.Length; i++)
{
var agg = validAggValues[i];
dp.Add(new MovingAverageDataPoint
{
Epoch = agg.Epoch,
Value = validSmaValues[i]
});
}
return(dp);
}
throw new Exception("Unable to calculate EMA - " + retCode);
}
public virtual string Format(FormatContext context, BareANY value, int indentLevel)
{
if (value == null)
{
return(string.Empty);
}
object bareValue = value.BareValue;
Interval <PlatformDate> innerDateInterval = null;
Interval <MbDate> innerMbDateInterval = null;
if (bareValue != null && bareValue is DateInterval)
{
DateInterval dateInterval = (DateInterval)bareValue;
HandleConstraints(context, context.GetModelToXmlResult(), context.GetPropertyPath(), dateInterval);
innerDateInterval = dateInterval.Interval;
innerMbDateInterval = IntervalFactory.CreateMbDateInterval(innerDateInterval);
}
BareANY newValue = new IVLImpl <TS, Interval <MbDate> >(typeof(Interval <object>), innerMbDateInterval, value.NullFlavor, value
.DataType);
return(actualFormatter.Format(context, newValue, indentLevel));
}
public virtual void TestPivlPhasePeriod()
{
ModelToXmlResult result = new ModelToXmlResult();
PlatformDate dateLow = DateUtil.GetDate(2012, 4, 3);
DateWithPattern dateWithPatternLow = new DateWithPattern(dateLow, "yyyyMMdd");
PlatformDate dateHigh = DateUtil.GetDate(2012, 6, 8);
DateWithPattern dateWithPatternHigh = new DateWithPattern(dateHigh, "yyyyMMdd");
Interval <PlatformDate> phase = IntervalFactory.CreateLowHigh((PlatformDate)dateWithPatternLow, (PlatformDate)dateWithPatternHigh
);
PhysicalQuantity period = new PhysicalQuantity(BigDecimal.ONE, Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive
.DAY);
PeriodicIntervalTimeR2 pivl = new PeriodicIntervalTimeR2(phase, period);
BareANY dataType = new PIVLTSCDAR1Impl(pivl);
FormatContext formatContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl(result, string.Empty
, "pivl", "PIVLTSCDAR1", null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.MANDATORY, Cardinality.Create("1"), false,
SpecificationVersion.R02_04_03, null, null, null, null, true);
string xml = this.formatter.Format(formatContext, dataType);
Assert.IsTrue(result.IsValid());
string expected = "<pivl><period unit=\"d\" value=\"1\"/><phase><low value=\"20120503\"/><high value=\"20120708\"/></phase></pivl>";
AssertXml("pivl output", expected, xml, true);
}
public virtual void TestEverythingSpecified()
{
Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(new DateWithPattern(DateUtil.GetDate(2006,
11, 25), "yyyyMMdd"), new DateWithPattern(DateUtil.GetDate(2007, 0, 2), "yyyyMMdd"));
CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>();
translation1.Code = CeRxDomainTestValues.KILOGRAM;
CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>();
translation2.Code = CeRxDomainTestValues.FLUID_OUNCE;
CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();
codedType.Code = CeRxDomainTestValues.CENTIMETRE;
codedType.CodeSystemName = "aCodeSystemName";
codedType.CodeSystemVersion = "aCodeSystemVersion";
codedType.DisplayName = "aDisplayName";
codedType.SimpleValue = "simpleValue";
codedType.Operator = SetOperator.CONVEX_HULL;
codedType.Value = BigDecimal.ONE;
codedType.Translation.Add(translation1);
codedType.Translation.Add(translation2);
codedType.Qualifier.Add(new CodeRole());
codedType.ValidTime = interval;
EncapsulatedData originalText = new EncapsulatedData();
originalText.Content = "some original text";
codedType.OriginalText = originalText;
CE_R2 <Code> ce = new CE_R2Impl <Code>(codedType);
string result = new HxitCeR2PropertyFormatter().Format(GetContext("name", "HXIT<CE>"), ce);
Assert.IsFalse(this.result.IsValid());
Assert.AreEqual(4, this.result.GetHl7Errors().Count);
AssertXml("result", "<name code=\"cm\" codeSystem=\"1.2.3.4\" codeSystemName=\"aCodeSystemName\" codeSystemVersion=\"aCodeSystemVersion\" displayName=\"aDisplayName\">"
+ "<originalText>some original text</originalText>" + "<translation code=\"kg\" codeSystem=\"1.2.3.4\"/>" + "<translation code=\"[foz_br]\" codeSystem=\"1.2.3.4\"/>"
+ "<validTime><low value=\"20061225\"/><high value=\"20070102\"/></validTime>" + "</name>", StringUtils.Trim(result), true
);
}
protected override string FormatNonNullDataType(FormatContext context, BareANY dataType, int indentLevel)
{
UncertainRange <PhysicalQuantity> value = (UncertainRange <PhysicalQuantity>)dataType.BareValue;
// convert URG to an IVL and use IVL formatter (loses any inclusive info; we'll pull that out later)
Interval <PhysicalQuantity> convertedInterval = IntervalFactory.CreateFromUncertainRange(value);
IVLImpl <PQ, Interval <PhysicalQuantity> > convertedHl7Interval = new IVLImpl <PQ, Interval <PhysicalQuantity> >(convertedInterval
);
FormatContext ivlContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl(context.Type.Replace
("URG", "IVL"), context.IsSpecializationType(), context);
string xml = this.formatter.Format(ivlContext, convertedHl7Interval, indentLevel);
xml = ChangeAnyIvlRemnants(xml);
xml = AddOriginalText(xml, dataType, indentLevel);
// add in inclusive attributes if necessary
if (value.LowInclusive != null)
{
xml = AddInclusiveAttribute(xml, "low", value.LowInclusive);
}
if (value.HighInclusive != null)
{
xml = AddInclusiveAttribute(xml, "high", value.HighInclusive);
}
return(xml);
}
public virtual BareANY Adapt(string toDataTypeName, BareANY any)
{
return(new DataTypeAdapterHelper().CopyAndReturnAdapted(any, (BareANY) new IVLImpl <TS, Interval <PlatformDate> >(), any.BareValue
!= null ? IntervalFactory.CreateLowHigh <PlatformDate>((PlatformDate)any.BareValue, (PlatformDate)any.BareValue) : null));
}
public virtual Interval <PlatformDate> GetEffectiveTimeAsInterval()
{
return(this.effectiveTime.Null ? null : IntervalFactory.CreateLow <PlatformDate>(this.effectiveTime.Value));
}
private Interval <PlatformDate> CreateSimpleValueInterval()
{
PlatformDate value = DateUtil.GetDate(2013, 11, 7);
return(IntervalFactory.CreateSimple(value));
}
public async Task SaveTradeAggregates(IStorageTransaction transaction, ExchangeEnum exchange, SymbolCodeEnum symbolCode, ICollection <MarketTrade> trades)
{
var min = trades.Min(t => t.Epoch);
var max = trades.Max(t => t.Epoch);
var expanded = new List <TradeCartesian>();
foreach (var group in IntervalFactory.ListGroups())
{
foreach (var ik in IntervalFactory.ListIntervalKeys(group.IntervalGroup))
{
foreach (var trade in trades)
{
var period = IntervalFactory.GenerateIntervals(ik, trade.Epoch, trade.Epoch).FirstOrDefault();
expanded.Add(new TradeCartesian
{
IntervalKey = period.IntervalKey,
IntervalEpoch = period.From,
Exchange = trade.Exchange,
SymbolCode = trade.SymbolCode,
Epoch = trade.Epoch,
TradeId = trade.TradeId,
Price = trade.Price,
Volume = trade.Volume,
Side = trade.Side
});
}
}
}
var context = (HistorianDbContext)transaction.GetContext();
using (var cmd = context.Database.GetDbConnection().CreateCommand())
{
cmd.Transaction = context.Database.CurrentTransaction.GetDbTransaction();
var sql = @"insert into `exchange_trade_aggregate`
(`exchange_id`,
`symbol_id`,
`interval_key`,
`timestamp`,
`open`,
`open_timestamp`,
`high`,
`low`,
`close`,
`close_timestamp`,
`buy_volume`,
`sell_volume`,
`total_volume`,
`buy_count`,
`sell_count`,
`total_count`) values ";
sql += string.Join(",\r\n", expanded.Select(t => $"(" +
$"{(int)t.Exchange}," +
$"{(int)t.SymbolCode}," +
$"'{t.IntervalKey.Key}'," +
$"{t.IntervalEpoch.TimestampMilliseconds}," +
$"{t.Price}," +
$"{t.Epoch.TimestampMilliseconds}," +
$"{t.Price}," +
$"{t.Price}," +
$"{t.Price}," +
$"{t.Epoch.TimestampMilliseconds}," +
$"{(t.Side == OrderSideEnum.Buy ? t.Volume.ToString() : "NULL")}," +
$"{(t.Side == OrderSideEnum.Sell ? t.Volume.ToString() : "NULL")}," +
$"{t.Volume}," +
$"{(t.Side == OrderSideEnum.Buy ? "1" : "NULL")}," +
$"{(t.Side == OrderSideEnum.Sell ? "1" : "NULL")}," +
$"1)"));
sql += @"
on duplicate key update
`open` = case when values(`open_timestamp`) < `open_timestamp` then values(`open`) else `open` end,
`open_timestamp` = case when values(`open_timestamp`) < `open_timestamp` then values(`open_timestamp`) else `open_timestamp` end,
`high` = case when values(`high`) > `high` then values(`high`) else `high` end,
`low` = case when values(`low`) < `low` then values(`low`) else `low` end,
`close` = case when values(`close_timestamp`) > `close_timestamp` then values(`close`) else `close` end,
`close_timestamp` = case when values(`close_timestamp`) > `close_timestamp` then values(`close_timestamp`) else `close_timestamp` end,
`buy_volume` = case when values(`buy_volume`) is not null then ifnull(`buy_volume`, 0) + values(`buy_volume`) else `buy_volume` end,
`sell_volume` = case when values(`sell_volume`) is not null then ifnull(`sell_volume`, 0) + values(`sell_volume`) else `sell_volume` end,
`total_volume` = `total_volume` + values(`total_volume`),
`buy_count` = case when values(`buy_count`) is not null then ifnull(`buy_count`, 0) + values(`buy_count`) else `buy_count` end,
`sell_count` = case when values(`sell_count`) is not null then ifnull(`sell_count`, 0) + values(`sell_count`) else `sell_count` end,
`total_count` = `total_count` + values(`total_count`)";
cmd.CommandText = sql;
await cmd.ExecuteNonQueryAsync();
}
}
public async Task SaveTradeStatAggregates(IStorageTransaction transaction, ExchangeEnum exchange, SymbolCodeEnum symbolCode, ICollection <MarketTradeStat> tradeStats)
{
var min = tradeStats.Min(t => t.Epoch);
var max = tradeStats.Max(t => t.Epoch);
var expanded = new List <TradeStatCartesian>();
foreach (var group in IntervalFactory.ListGroups())
{
foreach (var ik in IntervalFactory.ListIntervalKeys(group.IntervalGroup))
{
foreach (var tradeStat in tradeStats)
{
var period = IntervalFactory.GenerateIntervals(ik, tradeStat.Epoch, tradeStat.Epoch).FirstOrDefault();
expanded.Add(new TradeStatCartesian
{
IntervalKey = period.IntervalKey,
IntervalEpoch = period.From,
Exchange = tradeStat.Exchange,
SymbolCode = symbolCode,
StatKey = tradeStat.StatKey,
Epoch = tradeStat.Epoch,
Value = tradeStat.Value
});
}
}
}
using (var context = ContextFactory.CreateDbContext(null))
{
using (var cmd = context.Database.GetDbConnection().CreateCommand())
{
var sql = @"insert into `exchange_trade_aggregate`
(`exchange_id`,
`symbol_id`,
`interval_key`,
`timestamp`,
`open`,
`open_timestamp`,
`high`,
`low`,
`close`,
`close_timestamp`,
`total_count`) values ";
sql += string.Join(",\r\n", expanded.Select(t => $"(" +
$"{(int)t.Exchange}," +
$"{(int)t.SymbolCode}," +
$"'{t.IntervalKey.Key}'," +
$"{t.IntervalEpoch.TimestampMilliseconds}," +
$"{t.Value}," +
$"{t.Epoch.TimestampMilliseconds}," +
$"{t.Value}," +
$"{t.Value}," +
$"{t.Value}," +
$"{t.Epoch.TimestampMilliseconds}," +
$"1)"));
sql += @"
on duplicate key update
`open` = case when values(`open_timestamp`) < `open_timestamp` then values(`open`) else `open` end,
`open_timestamp` = case when values(`open_timestamp`) < `open_timestamp` then values(`open_timestamp`) else `open_timestamp` end,
`high` = case when values(`high`) > `high` then values(`high`) else `high` end,
`low` = case when values(`low`) < `low` then values(`low`) else `low` end,
`close` = case when values(`close_timestamp`) > `close_timestamp` then values(`close`) else `close` end,
`close_timestamp` = case when values(`close_timestamp`) > `close_timestamp` then values(`close_timestamp`) else `close_timestamp` end,
`total_count` = `total_count` + values(`total_count`)" ;
cmd.CommandText = sql;
await cmd.Connection.OpenAsync();
await cmd.ExecuteNonQueryAsync();
cmd.Connection.Close();
}
}
}
