public CustomDataRef(Type instanceType, IConversionRouter router, ICustomData instance)
{
_instanceType = instanceType;
_router = router;
_typeId = router.TypeIdentifier;
_instance = instance;
}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return(ValueConverter <RationalValue> .Router.CanConvertLosslessFrom(value));
}
//public static UndefinedSymbol ConvertFrom(IValueStructure value)
//{
// return Instance;
//}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return(ValueConverter <UndefinedSymbol> .Router.CanConvertLosslessFrom(value));
}
public static ComplexValue ConvertFrom(ICustomData value)
{
return((ComplexValue)ValueConverter <ComplexValue> .ConvertFrom(value));
}
private ICustomData <double, bool> CreateAndFillCross(HistoricalData currentData, ICustomData <double, double> a, ReferenceSeries b, CrossDirection direction)
{
CrossDataSeries.Insert(0, new CROSS(a, b.Name, direction));
(CrossDataSeries[0] as DataSeries <double, bool>).GetHistoricalData(currentData);
FillCross(currentData, a);
CrossDataSeries[0].GetValue(b.Value);
return(CrossDataSeries[0]);
}
private ICustomData <double, double> ExtremumSince(int offset, Func <double, int, bool> callback, ICustomData <double, double> searchData, EXTREMUM type)
{
var allNumericSeries = DataSeriesManager.getAllNumericSerries();
var name = type == EXTREMUM.High ? $"highestSince{searchData.Name}{offset}" : $"lowestSince{searchData.Name}{offset}";
var indexOfRequiredHighest = allNumericSeries.FindIndex(x => x.Name == name);
if (indexOfRequiredHighest != -1)
{
var index = allNumericSeries.FindIndex(x => x.Name == searchData.Name);
if (index != -1)
{
for (int i = 0; i < HistoryDataSeries.Count - 1; i++)
{
if (Convert.ToBoolean(callback(allNumericSeries[index].GetValueByIndex(i), i)))
{
allNumericSeries[indexOfRequiredHighest].GetValue(i);
break;
}
}
}
return(allNumericSeries[indexOfRequiredHighest] as CUSTOM);
}
else
{
return(AddCustom(name, (value) =>
{
var index = allNumericSeries.FindIndex(x => x.Name == searchData.Name);
if (index != -1)
{
var result = allNumericSeries[index].GetValueByIndex(0);
for (int j = 0; j < value; j++)
{
result = type == EXTREMUM.High ? allNumericSeries[index].GetValueByIndex(j) > result ? allNumericSeries[index].GetValueByIndex(j) : result
: allNumericSeries[index].GetValueByIndex(j) < result ? allNumericSeries[index].GetValueByIndex(j) : result;
}
return result;
}
return 0D;
}));
}
}
public static LiteralValue ConvertFrom(ICustomData value)
{
return((LiteralValue)ValueConverter <LiteralValue> .ConvertFrom(value));
}
public static ToggleValue ConvertFrom(ICustomData value)
{
return((ToggleValue)ValueConverter <ToggleValue> .ConvertFrom(value));
}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return ValueConverter<ToggleValue>.Router.CanConvertLosslessFrom(value);
}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return(_router.CanConvertLosslessFrom(value));
}
//// Explicit static constructor to tell C# compiler
//// not to mark type as beforefieldinit
//static ValueConverter()
//{
//}
public static TTarget ConvertFrom(ICustomData value)
{
return((TTarget)_router.ConvertFrom(value));
}
public CROSS(ICustomData <double, double> series, string refName, CrossDirection direction)
: base(direction == CrossDirection.Down? series.Name + "CROSS" + refName: refName + "CROSS" + series.Name)
{
Series = series;
Direction = direction;
}
private IFlyweightShape<SignalShape> GetFlyweightForSignal(ICustomData value)
{
IFlyweightShape<SignalShape> ret;
if(value != null && _signalFlies.TryGetValue(value.TypeId, out ret))
return ret;
return _defaultSignalFly;
}
private IFlyweightShape<BusShape> GetFlyweightForBus(ICustomData value)
{
IFlyweightShape<BusShape> ret;
if(value != null && _busFlies.TryGetValue(value.TypeId, out ret))
return ret;
return _defaultBusFly;
}
public static ACustomDataValue setValue(ACustomDataValue[] data, string key, object value, ICustomData obj)
{
if (!customFieldExists(data, key))
{
if (value is int)
{
createIntField(data, obj, key);
}
else if (value is string)
{
createStringField(data, obj, key);
}
}
ACustomDataValue cdv = data.Where(x => x.key == key).First();
cdv.setValue(value);
cdv.Save( );
return(cdv);
}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return(ValueConverter <ComplexInfinitySymbol> .Router.CanConvertLosslessFrom(value));
}
public static VectorValue <TScalar> ConvertFrom(ICustomData value)
{
return((VectorValue <TScalar>) ValueConverter <VectorValue <TScalar> > .ConvertFrom(value));
}
public static bool CanConvertLosslessFrom(ICustomData value)
{
return(ValueConverter <VectorValue <TScalar> > .Router.CanConvertLosslessFrom(value));
}
public static LogicValue ConvertFrom(ICustomData value)
{
return((LogicValue)ValueConverter <LogicValue> .ConvertFrom(value));
}
public ICustomData <double, bool> Cross(ReferenceSeries b, ICustomData <double, double> a)
{
var result = DataSeriesManager.CreateOrUpdateCross(HistoryDataSeries, a, b, CrossDirection.Up);
return(result);
}
public RewardGetter(ICustomData customData)
{
_customData = customData;
}
public CUSTOM LowestSince(int b, Func <double, int, bool> callback, ICustomData <double, double> a)
{
return(ExtremumSince(b, callback, a, EXTREMUM.Low) as CUSTOM);
}
public bool CanConvertLosslessFrom(ICustomData value)
{
return value != null && CanConvertFrom(value.TypeId, false);
}
public ICustomData <double, bool> CreateOrUpdateCross(HistoricalData currentData, ICustomData <double, double> a, ReferenceSeries b, CrossDirection direction)
{
ICustomData <double, bool> result;
string name = direction == CrossDirection.Down ? a.Name + CrossPartialName + b.Name : b.Name + CrossPartialName + a.Name;
int findResult = CrossDataSeries.FindIndex(x => x.Name == name);
if (findResult != -1)
{
CrossDataSeries[findResult].GetValue(b.Value);
result = CrossDataSeries[findResult];
}
else
{
result = CreateAndFillCross(currentData, a, b, direction);
}
return(result);
}
public bool CanConvertLossyFrom(ICustomData value)
{
return value != null && CanConvertFrom(value.TypeId, true);
}
public bool CanConvertLossyFrom(ICustomData value)
{
return(value != null && CanConvertFrom(value.TypeId, true));
}
public object ConvertFrom(ICustomData value)
{
MathIdentifier id = value.TypeId;
if(structureId.Equals(id))
return value;
IRouteDistance cd;
if(vector.TryGetValue(id,out cd))
return cd.Convert(value);
throw new NotSupportedException("no route available to convert from " + id.ToString());
//throw new MathNet.Symbolics.Backend.Exceptions.IncompatibleStructureException(id.Label, id.Domain);
}
public static RationalValue ConvertFrom(ICustomData value)
{
return((RationalValue)ValueConverter <RationalValue> .ConvertFrom(value));
}
public bool TryConvertFrom(ICustomData value, out object returnValue)
{
MathIdentifier id = value.TypeId;
if(structureId.Equals(id))
{
returnValue = value;
return true;
}
IRouteDistance cd;
if(vector.TryGetValue(id, out cd))
{
returnValue = cd.Convert(value);
return true;
}
returnValue = null;
return false;
}
public static IntegerValue ConvertFrom(ICustomData value)
{
return((IntegerValue)ValueConverter <IntegerValue> .ConvertFrom(value));
}
internal static void CopyCustomData(ICollection <ACustomDataValue> origonalCustomData, ICustomData destinationObj)
{
destinationObj.clearAllFields();
foreach (ACustomDataValue cdv in origonalCustomData)
{
switch (cdv.GetType().Name)
{
case "CustomDataValueString":
destinationObj.createStringField(cdv.key);
break;
case "CustomDataValueInt":
destinationObj.createIntField(cdv.key);
break;
default:
break;
}
destinationObj.setValue(cdv.key, cdv.getValue());
}
}
