MinusHelper.Minus Method

Definition

Namespace:

Microsoft.Dynamics.Ax.Xpp

Assembly:

Microsoft.Dynamics.AX.Xpp.Support.dll

Overloads

Minus(Date, Date)
Minus(SByte, Decimal)
Minus(SByte, Double)
Minus(SByte, Int16)
Minus(SByte, Int32)
Minus(SByte, Int64)
Minus(SByte, SByte)
Minus(SByte, Byte)
Minus(SByte, Single)
Minus(SByte, UInt32)
Minus(Single, Boolean)
Minus(Single, Byte)
Minus(Single, Double)
Minus(Single, Int16)
Minus(Single, Int32)
Minus(SByte, UInt16)
Minus(Single, Int64)
Minus(SByte, Boolean)
Minus(Int64, UInt32)
Minus(Int32, SByte)
Minus(Int32, Single)
Minus(Int32, UInt16)
Minus(Int32, UInt32)
Minus(Int64, Boolean)
Minus(Int64, Byte)
Minus(Object, Object)
Minus(Int64, Decimal)
Minus(Int64, Int16)
Minus(Int64, Int32)
Minus(Int64, Int64)
Minus(Int64, SByte)
Minus(Int64, Single)
Minus(Int64, UInt16)
Minus(Int64, Double)
Minus(Int32, Int64)
Minus(Single, SByte)
Minus(Single, UInt16)
Minus(UInt32, Int16)
Minus(UInt32, Int32)
Minus(UInt32, Int64)
Minus(UInt32, SByte)
Minus(UInt32, Single)
Minus(UInt32, UInt16)
Minus(UInt32, Double)
Minus(UInt32, UInt32)
Minus(UInt64, Boolean)
Minus(UInt64, Byte)
Minus(UInt64, Decimal)
Minus(UInt64, Double)
Minus(UInt64, Single)
Minus(UInt64, UInt16)
Minus(UInt32, UInt64)
Minus(Single, Single)
Minus(UInt32, Decimal)
Minus(UInt32, Boolean)
Minus(Single, UInt32)
Minus(Single, UInt64)
Minus(UInt16, Boolean)
Minus(UInt16, Byte)
Minus(UInt16, Decimal)
Minus(UInt16, Double)
Minus(UInt32, Byte)
Minus(UInt16, Int16)
Minus(UInt16, Int64)
Minus(UInt16, SByte)
Minus(UInt16, Single)
Minus(UInt16, UInt16)
Minus(UInt16, UInt32)
Minus(UInt16, UInt64)
Minus(UInt16, Int32)
Minus(Int32, Int32)
Minus(Int32, Int16)
Minus(Int32, Double)
Minus(Boolean, SByte)
Minus(Boolean, Single)
Minus(Boolean, UInt16)
Minus(Boolean, UInt32)
Minus(Boolean, UInt64)
Minus(Byte, Byte)
Minus(Boolean, Int64)
Minus(Byte, Decimal)
Minus(Byte, Int16)
Minus(Byte, Int32)
Minus(Byte, Int64)
Minus(Byte, SByte)
Minus(Byte, Single)
Minus(Byte, UInt16)
Minus(Byte, Double)
Minus(Byte, UInt32)
Minus(Boolean, Int32)
Minus(Boolean, Double)
Minus(Date, Byte)
Minus(Date, Decimal)
Minus(Date, Double)
Minus(Date, Int16)
Minus(Date, Int32)
Minus(Date, Int64)
Minus(Boolean, Int16)
Minus(Date, SByte)
Minus(Date, UInt16)
Minus(Date, UInt32)
Minus(Date, UInt64)
Minus(utcdatetime, utcdatetime)
Minus(Boolean, Boolean)
Minus(Boolean, Decimal)
Minus(Date, Single)
Minus(Byte, UInt64)
Minus(Decimal, Boolean)
Minus(Decimal, Byte)
Minus(Int16, Boolean)
Minus(Int16, Byte)
Minus(Int16, Decimal)
Minus(Int16, Double)
Minus(Int16, Int16)
Minus(Int16, Int32)
Minus(Double, UInt64)
Minus(Int16, Int64)
Minus(Int16, Single)
Minus(Int16, UInt16)
Minus(Int16, UInt32)
Minus(Int32, Boolean)
Minus(Int32, Byte)
Minus(Int32, Decimal)
Minus(Int16, SByte)
Minus(Double, UInt32)
Minus(Double, UInt16)
Minus(Double, Single)
Minus(Decimal, Decimal)
Minus(Decimal, Int16)
Minus(Decimal, Int32)
Minus(Decimal, Int64)
Minus(Decimal, SByte)
Minus(Decimal, UInt16)
Minus(Decimal, UInt32)
Minus(Decimal, UInt64)
Minus(Double, Boolean)
Minus(Double, Byte)
Minus(Double, Double)
Minus(Double, Int16)
Minus(Double, Int32)
Minus(Double, Int64)
Minus(Double, SByte)
Minus(UInt64, UInt32)
Minus(UInt64, UInt64)

Minus(Date, Date)

public:
 static int Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, Microsoft::Dynamics::Ax::Xpp::AxShared::Date y);

public static int Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, Microsoft.Dynamics.Ax.Xpp.AxShared.Date y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * Microsoft.Dynamics.Ax.Xpp.AxShared.Date -> int

Public Shared Function Minus (x As Date, y As Date) As Integer

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Returns

Int32

Minus(SByte, Decimal)

public:
 static System::Decimal Minus(System::SByte x, System::Decimal y);

public static decimal Minus (sbyte x, decimal y);

static member Minus : sbyte * decimal -> decimal

Public Shared Function Minus (x As SByte, y As Decimal) As Decimal

Parameters

x

SByte

y

Decimal

Returns

Decimal

Minus(SByte, Double)

public:
 static double Minus(System::SByte x, double y);

public static double Minus (sbyte x, double y);

static member Minus : sbyte * double -> double

Public Shared Function Minus (x As SByte, y As Double) As Double

