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))); }