public void TestIndexResourceObservation()
{
FhirJsonParser parser = new FhirJsonParser();
var obsResource = parser.Parse <Resource>(exampleObservationJson);
IKey cpKey = new Key("http://localhost/", "Observation", "blood-pressure", null);
IndexValue result = sutFull.IndexResource(obsResource, cpKey);
Assert.IsNotNull(result);
}
public void TestIndexResourceAppointmentComplete()
{
FhirJsonParser parser = new FhirJsonParser();
var appResource = parser.Parse <Resource>(exampleAppointmentJson);
IKey appKey = new Key("http://localhost/", "Appointment", "2docs", null);
IndexValue result = sutFull.IndexResource(appResource, appKey);
Assert.IsNotNull(result);
}
private void AddContainedResources(DomainResource resource, IndexValue parent)
{
parent.Values.AddRange(
resource.Contained.Where(c => c is DomainResource)
.Select(
c =>
{
IKey containedKey = c.ExtractKey();
return(IndexResourceRecursively(c as DomainResource, containedKey, "contained"));
}));
}
/// <inheritdoc />
public async Task Save(IndexValue indexValue)
{
using var session = _sessionFunc();
var values = indexValue.IndexValues().ToArray();
var id = (StringValue)values.First(x => x.Name == "internal_forResource").Values[0];
var resource = (StringValue)values.First(x => x.Name == "internal_resource").Values[0];
var canonicalId = (StringValue)values.First(x => x.Name == "internal_Id").Values[0];
var entry = new IndexEntry(id.Value, canonicalId.Value, resource.Value, new Dictionary <string, object>());
foreach (var value in values)
{
var array = value.Values.Where(x => x != null).Select(GetValue).ToHashSet();
var o = array.Count == 1 ? array.First() : array;
if (entry.Values.ContainsKey(value.Name))
{
var existing = entry.Values[value.Name];
switch (existing)
{
case HashSet <object> l:
switch (o)
{
case HashSet <object> list:
foreach (var item in list)
{
l.Add(item);
}
break;
default:
l.Add(o);
break;
}
entry.Values[value.Name] = l;
break;
case object x:
entry.Values[value.Name] = new HashSet <object> {
x, o
};
break;
}
}
else
{
entry.Values.Add(value.Name, o);
}
}
session.DeleteWhere <IndexEntry>(x => x.CanonicalId == canonicalId.Value);
session.Store(entry);
await session.SaveChangesAsync().ConfigureAwait(false);
}
public void TestIndexResourceCareplanWithContainedGoal()
{
FhirJsonParser parser = new FhirJsonParser();
var cpResource = parser.Parse <Resource>(carePlanWithContainedGoal);
IKey cpKey = new Key("http://localhost/", "Careplan", "f002", null);
IndexValue result = sutFull.IndexResource(cpResource, cpKey);
Assert.IsNotNull(result);
}
public void TestIndexResourcePatientComplete()
{
FhirJsonParser parser = new FhirJsonParser();
var patientResource = parser.Parse <Resource>(examplePatientJson);
IKey patientKey = new Key("http://localhost/", "Patient", "001", null);
IndexValue result = sutFull.IndexResource(patientResource, patientKey);
Assert.IsNotNull(result);
}
/// <summary>
/// Meant for mapping the root IndexValue (and all the stuff below it)
/// </summary>
/// <param name="indexValue"></param>
/// <returns>List of BsonDocuments, one for the root and one for each contained index in it.</returns>
public List <BsonDocument> MapEntry(IndexValue indexValue)
{
var result = new List <BsonDocument>();
if (indexValue.Name == "root")
{
EntryToDocument(indexValue, 0, result);
return(result);
}
throw new ArgumentException("MapEntry is only meant for mapping a root IndexValue.", nameof(indexValue));
}
protected override void OnProcessOutputSchema(MutableObject newSchema)
{
var entries = IndexValue.GetEntries(newSchema);
foreach (var entry in entries)
{
XAxisTarget.SetValue(0f, entry);
YAxisTarget.SetValue(0f, entry);
}
Router.TransmitAllSchema(newSchema);
}
public void TestIndexWithPath_x_()
{
Condition cd = new Condition();
cd.Onset = new FhirDateTime(2015, 6, 15);
IKey cdKey = new Key("http://localhost/", "Condition", "test", null);
IndexValue result = sutFull.IndexResource(cd, cdKey);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Values.Where(iv => (iv as IndexValue).Name == "onset"));
}
private static void AddMetaParts(Resource resource, IKey key, IndexValue entry)
{
entry.Values.Add(new IndexValue("internal_forResource", new StringValue(key.ToUriString())));
entry.Values.Add(new IndexValue(IndexFieldNames.RESOURCE, new StringValue(resource.TypeName)));
entry.Values.Add(
new IndexValue(IndexFieldNames.ID, new StringValue(resource.TypeName + "/" + key.ResourceId)));
entry.Values.Add(new IndexValue(IndexFieldNames.JUSTID, new StringValue(resource.Id)));
entry.Values.Add(
new IndexValue(
IndexFieldNames.SELFLINK,
new StringValue(
key.ToUriString()))); //CK TODO: This is actually Mongo-specific. Move it to Spark.Mongo, but then you will have to communicate the key to the MongoIndexMapper.
}
private object Escape(IndexValue value)
{
var stringValue = value.ValueAsString;
if (stringValue == null)
{
return(value);
}
if (stringValue.Length == 0 || _escaperRegex.IsMatch(stringValue))
{
return($"'{stringValue}'");
}
return(stringValue);
}
/// <summary>
/// Chen and Guevara 77
/// </summary>
/// <param name="numberOfPoints"></param>
/// <returns></returns>
public AttributedPointCollection SelectPointsBaesdOnCAG(int numberOfPoints)
{
int numberOfRow = this.NumberOfRows;
int numberOfColumns = this.NumberOfColumns;
IndexValue <double>[] significanceValues = new IndexValue <double> [numberOfRow * numberOfColumns];
for (int i = 1; i < numberOfRow - 1; i++)
{
for (int j = 1; j < numberOfColumns - 1; j++)
{
double first = CalculateSecondDifference(i, j, RasterDirection.EastWest);
double second = CalculateSecondDifference(i, j, RasterDirection.SouthNorth);
double third = CalculateSecondDifference(i, j, RasterDirection.NorthernWestSouthernEast);
double fourth = CalculateSecondDifference(i, j, RasterDirection.SouthernWestNorthernEast);
significanceValues[i * numberOfColumns + j] =
new IndexValue <double>(i * numberOfColumns + j, first + second + third + fourth);
}
}
IndexValue <double>[] sortedSignificanceValues = SortAlgorithm.Heapsort <IndexValue <double> >(significanceValues, SortDirection.Ascending);
AttributedPointCollection irregularPoints = new AttributedPointCollection();
for (int i = 0; i < numberOfPoints; i++)
{
int row = (int)Math.Floor((double)sortedSignificanceValues[i].Index / numberOfColumns);
int column = sortedSignificanceValues[i].Index % numberOfColumns;
irregularPoints.Add(this.GetPoint(row, column));
}
//AddBorder
irregularPoints.Add(this.LowerLeft);
irregularPoints.Add(this.LoweRight);
irregularPoints.Add(this.UpperLeft);
irregularPoints.Add(this.UppeRight);
return(irregularPoints);
}
public SossSessionStateItemCollection(string keyPrefix, int timeout)
{
this.keyPrefix = keyPrefix + "_";
countIndex = keyPrefix + ".Count";
versionIndex = keyPrefix + ".Version";
createPolicy = new CreatePolicy(TimeSpan.FromMinutes(timeout));
infinitePolicy = new CreatePolicy(TimeSpan.Zero);
namedCache = CacheFactory.GetCache("SossSessionState");
keyPrefixIndexValue = new IndexValue(this.keyPrefix);
keyPrefixInternalIndexValue = new IndexValue(keyPrefix + ".");
SyncRoot = new object();
IsSynchronized = true;
}
private void Initialize(int firstNode)
{
this.labelWeight = new List <IndexValue <double> >();
this.intendedIndexes = new List <int>();
for (int i = 0; i < this.NumberOfNodes; i++)
{
labelWeight.Add(new IndexValue <double>(firstNode, double.PositiveInfinity));
intendedIndexes.Add(i);
}
labelWeight[firstNode] = new IndexValue <double>(firstNode, 0);
}
private void EntryToDocument(IndexValue indexValue, int level, List <BsonDocument> result)
{
//Add the real values (not contained) to a document and add that to the result.
var notNestedValues = indexValue.Values.OfType <IndexValue>().Where(exp => exp.Name != "contained").ToList();
var doc = new BsonDocument(new BsonElement(InternalField.LEVEL, level));
doc.AddRange(notNestedValues.Select(IndexValueToElement));
result.Add(doc);
//Then do that recursively for all contained indexed resources.
var containedValues = indexValue.Values.OfType <IndexValue>().Where(exp => exp.Name == "contained").ToList();
foreach (var contained in containedValues)
{
EntryToDocument(contained, level + 1, result);
}
}
public IndexValue GetObjectByGuid(string id)
{
IndexValue tb = new IndexValue();
if (this.DataCatalogIndex != null)
{
var obj = this.DataCatalogIndex.IndexValueIn.Where(x => x.ObjectId == id).FirstOrDefault();
if (obj != null)
{
tb = obj;
}
else
{
tb.IndexName = id;
}
}
return(tb);
}
private BsonElement IndexValueToElement(IndexValue indexValue)
{
if (indexValue.Name == "_id")
{
indexValue.Name = "fhir_id"; //_id is reserved in Mongo for the primary key and must be unique.
}
if (indexValue.Values.Count == 1)
{
return(new BsonElement(indexValue.Name, Map(indexValue.Values[0])));
}
BsonArray values = new BsonArray();
foreach (var value in indexValue.Values)
{
values.Add(Map(value));
}
return(new BsonElement(indexValue.Name, values));
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var entries = IndexValue.GetEntries(payload.Data);
foreach (var entry in entries)
{
var location = ComputeXYPosition(IndexValue.GetValue(entry));
XAxisTarget.SetValue(location.x, entry);
YAxisTarget.SetValue(location.y, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public IndexValue GetTabela(string content)
{
IndexValue tb = new IndexValue();
if (content.Contains("finalEntity"))
{
var parentIdAr = content.Split(':');
var xname = parentIdAr[2].Replace("\"", "").Replace("\",\"disable\"", "").Replace(",disable", "");
if (this.DataCatalogIndex != null)
{
var obj = this.DataCatalogIndex.IndexValueIn.Where(x => x.ObjectId == xname).FirstOrDefault();
if (obj != null)
{
tb = obj;
}
}
}
return(tb);
}
public void TestIndexResourceSimple()
{
var patient = new Patient();
patient.Name.Add(new HumanName().WithGiven("Adriaan").AndFamily("Bestevaer"));
IKey patientKey = new Key("http://localhost/", "Patient", "001", "v02");
IndexValue result = sutLimited.IndexResource(patient, patientKey);
Assert.AreEqual("root", result.Name);
Assert.AreEqual(1, result.NonInternalValues().Count(), "Expected 1 non-internal result for searchparameter 'name'");
var first = result.NonInternalValues().First();
Assert.AreEqual("name", first.Name);
Assert.AreEqual(2, first.Values.Count);
Assert.IsInstanceOfType(first.Values[0], typeof(StringValue));
Assert.IsInstanceOfType(first.Values[1], typeof(StringValue));
}
public override SnQueryPredicate VisitRangePredicate(RangePredicate range)
{
var min = range.Min;
var max = range.Max;
var minExclusive = range.MinExclusive;
var maxExclusive = range.MaxExclusive;
IndexValue oneTerm = null;
_output.Append(range.FieldName);
_output.Append(":");
string op = null;
if (min == null)
{
op = !maxExclusive ? "<=" : "<";
oneTerm = max;
}
if (max == null)
{
op = !minExclusive ? ">=" : ">";
oneTerm = min;
}
if (op == null)
{
_output.Append(!minExclusive ? '[' : '{');
_output.Append(Escape(min));
_output.Append(" TO ");
_output.Append(Escape(max));
_output.Append(!maxExclusive ? ']' : '}');
}
else
{
_output.Append(op).Append(Escape(oneTerm));
}
BoostTostring(range.Boost);
return(base.VisitRangePredicate(range));
}
private IndexValue IndexResourceRecursively(Resource resource, IKey key, string rootPartName = "root")
{
var searchParametersForResource = _fhirModel.FindSearchParameters(resource.GetType());
if (searchParametersForResource != null)
{
var result = new IndexValue(rootPartName);
AddMetaParts(resource, key, result);
foreach (var par in searchParametersForResource)
{
var newIndexPart = new IndexValue(par.Code);
foreach (var path in par.GetPropertyPath())
{
_resourceVisitor.VisitByPath(resource,
obj =>
{
if (obj is Element)
{
newIndexPart.Values.AddRange(_elementIndexer.Map(obj as Element));
}
}
, path);
}
if (newIndexPart.Values.Any())
{
result.Values.Add(newIndexPart);
}
}
if (resource is DomainResource)
{
AddContainedResources((DomainResource)resource, result);
}
return(result);
}
return(null);
}
private static object GetValue(Expression expression)
{
return(expression switch
{
StringValue stringValue => stringValue.Value,
IndexValue indexValue => indexValue.Values.Count == 1
? GetValue(indexValue.Values[0])
: indexValue.Values.Select(GetValue).ToArray(),
CompositeValue compositeValue =>
compositeValue.Components.OfType <IndexValue>().All(x => x.Name == "code")
? compositeValue.Components.OfType <IndexValue>()
.SelectMany(x => x.Values.Select(GetValue))
.First()
: compositeValue.Components.OfType <IndexValue>()
.ToDictionary(
component => component.Name,
component =>
{
var a = component.Values.Select(GetValue).ToArray();
return a.Length == 1 ? a[0] : a;
}),
_ => expression.ToString()
});
public void TestMapRootIndexValue()
{
//"root" element should be skipped.
IndexValue iv = new IndexValue("root");
iv.Values.Add(new IndexValue("internal_resource", new StringValue("Patient")));
var results = sut.MapEntry(iv);
Assert.Single(results);
var result = results[0];
Assert.True(result.IsBsonDocument);
Assert.Equal(2, result.AsBsonDocument.ElementCount);
var firstElement = result.AsBsonDocument.GetElement(0);
Assert.Equal("internal_level", firstElement.Name);
var secondElement = result.GetElement(1);
Assert.Equal("internal_resource", secondElement.Name);
Assert.True(secondElement.Value.IsString);
Assert.Equal("Patient", secondElement.Value.AsString);
}
private string ConvertToTermValue(IndexValue value)
{
switch (value.Type)
{
case IndexValueType.String: return(value.StringValue);
case IndexValueType.StringArray: throw new NotSupportedException();
case IndexValueType.Bool: return(value.BooleanValue ? IndexValue.Yes : IndexValue.No);
case IndexValueType.Int: return(NumericUtils.IntToPrefixCoded(value.IntegerValue));
case IndexValueType.Long: return(NumericUtils.LongToPrefixCoded(value.LongValue));
case IndexValueType.Float: return(NumericUtils.FloatToPrefixCoded(value.SingleValue));
case IndexValueType.Double: return(NumericUtils.DoubleToPrefixCoded(value.DoubleValue));
case IndexValueType.DateTime: return(NumericUtils.LongToPrefixCoded(value.DateTimeValue.Ticks));
default:
throw new ArgumentOutOfRangeException();
}
}
public static List <int> GetConvexHullVertexes(PointCollection points)
{
int leftBoundIndex = points.LowerBoundIndex;
IRI.Ket.Geometry.Point initialPoint = points[leftBoundIndex];
int length = points.Count;
IndexValue <double>[] list = new IndexValue <double> [length - 1];
int counter = 0;
for (int i = 0; i < length; i++)
{
if (i == leftBoundIndex)
{
continue;
}
list[counter] = new IndexValue <double>(i,
Math.Atan2(points[i].Y - initialPoint.Y,
points[i].X - initialPoint.X));
counter++;
}
list = SortAlgorithm.Heapsort <IndexValue <double> >(list, SortDirection.Descending);
List <int> result = new List <int>();
result.Add(leftBoundIndex);
counter = 0;
while (counter < list.Length)
{
IRI.Ket.Geometry.Point tempPoint = points[list[counter].Index];
if (result.Count < 2)
{
result.Add(list[counter].Index);
counter++;
continue;
}
PointVectorRelation pointSituation = GetPointVectorRelation(tempPoint,
points[result[result.Count - 2]],
points[result[result.Count - 1]]);
if (pointSituation == PointVectorRelation.LiesLeft)
{
result.Add(list[counter].Index);
counter++;
}
else if (pointSituation == PointVectorRelation.LiesRight)
{
result.RemoveAt(result.Count - 1);
}
else
{
if (list[counter].Value == list[0].Value &&
CalculateDistance(initialPoint, tempPoint) > CalculateDistance(initialPoint, points[result[result.Count - 1]]))
{
result.Add(list[counter].Index);
counter++;
}
else if (list[counter].Value == list[length - 2].Value &&
CalculateDistance(initialPoint, tempPoint) < CalculateDistance(initialPoint, points[result[result.Count - 1]]))
{
result.Add(list[counter].Index);
counter++;
}
else
{
result.RemoveAt(result.Count - 1);
}
}
}
return(result);
}
public static PointCollection CreateConvexHull(PointCollection points)
{
int leftBoundIndex = points.LowerBoundIndex;
IRI.Ket.Geometry.Point initialPoint = points[leftBoundIndex];
int length = points.Count;
IndexValue <double>[] unsortedPoints = new IndexValue <double> [length - 1];
int counter = 0;
for (int i = 0; i < length; i++)
{
if (i == leftBoundIndex)
{
continue;
}
unsortedPoints[counter] = new IndexValue <double>(i,
Math.Atan2(points[i].Y - initialPoint.Y,
points[i].X - initialPoint.X));
counter++;
}
IndexValue <double>[] sortedPoints = SortAlgorithm.Heapsort <IndexValue <double> >(unsortedPoints, SortDirection.Descending);
IRI.Ket.Geometry.PointCollection result = new IRI.Ket.Geometry.PointCollection();
result.Add(points[leftBoundIndex]);
counter = 0;
while (counter < sortedPoints.Length)
{
IRI.Ket.Geometry.Point tempPoint = points[sortedPoints[counter].Index];
if (result.Count < 2)
{
result.Add(tempPoint);
counter++;
continue;
}
PointVectorRelation pointSituation = GetPointVectorRelation(tempPoint, result[result.Count - 2], result[result.Count - 1]);
if (pointSituation == PointVectorRelation.LiesLeft)
{
result.Add(tempPoint);
counter++;
}
else if (pointSituation == PointVectorRelation.LiesRight)
{
result.RemoveAt(result.Count - 1);
}
else
{
if (sortedPoints[counter].Value == sortedPoints[0].Value)
{
if (CalculateDistance(initialPoint, tempPoint) > CalculateDistance(initialPoint, result[result.Count - 1]))
{
result.Add(tempPoint);
}
counter++;
}
else if (sortedPoints[counter].Value == sortedPoints[length - 2].Value)
{
if (CalculateDistance(initialPoint, tempPoint) < CalculateDistance(initialPoint, result[result.Count - 1]))
{
result.Add(tempPoint);
}
counter++;
}
else
{
result.RemoveAt(result.Count - 1);
}
}
}
return(result);
}
public static void ED(string inputFileName, string queryFileName, int queryLength)
{
FileStream fp = null;
FileStream qp = null;
double[] Q = null; // query array
double[] T = null; // array of current data
long[] order; // ordering of query by |z(q_i)|
double bsf; // best-so-far
int m; // length of query
long loc = 0; // answer: location of the best-so-far match
double d;
int i, j;
double ex, ex2, mean, std;
double t1, t2;
t1 = DateTime.Now.Ticks;
bsf = double.PositiveInfinity;
i = 0;
j = 0;
ex = ex2 = 0;
try
{
using (qp = File.OpenRead(queryFileName))
{
m = queryLength;
// Array for keeping the query data
Q = new double[m];
// Read the query data from input file and calculate its statistic such as mean, std
using (TextReader reader = new StreamReader(qp))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string[] strs = line.Split(' ');
for (int k = 0; k < strs.Length && i < m; k++)
{
if (String.IsNullOrEmpty(strs[k]))
{
continue;
}
d = double.Parse(strs[k]);
ex += d;
ex2 += d * d;
Q[i] = d;
i++;
}
}
}
mean = ex / m;
std = ex2 / m;
std = (double)Math.Sqrt(std - mean * mean);
}
// Do z_normalixation on query data
for (i = 0; i < m; i++)
{
Q[i] = (Q[i] - mean) / std;
}
// Array for keeping the query data
order = new long[m]; // (double *)malloc(sizeof(double)*m);
IndexValue[] Q_tmp = new IndexValue[m];
for (i = 0; i < m; i++)
{
Q_tmp[i].Value = Q[i];
Q_tmp[i].Index = i;
}
// Sort the query data
Array.Sort(Q_tmp, Comp);
for (i = 0; i < m; i++)
{
Q[i] = Q_tmp[i].Value;
order[i] = Q_tmp[i].Index;
}
// Array for keeping the current data; Twice the size for removing modulo (circulation) in distance calculation
T = new double[2 * m]; //(double *)malloc(sizeof(double)*2*m);
double dist = 0;
i = 0;
j = 0;
ex = ex2 = 0;
using (fp = File.OpenRead(inputFileName))
{
// Read data file, one row at a time
using (TextReader reader = new StreamReader(fp))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string[] strs = line.Split(' ');
for (int k = 0; k < strs.Length; k++)
{
if (String.IsNullOrEmpty(strs[k]))
{
continue;
}
d = double.Parse(strs[k]);
ex += d;
ex2 += d * d;
T[i % m] = d;
T[(i % m) + m] = d;
// If there is enough data in T, the ED distance can be calculated
if (i >= m - 1)
{
// the current starting location of T
j = (i + 1) % m;
// Z_norm(T[i]) will be calculated on the fly
mean = ex / m;
std = ex2 / m;
std = (double)Math.Sqrt(std - mean * mean);
// Calculate ED distance
dist = distance(Q, T, j, m, mean, std, order, bsf);
if (dist < bsf)
{
bsf = dist;
loc = i - m + 1;
}
ex -= T[j];
ex2 -= T[j] * T[j];
}
i++;
}
}
}
}
t2 = DateTime.Now.Ticks;
Console.WriteLine("Location : " + loc);
Console.WriteLine("Distance : " + Math.Sqrt(bsf));
Console.WriteLine("Data Scanned : " + i);
Console.WriteLine("Total Execution Time : " + (t2 - t1) / TimeSpan.TicksPerSecond + " sec");
}
catch (OutOfMemoryException)
{
error_ed(1);
}
catch (FileNotFoundException)
{
error_ed(2);
}
catch (Exception)
{
Environment.Exit(2);
}
}
/// Comparison function for sorting the query.
/// The query will be sorted by absolute z-normalization value, |z_norm(Q[i])| from high to low.
private static int Comp(IndexValue a, IndexValue b)
{
return(Convert.ToInt16(Math.Abs(b.Value) - Math.Abs(a.Value)));
}
private bool IsWildcardPredicate(IndexField field, IndexValue predicationValue)
{
return(predicationValue.Type == IndexValueType.String && field.Type == IndexValueType.String &&
(predicationValue.StringValue.Contains("*") || predicationValue.StringValue.Contains("?")));
}