Parameters

x

SByte

y

Double

Returns

Double

Minus(SByte, Int16)

public:
 static int Minus(System::SByte x, short y);

public static int Minus (sbyte x, short y);

static member Minus : sbyte * int16 -> int

Public Shared Function Minus (x As SByte, y As Short) As Integer

Parameters

x

SByte

y

Int16

Returns

Int32

Minus(SByte, Int32)

public:
 static int Minus(System::SByte x, int y);

public static int Minus (sbyte x, int y);

static member Minus : sbyte * int -> int

Public Shared Function Minus (x As SByte, y As Integer) As Integer

Parameters

x

SByte

y

Int32

Returns

Int32

Minus(SByte, Int64)

public:
 static long Minus(System::SByte x, long y);

public static long Minus (sbyte x, long y);

static member Minus : sbyte * int64 -> int64

Public Shared Function Minus (x As SByte, y As Long) As Long

Parameters

x

SByte

y

Int64

Returns

Int64

Minus(SByte, SByte)

public:
 static int Minus(System::SByte x, System::SByte y);

public static int Minus (sbyte x, sbyte y);

static member Minus : sbyte * sbyte -> int

Public Shared Function Minus (x As SByte, y As SByte) As Integer

Parameters

x

SByte

y

SByte

Returns

Int32

Minus(SByte, Byte)

public:
 static int Minus(System::SByte x, System::Byte y);

public static int Minus (sbyte x, byte y);

static member Minus : sbyte * byte -> int

Public Shared Function Minus (x As SByte, y As Byte) As Integer

Parameters

x

SByte

y

Byte

Returns

Int32

Minus(SByte, Single)

public:
 static float Minus(System::SByte x, float y);

public static float Minus (sbyte x, float y);

static member Minus : sbyte * single -> single

Public Shared Function Minus (x As SByte, y As Single) As Single

Parameters

x

SByte

y

Single

Returns

Single

Minus(SByte, UInt32)

public:
 static long Minus(System::SByte x, System::UInt32 y);

public static long Minus (sbyte x, uint y);

static member Minus : sbyte * uint32 -> int64

Public Shared Function Minus (x As SByte, y As UInteger) As Long

Parameters

x

SByte

y

UInt32

Returns

Int64

Minus(Single, Boolean)

public:
 static float Minus(float x, bool y);

public static float Minus (float x, bool y);

static member Minus : single * bool -> single

Public Shared Function Minus (x As Single, y As Boolean) As Single

Parameters

x

Single

y

Boolean

Returns

Single

Minus(Single, Byte)

public:
 static float Minus(float x, System::Byte y);

public static float Minus (float x, byte y);

static member Minus : single * byte -> single

Public Shared Function Minus (x As Single, y As Byte) As Single

Parameters

x

Single

y

Byte

Returns

Single

Minus(Single, Double)

public:
 static double Minus(float x, double y);

public static double Minus (float x, double y);

static member Minus : single * double -> double

Public Shared Function Minus (x As Single, y As Double) As Double

Parameters

x

Single

y

Double

Returns

Double

Minus(Single, Int16)

public:
 static float Minus(float x, short y);

public static float Minus (float x, short y);

static member Minus : single * int16 -> single

Public Shared Function Minus (x As Single, y As Short) As Single

Parameters

x

Single

y

Int16

Returns

Single

Minus(Single, Int32)

public:
 static float Minus(float x, int y);

public static float Minus (float x, int y);

static member Minus : single * int -> single

Public Shared Function Minus (x As Single, y As Integer) As Single

Parameters

x

Single

y

Int32

Returns

Single

Minus(SByte, UInt16)

public:
 static int Minus(System::SByte x, System::UInt16 y);

public static int Minus (sbyte x, ushort y);

static member Minus : sbyte * uint16 -> int

Public Shared Function Minus (x As SByte, y As UShort) As Integer

Parameters

x

SByte

y

UInt16

Returns

Int32

Minus(Single, Int64)

public:
 static float Minus(float x, long y);

public static float Minus (float x, long y);

static member Minus : single * int64 -> single

Public Shared Function Minus (x As Single, y As Long) As Single

Parameters

x

Single

y

Int64

Returns

Single

Minus(SByte, Boolean)

public:
 static int Minus(System::SByte x, bool y);

public static int Minus (sbyte x, bool y);

static member Minus : sbyte * bool -> int

Public Shared Function Minus (x As SByte, y As Boolean) As Integer

Parameters

x

SByte

y

Boolean

Returns

Int32

Minus(Int64, UInt32)

public:
 static long Minus(long x, System::UInt32 y);

public static long Minus (long x, uint y);

static member Minus : int64 * uint32 -> int64

Public Shared Function Minus (x As Long, y As UInteger) As Long

Parameters

x

Int64

y

UInt32

Returns

Int64

Minus(Int32, SByte)

public:
 static int Minus(int x, System::SByte y);

public static int Minus (int x, sbyte y);

static member Minus : int * sbyte -> int

Public Shared Function Minus (x As Integer, y As SByte) As Integer

Parameters

x

Int32

y

SByte

Returns

Int32

Minus(Int32, Single)

public:
 static float Minus(int x, float y);

public static float Minus (int x, float y);

static member Minus : int * single -> single

Public Shared Function Minus (x As Integer, y As Single) As Single

Parameters

x

Int32

y

Single

Returns

Single

Minus(Int32, UInt16)

public:
 static int Minus(int x, System::UInt16 y);

public static int Minus (int x, ushort y);

static member Minus : int * uint16 -> int

Public Shared Function Minus (x As Integer, y As UShort) As Integer

Parameters

x

Int32

y

UInt16

Returns

Int32

Minus(Int32, UInt32)

public:
 static long Minus(int x, System::UInt32 y);

public static long Minus (int x, uint y);

static member Minus : int * uint32 -> int64

Public Shared Function Minus (x As Integer, y As UInteger) As Long

Parameters

x

Int32

y

UInt32

Returns

