MinusHelper.Minus Method

Reference

Definition

Namespace:: Microsoft.Dynamics.Ax.Xpp

Assembly:: Microsoft.Dynamics.AX.Xpp.Support.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

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

Applies to

Condividi tramite

MinusHelper.Minus Method

Definition

Overloads

Minus(Date, Date)

Parameters

Returns

Applies to

Minus(SByte, Decimal)

Parameters

Returns

Applies to

Minus(SByte, Double)

Parameters

Returns

Applies to

Minus(SByte, Int16)

Parameters

Returns

Applies to

Minus(SByte, Int32)

Parameters

Returns

Applies to

Minus(SByte, Int64)

Parameters

Returns

Applies to

Minus(SByte, SByte)

Parameters

Returns

Applies to

Minus(SByte, Byte)

Parameters

Returns

Applies to

Minus(SByte, Single)

Parameters

Returns

Applies to

Minus(SByte, UInt32)

Parameters

Returns

Applies to

Minus(Single, Boolean)

Parameters

Returns

Applies to

Minus(Single, Byte)

Parameters

Returns

Applies to

Minus(Single, Double)

Parameters

Returns

Applies to

Minus(Single, Int16)

Parameters

Returns

Applies to

Minus(Single, Int32)

Parameters

Returns

Applies to

Minus(SByte, UInt16)

Parameters

Returns

Applies to

Minus(Single, Int64)

Parameters

Returns

Applies to

Minus(SByte, Boolean)

Parameters

Returns

Applies to

Minus(Int64, UInt32)

Parameters

Returns

Applies to