Changeset 1811


Ignore:
Timestamp:
Dec 22, 2005, 4:05:15 PM (15 years ago)
Author:
alex
Message:
  • gcd, rem and div_m_rem static methods added
File:
1 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/java/org/refal/plus/library/Arithm.java

    r1807 r1811  
    77import org.refal.plus.*;
    88
    9 public class Arithm
    10 {
    11     static public void _p_ (Expr s1, Expr s2, Expr res) throws RefalException
    12     {
     9public class Arithm {
     10    /**
     11     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     12     * Byte, BigInteger)
     13     *
     14     * @param s1 -- Refal expression.
     15     * @param s2 -- Refal expression
     16     * @param res -- The result
     17     * @throws RefalException
     18     */
     19    static public void _p_(Expr s1, Expr s2, Expr res) throws RefalException {
    1320        // FIXME: insert here assertion s1.getLen() == 1
    1421        // FIXME: insert here assertion s2.getLen() == 1
    1522        try {
    1623            res.assign(new Expr(Int.toBigInteger(s1.at(0)).add(
    17                                 Int.toBigInteger(s2.at(0)))));
    18         }
    19         catch (ClassCastException e) {
     24                    Int.toBigInteger(s2.at(0)))));
     25        } catch (ClassCastException e) {
    2026            throw new RefalException("Arithm", "+", "Invalid argument");
    2127        }
    2228    }
    2329
    24     static public void _m_ (Expr s1, Expr s2, Expr res) throws RefalException
    25     {
     30    /**
     31     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     32     * Byte, BigInteger)
     33     *
     34     * @param s1 -- Refal expression.
     35     * @param s2 -- Refal expression
     36     * @param res -- The result
     37     * @throws RefalException
     38     */
     39    static public void _m_(Expr s1, Expr s2, Expr res) throws RefalException {
    2640        // FIXME: insert here assertion s1.getLen() == 1
    2741        // FIXME: insert here assertion s2.getLen() == 1
    2842        try {
    2943            res.assign(new Expr(Int.toBigInteger(s1.at(0)).subtract(
    30                                 Int.toBigInteger(s2.at(0)))));
    31         }
    32         catch (ClassCastException e) {
     44                    Int.toBigInteger(s2.at(0)))));
     45        } catch (ClassCastException e) {
    3346            throw new RefalException("Arithm", "-", "Invalid argument");
    3447        }
    3548    }
    3649
    37     static public void _a_ (Expr s1, Expr s2, Expr res) throws RefalException
    38     {
     50    /**
     51     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     52     * Byte, BigInteger)
     53     *
     54     * @param s1 -- Refal expression.
     55     * @param s2 -- Refal expression
     56     * @param res -- The result
     57     * @throws RefalException
     58     */
     59    static public void _a_(Expr s1, Expr s2, Expr res) throws RefalException {
    3960        // FIXME: insert here assertion s1.getLen() == 1
    4061        // FIXME: insert here assertion s2.getLen() == 1
    4162        try {
    4263            res.assign(new Expr(Int.toBigInteger(s1.at(0)).multiply(
    43                                 Int.toBigInteger(s2.at(0)))));
    44         }
    45         catch (ClassCastException e) {
     64                    Int.toBigInteger(s2.at(0)))));
     65        } catch (ClassCastException e) {
    4666            throw new RefalException("Arithm", "*", "Invalid argument");
    4767        }
    4868    }
    4969
    50     static public void Div (Expr s1, Expr s2, Expr res) throws RefalException
    51     {
     70    /**
     71     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     72     * Byte, BigInteger)
     73     *
     74     * @param s1 -- Refal expression.
     75     * @param s2 -- Refal expression
     76     * @param res -- The result
     77     * @throws RefalException
     78     */
     79    static public void Div(Expr s1, Expr s2, Expr res) throws RefalException {
    5280        // FIXME: insert here assertion s1.getLen() == 1
    5381        // FIXME: insert here assertion s2.getLen() == 1
    5482        try {
    5583            res.assign(new Expr(Int.toBigInteger(s1.at(0)).divide(
    56                                 Int.toBigInteger(s2.at(0)))));
    57         }
    58         catch (ClassCastException e) {
     84                    Int.toBigInteger(s2.at(0)))));
     85        } catch (ClassCastException e) {
    5986            throw new RefalException("Arithm", "Div", "Invalid argument");
    60         }
    61         catch (ArithmeticException e) {
     87        } catch (ArithmeticException e) {
    6288            throw new RefalException("Arithm", "Div", "Divide by zero");
    6389        }
    6490    }
     91
     92    /**
     93     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     94     * Byte, BigInteger)
     95     *
     96     * @param s1 -- Refal expression.
     97     * @param s2 -- Refal expression
     98     * @param res -- The result
     99     * @throws RefalException
     100     */
     101    static public void Rem(Expr s1, Expr s2, Expr res) throws RefalException {
     102        if (s1.getLen() != 1 || s2.getLen() != 1) {
     103            throw new RefalException("Arithm", "Rem", "Invalid argument");
     104        }
     105        try {
     106            res.assign(new Expr(Int.toBigInteger(s1.at(0)).remainder(
     107                    Int.toBigInteger(s2.at(0)))));
     108        } catch (ClassCastException e) {
     109            throw new RefalException("Arithm", "Rem", "Invalid argument");
     110        }
     111               
     112    }
     113    /**
     114     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     115     * Byte, BigInteger)
     116     *
     117     * @param s1 -- Refal expression.
     118     * @param s2 -- Refal expression
     119     * @param res -- The result
     120     * @throws RefalException
     121     */
     122    static public void Div_m_Rem (Expr s1, Expr s2, Expr res1, Expr res2) throws RefalException {
     123        if (s1.getLen() != 1 || s2.getLen() != 1) {
     124            throw new RefalException("Arithm", "Div_m_Rem", "Invalid argument");
     125        }
     126        try {
     127            res1.assign(new Expr(Int.toBigInteger(s1.at(0)).divide(
     128                    Int.toBigInteger(s2.at(0)))));
     129        } catch (ClassCastException e) {
     130            throw new RefalException("Arithm", "Div_m_Rem", "Invalid argument");
     131        } catch (ArithmeticException e) {
     132            throw new RefalException("Arithm", "Div_m_Rem", "Divide by zero");
     133        }       
     134        try {
     135            res2.assign(new Expr(Int.toBigInteger(s1.at(0)).remainder(
     136                    Int.toBigInteger(s2.at(0)))));
     137        } catch (ClassCastException e) {
     138            throw new RefalException("Arithm", "Div_m_Rem", "Invalid argument");
     139        }               
     140    }
     141   
     142    /**
     143     * Refal expresions `s1` and `s2` must contain one of the numeric classes (Integer, Short, Long,
     144     * Byte, BigInteger)
     145     *
     146     * @param s1 -- Refal expression.
     147     * @param s2 -- Refal expression
     148     * @param res -- The result
     149     * @throws RefalException
     150     */
     151    static public void GCD (Expr s1, Expr s2, Expr res) throws RefalException {
     152        if (s1.getLen() != 1 || s2.getLen() != 1) {
     153            throw new RefalException("Arithm", "GCD", "Invalid argument");
     154        }
     155        try {
     156            res.assign(new Expr(Int.toBigInteger(s1.at(0)).gcd(
     157                    Int.toBigInteger(s2.at(0)))));
     158        } catch (ClassCastException e) {
     159            throw new RefalException("Arithm", "GCD", "Invalid argument");
     160        }
     161    }
    65162}
Note: See TracChangeset for help on using the changeset viewer.