Int64

Minus(Int64, Boolean)

public:
 static long Minus(long x, bool y);

public static long Minus (long x, bool y);

static member Minus : int64 * bool -> int64

Public Shared Function Minus (x As Long, y As Boolean) As Long

Parameters

x

Int64

y

Boolean

Returns

Int64

Minus(Int64, Byte)

public:
 static long Minus(long x, System::Byte y);

public static long Minus (long x, byte y);

static member Minus : int64 * byte -> int64

Public Shared Function Minus (x As Long, y As Byte) As Long

Parameters

x

Int64

y

Byte

Returns

Int64

Minus(Object, Object)

public:
 static System::Object ^ Minus(System::Object ^ x, System::Object ^ y);

public static object Minus (object x, object y);

static member Minus : obj * obj -> obj

Public Shared Function Minus (x As Object, y As Object) As Object

Parameters

x

Object

y

Object

Returns

Object

Minus(Int64, Decimal)

public:
 static System::Decimal Minus(long x, System::Decimal y);

public static decimal Minus (long x, decimal y);

static member Minus : int64 * decimal -> decimal

Public Shared Function Minus (x As Long, y As Decimal) As Decimal

Parameters

x

Int64

y

Decimal

Returns

Decimal

Minus(Int64, Int16)

public:
 static long Minus(long x, short y);

public static long Minus (long x, short y);

static member Minus : int64 * int16 -> int64

Public Shared Function Minus (x As Long, y As Short) As Long

Parameters

x

Int64

y

Int16

Returns

Int64

Minus(Int64, Int32)

public:
 static long Minus(long x, int y);

public static long Minus (long x, int y);

static member Minus : int64 * int -> int64

Public Shared Function Minus (x As Long, y As Integer) As Long

Parameters

x

Int64

y

Int32

Returns

Int64

Minus(Int64, Int64)

public:
 static long Minus(long x, long y);

public static long Minus (long x, long y);

static member Minus : int64 * int64 -> int64

Public Shared Function Minus (x As Long, y As Long) As Long

Parameters

x

Int64

y

Int64

Returns

Int64

Minus(Int64, SByte)

public:
 static long Minus(long x, System::SByte y);

public static long Minus (long x, sbyte y);

static member Minus : int64 * sbyte -> int64

Public Shared Function Minus (x As Long, y As SByte) As Long

Parameters

x

Int64

y

SByte

Returns

Int64

Minus(Int64, Single)

public:
 static float Minus(long x, float y);

public static float Minus (long x, float y);

static member Minus : int64 * single -> single

Public Shared Function Minus (x As Long, y As Single) As Single

Parameters

x

Int64

y

Single

Returns

Single

Minus(Int64, UInt16)

public:
 static long Minus(long x, System::UInt16 y);

public static long Minus (long x, ushort y);

static member Minus : int64 * uint16 -> int64

Public Shared Function Minus (x As Long, y As UShort) As Long

Parameters

x

Int64

y

UInt16

Returns

Int64

Minus(Int64, Double)

public:
 static double Minus(long x, double y);

public static double Minus (long x, double y);

static member Minus : int64 * double -> double

Public Shared Function Minus (x As Long, y As Double) As Double

Parameters

x

Int64

y

Double

Returns

Double

Minus(Int32, Int64)

public:
 static long Minus(int x, long y);

public static long Minus (int x, long y);

static member Minus : int * int64 -> int64

Public Shared Function Minus (x As Integer, y As Long) As Long

Parameters

x

Int32

y

Int64

Returns

Int64

Minus(Single, SByte)

public:
 static float Minus(float x, System::SByte y);

public static float Minus (float x, sbyte y);

static member Minus : single * sbyte -> single

Public Shared Function Minus (x As Single, y As SByte) As Single

Parameters

x

Single

y

SByte

Returns

Single

Minus(Single, UInt16)

public:
 static float Minus(float x, System::UInt16 y);

public static float Minus (float x, ushort y);

static member Minus : single * uint16 -> single

Public Shared Function Minus (x As Single, y As UShort) As Single

Parameters

x

Single

y

UInt16

Returns

Single

Minus(UInt32, Int16)

public:
 static long Minus(System::UInt32 x, short y);

public static long Minus (uint x, short y);

static member Minus : uint32 * int16 -> int64

Public Shared Function Minus (x As UInteger, y As Short) As Long

Parameters

x

UInt32

y

Int16

Returns

Int64

Minus(UInt32, Int32)

public:
 static long Minus(System::UInt32 x, int y);

public static long Minus (uint x, int y);

static member Minus : uint32 * int -> int64

Public Shared Function Minus (x As UInteger, y As Integer) As Long

Parameters

x

UInt32

y

Int32

Returns

Int64

Minus(UInt32, Int64)

public:
 static long Minus(System::UInt32 x, long y);

public static long Minus (uint x, long y);

static member Minus : uint32 * int64 -> int64

Public Shared Function Minus (x As UInteger, y As Long) As Long

Parameters

x

UInt32

y

Int64

Returns

Int64

Minus(UInt32, SByte)

public:
 static long Minus(System::UInt32 x, System::SByte y);

public static long Minus (uint x, sbyte y);

static member Minus : uint32 * sbyte -> int64

Public Shared Function Minus (x As UInteger, y As SByte) As Long

Parameters

x

UInt32

y

SByte

Returns

Int64

Minus(UInt32, Single)

public:
 static float Minus(System::UInt32 x, float y);

public static float Minus (uint x, float y);

static member Minus : uint32 * single -> single

Public Shared Function Minus (x As UInteger, y As Single) As Single

Parameters

x

UInt32

y

Single

Returns

Single

Minus(UInt32, UInt16)

public:
 static System::UInt32 Minus(System::UInt32 x, System::UInt16 y);

public static uint Minus (uint x, ushort y);

static member Minus : uint32 * uint16 -> uint32

Public Shared Function Minus (x As UInteger, y As UShort) As UInteger

Parameters

x

UInt32

y

UInt16

