예제 #1
0
파일: BCD.cs 프로젝트: nao-sky/BCD
        public static BCD operator -(BCD l, BCD r)
        {
            try
            {
                int maxLen = Math.Max(l.Length, r.Length);

                l.MaxLen = maxLen;
                r.MaxLen = maxLen;

                if (l.Sign < 0)
                {
                    if (r.Sign < 0)
                    {
                        BCD a = Abs(l) + Abs(r);
                        a.SetSign(-1);

                        return(a);
                    }
                    else
                    {
                        return(r + Abs(l));
                    }
                }
                else
                {
                    if (r.Sign < 0)
                    {
                        return(l + Abs(r));
                    }
                    else
                    {
                        BCD ret = BCD.Zero;
                        ret.MaxLen = maxLen;

                        if (l > r)
                        {
                            int carry = 0;
                            for (int i = maxLen - 1; i >= 0; i--)
                            {
                                Once a = l[i] - r[i];
                                a.ValueSub(Math.Abs(carry));

                                ret[i] = a;

                                carry = a.Carry;
                            }

                            if (carry != 0)
                            {
                                ret[0].ValueSub(Math.Abs(carry));
                            }

                            return(ret);
                        }
                        else
                        {
                            if (l == r)
                            {
                                return(BCD.Zero);
                            }

                            BCD a = r - l;
                            a.SetSign(-1);
                            return(a);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new BCDException("operator - error.", l, r, ex);
            }
        }
예제 #2
0
파일: BCD.cs 프로젝트: nao-sky/BCD
        public static BCD operator *(BCD l, BCD r)
        {
            try
            {
                int maxLen = Math.Max(l.Length, r.Length);
                l.BCDbyteValue.VirtualCount = maxLen;
                r.BCDbyteValue.VirtualCount = maxLen;


                if (l.Sign < 0)
                {
                    if (r.Sign < 0)
                    {
                        return(Abs(l) * Abs(r));
                    }
                    else
                    {
                        BCD a, b, c;

                        b = Abs(l);
                        c = Abs(r);

                        a = b * c;

                        a.SetSign(-1);

                        return(a);
                    }
                }
                else
                {
                    if (r.Sign < 0)
                    {
                        BCD a, b, c;

                        b = Abs(l);
                        c = Abs(r);

                        a = b * c;

                        a.SetSign(-1);

                        return(a);
                    }
                    else
                    {
                        if (IsZero(l) || IsZero(r))
                        {
                            return(new BCD());
                        }

                        BCD gre = l > r ? l : r;
                        if (gre != l)
                        {
                            r = l;
                            l = gre;
                        }

                        BCD ans = new BCD();

                        IEnumerator <Once> re = r.BCDbyteValue.GetReverseEnumerator();
                        int digit             = 0;


                        while (re.MoveNext())
                        {
                            BCD m1 = new BCD
                            {
                                MaxLen = maxLen
                            };

                            int carry = 0;
                            int idx   = maxLen - 1;

                            Once m = re.Current;
                            if (m.Val == Once.Zero.Val)
                            {
                                digit++;
                                continue;
                            }

                            IEnumerator <Once> le = l.BCDbyteValue.GetReverseEnumerator();

                            while (le.MoveNext())
                            {
                                Once a = le.Current * m;

                                a.ValueAdd(carry);

                                m1[idx--] = a;

                                carry = a.Carry;
                            }

                            if (carry > 0)
                            {
                                if (idx >= 0)
                                {
                                    m1[idx] = new Once()
                                    {
                                        Val = (byte)carry
                                    };
                                }
                                else
                                {
                                    m1.BCDbyteValue.Insert(0, new Once()
                                    {
                                        Val = (byte)carry
                                    });
                                }
                            }

                            if (!BCD.IsZero(m1))
                            {
                                BCD tmp = Multiply10(m1, digit++);
                                ans += tmp;
                            }
                        }
                        return(ans);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new BCDException("operator * error.", l, r, ex);
            }
        }
예제 #3
0
파일: BCD.cs 프로젝트: nao-sky/BCD
        public static BCD operator +(BCD l, BCD r)
        {
            try
            {
                int maxLen = Math.Max(l.Length, r.Length);
                l.MaxLen = maxLen;
                r.MaxLen = maxLen;


                if (l.Sign < 0)
                {
                    if (r.Sign < 0)
                    {
                        BCD a = Abs(l) + Abs(r);

                        a.SetSign(-1);

                        return(a);
                    }
                    else
                    {
                        BCD a, b, c;

                        b = Abs(l);
                        c = Abs(r);

                        if (b == c)
                        {
                            return(new BCD());
                        }
                        if (b > c)
                        {
                            a = b - c;
                            a.SetSign(l.Sign);
                        }
                        else
                        {
                            a = c - b;
                            a.SetSign(r.Sign);
                        }

                        return(a);
                    }
                }
                else
                {
                    if (r.Sign < 0)
                    {
                        BCD newR = Abs(r);

                        return(l - newR);
                    }
                    else
                    {
                        BCD ret = new BCD
                        {
                            MaxLen = maxLen
                        };

                        int carry = 0;
                        for (int i = maxLen - 1; i >= 0; i--)
                        {
                            Once a = l[i] + r[i];
                            a.ValueAdd(carry);

                            ret[i] = a;

                            carry = a.Carry;
                        }

                        if (carry > 0)
                        {
                            ret.MaxLen++;
                            ret[0] = new Once()
                            {
                                Val = (byte)carry
                            };
                        }

                        return(ret);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new BCDException("operator + error.", l, r, ex);
            }
        }