public MatrixValue Function(StringValue str)
{
var m = new MatrixValue();
m[1, 1] = new ScalarValue(1);
m[1, 2] = new ScalarValue(str.Value.Length);
return m;
}
public override ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar field)
{
if (value == null)
return ScalarValue.Null;
return value;
}
public MatrixValue Function(FunctionValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
{
var numberOfMeasurements = (Int32)n.Value;
var timeBetweenMeasurements = (Int32)Math.Floor(dt.Value * 1000);
var results = new MatrixValue(numberOfMeasurements, 2);
var time = 0.0;
for (var i = 1; i <= numberOfMeasurements; i++)
{
Thread.Sleep(timeBetweenMeasurements);
var result = f.Perform(context, args);
results[i, 1] = new ScalarValue(time);
if (result is ScalarValue)
{
results[i, 2] = result as ScalarValue;
}
else if (result is MatrixValue)
{
var m = result as MatrixValue;
for (var j = 1; j <= m.Length; j++)
{
results[i, 1 + j] = m[j];
}
}
time += dt.Value;
}
return results;
}
static ScalarValue DiLog1(ScalarValue e)
{
var f = new ScalarValue(Math.PI * Math.PI / 6.0);
if (e == 0.0)
{
return f;
}
var L = e.Ln();
var ek = ScalarValue.One;
for (var k = 1; k < 250; k++)
{
var f_old = f.Clone();
ek *= e;
var df = ek * (L - 1.0 / k) / k;
f += df;
if (f == f_old)
{
return f;
}
}
throw new YAMPNotConvergedException("spence");
}
public MatrixValue Function(ScalarValue x)
{
var m = new MatrixValue();
m[1, 1] = new ScalarValue(1);
m[1, 2] = new ScalarValue(1);
return m;
}
public override ScalarValue DecodeEmptyValue(ScalarValue priorValue, Scalar field)
{
if (!field.IsOptional)
return field.DefaultValue;
return null;
}
public override byte[] EncodeValue(ScalarValue v)
{
if (v == ScalarValue.NULL)
{
return NULL_VALUE_ENCODING;
}
var buffer = new System.IO.MemoryStream();
var value_Renamed = (DecimalValue) v;
try
{
if (Math.Abs(value_Renamed.exponent) > 63)
{
Global.HandleError(Error.FastConstants.R1_LARGE_DECIMAL, "Encountered exponent of size " + value_Renamed.exponent);
}
byte[] temp_byteArray = INTEGER.Encode(new IntegerValue(value_Renamed.exponent));
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
byte[] temp_byteArray2 = INTEGER.Encode(new LongValue(value_Renamed.mantissa));
buffer.Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
catch (System.IO.IOException e)
{
throw new RuntimeException(e);
}
return buffer.ToArray();
}
public override ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, Scalar field)
{
if (priorValue == null)
{
return value_Renamed;
}
if (value_Renamed == null)
{
if (field.Optional)
{
if (priorValue == ScalarValue.UNDEFINED && field.DefaultValue.Undefined)
{
return null;
}
return ScalarValue.NULL;
}
throw new ArgumentException();
}
if (priorValue.Undefined)
{
if (value_Renamed.Equals(field.DefaultValue))
{
return null;
}
return value_Renamed;
}
if (!value_Renamed.Equals(((NumericValue) priorValue).Increment()))
{
return value_Renamed;
}
return null;
}
public override ScalarValue DecodeValue(ScalarValue newValue, ScalarValue priorValue, Scalar field)
{
if (priorValue == null && !field.IsOptional)
{
Global.ErrorHandler.OnError(null, DynError.MandatoryFieldNotPresent, "");
return null;
}
var baseValue = (StringValue) (priorValue == null || priorValue.IsUndefined
? field.BaseValue
: priorValue);
if (newValue == null || newValue.IsNull)
{
if (!field.IsOptional)
throw new ArgumentException("");
return null;
}
string delta = ((StringValue) newValue).Value;
int length = Math.Max(baseValue.Value.Length - delta.Length, 0);
string root = baseValue.Value.Substring(0, (length) - (0));
return new StringValue(root + delta);
}
public static ScalarValue Gegenbauer(Int32 n, Double alpha, ScalarValue x)
{
if (n < 0)
throw new YAMPArgumentRangeException("n");
if (alpha <= 0)
throw new YAMPArgumentRangeException("alpha", 0);
if (x.Abs() > 1.0)
throw new YAMPArgumentRangeException("x", -1, 1);
var C0 = ScalarValue.One;
if (n == 0)
{
return C0;
}
var C1 = 2.0 * alpha * x;
if (n == 1)
{
return C1;
}
for (var k = 2; k <= n; k++)
{
var Ck = (2 * x * (k + alpha - 1) * C1 - (k + 2 * alpha - 2) * C0) / k;
C0 = C1;
C1 = Ck;
}
return C1;
}
/// <summary>
/// Computes the complex (linear) gamma function.
/// </summary>
/// <param name="z">The complex argument.</param>
/// <returns>The evaluated value.</returns>
public static ScalarValue LinearGamma(ScalarValue z)
{
if (z.Re < 0.5)
return Math.PI / LinearGamma(1.0 - z) / (Math.PI * z).Sin();
return LogGamma(z).Exp();
}
// series useful for large x
static ScalarValue SeriesLarge(ScalarValue x)
{
var L1 = x.Ln();
var L2 = L1.Ln();
var L2L1 = L2 / L1;
return L1 - L2 + L2L1 + (L2 - 2.0) * L2L1 / L1 / 2.0;
}
public override byte[] EncodeValue(ScalarValue v)
{
if (v == ScalarValue.Null)
{
return NullValueEncoding;
}
var buffer = new MemoryStream();
var value = (DecimalValue) v;
try
{
if (Math.Abs(value.Exponent) > 63)
{
Global.ErrorHandler.OnError(null, RepError.LargeDecimal, "Encountered exponent of size {0}", value.Exponent);
}
byte[] tmp = Integer.Encode(new IntegerValue(value.Exponent));
buffer.Write(tmp, 0, tmp.Length);
tmp = Integer.Encode(new LongValue(value.Mantissa));
buffer.Write(tmp, 0, tmp.Length);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
return buffer.ToArray();
}
static ScalarValue LambertW(ScalarValue x)
{
var EI = 1.0 / Math.E;
// use an initial approximation
var W = ScalarValue.Zero;
var abs = x.Abs();
if (abs < EI / 2.0)
{
W = SeriesSmall(x);
if ((x + EI).Abs() < 1e-6)
{
return W;
}
}
else if (abs < EI)
{
W = SeriesZero(x);
}
else if (abs > Math.E)
{
W = SeriesLarge(x);
}
else
{
W = new ScalarValue(0.5);
}
return Halley(x, W);
}
public override ScalarValue DecodeValue(ScalarValue val, ScalarValue priorVal, Scalar field)
{
if (priorVal == null)
{
Global.HandleError(Error.FastConstants.D6_MNDTRY_FIELD_NOT_PRESENT, "The field " + field + " must have a priorValue defined.");
return null;
}
if (val == null)
{
return null;
}
DecimalValue priorValue;
if (priorVal.Undefined)
{
if (field.DefaultValue.Undefined)
{
priorValue = (DecimalValue) field.BaseValue;
}
else
{
priorValue = (DecimalValue) field.DefaultValue;
}
}
else
{
priorValue = (DecimalValue) priorVal;
}
var value_Renamed = (DecimalValue) val;
return new DecimalValue(value_Renamed.mantissa + priorValue.mantissa, value_Renamed.exponent + priorValue.exponent);
}
public MatrixValue Function(MatrixValue M)
{
var m = new MatrixValue();
m[1, 1] = new ScalarValue(M.DimensionY);
m[1, 2] = new ScalarValue(M.DimensionX);
return m;
}
public ContourPlotValue Function(MatrixValue X, MatrixValue Y, MatrixValue Z, ScalarValue n)
{
var nn = n.GetIntegerOrThrowException("n", Name);
var plot = new ContourPlotValue();
plot.AddPoints(X, Y, Z);
plot.SetLevels(nn);
return plot;
}
public override byte[] EncodeValue(ScalarValue value)
{
#warning BUG? This used to format all values using "d-MMM-yy h:mm:ss tt" format, and now it uses constructor parameter instead
return
Ascii.Encode(
new StringValue(
(((DateValue) value).Value).ToString(_format, _formatter)));
}
public override byte[] EncodeValue(ScalarValue value)
{
if (value.IsNull)
return NullableByteVectorType.EncodeValue(ScalarValue.Null);
byte[] utf8encoding = Encoding.UTF8.GetBytes(((StringValue) value).Value);
return NullableByteVectorType.Encode(new ByteVectorValue(utf8encoding));
}
public ArgumentsValue Function(ScalarValue Coarsening)
{
var result = _sensor.Capture(Coarsening.Value).Result;
var red = new MatrixValue(result.Red);
var green = new MatrixValue(result.Green);
var blue = new MatrixValue(result.Blue);
return new ArgumentsValue(red, green, blue);
}
public override ScalarValue DecodeEmptyValue(ScalarValue previousValue, Scalar field)
{
if (!field.Optional)
{
return field.DefaultValue;
}
return null;
}
public override byte[] EncodeValue(ScalarValue value_Renamed)
{
if (value_Renamed.Null)
return NULLABLE_BYTE_VECTOR_TYPE.EncodeValue(ScalarValue.NULL);
byte[] utf8encoding = System.Text.Encoding.UTF8.GetBytes(((StringValue) value_Renamed).value_Renamed);
return NULLABLE_BYTE_VECTOR_TYPE.Encode(new ByteVectorValue(utf8encoding));
}
protected internal override ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, ScalarValue defaultValue)
{
if ((priorValue == ScalarValue.UNDEFINED) && value_Renamed.Equals(defaultValue))
{
return null;
}
return (value_Renamed.Equals(priorValue))?null:value_Renamed;
}
public SubPlotValue Function(ScalarValue rows, ScalarValue columns)
{
var r = rows.GetIntegerOrThrowException("rows", Name);
var c = columns.GetIntegerOrThrowException("columns", Name);
var subplot = new SubPlotValue();
subplot.Rows = r;
subplot.Columns = c;
return subplot;
}
public override byte[] EncodeValue(ScalarValue v)
{
if (v.Null)
{
return NULL_VALUE_ENCODING;
}
return UINT.EncodeValue(((NumericValue) v).Increment());
}
public override ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, Scalar field)
{
if (value_Renamed == null)
{
return ScalarValue.NULL;
}
return value_Renamed;
}
public override ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, Scalar field)
{
if (value_Renamed == null)
{
return field.DefaultValue.Undefined ? null : ScalarValue.NULL;
}
return value_Renamed.Equals(field.DefaultValue)?null:value_Renamed;
}
public override byte[] Encode(ScalarValue value_Renamed)
{
byte[] bytes = value_Renamed.Bytes;
int lengthSize = IntegerCodec.GetUnsignedIntegerSize(bytes.Length);
var encoding = new byte[bytes.Length + lengthSize];
byte[] length = UINT.Encode(new IntegerValue(bytes.Length));
Array.Copy(length, 0, encoding, 0, lengthSize);
Array.Copy(bytes, 0, encoding, lengthSize, bytes.Length);
return encoding;
}
public MatrixValue Function(StringValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
{
var function = GetSensorFunction(f.Value);
if (function == null)
{
throw new YAMPRuntimeException("The given function {0} could not be found.", f.Value);
}
return Function(new FunctionValue(function), n, dt, args);
}
public Scalar(Scalar other)
: base(other)
{
_defaultValue = (ScalarValue) other._defaultValue.Clone();
_fastType = other._fastType;
_initialValue = (ScalarValue) other._initialValue.Clone();
_operator = other._operator;
_operatorCodec = other._operatorCodec;
_typeCodec = other._typeCodec;
_dictionary = other._dictionary;
}
public override ScalarValue DecodeValue(ScalarValue newValue, ScalarValue priorValue, Scalar field)
{
return(newValue);
}
protected override ScalarValue GetValue(ScalarValue value)
{
return(new ScalarValue(EllipticK(value.Re)));
}
/// <summary>
/// Escapes Dots in Strings and does nothing to objects
/// </summary>
protected virtual ScalarValue DotEscapeFieldName(ScalarValue value)
{
var s = value.Value as string;
return(s != null ? new ScalarValue(DotEscapeFieldName(s)) : value);
}
public ScalarValue Decode(ScalarValue previousValue)
{
return(operatorCodec.DecodeEmptyValue(previousValue, this));
}
public void TestToString()
{
ScalarValue value = String("1234abcd");
Assert.AreEqual("1234abcd", value.ToString());
}
public void TestToShort()
{
ScalarValue value = String("128");
Assert.AreEqual(0x80, value.ToShort());
}
public string Serialize(ScalarValue value_Renamed)
{
return(type.Serialize(value_Renamed));
}
protected override ScalarValue GetValue(ScalarValue value)
{
return(new ScalarValue(value.IsPrime));
}
public override byte[] Encode(ScalarValue value_Renamed)
{
return(EncodeValue(value_Renamed));
}
public int FormatLiteralValue(ScalarValue scalar, TextWriter output, string format)
{
var value = scalar.Value;
var count = 0;
if (value == null)
{
using (ApplyStyle(output, KonsoleThemeStyle.Null, ref count))
output.Write("null");
return(count);
}
if (value is string str)
{
using (ApplyStyle(output, KonsoleThemeStyle.String, ref count))
{
if (format != "l")
{
JsonValueFormatter.WriteQuotedJsonString(str, output);
}
else
{
output.Write(str);
}
}
return(count);
}
if (value is ValueType)
{
if (value is int || value is uint || value is long || value is ulong ||
value is decimal || value is byte || value is sbyte || value is short ||
value is ushort || value is float || value is double)
{
using (ApplyStyle(output, KonsoleThemeStyle.Number, ref count))
scalar.Render(output, format, _formatProvider);
return(count);
}
if (value is bool b)
{
using (ApplyStyle(output, KonsoleThemeStyle.Boolean, ref count))
output.Write(b);
return(count);
}
if (value is char ch)
{
using (ApplyStyle(output, KonsoleThemeStyle.Scalar, ref count))
{
output.Write('\'');
output.Write(ch);
output.Write('\'');
}
return(count);
}
}
using (ApplyStyle(output, KonsoleThemeStyle.Scalar, ref count))
scalar.Render(output, format, _formatProvider);
return(count);
}
public virtual bool CanEncode(ScalarValue value, Scalar field)
{
return(true);
}
public abstract ScalarValue DecodeEmptyValue(ScalarValue priorValue, Scalar field);
public void SetVariable(string name, double value)
{
variables[name] = new ScalarValue(value);
cacheIsDirty = true;
}
protected override ScalarValue GetValue(ScalarValue z)
{
return(z.Arccsc());
}
protected override ScalarValue GetValue(ScalarValue z)
{
return((1.0 / z + (1.0 / z.Square() + 1.0).Sqrt()).Ln());
}
public override bool IsValueOf(ScalarValue priorValue)
{
return(priorValue is ByteVectorValue);
}
public void TestToInt()
{
ScalarValue value = String("32768");
Assert.AreEqual(32768, value.ToInt());
}
protected override ScalarValue GetValue(ScalarValue value)
{
return(value.Log10());
}
public void TestToByte()
{
ScalarValue value = String("5");
Assert.AreEqual(0x05, value.ToByte());
}
public ScalarValue DecodeValue(ScalarValue newValue, ScalarValue previousValue)
{
return(operatorCodec.DecodeValue(newValue, previousValue, this));
}
public void TestToDouble()
{
ScalarValue value = String(" -1.234 ");
Assert.AreEqual(-1.234, value.ToDouble(), .001);
}
public bool TryConvertToScalar(object value, ILogEventPropertyValueFactory propertyValueFactory, out ScalarValue result)
{
if (value.GetType().IsEnum)
{
result = new ScalarValue(value);
return(true);
}
result = null;
return(false);
}
public void TestToLong()
{
ScalarValue value = String("2147483648");
Assert.AreEqual(2147483648L, value.ToLong());
}
public ScalarValue Function(ScalarValue n, ScalarValue alpha, ScalarValue z)
{
var nn = n.GetIntegerOrThrowException("n", Name);
return(Gegenbauer(nn, alpha.Re, z));
}
public ScalarValue GetMaxThrustAt(ScalarValue atmPressure)
{
return(VesselUtils.GetMaxThrust(Vessel, atmPressure));
}
public bool TryConvertToScalar(object value, ITemplatePropertyValueFactory propertyValueFactory, out ScalarValue result)
{
if (_scalarTypes.Contains(value.GetType()))
{
result = new ScalarValue(value);
return(true);
}
result = null;
return(false);
}
public abstract ScalarValue DecodeValue(ScalarValue newValue, ScalarValue priorValue, Scalar field);
public Scalar(string name, FASTType type, Operator.Operator operator_Renamed, ScalarValue defaultValue, bool optional)
: this(new QName(name), type, operator_Renamed, defaultValue, optional)
{
}
public abstract ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar field);
public ScalarValue Function(ScalarValue x, ScalarValue y, ScalarValue z)
{
return(new ScalarValue(CarlsonF(x.Re, y.Re, z.Re)));
}