Returns

UInt32

Minus(UInt32, Double)

public:
 static double Minus(System::UInt32 x, double y);

public static double Minus (uint x, double y);

static member Minus : uint32 * double -> double

Public Shared Function Minus (x As UInteger, y As Double) As Double

Parameters

x

UInt32

y

Double

Returns

Double

Minus(UInt32, UInt32)

public:
 static System::UInt32 Minus(System::UInt32 x, System::UInt32 y);

public static uint Minus (uint x, uint y);

static member Minus : uint32 * uint32 -> uint32

Public Shared Function Minus (x As UInteger, y As UInteger) As UInteger

Parameters

x

UInt32

y

UInt32

Returns

UInt32

Minus(UInt64, Boolean)

public:
 static System::UInt64 Minus(System::UInt64 x, bool y);

public static ulong Minus (ulong x, bool y);

static member Minus : uint64 * bool -> uint64

Public Shared Function Minus (x As ULong, y As Boolean) As ULong

Parameters

x

UInt64

y

Boolean

Returns

UInt64

Minus(UInt64, Byte)

public:
 static System::UInt64 Minus(System::UInt64 x, System::Byte y);

public static ulong Minus (ulong x, byte y);

static member Minus : uint64 * byte -> uint64

Public Shared Function Minus (x As ULong, y As Byte) As ULong

Parameters

x

UInt64

y

Byte

Returns

UInt64

Minus(UInt64, Decimal)

public:
 static System::Decimal Minus(System::UInt64 x, System::Decimal y);

public static decimal Minus (ulong x, decimal y);

static member Minus : uint64 * decimal -> decimal

Public Shared Function Minus (x As ULong, y As Decimal) As Decimal

Parameters

x

UInt64

y

Decimal

Returns

Decimal

Minus(UInt64, Double)

public:
 static double Minus(System::UInt64 x, double y);

public static double Minus (ulong x, double y);

static member Minus : uint64 * double -> double

Public Shared Function Minus (x As ULong, y As Double) As Double

Parameters

x

UInt64

y

Double

Returns

Double

Minus(UInt64, Single)

public:
 static float Minus(System::UInt64 x, float y);

public static float Minus (ulong x, float y);

static member Minus : uint64 * single -> single

Public Shared Function Minus (x As ULong, y As Single) As Single

Parameters

x

UInt64

y

Single

Returns

Single

Minus(UInt64, UInt16)

public:
 static System::UInt64 Minus(System::UInt64 x, System::UInt16 y);

public static ulong Minus (ulong x, ushort y);

static member Minus : uint64 * uint16 -> uint64

Public Shared Function Minus (x As ULong, y As UShort) As ULong

Parameters

x

UInt64

y

UInt16

Returns

UInt64

Minus(UInt32, UInt64)

public:
 static System::UInt64 Minus(System::UInt32 x, System::UInt64 y);

public static ulong Minus (uint x, ulong y);

static member Minus : uint32 * uint64 -> uint64

Public Shared Function Minus (x As UInteger, y As ULong) As ULong

Parameters

x

UInt32

y

UInt64

Returns

UInt64

Minus(Single, Single)

public:
 static float Minus(float x, float y);

public static float Minus (float x, float y);

static member Minus : single * single -> single

Public Shared Function Minus (x As Single, y As Single) As Single

Parameters

x

Single

y

Single

Returns

Single

Minus(UInt32, Decimal)

public:
 static System::Decimal Minus(System::UInt32 x, System::Decimal y);

public static decimal Minus (uint x, decimal y);

static member Minus : uint32 * decimal -> decimal

Public Shared Function Minus (x As UInteger, y As Decimal) As Decimal

Parameters

x

UInt32

y

Decimal

Returns

Decimal

Minus(UInt32, Boolean)

public:
 static System::UInt32 Minus(System::UInt32 x, bool y);

public static uint Minus (uint x, bool y);

static member Minus : uint32 * bool -> uint32

Public Shared Function Minus (x As UInteger, y As Boolean) As UInteger

Parameters

x

UInt32

y

Boolean

Returns

UInt32

Minus(Single, UInt32)

public:
 static float Minus(float x, System::UInt32 y);

public static float Minus (float x, uint y);

static member Minus : single * uint32 -> single

Public Shared Function Minus (x As Single, y As UInteger) As Single

Parameters

x

Single

y

UInt32

Returns

Single

Minus(Single, UInt64)

public:
 static float Minus(float x, System::UInt64 y);

public static float Minus (float x, ulong y);

static member Minus : single * uint64 -> single

Public Shared Function Minus (x As Single, y As ULong) As Single

Parameters

x

Single

y

UInt64

Returns

Single

Minus(UInt16, Boolean)

public:
 static int Minus(System::UInt16 x, bool y);

public static int Minus (ushort x, bool y);

static member Minus : uint16 * bool -> int

Public Shared Function Minus (x As UShort, y As Boolean) As Integer

Parameters

x

UInt16

y

Boolean

Returns

Int32

Minus(UInt16, Byte)

public:
 static int Minus(System::UInt16 x, System::Byte y);

public static int Minus (ushort x, byte y);

static member Minus : uint16 * byte -> int

Public Shared Function Minus (x As UShort, y As Byte) As Integer

Parameters

x

UInt16

y

Byte

Returns

Int32

Minus(UInt16, Decimal)

public:
 static System::Decimal Minus(System::UInt16 x, System::Decimal y);

public static decimal Minus (ushort x, decimal y);

static member Minus : uint16 * decimal -> decimal

Public Shared Function Minus (x As UShort, y As Decimal) As Decimal

Parameters

x

UInt16

y

Decimal

Returns

Decimal

Minus(UInt16, Double)

public:
 static double Minus(System::UInt16 x, double y);

public static double Minus (ushort x, double y);

static member Minus : uint16 * double -> double

Public Shared Function Minus (x As UShort, y As Double) As Double

Parameters

x

UInt16

y

Double

Returns

Double

Minus(UInt32, Byte)

