Changeset 5778


Ignore:
Timestamp:
02/12/04 10:27:48 (17 years ago)
Author:
piso
Message:

Moved math functions to MathFunctions?.java.

Location:
trunk/j/src/org/armedbear/lisp
Files:
2 edited

Legend:

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

    r5746 r5778  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Autoload.java,v 1.153 2004-02-10 15:54:12 piso Exp $
     5 * $Id: Autoload.java,v 1.154 2004-02-12 10:27:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    210210        autoload("array-displacement", "DisplacedArray");
    211211        autoload("ash", "ash");
    212         autoload("atan", "atan");
     212        autoload("atan", "MathFunctions");
    213213        autoload("broadcast-stream-streams", "BroadcastStream");
    214214        autoload("cell-error-name", "cell_error_name");
     
    221221        autoload("clrhash", "HashTable");
    222222        autoload("copy-structure", "StructureObject");
     223        autoload("cos", "MathFunctions");
    223224        autoload("delete-file", "delete_file");
    224225        autoload("delete-package", "PackageFunctions");
     
    226227        autoload("echo-stream-input-stream", "EchoStream");
    227228        autoload("echo-stream-output-stream", "EchoStream");
     229        autoload("exp", "MathFunctions");
    228230        autoload("file-author", "file_author");
    229231        autoload("file-error-pathname", "file_error_pathname");
     
    252254        autoload("listen", "listen");
    253255        autoload("load-logical-pathname-translations", "LogicalPathname");
     256        autoload("log", "MathFunctions");
    254257        autoload("logand", "logand");
    255258        autoload("logandc1", "logandc1");
     
    289292        autoload("shadow", "PackageFunctions");
    290293        autoload("shadowing-import", "PackageFunctions");
     294        autoload("sin", "MathFunctions");
     295        autoload("sqrt", "MathFunctions");
    291296        autoload("stream-element-type", "stream_element_type");
    292297        autoload("stream-external-format", "stream_external_format");
    293298        autoload("sxhash", "HashTable");
    294299        autoload("synonym-stream-symbol", "SynonymStream");
     300        autoload("tan", "MathFunctions");
    295301        autoload("truename", "probe_file");
    296302        autoload("unbound-slot-instance", "unbound_slot_instance");
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5770 r5778  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Primitives.java,v 1.565 2004-02-12 01:42:58 piso Exp $
     5 * $Id: Primitives.java,v 1.566 2004-02-12 10:27:40 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    19951995    // ### vector-pop
    19961996    // vector-pop vector => element
    1997     private static final Primitive1 VECTOR_POP = new Primitive1("vector-pop","vector") {
     1997    private static final Primitive1 VECTOR_POP = new Primitive1("vector-pop", "vector")
     1998    {
    19981999        public LispObject execute(LispObject arg) throws ConditionThrowable
    19992000        {
     
    20122013
    20132014    // ### type-of
    2014     private static final Primitive1 TYPE_OF = new Primitive1("type-of","object") {
     2015    private static final Primitive1 TYPE_OF = new Primitive1("type-of", "object")
     2016    {
    20152017        public LispObject execute(LispObject arg) throws ConditionThrowable
    20162018        {
     
    20202022
    20212023    // ### class-of
    2022     private static final Primitive1 CLASS_OF = new Primitive1("class-of","object") {
     2024    private static final Primitive1 CLASS_OF = new Primitive1("class-of", "object")
     2025    {
    20232026        public LispObject execute(LispObject arg) throws ConditionThrowable
    20242027        {
     
    43524355    };
    43534356
    4354     private static final Primitive1 COS = new Primitive1("cos", "radians")
    4355     {
    4356         public LispObject execute(LispObject arg) throws ConditionThrowable
    4357         {
    4358             return cos(arg);
    4359         }
    4360     };
    4361 
    4362     private static LispObject cos(LispObject arg) throws ConditionThrowable
    4363     {
    4364         if (arg.realp())
    4365             return new LispFloat(Math.cos(LispFloat.coerceToFloat(arg).getValue()));
    4366         if (arg instanceof Complex) {
    4367             LispObject n = arg.multiplyBy(Complex.getInstance(Fixnum.ZERO,
    4368                                                               Fixnum.ONE));
    4369             LispObject result = exp(n);
    4370             result = result.add(exp(n.multiplyBy(Fixnum.MINUS_ONE)));
    4371             return result.divideBy(Fixnum.TWO);
    4372         }
    4373         return signal(new TypeError(arg, "number"));
    4374     }
    4375 
    4376     private static final Primitive1 SIN = new Primitive1("sin", "radians")
    4377     {
    4378         public LispObject execute(LispObject arg) throws ConditionThrowable
    4379         {
    4380             return sin(arg);
    4381         }
    4382     };
    4383 
    4384     private static LispObject sin(LispObject arg) throws ConditionThrowable
    4385     {
    4386         if (arg.realp())
    4387             return new LispFloat(Math.sin(LispFloat.coerceToFloat(arg).getValue()));
    4388         if (arg instanceof Complex) {
    4389             LispObject n = arg.multiplyBy(Complex.getInstance(Fixnum.ZERO,
    4390                                                               Fixnum.ONE));
    4391             LispObject result = exp(n);
    4392             result = result.subtract(exp(n.multiplyBy(Fixnum.MINUS_ONE)));
    4393             return result.divideBy(Fixnum.TWO.multiplyBy(Complex.getInstance(Fixnum.ZERO,
    4394                                                                              Fixnum.ONE)));
    4395         }
    4396         return signal(new TypeError(arg, Symbol.NUMBER));
    4397     }
    4398 
    4399     private static final Primitive1 TAN = new Primitive1("tan", "radians")
    4400     {
    4401         public LispObject execute(LispObject arg) throws ConditionThrowable
    4402         {
    4403             return tan(arg);
    4404         }
    4405     };
    4406 
    4407     private static LispObject tan(LispObject arg) throws ConditionThrowable
    4408     {
    4409         return sin(arg).divideBy(cos(arg));
    4410     }
    4411 
    4412     private static final Primitive1 EXP = new Primitive1("exp", "number")
    4413     {
    4414         public LispObject execute(LispObject arg) throws ConditionThrowable
    4415         {
    4416             return exp(arg);
    4417         }
    4418     };
    4419 
    4420     private static LispObject exp(LispObject arg) throws ConditionThrowable
    4421     {
    4422         if (arg.realp()) {  // return real
    4423             LispFloat argf = LispFloat.coerceToFloat(arg);
    4424             return new LispFloat(Math.exp(argf.getValue()));
    4425         } else if (arg instanceof Complex) {
    4426             Complex argc = (Complex)arg;
    4427             double re = LispFloat.coerceToFloat(argc.getRealPart()).getValue();
    4428             double im = LispFloat.coerceToFloat(argc.getImaginaryPart()).getValue();
    4429             LispFloat resX = new LispFloat(Math.exp(re) * Math.cos(im));
    4430             LispFloat resY = new LispFloat(Math.exp(re) * Math.sin(im));
    4431             return Complex.getInstance(resX, resY);
    4432         }
    4433         return signal(new TypeError(arg, "number"));
    4434     }
    4435 
    4436     // ### sqrt
    4437     private static final Primitive1 SQRT =
    4438         new Primitive1("sqrt","number") {
    4439         public LispObject execute(LispObject arg) throws ConditionThrowable
    4440         {
    4441             return sqrt(arg);
    4442         }
    4443     };
    4444 
    4445     private static final LispObject sqrt(LispObject obj) throws ConditionThrowable
    4446     {
    4447         if (obj.realp() && !obj.minusp()) {  // returning real
    4448             LispFloat f = LispFloat.coerceToFloat(obj);
    4449             return new LispFloat(Math.sqrt(f.getValue()));
    4450         } else {  // returning Complex
    4451             if (obj.realp()) {
    4452                 return Complex.getInstance(new LispFloat(0),
    4453                                            sqrt(Fixnum.ZERO.subtract(obj)));
    4454             } else if (obj instanceof Complex) {
    4455                 return exp(log(obj).divideBy(Fixnum.TWO));
    4456             }
    4457         }
    4458         signal(new TypeError(obj, "number"));
    4459         return NIL;
    4460     }
    4461 
    4462     private static final Primitive LOG = new Primitive("log","number &optional base") {
    4463         public LispObject execute(LispObject arg) throws ConditionThrowable
    4464         {
    4465             return log(arg);
    4466         }
    4467         public LispObject execute(LispObject number, LispObject base)
    4468             throws ConditionThrowable
    4469         {
    4470             return log(number).divideBy(log(base));
    4471         }
    4472     };
    4473 
    4474     private static final LispObject log(LispObject obj) throws ConditionThrowable
    4475     {
    4476         if (obj.realp() && !obj.minusp()) {  // real value
    4477             if (obj instanceof Fixnum)
    4478                 return new LispFloat(Math.log(((Fixnum)obj).getValue()));
    4479             if (obj instanceof Bignum)
    4480                 return new LispFloat(Math.log(((Bignum)obj).floatValue()));
    4481             if (obj instanceof Ratio)
    4482                 return new LispFloat(Math.log(((Ratio)obj).floatValue()));
    4483             if (obj instanceof LispFloat)
    4484                 return new LispFloat(Math.log(((LispFloat)obj).getValue()));
    4485         } else { // returning Complex
    4486             LispFloat re, im, phase, abs;
    4487             if (obj.realp() && obj.minusp()) {
    4488                 re = LispFloat.coerceToFloat(obj);
    4489                 abs = new LispFloat(Math.abs(re.getValue()));
    4490                 phase = new LispFloat(Math.PI);
    4491                 return Complex.getInstance(new LispFloat(Math.log(abs.getValue())), phase);
    4492             } else if (obj instanceof Complex) {
    4493                 re = LispFloat.coerceToFloat(((Complex)obj).getRealPart());
    4494                 im = LispFloat.coerceToFloat(((Complex)obj).getImaginaryPart());
    4495                 phase = new LispFloat(Math.atan2(im.getValue(), re.getValue()));  // atan(y/x)
    4496                 abs = (LispFloat)((Complex)obj).ABS();
    4497                 return Complex.getInstance(new LispFloat(Math.log(abs.getValue())), phase);
    4498             }
    4499         }
    4500         signal(new TypeError(obj, "number"));
    4501         return NIL;
    4502     }
    4503 
    45044357    // ### gcd-2
    45054358    private static final Primitive2 GCD_2 =
Note: See TracChangeset for help on using the changeset viewer.