Beispiel #1
0
        public UBigIntHandle Multiply(UInt64 u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Multiply_UL_UX(u, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #2
0
        public UBigIntHandle ModPow(UBigIntHandle v, UBigIntHandle e, UBigIntHandle m)
        {
            IntPtr r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_ModPow_UX_UX_UX(v.NativeHandle, e.NativeHandle, m.NativeHandle, out r));
            return(new UBigIntHandle(r));
        }
Beispiel #3
0
        public UInt64 GetBitLength(UBigIntHandle value)
        {
            UInt64 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_GET_BIT_LENGTH(value.NativeHandle, out r));
            return(r);
        }
Beispiel #4
0
        public bool Equals(UBigIntHandle u, UBigIntHandle v)
        {
            UInt32 w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Equals_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(w != 0);
        }
Beispiel #5
0
        public UBigIntHandle GreatestCommonDivisor(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_GreatestCommonDivisor_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #6
0
        public UBigIntHandle BitwiseOr(UBigIntHandle u, UInt64 v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_BitwiseOr_UX_UL(u.NativeHandle, v, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #7
0
        public bool IsZero(UBigIntHandle value)
        {
            UInt32 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_IS_ZERO(value.NativeHandle, out r));
            return(r != 0);
        }
Beispiel #8
0
        public UBigIntHandle DivideExactly(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr q_handle;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_DivideExactly_UX_UX(u.NativeHandle, v.NativeHandle, out q_handle));
            return(new UBigIntHandle(q_handle));
        }
Beispiel #9
0
        public UInt64 Remainder(UInt64 u, UBigIntHandle v)
        {
            UInt64 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Remainder_UL_UX(u, v.NativeHandle, out r));
            return(r);
        }
Beispiel #10
0
        public UBigIntHandle DivRem(UBigIntHandle u, UInt64 v, out UInt64 r)
        {
            IntPtr q_handle;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_DivRem_UX_UL(u.NativeHandle, v, out q_handle, out r));
            return(new UBigIntHandle(q_handle));
        }
Beispiel #11
0
        public UInt64 DivideExactly(UInt64 u, UBigIntHandle v)
        {
            UInt64 q;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_DivideExactly_UL_UX(u, v.NativeHandle, out q));
            return(q);
        }
Beispiel #12
0
        public UInt64 DivRem(UInt64 u, UBigIntHandle v, out UInt64 r)
        {
            UInt64 q;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_DivRem_UL_UX(u, v.NativeHandle, out q, out r));
            return(q);
        }
Beispiel #13
0
        public UBigIntHandle Multiply(MultiplicationMethod method, UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Multiply_I_UX_UX((Int32)method, u.NativeHandle, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #14
0
        public UBigIntHandle Multiply(UBigIntHandle u, UInt64 v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Multiply_UX_UL(u.NativeHandle, v, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #15
0
        public bool IsPowerOfTwo(UBigIntHandle value)
        {
            UInt32 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_IS_POWER_OF_TWO(value.NativeHandle, out r));
            return(r != 0);
        }
Beispiel #16
0
        public UInt64 Remainder(UBigIntHandle u, UInt64 v)
        {
            UInt64 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Remainder_UX_UL(u.NativeHandle, v, out r));
            return(r);
        }
Beispiel #17
0
        public UBigIntHandle BitwiseOr(UInt64 u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_BitwiseOr_UL_UX(u, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #18
0
        public UBigIntHandle Remainder(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Remainder_UX_UX(u.NativeHandle, v.NativeHandle, out r));
            return(new UBigIntHandle(r));
        }
Beispiel #19
0
        public UBigIntHandle ExclusiveOr(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_ExclusiveOr_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #20
0
        public UBigIntHandle RightShift(UBigIntHandle x, Int32 n)
        {
            IntPtr r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_RightShift_UX_I(x.NativeHandle, n, out r));
            return(new UBigIntHandle(r));
        }
Beispiel #21
0
        public Int32 Compare(UBigIntHandle u, UBigIntHandle v)
        {
            Int32 w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Compare_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(w);
        }
Beispiel #22
0
        public UBigIntHandle LeftShift(UBigIntHandle x, UInt64 n)
        {
            IntPtr r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_LeftShift_UX_UL(x.NativeHandle, n, out r));
            return(new UBigIntHandle(r));
        }
Beispiel #23
0
        public Int32 GetHashCode(UBigIntHandle value)
        {
            Int32 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_GET_HASH_CODE(value.NativeHandle, out r));
            return(r);
        }
Beispiel #24
0
        public UInt64 BitwiseAnd(UInt64 u, UBigIntHandle v)
        {
            UInt64 w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_BitwiseAnd_UL_UX(u, v.NativeHandle, out w));
            return(w);
        }
Beispiel #25
0
        public UBigIntHandle Pow(UBigIntHandle x, UInt32 n)
        {
            IntPtr v;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Pow_UX_UI(x.NativeHandle, n, out v));
            return(new UBigIntHandle(v));
        }
Beispiel #26
0
        public UInt64 BitwiseAnd(UBigIntHandle u, UInt64 v)
        {
            UInt64 w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_BitwiseAnd_UX_UL(u.NativeHandle, v, out w));
            return(w);
        }
Beispiel #27
0
        public UInt32 FloorLog10(UBigIntHandle v)
        {
            UInt32 r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_FloorLog10_UX(v.NativeHandle, out r));
            return(r);
        }
Beispiel #28
0
        public UBigIntHandle BitwiseAnd(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_BitwiseAnd_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }
Beispiel #29
0
        public UBigIntHandle Decrement(UBigIntHandle x)
        {
            IntPtr r;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Decrement_UX(x.NativeHandle, out r));
            return(new UBigIntHandle(r));
        }
Beispiel #30
0
        public UBigIntHandle Subtruct(UBigIntHandle u, UBigIntHandle v)
        {
            IntPtr w;

            HandleResultCode((PMC_STATUS_CODE)PMCCS_Subtruct_UX_UX(u.NativeHandle, v.NativeHandle, out w));
            return(new UBigIntHandle(w));
        }