public:
 static System::UInt32 Minus(System::UInt32 x, System::Byte y);

public static uint Minus (uint x, byte y);

static member Minus : uint32 * byte -> uint32

Public Shared Function Minus (x As UInteger, y As Byte) As UInteger

Parameters

x

UInt32

y

Byte

Returns

UInt32

Minus(UInt16, Int16)

public:
 static int Minus(System::UInt16 x, short y);

public static int Minus (ushort x, short y);

static member Minus : uint16 * int16 -> int

Public Shared Function Minus (x As UShort, y As Short) As Integer

Parameters

x

UInt16

y

Int16

Returns

Int32

Minus(UInt16, Int64)

public:
 static long Minus(System::UInt16 x, long y);

public static long Minus (ushort x, long y);

static member Minus : uint16 * int64 -> int64

Public Shared Function Minus (x As UShort, y As Long) As Long

Parameters

x

UInt16

y

Int64

Returns

Int64

Minus(UInt16, SByte)

public:
 static int Minus(System::UInt16 x, System::SByte y);

public static int Minus (ushort x, sbyte y);

static member Minus : uint16 * sbyte -> int

Public Shared Function Minus (x As UShort, y As SByte) As Integer

Parameters

x

UInt16

y

SByte

Returns

Int32

Minus(UInt16, Single)

public:
 static float Minus(System::UInt16 x, float y);

public static float Minus (ushort x, float y);

static member Minus : uint16 * single -> single

Public Shared Function Minus (x As UShort, y As Single) As Single

Parameters

x

UInt16

y

Single

Returns

Single

Minus(UInt16, UInt16)

public:
 static int Minus(System::UInt16 x, System::UInt16 y);

public static int Minus (ushort x, ushort y);

static member Minus : uint16 * uint16 -> int

Public Shared Function Minus (x As UShort, y As UShort) As Integer

Parameters

x

UInt16

y

UInt16

Returns

Int32

Minus(UInt16, UInt32)

public:
 static System::UInt32 Minus(System::UInt16 x, System::UInt32 y);

public static uint Minus (ushort x, uint y);

static member Minus : uint16 * uint32 -> uint32

Public Shared Function Minus (x As UShort, y As UInteger) As UInteger

Parameters

x

UInt16

y

UInt32

Returns

UInt32

Minus(UInt16, UInt64)

public:
 static System::UInt64 Minus(System::UInt16 x, System::UInt64 y);

public static ulong Minus (ushort x, ulong y);

static member Minus : uint16 * uint64 -> uint64

Public Shared Function Minus (x As UShort, y As ULong) As ULong

Parameters

x

UInt16

y

UInt64

Returns

UInt64

Minus(UInt16, Int32)

public:
 static int Minus(System::UInt16 x, int y);

public static int Minus (ushort x, int y);

static member Minus : uint16 * int -> int

Public Shared Function Minus (x As UShort, y As Integer) As Integer

Parameters

x

UInt16

y

Int32

Returns

Int32

Minus(Int32, Int32)

public:
 static int Minus(int x, int y);

public static int Minus (int x, int y);

static member Minus : int * int -> int

Public Shared Function Minus (x As Integer, y As Integer) As Integer

Parameters

x

Int32

y

Int32

Returns

Int32

Minus(Int32, Int16)

public:
 static int Minus(int x, short y);

public static int Minus (int x, short y);

static member Minus : int * int16 -> int

Public Shared Function Minus (x As Integer, y As Short) As Integer

Parameters

x

Int32

y

Int16

Returns

Int32

Minus(Int32, Double)

public:
 static double Minus(int x, double y);

public static double Minus (int x, double y);

static member Minus : int * double -> double

Public Shared Function Minus (x As Integer, y As Double) As Double

Parameters

x

Int32

y

Double

Returns

Double

Minus(Boolean, SByte)

public:
 static int Minus(bool x, System::SByte y);

public static int Minus (bool x, sbyte y);

static member Minus : bool * sbyte -> int

Public Shared Function Minus (x As Boolean, y As SByte) As Integer

Parameters

x

Boolean

y

SByte

Returns

Int32

Minus(Boolean, Single)

public:
 static float Minus(bool x, float y);

public static float Minus (bool x, float y);

static member Minus : bool * single -> single

Public Shared Function Minus (x As Boolean, y As Single) As Single

Parameters

x

Boolean

y

Single

Returns

Single

Minus(Boolean, UInt16)

public:
 static int Minus(bool x, System::UInt16 y);

public static int Minus (bool x, ushort y);

static member Minus : bool * uint16 -> int

Public Shared Function Minus (x As Boolean, y As UShort) As Integer

Parameters

x

Boolean

y

UInt16

Returns

Int32

Minus(Boolean, UInt32)

public:
 static System::UInt32 Minus(bool x, System::UInt32 y);

public static uint Minus (bool x, uint y);

static member Minus : bool * uint32 -> uint32

Public Shared Function Minus (x As Boolean, y As UInteger) As UInteger

Parameters

x

Boolean

y

UInt32

Returns

UInt32

Minus(Boolean, UInt64)

public:
 static System::UInt64 Minus(bool x, System::UInt64 y);

public static ulong Minus (bool x, ulong y);

static member Minus : bool * uint64 -> uint64

Public Shared Function Minus (x As Boolean, y As ULong) As ULong

Parameters

x

Boolean

y

UInt64

Returns

UInt64

Minus(Byte, Byte)

public:
 static int Minus(System::Byte x, System::Byte y);

public static int Minus (byte x, byte y);

static member Minus : byte * byte -> int

Public Shared Function Minus (x As Byte, y As Byte) As Integer

Parameters

x

Byte

y

Byte

Returns

Int32

Minus(Boolean, Int64)

public:
 static long Minus(bool x, long y);

public static long Minus (bool x, long y);

static member Minus : bool * int64 -> int64

Public Shared Function Minus (x As Boolean, y As Long) As Long

Parameters

x

Boolean

y

Int64

Returns

