コード例 #1
0
ファイル: Numeric.cs プロジェクト: Lipsis/Lipsis
        public void Modulus(ArithmeticNumeric number) {
            #region SBYTE
            if (p_Type == NumericalType.SBYTE) {
                sbyte ret = (sbyte)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (sbyte)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (sbyte)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (sbyte)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (sbyte)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (sbyte)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (sbyte)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (sbyte)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (sbyte)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (sbyte)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region BYTE
            else if (p_Type == NumericalType.BYTE) {
                byte ret = (byte)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (byte)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (byte)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (byte)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (byte)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (byte)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (byte)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (byte)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (byte)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (byte)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region INT16
            else if (p_Type == NumericalType.INT16) {
                short ret = (short)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (short)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (short)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (short)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (short)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (short)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (short)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (short)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (short)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (short)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region UINT16
            else if (p_Type == NumericalType.UINT16) {
                ushort ret = (ushort)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (ushort)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (ushort)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (ushort)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (ushort)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (ushort)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (ushort)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (ushort)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (ushort)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (ushort)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region INT32
            else if (p_Type == NumericalType.INT32) {
                int ret = (int)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (int)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (int)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (int)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (int)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (int)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (int)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (int)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (int)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (int)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region UINT32
            else if (p_Type == NumericalType.UINT32) {
                uint ret = (uint)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (uint)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (uint)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (uint)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (uint)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (uint)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (uint)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (uint)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (uint)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (uint)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region INT64
            else if (p_Type == NumericalType.INT64) {
                long ret = (long)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (long)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (long)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (long)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (long)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (long)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (long)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (long)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (long)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (long)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region UINT64
            else if (p_Type == NumericalType.UINT64) {
                ulong ret = (ulong)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (ulong)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (ulong)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (ulong)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (ulong)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (ulong)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (ulong)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (ulong)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (ulong)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (ulong)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region FLOAT
            else if (p_Type == NumericalType.FLOAT) {
                float ret = (float)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (float)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (float)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (float)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (float)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (float)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (float)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (float)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (float)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (float)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region DOUBLE
            else if (p_Type == NumericalType.DOUBLE) {
                double ret = (double)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret %= (double)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret %= (double)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret %= (double)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret %= (double)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret %= (double)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret %= (double)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret %= (double)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret %= (double)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret %= (double)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret %= (double)number.p_Value; }
                p_Value = ret;
            }
            #endregion
        }
コード例 #2
0
ファイル: Numeric.cs プロジェクト: Lipsis/Lipsis
        public void ShiftLeft(ArithmeticNumeric number) {
            #region SBYTE
            if (p_Type == NumericalType.SBYTE) {
                sbyte ret = (sbyte)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret <<= (sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret <<= (sbyte)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret <<= (sbyte)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret <<= (sbyte)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret <<= (sbyte)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret <<= (sbyte)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret <<= (sbyte)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret <<= (sbyte)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret <<= (sbyte)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret <<= (sbyte)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region BYTE
            else if (p_Type == NumericalType.BYTE) {
                byte ret = (byte)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret <<= (byte)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret <<= (byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret <<= (byte)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret <<= (byte)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret <<= (byte)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret <<= (byte)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret <<= (byte)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret <<= (byte)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret <<= (byte)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret <<= (byte)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region INT16
            else if (p_Type == NumericalType.INT16) {
                short ret = (short)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret <<= (short)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret <<= (short)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret <<= (short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret <<= (short)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret <<= (short)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret <<= (short)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret <<= (short)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret <<= (short)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret <<= (short)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret <<= (short)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region UINT16
            else if (p_Type == NumericalType.UINT16) {
                ushort ret = (ushort)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret <<= (ushort)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret <<= (ushort)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret <<= (ushort)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret <<= (ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret <<= (ushort)(int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret <<= (ushort)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret <<= (ushort)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret <<= (ushort)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret <<= (ushort)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret <<= (ushort)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region INT32
            else if (p_Type == NumericalType.INT32) {
                int ret = (int)p_Value;
                if (number.p_Type == NumericalType.SBYTE) { ret <<= (int)(sbyte)number.p_Value; }
                else if (number.p_Type == NumericalType.BYTE) { ret <<= (int)(byte)number.p_Value; }
                else if (number.p_Type == NumericalType.INT16) { ret <<= (int)(short)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT16) { ret <<= (int)(ushort)number.p_Value; }
                else if (number.p_Type == NumericalType.INT32) { ret <<= (int)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT32) { ret <<= (int)(uint)number.p_Value; }
                else if (number.p_Type == NumericalType.INT64) { ret <<= (int)(long)number.p_Value; }
                else if (number.p_Type == NumericalType.UINT64) { ret <<= (int)(ulong)number.p_Value; }
                else if (number.p_Type == NumericalType.FLOAT) { ret <<= (int)(float)number.p_Value; }
                else if (number.p_Type == NumericalType.DOUBLE) { ret <<= (int)(double)number.p_Value; }
                p_Value = ret;
            }
            #endregion

            #region UINT32
            else if (p_Type == NumericalType.UINT32) {
                throw new Exception("Not supported");
            }
            #endregion

            #region INT64
            else if (p_Type == NumericalType.INT64) {
                throw new Exception("Not supported");
            }
            #endregion

            #region UINT64
            else if (p_Type == NumericalType.UINT64) {
                throw new Exception("Not supported");
            }
            #endregion

            #region FLOAT
            else if (p_Type == NumericalType.FLOAT) {
                throw new Exception("Not supported");
            }
            #endregion

            #region DOUBLE
            else if (p_Type == NumericalType.DOUBLE) {
                throw new Exception("Not supported");
            }
            #endregion
        }        
コード例 #3
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
        private void processOperand(ref ArithmeticOperand operand, bool canResize, ref ArithmeticNumeric buffer, LinkedList<ArithmeticSubstitute> subs)
        {
            if (operand.IsSubstitution) {
                ArithmeticOperand newOpAnd = processSubstitute(operand, subs);

                //do we have to resize the buffer? to store the substitution?
                if (canResize) {
                    ArithmeticNumeric val = (ArithmeticNumeric)newOpAnd.Value;

                    //decimal?
                    if (!buffer.IsDecimal && newOpAnd.IsDecimal) {
                        ArithmeticNumeric bufferCopy = buffer;

                        buffer = ArithmeticNumeric.CreateOfSize(val.Size, true);
                        buffer += bufferCopy;
                    }

                    //need more memory?
                    else if (buffer.Size < val.Size) {
                        ArithmeticNumeric bufferCopy = buffer;
                        buffer = ArithmeticNumeric.CreateOfSize(val.Size, newOpAnd.IsDecimal);
                        buffer += bufferCopy;
                    }
                }

                if (operand.IsNegative) { newOpAnd.IsNegative = true; }
                operand = newOpAnd;
                return;
            }
            if (operand.IsQueue) {
                ArithmeticNumeric ret = ((ArithmeticQueue)operand.Value).Calculate(subs);
                operand = new ArithmeticOperand(ret, operand.IsNegative);
            }
            if (operand.IsFunction) {
                ArithmeticNumeric ret = ((ArithmeticFunction)operand.Value).Call(subs);
                operand = new ArithmeticOperand(ret, operand.IsNegative);
            }
        }
コード例 #4
0
ファイル: Numeric.cs プロジェクト: Lipsis/Lipsis
        public bool Equals(ArithmeticNumeric compare) {
            #region SBYTE
            if (p_Type == NumericalType.SBYTE) {
                sbyte val = (sbyte)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (sbyte)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (sbyte)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (sbyte)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (sbyte)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (sbyte)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (sbyte)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (sbyte)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (sbyte)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (sbyte)(double)compare.p_Value; }
            }
            #endregion
            
            #region BYTE
            else if (p_Type == NumericalType.BYTE) {
                byte val = (byte)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (byte)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (byte)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (byte)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (byte)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (byte)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (byte)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (byte)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (byte)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (byte)(double)compare.p_Value; }
            }
            #endregion

            #region INT16
            else if (p_Type == NumericalType.INT16) {
                short val = (short)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (short)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (short)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (short)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (short)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (short)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (short)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (short)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (short)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (short)(double)compare.p_Value; }
            }
            #endregion

            #region UINT16
            else if (p_Type == NumericalType.UINT16) {
                ushort val = (ushort)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (ushort)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (ushort)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (ushort)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (ushort)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (ushort)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (ushort)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (ushort)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (ushort)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (ushort)(double)compare.p_Value; }
            }
            #endregion

            #region INT32
            else if (p_Type == NumericalType.INT32) {
                int val = (int)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (int)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (int)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (int)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (int)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (int)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (int)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (int)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (int)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (int)(double)compare.p_Value; }
            }
            #endregion

            #region UINT32
            else if (p_Type == NumericalType.UINT32) {
                uint val = (uint)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (uint)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (uint)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (uint)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (uint)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (uint)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (uint)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (uint)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (uint)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (uint)(double)compare.p_Value; }
            }
            #endregion

            #region INT64
            else if (p_Type == NumericalType.INT64) {
                long val = (long)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (long)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (long)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (long)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (long)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (long)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (long)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (long)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (long)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (long)(double)compare.p_Value; }
            }
            #endregion

            #region UINT64
            else if (p_Type == NumericalType.UINT64) {
                ulong val = (ulong)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (ulong)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (ulong)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (ulong)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (ulong)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (ulong)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (ulong)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (ulong)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (ulong)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (ulong)(double)compare.p_Value; }
            }
            #endregion

            #region FLOAT
            else if (p_Type == NumericalType.FLOAT) {
                float val = (float)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (float)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (float)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (float)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (float)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (float)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (float)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (float)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (float)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (float)(double)compare.p_Value; }
            }
            #endregion

            #region DOUBLE
            else if (p_Type == NumericalType.DOUBLE) {
                double val = (double)p_Value;
                if (compare.p_Type == NumericalType.SBYTE) { return val == (double)(sbyte)compare.p_Value; }
                if (compare.p_Type == NumericalType.BYTE) { return val == (double)(byte)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT16) { return val == (double)(short)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT16) { return val == (double)(ushort)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT32) { return val == (double)(int)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT32) { return val == (double)(uint)compare.p_Value; }
                if (compare.p_Type == NumericalType.INT64) { return val == (double)(long)compare.p_Value; }
                if (compare.p_Type == NumericalType.UINT64) { return val == (double)(ulong)compare.p_Value; }
                if (compare.p_Type == NumericalType.FLOAT) { return val == (double)(float)compare.p_Value; }
                if (compare.p_Type == NumericalType.DOUBLE) { return val == (double)compare.p_Value; }
            }
            #endregion

            //this should never happen
            throw new Exception("");
        }
コード例 #5
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_trunc(ArithmeticNumeric arg)
 {
     return Math.Truncate(Convert.ToDouble(arg.RAWObject));
 }
コード例 #6
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
        private void performCalc(ref ArithmeticNumeric current, ArithmeticOperator op, ArithmeticOperand opAnd)
        {
            //get the operand as decimal
            ArithmeticNumeric opAndDecimal = getOperandValue(opAnd);

            //perform the calculation
            switch (op) {
                case ArithmeticOperator.Addition: current += opAndDecimal; break;
                case ArithmeticOperator.Subtract: current -= opAndDecimal; break;
                case ArithmeticOperator.Multiply: current *= opAndDecimal; break;
                case ArithmeticOperator.Divide: current /= opAndDecimal; break;
                case ArithmeticOperator.Modulus: current %= opAndDecimal; break;
                case ArithmeticOperator.Power:
                    current = Math.Pow(
                        Convert.ToDouble(current.RAWObject),
                        Convert.ToDouble(opAndDecimal.RAWObject));
                    break;
            }
        }
コード例 #7
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_round(ArithmeticNumeric arg)
 {
     return Math.Round(Convert.ToDouble(arg.RAWObject));
 }
コード例 #8
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_sqrt(ArithmeticNumeric arg)
 {
     return Math.Sqrt(Convert.ToDouble(arg.RAWObject));
 }
コード例 #9
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_rand(ArithmeticNumeric arg)
 {
     return p_Random.NextDouble();
 }
コード例 #10
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_floor(ArithmeticNumeric arg)
 {
     return Math.Floor(Convert.ToDouble(arg.RAWObject));
 }
コード例 #11
0
ファイル: Queue.cs プロジェクト: Lipsis/Lipsis
 private static ArithmeticNumeric func_ceil(ArithmeticNumeric arg)
 {
     return Math.Ceiling(Convert.ToDouble(arg.RAWObject));
 }
コード例 #12
0
ファイル: Function.cs プロジェクト: Lipsis/Lipsis
 protected abstract ArithmeticNumeric OnCall(ArithmeticNumeric arg);
コード例 #13
0
ファイル: Function.cs プロジェクト: Lipsis/Lipsis
 protected override ArithmeticNumeric OnCall(ArithmeticNumeric arg)
 {
     return p_Handler(arg);
 }