001: /*
002: * RandomState.java
003: *
004: * Copyright (C) 2003-2004 Peter Graves
005: * $Id: RandomState.java,v 1.2 2004/06/11 14:43:29 piso Exp $
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License
009: * as published by the Free Software Foundation; either version 2
010: * of the License, or (at your option) any later version.
011: *
012: * This program is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU General Public License for more details.
016: *
017: * You should have received a copy of the GNU General Public License
018: * along with this program; if not, write to the Free Software
019: * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
020: */
021:
022: package org.armedbear.lisp;
023:
024: import java.io.File;
025: import java.io.FileInputStream;
026: import java.io.FileOutputStream;
027: import java.io.ObjectInputStream;
028: import java.io.ObjectOutputStream;
029: import java.math.BigInteger;
030: import java.util.Random;
031:
032: public final class RandomState extends LispObject {
033: private Random random;
034:
035: public RandomState() {
036: random = new Random();
037: }
038:
039: public RandomState(RandomState rs) throws ConditionThrowable {
040: try {
041: File file = File.createTempFile("MAKE-RANDOM-STATE", null);
042: FileOutputStream fileOut = new FileOutputStream(file);
043: ObjectOutputStream out = new ObjectOutputStream(fileOut);
044: out.writeObject(rs.random);
045: out.close();
046: FileInputStream fileIn = new FileInputStream(file);
047: ObjectInputStream in = new ObjectInputStream(fileIn);
048: random = (Random) in.readObject();
049: in.close();
050: file.delete();
051: } catch (Throwable t) {
052: signal(new LispError("Unable to copy random state."));
053: }
054: }
055:
056: public LispObject typeOf() {
057: return Symbol.RANDOM_STATE;
058: }
059:
060: public LispClass classOf() {
061: return BuiltInClass.RANDOM_STATE;
062: }
063:
064: public LispObject typep(LispObject type) throws ConditionThrowable {
065: if (type == Symbol.RANDOM_STATE)
066: return T;
067: if (type == BuiltInClass.RANDOM_STATE)
068: return T;
069: return super .typep(type);
070: }
071:
072: public String writeToString() {
073: return unreadableString("RANDOM-STATE");
074: }
075:
076: public LispObject random(LispObject arg) throws ConditionThrowable {
077: if (arg instanceof Fixnum) {
078: int limit = ((Fixnum) arg).getValue();
079: if (limit > 0) {
080: int n = random.nextInt((int) limit);
081: return new Fixnum(n);
082: }
083: } else if (arg instanceof Bignum) {
084: BigInteger limit = ((Bignum) arg).getValue();
085: if (limit.signum() > 0) {
086: int bitLength = limit.bitLength();
087: BigInteger rand = new BigInteger(bitLength + 1, random);
088: BigInteger remainder = rand.remainder(limit);
089: return number(remainder);
090: }
091: } else if (arg instanceof LispFloat) {
092: double limit = ((LispFloat) arg).getValue();
093: if (limit > 0) {
094: double rand = random.nextDouble();
095: return new LispFloat(rand * limit);
096: }
097: }
098: return signal(new TypeError(arg,
099: "positive integer or positive float"));
100: }
101:
102: // ### random
103: // random limit &optional random-state => random-number
104: private static final Primitive RANDOM = new Primitive("random",
105: "limit &optional random-state") {
106: public LispObject execute(LispObject arg)
107: throws ConditionThrowable {
108: RandomState randomState = (RandomState) _RANDOM_STATE_
109: .symbolValueNoThrow();
110: return randomState.random(arg);
111: }
112:
113: public LispObject execute(LispObject first, LispObject second)
114: throws ConditionThrowable {
115: if (second instanceof RandomState) {
116: RandomState randomState = (RandomState) second;
117: return randomState.random(first);
118: }
119: return signal(new TypeError(first, Symbol.RANDOM_STATE));
120: }
121: };
122:
123: // ### make-random-state
124: // make-random-state &optional state
125: private static final Primitive MAKE_RANDOM_STATE = new Primitive(
126: "make-random-state", "&optional state") {
127: public LispObject execute() throws ConditionThrowable {
128: return new RandomState((RandomState) _RANDOM_STATE_
129: .symbolValueNoThrow());
130: }
131:
132: public LispObject execute(LispObject arg)
133: throws ConditionThrowable {
134: if (arg == NIL)
135: return new RandomState((RandomState) _RANDOM_STATE_
136: .symbolValueNoThrow());
137: if (arg == T)
138: return new RandomState();
139: if (arg instanceof RandomState)
140: return new RandomState((RandomState) arg);
141: return signal(new TypeError(arg, Symbol.RANDOM_STATE));
142: }
143: };
144:
145: // ### random-state-p
146: private static final Primitive1 RANDOM_STATE_P = new Primitive1(
147: "random-state-p", "object") {
148: public LispObject execute(LispObject arg) {
149: return arg instanceof RandomState ? T : NIL;
150: }
151: };
152: }
|