Int64

Minus(Byte, Decimal)

public:
 static System::Decimal Minus(System::Byte x, System::Decimal y);

public static decimal Minus (byte x, decimal y);

static member Minus : byte * decimal -> decimal

Public Shared Function Minus (x As Byte, y As Decimal) As Decimal

Parameters

x

Byte

y

Decimal

Returns

Decimal

Minus(Byte, Int16)

public:
 static int Minus(System::Byte x, short y);

public static int Minus (byte x, short y);

static member Minus : byte * int16 -> int

Public Shared Function Minus (x As Byte, y As Short) As Integer

Parameters

x

Byte

y

Int16

Returns

Int32

Minus(Byte, Int32)

public:
 static int Minus(System::Byte x, int y);

public static int Minus (byte x, int y);

static member Minus : byte * int -> int

Public Shared Function Minus (x As Byte, y As Integer) As Integer

Parameters

x

Byte

y

Int32

Returns

Int32

Minus(Byte, Int64)

public:
 static long Minus(System::Byte x, long y);

public static long Minus (byte x, long y);

static member Minus : byte * int64 -> int64

Public Shared Function Minus (x As Byte, y As Long) As Long

Parameters

x

Byte

y

Int64

Returns

Int64

Minus(Byte, SByte)

public:
 static int Minus(System::Byte x, System::SByte y);

public static int Minus (byte x, sbyte y);

static member Minus : byte * sbyte -> int

Public Shared Function Minus (x As Byte, y As SByte) As Integer

Parameters

x

Byte

y

SByte

Returns

Int32

Minus(Byte, Single)

public:
 static float Minus(System::Byte x, float y);

public static float Minus (byte x, float y);

static member Minus : byte * single -> single

Public Shared Function Minus (x As Byte, y As Single) As Single

Parameters

x

Byte

y

Single

Returns

Single

Minus(Byte, UInt16)

public:
 static int Minus(System::Byte x, System::UInt16 y);

public static int Minus (byte x, ushort y);

static member Minus : byte * uint16 -> int

Public Shared Function Minus (x As Byte, y As UShort) As Integer

Parameters

x

Byte

y

UInt16

Returns

Int32

Minus(Byte, Double)

public:
 static double Minus(System::Byte x, double y);

public static double Minus (byte x, double y);

static member Minus : byte * double -> double

Public Shared Function Minus (x As Byte, y As Double) As Double

Parameters

x

Byte

y

Double

Returns

Double

Minus(Byte, UInt32)

public:
 static System::UInt32 Minus(System::Byte x, System::UInt32 y);

public static uint Minus (byte x, uint y);

static member Minus : byte * uint32 -> uint32

Public Shared Function Minus (x As Byte, y As UInteger) As UInteger

Parameters

x

Byte

y

UInt32

Returns

UInt32

Minus(Boolean, Int32)

public:
 static int Minus(bool x, int y);

public static int Minus (bool x, int y);

static member Minus : bool * int -> int

Public Shared Function Minus (x As Boolean, y As Integer) As Integer

Parameters

x

Boolean

y

Int32

Returns

Int32

Minus(Boolean, Double)

public:
 static double Minus(bool x, double y);

public static double Minus (bool x, double y);

static member Minus : bool * double -> double

Public Shared Function Minus (x As Boolean, y As Double) As Double

Parameters

x

Boolean

y

Double

Returns

Double

Minus(Date, Byte)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::Byte y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, byte y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * byte -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Byte) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Byte

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, Decimal)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::Decimal y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, decimal y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * decimal -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Decimal) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Decimal

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, Double)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, double y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, double y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * double -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Double) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Double

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, Int16)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, short y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, short y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * int16 -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Short) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Int16

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, Int32)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, int y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, int y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * int -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Integer) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Int32

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, Int64)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, long y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, long y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * int64 -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Long) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Int64

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Boolean, Int16)

public:
 static int Minus(bool x, short y);

public static int Minus (bool x, short y);

static member Minus : bool * int16 -> int

Public Shared Function Minus (x As Boolean, y As Short) As Integer

Parameters

x

Boolean

y

Int16

Returns

Int32

Minus(Date, SByte)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::SByte y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, sbyte y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * sbyte -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As SByte) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

SByte

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, UInt16)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::UInt16 y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, ushort y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * uint16 -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As UShort) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

UInt16

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, UInt32)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::UInt32 y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, uint y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * uint32 -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As UInteger) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

UInt32

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Date, UInt64)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, System::UInt64 y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, ulong y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * uint64 -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As ULong) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

UInt64

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(utcdatetime, utcdatetime)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::utcdatetime Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::utcdatetime x, Microsoft::Dynamics::Ax::Xpp::AxShared::utcdatetime y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime x, Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime * Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime -> Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime

Public Shared Function Minus (x As utcdatetime, y As utcdatetime) As utcdatetime

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime

y

Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.utcdatetime

Minus(Boolean, Boolean)

public:
 static int Minus(bool x, bool y);

public static int Minus (bool x, bool y);

static member Minus : bool * bool -> int

Public Shared Function Minus (x As Boolean, y As Boolean) As Integer

Parameters

x

Boolean

y

Boolean

Returns

Int32

Minus(Boolean, Decimal)

public:
 static System::Decimal Minus(bool x, System::Decimal y);

public static decimal Minus (bool x, decimal y);

static member Minus : bool * decimal -> decimal

Public Shared Function Minus (x As Boolean, y As Decimal) As Decimal

Parameters

x

Boolean

y

Decimal

Returns

Decimal

Minus(Date, Single)

public:
 static Microsoft::Dynamics::Ax::Xpp::AxShared::Date Minus(Microsoft::Dynamics::Ax::Xpp::AxShared::Date x, float y);

public static Microsoft.Dynamics.Ax.Xpp.AxShared.Date Minus (Microsoft.Dynamics.Ax.Xpp.AxShared.Date x, float y);

static member Minus : Microsoft.Dynamics.Ax.Xpp.AxShared.Date * single -> Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Public Shared Function Minus (x As Date, y As Single) As Date

