Changeset 5018


Ignore:
Timestamp:
12/08/03 04:25:04 (18 years ago)
Author:
piso
Message:

*, /, MIN, MAX

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5011 r5018  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.517 2003-12-08 02:51:37 piso Exp $
     5 * $Id: Primitives.java,v 1.518 2003-12-08 04:25:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3030public final class Primitives extends Module
    3131{
    32     // Primitive
    33     private static final int DIVIDE                     = 1;
    34     private static final int MAX                        = 2;
    35     private static final int MIN                        = 3;
    36     private static final int MULTIPLY                   = 4;
    37 
    3832    // Primitive1
    39     private static final int ABS                        = 5;
    40     private static final int ARRAYP                     = 6;
    41     private static final int ARRAY_HAS_FILL_POINTER_P   = 7;
    42     private static final int BIT_VECTOR_P               = 8;
    43     private static final int COMPILED_FUNCTION_P        = 9;
    44     private static final int CONSP                      = 10;
    45     private static final int EVAL                       = 11;
    46     private static final int IDENTITY                   = 12;
    47     private static final int LISTP                      = 13;
    48     private static final int SIMPLE_BIT_VECTOR_P        = 14;
    49     private static final int SIMPLE_VECTOR_P            = 15;
    50     private static final int VECTORP                    = 16;
     33    private static final int ABS                        = 1;
     34    private static final int ARRAYP                     = 2;
     35    private static final int ARRAY_HAS_FILL_POINTER_P   = 3;
     36    private static final int BIT_VECTOR_P               = 4;
     37    private static final int COMPILED_FUNCTION_P        = 5;
     38    private static final int CONSP                      = 6;
     39    private static final int EVAL                       = 7;
     40    private static final int IDENTITY                   = 8;
     41    private static final int LISTP                      = 9;
     42    private static final int SIMPLE_BIT_VECTOR_P        = 10;
     43    private static final int SIMPLE_VECTOR_P            = 11;
     44    private static final int VECTORP                    = 12;
    5145
    5246    private Primitives()
    5347    {
    54         definePrimitive("*", MULTIPLY);
    55         definePrimitive("/", DIVIDE);
    56         definePrimitive("max", MAX);
    57         definePrimitive("min", MIN);
    58 
    5948        definePrimitive1("abs", ABS);
    6049        definePrimitive1("array-has-fill-pointer-p", ARRAY_HAS_FILL_POINTER_P);
     
    6958        definePrimitive1("simple-vector-p", SIMPLE_VECTOR_P);
    7059        definePrimitive1("vectorp", VECTORP);
    71     }
    72 
    73     // Primitive
    74     public LispObject dispatch(LispObject[] args, int index)
    75         throws ConditionThrowable
    76     {
    77         switch (index) {
    78             case MULTIPLY: {                    // ### *
    79                 LispObject result = Fixnum.ONE;
    80                 for (int i = 0; i < args.length; i++)
    81                     result = result.multiplyBy(args[i]);
    82                 return result;
    83             }
    84             case DIVIDE: {                      // ### /
    85                 if (args.length < 1)
    86                     throw new ConditionThrowable(new WrongNumberOfArgumentsException("/"));
    87                 if (args.length == 1)
    88                     return Fixnum.ONE.divideBy(args[0]);
    89                 LispObject result = args[0];
    90                 for (int i = 1; i < args.length; i++)
    91                     result = result.divideBy(args[i]);
    92                 return result;
    93             }
    94             case MIN: {                         // ### min
    95                 if (args.length < 1)
    96                     throw new ConditionThrowable(new WrongNumberOfArgumentsException("MIN"));
    97                 LispObject result = args[0];
    98                 if (!result.realp())
    99                     throw new ConditionThrowable(new TypeError(result, "real"));
    100                 for (int i = 1; i < args.length; i++) {
    101                     if (args[i].isLessThan(result))
    102                         result = args[i];
    103                 }
    104                 return result;
    105             }
    106             case MAX: {                         // ### max
    107                 if (args.length < 1)
    108                     throw new ConditionThrowable(new WrongNumberOfArgumentsException("MAX"));
    109                 LispObject result = args[0];
    110                 if (!result.realp())
    111                     throw new ConditionThrowable(new TypeError(result, "real"));
    112                 for (int i = 1; i < args.length; i++) {
    113                     if (args[i].isGreaterThan(result))
    114                         result = args[i];
    115                 }
    116                 return result;
    117             }
    118             default:
    119                 Debug.trace("bad index " + index);
    120                 throw new ConditionThrowable(new WrongNumberOfArgumentsException((String)null));
    121         }
    12260    }
    12361
     
    16199    }
    162100
     101    // ### *
     102    public static final Primitive MULTIPLY = new Primitive("*")
     103    {
     104        public LispObject execute()
     105        {
     106            return Fixnum.ONE;
     107        }
     108        public LispObject execute(LispObject arg) throws ConditionThrowable
     109        {
     110            if (arg.numberp())
     111                return arg;
     112            throw new ConditionThrowable(new TypeError(arg, "number"));
     113        }
     114        public LispObject execute(LispObject first, LispObject second)
     115            throws ConditionThrowable
     116        {
     117            return first.multiplyBy(second);
     118        }
     119        public LispObject execute(LispObject[] args) throws ConditionThrowable
     120        {
     121            LispObject result = Fixnum.ONE;
     122            for (int i = 0; i < args.length; i++)
     123                result = result.multiplyBy(args[i]);
     124            return result;
     125        }
     126    };
     127
     128    // ### /
     129    public static final Primitive DIVIDE = new Primitive("/")
     130    {
     131        public LispObject execute() throws ConditionThrowable
     132        {
     133            throw new ConditionThrowable(new WrongNumberOfArgumentsException("/"));
     134        }
     135        public LispObject execute(LispObject arg) throws ConditionThrowable
     136        {
     137            return Fixnum.ONE.divideBy(arg);
     138        }
     139        public LispObject execute(LispObject first, LispObject second)
     140            throws ConditionThrowable
     141        {
     142            return first.divideBy(second);
     143        }
     144        public LispObject execute(LispObject[] args) throws ConditionThrowable
     145        {
     146            LispObject result = args[0];
     147            for (int i = 1; i < args.length; i++)
     148                result = result.divideBy(args[i]);
     149            return result;
     150        }
     151    };
     152
     153    // ### min
     154    public static final Primitive MIN = new Primitive("min")
     155    {
     156        public LispObject execute() throws ConditionThrowable
     157        {
     158            throw new ConditionThrowable(new WrongNumberOfArgumentsException("min"));
     159        }
     160        public LispObject execute(LispObject arg) throws ConditionThrowable
     161        {
     162            if (arg.realp())
     163                return arg;
     164            throw new ConditionThrowable(new TypeError(arg, "real number"));
     165        }
     166        public LispObject execute(LispObject[] args) throws ConditionThrowable
     167        {
     168            LispObject result = args[0];
     169            if (!result.realp())
     170                throw new ConditionThrowable(new TypeError(result, "real number"));
     171            for (int i = 1; i < args.length; i++) {
     172                if (args[i].isLessThan(result))
     173                    result = args[i];
     174            }
     175            return result;
     176        }
     177    };
     178
     179
     180    // ### max
     181    public static final Primitive MAX = new Primitive("max")
     182    {
     183        public LispObject execute() throws ConditionThrowable
     184        {
     185            throw new ConditionThrowable(new WrongNumberOfArgumentsException("max"));
     186        }
     187        public LispObject execute(LispObject arg) throws ConditionThrowable
     188        {
     189            if (arg.realp())
     190                return arg;
     191            throw new ConditionThrowable(new TypeError(arg, "real number"));
     192        }
     193        public LispObject execute(LispObject[] args) throws ConditionThrowable
     194        {
     195            LispObject result = args[0];
     196            if (!result.realp())
     197                throw new ConditionThrowable(new TypeError(result, "real number"));
     198            for (int i = 1; i < args.length; i++) {
     199                if (args[i].isGreaterThan(result))
     200                    result = args[i];
     201            }
     202            return result;
     203        }
     204    };
     205
    163206    // ### eq
    164207    private static final Primitive2 EQ = new Primitive2("eq")
     
    453496    };
    454497
    455     private static final Primitive1 SUCCESSOR = new Primitive1("1+")
     498    // ### 1+
     499    private static final Primitive1 ONE_PLUS = new Primitive1("1+")
    456500    {
    457501        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    489533    };
    490534
    491     private static final Primitive1 PREDECESSOR = new Primitive1("1-")
     535    // ### 1-
     536    private static final Primitive1 ONE_MINUS = new Primitive1("1-")
    492537    {
    493538        public LispObject execute(LispObject arg) throws ConditionThrowable
Note: See TracChangeset for help on using the changeset viewer.