/// <summary> /// Creates metadata for a curve providing a SABR parameter. /// <para> /// The x-values represent time to expiry year fractions as defined by the specified day count. /// /// </para> /// </summary> /// <param name="name"> the curve name </param> /// <param name="dayCount"> the day count </param> /// <param name="yType"> the y-value type, which must be one of the four SABR values </param> /// <returns> the curve metadata </returns> public static CurveMetadata sabrParameterByExpiry(CurveName name, DayCount dayCount, ValueType yType) { if (!yType.Equals(ValueType.SABR_ALPHA) && !yType.Equals(ValueType.SABR_BETA) && !yType.Equals(ValueType.SABR_RHO) && !yType.Equals(ValueType.SABR_NU)) { throw new System.ArgumentException("SABR y-value type must be SabrAlpha, SabrBeta, SabrRho or SabrNu"); } return(DefaultCurveMetadata.builder().curveName(name).xValueType(ValueType.YEAR_FRACTION).yValueType(yType).dayCount(dayCount).build()); }
/// <summary> /// Creates metadata for a curve providing a SABR parameter. /// <para> /// The x-values represent time to expiry year fractions as defined by the specified day count. /// /// </para> /// </summary> /// <param name="name"> the curve name </param> /// <param name="dayCount"> the day count </param> /// <param name="yType"> the y-value type, which must be one of the four SABR values </param> /// <param name="parameterMetadata"> the parameter metadata </param> /// <returns> the curve metadata </returns> public static CurveMetadata sabrParameterByExpiry <T1>(CurveName name, DayCount dayCount, ValueType yType, IList <T1> parameterMetadata) where T1 : com.opengamma.strata.market.param.ParameterMetadata { if (!yType.Equals(ValueType.SABR_ALPHA) && !yType.Equals(ValueType.SABR_BETA) && !yType.Equals(ValueType.SABR_RHO) && !yType.Equals(ValueType.SABR_NU)) { throw new System.ArgumentException("SABR y-value type must be SabrAlpha, SabrBeta, SabrRho or SabrNu"); } return(DefaultCurveMetadata.builder().curveName(name).xValueType(ValueType.YEAR_FRACTION).yValueType(yType).dayCount(dayCount).parameterMetadata(parameterMetadata).build()); }
public static void HandleFrame(IFrame frame, GUISkin skin, float numPixelsIndentation = 0.0f, bool includeFrameToolIfPresent = true) { bool guiWasEnabled = UnityEngine.GUI.enabled; using (new Indent(numPixelsIndentation)) { UnityEngine.GUI.enabled = true; GameObject newParent = (GameObject)EditorGUILayout.ObjectField(MakeLabel("Parent"), frame.Parent, typeof(GameObject), true); UnityEngine.GUI.enabled = guiWasEnabled; if (newParent != frame.Parent) { frame.SetParent(newParent); } frame.LocalPosition = Vector3Field(MakeLabel("Local position"), frame.LocalPosition, skin.label); // Converting from quaternions to Euler - make sure the actual Euler values has // changed before updating local rotation to not mess up the undo stack. Vector3 inputEuler = frame.LocalRotation.eulerAngles; Vector3 outputEuler = Vector3Field(MakeLabel("Local rotation"), inputEuler, skin.label); if (!ValueType.Equals(inputEuler, outputEuler)) { frame.LocalRotation = Quaternion.Euler(outputEuler); } Separator(); Tools.FrameTool frameTool = null; if (includeFrameToolIfPresent && (frameTool = Tools.FrameTool.FindActive(frame)) != null) { using (new Indent(12)) frameTool.OnPreTargetMembersGUI(skin); } } }
//------------------------------------------------------------------------- // loads the curve settings CSV file internal static IDictionary <CurveName, LoadedCurveSettings> parseCurveSettings(CharSource settingsResource) { ImmutableMap.Builder <CurveName, LoadedCurveSettings> builder = ImmutableMap.builder(); CsvFile csv = CsvFile.of(settingsResource, true); foreach (CsvRow row in csv.rows()) { string curveNameStr = row.getField(SETTINGS_CURVE_NAME); string valueTypeStr = row.getField(SETTINGS_VALUE_TYPE); string dayCountStr = row.getField(SETTINGS_DAY_COUNT); string interpolatorStr = row.getField(SETTINGS_INTERPOLATOR); string leftExtrapolatorStr = row.getField(SETTINGS_LEFT_EXTRAPOLATOR); string rightExtrapolatorStr = row.getField(SETTINGS_RIGHT_EXTRAPOLATOR); if (!VALUE_TYPE_MAP.containsKey(valueTypeStr.ToLower(Locale.ENGLISH))) { throw new System.ArgumentException(Messages.format("Unsupported {} in curve settings: {}", SETTINGS_VALUE_TYPE, valueTypeStr)); } CurveName curveName = CurveName.of(curveNameStr); ValueType yValueType = VALUE_TYPE_MAP.get(valueTypeStr.ToLower(Locale.ENGLISH)); CurveInterpolator interpolator = CurveInterpolator.of(interpolatorStr); CurveExtrapolator leftExtrap = CurveExtrapolator.of(leftExtrapolatorStr); CurveExtrapolator rightExtrap = CurveExtrapolator.of(rightExtrapolatorStr); bool isPriceIndex = yValueType.Equals(ValueType.PRICE_INDEX); ValueType xValueType = isPriceIndex ? ValueType.MONTHS : ValueType.YEAR_FRACTION; DayCount dayCount = isPriceIndex ? ONE_ONE : LoaderUtils.parseDayCount(dayCountStr); LoadedCurveSettings settings = LoadedCurveSettings.of(curveName, xValueType, yValueType, dayCount, interpolator, leftExtrap, rightExtrap); builder.put(curveName, settings); } return(builder.build()); }
public bool PosTest4() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest4: Comparing two unicode name structs"); try { Структура s1; Структура s2; if (!ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("007", "ValueType.Equals(s1,s2) should have returned true!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e); } return(retVal); }
protected override MarkerViewModel[] GenerateItems(IEnumerable <EventViewModel> Items) { object severity; MarkerViewModel marker = null; int index = 0; List <MarkerViewModel> items; if (severityColumn == null) { return new MarkerViewModel[] { } } ; items = new List <MarkerViewModel>(); foreach (EventViewModel item in Items) { if ((item.Brush != null) && (item.Brush != "Transparent")) { severity = item[severityColumn].Value; if ((marker == null) || (!ValueType.Equals(severity, marker.Severity)) || (index != marker.Position + marker.Size)) { marker = new MarkerViewModel(Logger); marker.Position = index; marker.Background = item.Brush; marker.Severity = severity; items.Add(marker); } marker.Size++; } index++; } return(items.ToArray()); } }
public bool PosTest9() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest9: Comparing a struct with null"); try { S s1 = new S(); if (ValueType.Equals(s1, null)) { TestLibrary.TestFramework.LogError("017", "ValueType.Equals(s1,s2) should have returned false!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("018", "Unexpected exception: " + e); } return(retVal); }
public bool PosTest7() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest7: Comparing two structs with very large different names"); try { AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELK s1; AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELM s2; if (ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("013", "ValueType.Equals(s1,s2) should have returned false!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("014", "Unexpected exception: " + e); } return(retVal); }
public bool PosTest2() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest2: Comparing generic struct with non-generic struct"); try { S s1 = new S(); SGen <string> s2; if (ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("003", "ValueType.Equals(s1,s2) should have returned false!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e); } return(retVal); }
internal override void SetPropertyValue(string value) { if (!ValueType.Equals(value, this.value)) { this.value = unevaluatedValue = value; } }
public bool PosTest5() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest5: Comparing unicode name struct with non-generic struct"); try { Структура s1; S s2 = new S(); if (ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("009", "ValueType.Equals(s1,s2) should have returned false!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e); } return(retVal); }
private static void ValidateUserSpecifiedValueType( Type resourceType, MethodInfo method, ValueType userSpecifiedValueType, Type componentType) { var calculatedValueType = TYPE_TO_VALUE_TYPE[componentType]; // If user-specified value type matches calculated value type // or // user-specified value type is local resource (we will validate the local resource later) // or // user-specified value type is xml literal and calculated value type is string // or // user-specified value type is decimal and calculated value type is numeric if (userSpecifiedValueType.Equals(calculatedValueType) || ValueType.LocalResource.Equals(userSpecifiedValueType) || ValueType.XMLLiteral.Equals(userSpecifiedValueType) && ValueType.String.Equals(calculatedValueType) || ValueType.Decimal.Equals(userSpecifiedValueType) && (ValueType.Double.Equals(calculatedValueType) || ValueType.Float.Equals(calculatedValueType) || ValueType.Integer.Equals(calculatedValueType))) { // We have a valid user-specified value type for our Java type return; } throw new OslcCoreInvalidValueTypeException(resourceType, method, userSpecifiedValueType); }
public bool PosTest3() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest3: Comparing two generic structs"); try { SGen <int> s1; SGen <int> s2; if (!ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("005", "ValueType.Equals(s1,s2) should have returned true!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e); } return(retVal); }
public override bool MustDiscard(EventViewModel Event) { FilterItemViewModel item; item = ItemsSource.FirstOrDefault(item2 => ValueType.Equals(item2.Value, Event[PropertyName].Value)); return(!item?.IsChecked ?? false); }
public void Poll(Func <ValueType> getLastValue, EventHandler <AbstractSensorDataEventArgs> sensorDataChanged, int pollingIntervall) { using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource()) { CancellationToken cancellationToken = cancellationTokenSource.Token; lastValue = getLastValue(); Task listener = Task.Factory.StartNew(() => { while (!cancellationToken.IsCancellationRequested) { ValueType currentValue = getLastValue(); if (!lastValue.Equals(currentValue)) { sensorDataChanged?.Invoke(this, new SensorDataEventArgs(currentValue)); } lastValue = currentValue; Thread.Sleep(pollingIntervall); } }, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default); } }
/// <summary> /// ValueType Equals Check /// </summary> private void CheckVariableChanged(ValueType previous, ValueType next) { if (!previous.Equals(next)) { ValueChanged(); } }
/// <summary> /// Compares two instances with primitive types. /// </summary> /// <param name="instance1">The first instance.</param> /// <param name="instance2">The second instance.</param> /// <exception cref="NotSupportedException">Raised if the instances don't implement IComparable, IComparer or /// IEqualityComparer.</exception> /// <returns>True if they are equal, false otherwise.</returns> private static bool ComparePrimitiveObjects(object instance1, object instance2) { IComparable comparable = instance1 as IComparable; if (comparable != null) { return(comparable.CompareTo(instance2) == 0); } IComparer comparer = instance1 as IComparer; if (comparer != null) { return(comparer.Compare(instance1, instance2) == 0); } IEqualityComparer equaler = instance1 as IEqualityComparer; if (equaler != null) { return(equaler.Equals(instance2)); } ValueType valueType = instance1 as ValueType; if (valueType != null) { return(valueType.Equals(instance2)); } throw new NotSupportedException("Not supported object type: " + instance1.GetType().FullName); }
public bool PosTest1() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest1: Comparing two non-generic structs"); try { S s1 = new S(); S s2 = new S(); if (!ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("001", "ValueType.Equals(s1,s2) should have returned true!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e); } return(retVal); }
public bool PosTest8() { bool retVal = false; TestLibrary.TestFramework.BeginScenario("PosTest8: Comparing a struct with a reference type"); try { A s1 = new A(); S s2 = new S(); if (ValueType.Equals(s1, s2)) { TestLibrary.TestFramework.LogError("015", "ValueType.Equals(s1,s2) should have returned false!"); } else { retVal = true; } } catch (Exception e) { TestLibrary.TestFramework.LogError("016", "Unexpected exception: " + e); } return(retVal); }
public void Self_equality_is_sane() { var x = new ValueType("asdf", 42, true, new CustomRefType("qwer"), new ValueType2("xyz")); #pragma warning disable 1718 // ReSharper disable EqualExpressionComparison Assert.True(x.Equals(x)); Assert.True(x == x); Assert.False(x != x); Assert.False(x.Equals(null)); Assert.False(Equals(null, x)); // ReSharper disable once HeuristicUnreachableCode Assert.Equal(x.GetHashCode(), x.GetHashCode()); // ReSharper restore EqualExpressionComparison #pragma warning restore 1718 }
/*protected override void OnPreviewKeyDown(KeyEventArgs e) * { * base.OnPreviewKeyDown(e); * }*/ protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) { base.OnPropertyChanged(e); if ((e.Property == VisibilityProperty) && (ValueType.Equals(e.NewValue, Visibility.Visible))) { textBox.Focus(); } }
public string GetBuffName() { if (ValueType.Equals(BuffValueEnum.Name)) { return(Value); } return(string.Empty); }
private static void CompareValueTypes(ValueType actual, ValueType expected, IEnumerable <string> path, string?customMessage, [CallerMemberName] string shouldlyMethod = null !) { if (!actual.Equals(expected)) { ThrowException(actual, expected, path, customMessage, shouldlyMethod); } }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// <c>true</c> if the current object is equal to the other parameter; otherwise, <c>false</c>. /// </returns> public bool Equals(AttributeKey other) { return(other != null && FriendlyName.Equals(other.FriendlyName, StringComparison.Ordinal) && Name.Equals(other.Name, StringComparison.Ordinal) && NameFormat.Equals(other.NameFormat, StringComparison.Ordinal) && ValueType.Equals(other.ValueType, StringComparison.Ordinal) && OriginalIssuer.Equals(other.OriginalIssuer, StringComparison.Ordinal)); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// <c>true</c> if the current object is equal to the other parameter; otherwise, <c>false</c>. /// </returns> public bool Equals(AttributeKey other) { return(other != null && FriendlyName.Equals(other.FriendlyName) && Name.Equals(other.Name) && NameFormat.Equals(other.NameFormat) && ValueType.Equals(other.ValueType) && OriginalIssuer.Equals(other.OriginalIssuer)); }
/// <summary> /// Asserts if two objects are equal. Checks both overridden and referential equality. /// </summary> /// <param name="expected">Expected object.</param> /// <param name="actual">Actual object.</param> /// <exception cref="AssertionException">Throws if objects are not equal.</exception> public static void AssertEquals(ValueType expected, ValueType actual) { if (expected.Equals(actual)) { return; } Console.WriteLine($"Expected: {expected}{Environment.NewLine} Actual: {actual}"); throw new AssertionException(); }
bool BinaryNotEqual(BinaryExpression binary, object left, object right) { if (typeof(ValueType).IsAssignableFrom(binary.Right.Type)) { return(!ValueType.Equals(left, right)); } else { return(left != right); } }
private static bool IsValueTypeUnitializedValue(ValueType value, Type valueType) { if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Nullable <>)) { return(value == null); } else { return(value.Equals((ValueType)Activator.CreateInstance(valueType))); } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (!ValueType.Equals(value, 0)) { return(Visibility.Visible); } else { return(Visibility.Collapsed); } }
//пока только ValueType.NoSpaceValue Option(string name, ValueType valueType) { if (!valueType.Equals(ValueType.NoSpaceValue) /* && ! valueType.Equals(ValueType.QuotedValue) */ ) { throw new System.NotSupportedException("Invalid ProgramCommand Option argument."); } Init(name, valueType, null); }