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