Parameters

x

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

y

Single

Returns

Microsoft.Dynamics.Ax.Xpp.AxShared.Date

Minus(Byte, UInt64)

public:
 static System::UInt64 Minus(System::Byte x, System::UInt64 y);

public static ulong Minus (byte x, ulong y);

static member Minus : byte * uint64 -> uint64

Public Shared Function Minus (x As Byte, y As ULong) As ULong

Parameters

x

Byte

y

UInt64

Returns

UInt64

Minus(Decimal, Boolean)

public:
 static System::Decimal Minus(System::Decimal x, bool y);

public static decimal Minus (decimal x, bool y);

static member Minus : decimal * bool -> decimal

Public Shared Function Minus (x As Decimal, y As Boolean) As Decimal

Parameters

x

Decimal

y

Boolean

Returns

Decimal

Minus(Decimal, Byte)

public:
 static System::Decimal Minus(System::Decimal x, System::Byte y);

public static decimal Minus (decimal x, byte y);

static member Minus : decimal * byte -> decimal

Public Shared Function Minus (x As Decimal, y As Byte) As Decimal

Parameters

x

Decimal

y

Byte

Returns

Decimal

Minus(Int16, Boolean)

public:
 static int Minus(short x, bool y);

public static int Minus (short x, bool y);

static member Minus : int16 * bool -> int

Public Shared Function Minus (x As Short, y As Boolean) As Integer

Parameters

x

Int16

y

Boolean

Returns

Int32

Minus(Int16, Byte)

public:
 static int Minus(short x, System::Byte y);

public static int Minus (short x, byte y);

static member Minus : int16 * byte -> int

Public Shared Function Minus (x As Short, y As Byte) As Integer

Parameters

x

Int16

y

Byte

Returns

Int32

Minus(Int16, Decimal)

public:
 static System::Decimal Minus(short x, System::Decimal y);

public static decimal Minus (short x, decimal y);

static member Minus : int16 * decimal -> decimal

Public Shared Function Minus (x As Short, y As Decimal) As Decimal

Parameters

x

Int16

y

Decimal

Returns

Decimal

Minus(Int16, Double)

public:
 static double Minus(short x, double y);

public static double Minus (short x, double y);

static member Minus : int16 * double -> double

Public Shared Function Minus (x As Short, y As Double) As Double

Parameters

x

Int16

y

Double

Returns

Double

Minus(Int16, Int16)

public:
 static int Minus(short x, short y);

public static int Minus (short x, short y);

static member Minus : int16 * int16 -> int

Public Shared Function Minus (x As Short, y As Short) As Integer

Parameters

x

Int16

y

Int16

Returns

Int32

Minus(Int16, Int32)

public:
 static int Minus(short x, int y);

public static int Minus (short x, int y);

static member Minus : int16 * int -> int

Public Shared Function Minus (x As Short, y As Integer) As Integer

Parameters

x

Int16

y

Int32

Returns

Int32

Minus(Double, UInt64)

public:
 static double Minus(double x, System::UInt64 y);

public static double Minus (double x, ulong y);

static member Minus : double * uint64 -> double

Public Shared Function Minus (x As Double, y As ULong) As Double

Parameters

x

Double

y

UInt64

Returns

Double

Minus(Int16, Int64)

public:
 static long Minus(short x, long y);

public static long Minus (short x, long y);

static member Minus : int16 * int64 -> int64

Public Shared Function Minus (x As Short, y As Long) As Long

Parameters

x

Int16

y

Int64

Returns

Int64

Minus(Int16, Single)

public:
 static float Minus(short x, float y);

public static float Minus (short x, float y);

static member Minus : int16 * single -> single

Public Shared Function Minus (x As Short, y As Single) As Single

Parameters

x

Int16

y

Single

Returns

Single

Minus(Int16, UInt16)

public:
 static int Minus(short x, System::UInt16 y);

public static int Minus (short x, ushort y);

static member Minus : int16 * uint16 -> int

Public Shared Function Minus (x As Short, y As UShort) As Integer

Parameters

x

Int16

y

UInt16

Returns

Int32

Minus(Int16, UInt32)

public:
 static long Minus(short x, System::UInt32 y);

public static long Minus (short x, uint y);

static member Minus : int16 * uint32 -> int64

Public Shared Function Minus (x As Short, y As UInteger) As Long

Parameters

x

Int16

y

UInt32

Returns

Int64

Minus(Int32, Boolean)

public:
 static int Minus(int x, bool y);

public static int Minus (int x, bool y);

static member Minus : int * bool -> int

Public Shared Function Minus (x As Integer, y As Boolean) As Integer

Parameters

x

Int32

y

Boolean

Returns

Int32

Minus(Int32, Byte)

public:
 static int Minus(int x, System::Byte y);

public static int Minus (int x, byte y);

static member Minus : int * byte -> int

Public Shared Function Minus (x As Integer, y As Byte) As Integer

Parameters

x

Int32

y

Byte

Returns

Int32

Minus(Int32, Decimal)

public:
 static System::Decimal Minus(int x, System::Decimal y);

public static decimal Minus (int x, decimal y);

static member Minus : int * decimal -> decimal

Public Shared Function Minus (x As Integer, y As Decimal) As Decimal

Parameters

x

Int32

y

Decimal

Returns

Decimal

Minus(Int16, SByte)

public:
 static int Minus(short x, System::SByte y);

public static int Minus (short x, sbyte y);

static member Minus : int16 * sbyte -> int

Public Shared Function Minus (x As Short, y As SByte) As Integer

Parameters

x

Int16

y

SByte

Returns

Int32

Minus(Double, UInt32)

public:
 static double Minus(double x, System::UInt32 y);

public static double Minus (double x, uint y);

static member Minus : double * uint32 -> double

Public Shared Function Minus (x As Double, y As UInteger) As Double

Parameters

x

Double

y

UInt32

Returns

Double

Minus(Double, UInt16)

