/// <summary> /// Adds the given values incrementally /// </summary> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>The incremental sum</returns> public static INotifyExpression <double> Add(INotifyExpression <double> left, INotifyExpression <double> right) { return(new ObservableDoublePlus(left, right)); }
public ObservableLogicNot(INotifyExpression <bool> inner) : base(inner) { }
public ObservableULongDivide(INotifyExpression <ulong> left, INotifyExpression <ulong> right) : base(left, right) { }
public ObservableLongModulo(INotifyExpression <long> left, INotifyExpression <long> right) : base(left, right) { }
public ModelFuncExtractionParameter(INotifyExpression <TBase1> base1, Func <TBase1, T> memberGetter) { Base1 = base1; MemberGetter = memberGetter; }
protected ObservableReversableBinaryExpressionBase(INotifyExpression <TLeft> left, INotifyExpression <TRight> right) : base(left, right) { }
public ObservableFloatModulo(INotifyExpression <float> left, INotifyExpression <float> right) : base(left, right) { }
public static INotifyExpression <ulong> Modulo(INotifyExpression <ulong> left, INotifyExpression <ulong> right) { return(new ObservableULongModulo(left, right)); }
/// <summary> /// Computes an incremental modulo of the operands /// </summary> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>The incremental modulo</returns> public static INotifyExpression <float> Modulo(INotifyExpression <float> left, INotifyExpression <float> right) { return(new ObservableFloatModulo(left, right)); }
/// <summary> /// Multiplies the given values incrementally /// </summary> /// <param name="left">The left factor</param> /// <param name="right">The right factor</param> /// <returns>The incremental product</returns> public static INotifyExpression <double> Multiply(INotifyExpression <double> left, INotifyExpression <double> right) { return(new ObservableDoubleMultiply(left, right)); }
public static INotifyExpression <uint> Modulo(INotifyExpression <uint> left, INotifyExpression <uint> right) { return(new ObservableUIntModulo(left, right)); }
/// <summary> /// Multiplies the given values incrementally /// </summary> /// <param name="left">The left factor</param> /// <param name="right">The right factor</param> /// <returns>The incremental product</returns> public static INotifyExpression <long> Multiply(INotifyExpression <long> left, INotifyExpression <long> right) { return(new ObservableLongMultiply(left, right)); }
/// <summary> /// Multiplies the given values incrementally /// </summary> /// <param name="left">The left factor</param> /// <param name="right">The right factor</param> /// <returns>The incremental product</returns> public static INotifyExpression <int> Multiply(INotifyExpression <int> left, INotifyExpression <int> right) { return(new ObservableIntMultiply(left, right)); }
/// <summary> /// Adds the given values incrementally /// </summary> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>The incremental sum</returns> public static INotifyExpression <string> Add(INotifyExpression <string> left, INotifyExpression <string> right) { return(new ObservableStringPlus(left, right)); }
public ObservableBinaryExpression(INotifyExpression <TLeft> left, INotifyExpression <TRight> right, Func <TLeft, TRight, TResult> implementation) : base(left, right) { Implementation = implementation; }
/// <summary> /// Computes an incremental modulo of the operands /// </summary> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>The incremental modulo</returns> public static INotifyExpression <double> Modulo(INotifyExpression <double> left, INotifyExpression <double> right) { return(new ObservableDoubleModulo(left, right)); }
public ObservableCoalesceExpression(INotifyExpression <T> left, INotifyExpression <T> right) : base(left, right) { }
/// <summary> /// Coalesces the given value with the given alternative /// </summary> /// <typeparam name="T">The element type</typeparam> /// <param name="value">The incremental value that should be coalesced</param> /// <param name="ifNull">The incremental coalesce value</param> /// <returns>An incremental coalesced value</returns> public static INotifyExpression <T> Coalesce <T>(INotifyExpression <T> value, INotifyExpression <T> ifNull) where T : class { return(new ObservableCoalesceExpression <T>(value, ifNull)); }
public ObservableNewArray3Expression(INotifyExpression <int> bounds1, INotifyExpression <int> bounds2, INotifyExpression <int> bounds3) { if (bounds1 == null) { throw new ArgumentNullException("bounds1"); } if (bounds2 == null) { throw new ArgumentNullException("bounds2"); } if (bounds3 == null) { throw new ArgumentNullException("bounds3"); } Bounds1 = bounds1; Bounds2 = bounds2; Bounds3 = bounds3; bounds1.ValueChanged += ArgumentChanged; bounds2.ValueChanged += ArgumentChanged; bounds3.ValueChanged += ArgumentChanged; }
/// <summary> /// Performs an incremental right shift /// </summary> /// <param name="left">The value to be shifted</param> /// <param name="right">The shift</param> /// <returns>An incremental shift</returns> public static INotifyExpression <long> RightShift(INotifyExpression <long> left, INotifyExpression <int> right) { return(new ObservableLongRightShift(left, right)); }
public ObservableDoubleModulo(INotifyExpression <double> left, INotifyExpression <double> right) : base(left, right) { }
/// <summary> /// Performs an incremental left shift /// </summary> /// <param name="left">The value to be shifted</param> /// <param name="right">The shift</param> /// <returns>An incremental shift</returns> public static INotifyExpression <int> LeftShift(INotifyExpression <int> left, INotifyExpression <int> right) { return(new ObservableIntLeftShift(left, right)); }
public ObservableUIntModulo(INotifyExpression <uint> left, INotifyExpression <uint> right) : base(left, right) { }
public static INotifyExpression <ulong> LeftShift(INotifyExpression <ulong> left, INotifyExpression <int> right) { return(new ObservableULongLeftShift(left, right)); }
public ObservableMethodLensProxyCall(MethodInfo proxyMethod, INotifyExpression <T> target, LensPut <T, TResult> lensPut) : base(target, proxyMethod) { LensPut = lensPut; }
/// <summary> /// Incrementally determines whether the left value is greather than or equals to the right value /// </summary> /// <typeparam name="T">The type of the elements</typeparam> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>An incremental value determing whether the left operand is greather than or equals to the right operand</returns> public static INotifyExpression <bool> GreatherThanOrEquals <T>(INotifyExpression <T> left, INotifyExpression <T> right) where T : IComparable <T> { return(new ObservableGreatherThanOrEquals <T>(left, right)); }
public ObservableLogicXor(INotifyExpression <bool> left, INotifyExpression <bool> right) : base(left, right) { }
/// <summary> /// Incrementally determines whether the left value is less than the right value /// </summary> /// <typeparam name="T">The type of the elements</typeparam> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>An incremental value determing whether the left operand is less than the right operand</returns> public static INotifyExpression <bool> LessThan <T>(INotifyExpression <T> left, INotifyExpression <T> right) where T : IComparable <T> { return(new ObservableLessThan <T>(left, right)); }
public ObservableIntDivide(INotifyExpression <int> left, INotifyExpression <int> right) : base(left, right) { }
/// <summary> /// Adds the given values incrementally /// </summary> /// <param name="left">The left operand</param> /// <param name="right">The right operand</param> /// <returns>The incremental sum</returns> public static INotifyExpression <float> Add(INotifyExpression <float> left, INotifyExpression <float> right) { return(new ObservableFloatPlus(left, right)); }