public:
 static double Minus(double x, System::UInt16 y);

public static double Minus (double x, ushort y);

static member Minus : double * uint16 -> double

Public Shared Function Minus (x As Double, y As UShort) As Double

Parameters

x

Double

y

UInt16

Returns

Double

Minus(Double, Single)

public:
 static double Minus(double x, float y);

public static double Minus (double x, float y);

static member Minus : double * single -> double

Public Shared Function Minus (x As Double, y As Single) As Double

Parameters

x

Double

y

Single

Returns

Double

Minus(Decimal, Decimal)

public:
 static System::Decimal Minus(System::Decimal x, System::Decimal y);

public static decimal Minus (decimal x, decimal y);

static member Minus : decimal * decimal -> decimal

Public Shared Function Minus (x As Decimal, y As Decimal) As Decimal

Parameters

x

Decimal

y

Decimal

Returns

Decimal

Minus(Decimal, Int16)

public:
 static System::Decimal Minus(System::Decimal x, short y);

public static decimal Minus (decimal x, short y);

static member Minus : decimal * int16 -> decimal

Public Shared Function Minus (x As Decimal, y As Short) As Decimal

Parameters

x

Decimal

y

Int16

Returns

Decimal

Minus(Decimal, Int32)

public:
 static System::Decimal Minus(System::Decimal x, int y);

public static decimal Minus (decimal x, int y);

static member Minus : decimal * int -> decimal

Public Shared Function Minus (x As Decimal, y As Integer) As Decimal

Parameters

x

Decimal

y

Int32

Returns

Decimal

Minus(Decimal, Int64)

public:
 static System::Decimal Minus(System::Decimal x, long y);

public static decimal Minus (decimal x, long y);

static member Minus : decimal * int64 -> decimal

Public Shared Function Minus (x As Decimal, y As Long) As Decimal

Parameters

x

Decimal

y

Int64

Returns

Decimal

Minus(Decimal, SByte)

public:
 static System::Decimal Minus(System::Decimal x, System::SByte y);

public static decimal Minus (decimal x, sbyte y);

static member Minus : decimal * sbyte -> decimal

Public Shared Function Minus (x As Decimal, y As SByte) As Decimal

Parameters

x

Decimal

y

SByte

Returns

Decimal

Minus(Decimal, UInt16)

public:
 static System::Decimal Minus(System::Decimal x, System::UInt16 y);

public static decimal Minus (decimal x, ushort y);

static member Minus : decimal * uint16 -> decimal

Public Shared Function Minus (x As Decimal, y As UShort) As Decimal

Parameters

x

Decimal

y

UInt16

Returns

Decimal

Minus(Decimal, UInt32)

public:
 static System::Decimal Minus(System::Decimal x, System::UInt32 y);

public static decimal Minus (decimal x, uint y);

static member Minus : decimal * uint32 -> decimal

Public Shared Function Minus (x As Decimal, y As UInteger) As Decimal

Parameters

x

Decimal

y

UInt32

Returns

Decimal

Minus(Decimal, UInt64)

public:
 static System::Decimal Minus(System::Decimal x, System::UInt64 y);

public static decimal Minus (decimal x, ulong y);

static member Minus : decimal * uint64 -> decimal

Public Shared Function Minus (x As Decimal, y As ULong) As Decimal

Parameters

x

Decimal

y

UInt64

Returns

Decimal

Minus(Double, Boolean)

public:
 static double Minus(double x, bool y);

public static double Minus (double x, bool y);

static member Minus : double * bool -> double

Public Shared Function Minus (x As Double, y As Boolean) As Double

Parameters

x

Double

y

Boolean

Returns

Double

Minus(Double, Byte)

public:
 static double Minus(double x, System::Byte y);

public static double Minus (double x, byte y);

static member Minus : double * byte -> double

Public Shared Function Minus (x As Double, y As Byte) As Double

Parameters

x

Double

y

Byte

Returns

Double

Minus(Double, Double)

public:
 static double Minus(double x, double y);

public static double Minus (double x, double y);

static member Minus : double * double -> double

Public Shared Function Minus (x As Double, y As Double) As Double

Parameters

x

Double

y

Double

Returns

Double

Minus(Double, Int16)

public:
 static double Minus(double x, short y);

public static double Minus (double x, short y);

static member Minus : double * int16 -> double

Public Shared Function Minus (x As Double, y As Short) As Double

Parameters

x

Double

y

Int16

Returns

Double

Minus(Double, Int32)

public:
 static double Minus(double x, int y);

public static double Minus (double x, int y);

static member Minus : double * int -> double

Public Shared Function Minus (x As Double, y As Integer) As Double

Parameters

x

Double

y

Int32

Returns

Double

Minus(Double, Int64)

public:
 static double Minus(double x, long y);

public static double Minus (double x, long y);

static member Minus : double * int64 -> double

Public Shared Function Minus (x As Double, y As Long) As Double

Parameters

x

Double

y

Int64

Returns

Double

Minus(Double, SByte)

public:
 static double Minus(double x, System::SByte y);

public static double Minus (double x, sbyte y);

static member Minus : double * sbyte -> double

Public Shared Function Minus (x As Double, y As SByte) As Double

Parameters

x

Double

y

SByte

Returns

Double

Minus(UInt64, UInt32)

public:
 static System::UInt64 Minus(System::UInt64 x, System::UInt32 y);

public static ulong Minus (ulong x, uint y);

static member Minus : uint64 * uint32 -> uint64

Public Shared Function Minus (x As ULong, y As UInteger) As ULong

Parameters

x

UInt64

y

UInt32

Returns

UInt64

Minus(UInt64, UInt64)

public:
 static System::UInt64 Minus(System::UInt64 x, System::UInt64 y);

public static ulong Minus (ulong x, ulong y);

static member Minus : uint64 * uint64 -> uint64

Public Shared Function Minus (x As ULong, y As ULong) As ULong

Parameters

x

UInt64

y

UInt64

Returns

UInt64