Logo Search packages:      
Sourcecode: yap version File versions  Download package

Float.java

//tabstop=4
//*****************************************************************************/
// Project: jpl
//
// File:    $Id: Float.java,v 1.1 2004/08/27 20:27:56 vsc Exp $
// Date:    $Date: 2004/08/27 20:27:56 $
// Author:  Fred Dushin <fadushin@syr.edu>
//          
//
// Description:
//    
//
// -------------------------------------------------------------------------
// Copyright (c) 2004 Paul Singleton
// Copyright (c) 1998 Fred Dushin
//                    All rights reserved.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library Public License for more details.
//*****************************************************************************/
package jpl;

import java.util.Map;

import jpl.fli.DoubleHolder;
import jpl.fli.Prolog;
import jpl.fli.term_t;

//----------------------------------------------------------------------/
// Float
/**
 * Float is a specialised Term with a double field, representing a Prolog 64-bit ISO/IEC floating point value.
 * Once constructed, a Float's value cannot be altered.
 * <pre>
 * Float f = new Float( 3.14159265 );
 * </pre>
 * A Float can be used (and re-used) in Compound Terms.
 * Two Float instances are equal (by .equals()) iff their (double) values are equal.
 * 
 * <hr><i>
 * Copyright (C) 2004  Paul Singleton<p>
 * Copyright (C) 1998  Fred Dushin<p>
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.<p>
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library Public License for more details.<p>
 * </i><hr>
 * @author  Fred Dushin <fadushin@syr.edu>
 * @version $Revision: 1.1 $
 * @see jpl.Term
 * @see jpl.Compound
 */
00066 public class Float extends Term {
      
      //==================================================================/
      //  Attributes
      //==================================================================/

      /**
       * the Float's immutable value
       */
00075       protected final double value;

      //==================================================================/
      //  Constructors and Initialization
      //==================================================================/

      /**
       * This constructor creates a Float with the supplied 
       * (double) value.
       * 
       * @param   value  this Float's value
       */
00087       public Float(double value) {
            this.value = value;
      }

      //==================================================================/
      //  Methods (common)
      //==================================================================/

      /**
       * throws a JPLException (arg(int) is defined only for Compound and Atom)
       * 
       * @return the ith argument (counting from 1) of this Float (never)
       */
00100       public final Term arg(int i) {
            throw new JPLException("jpl.Float.arg(int) is undefined");
      }

      /**
       * Tests whether this Float's functor has (String) 'name' and 'arity' (never)
       * 
       * @return whether this Float's functor has (String) 'name' and 'arity' (never)
       */
00109       public final boolean hasFunctor(String name, int arity) {
            return false;
      }

      /**
       * Tests whether this Float's functor has (int) 'name' and 'arity' (never)
       * 
       * @return whether this Float's functor has (int) 'name' and 'arity' (never)
       */
00118       public final boolean hasFunctor(int val, int arity) {
            return false;
      }

      /**
       * Tests whether this Float's functor has (double) 'name' and 'arity'
       * 
       * @return whether this Float's functor has (double) 'name' and 'arity'
       */
00127       public final boolean hasFunctor(double val, int arity) {
            return val == this.value && arity == 0;
      }

      /**
       * throws a JPLException (name() is defined only for Compound, Atom and Variable)
       * 
       * @return the name of this Float (never)
       */
00136       public final String name() {
            throw new JPLException("jpl.Float.name() is undefined");
      }

      /**
       * Returns the arity (0) of this Float
       * 
       * @return the arity (0) of this Float
       */
00145       public final int arity() {
            return 0;
      }

      /**
       * returns the (double) value of this Float, converted to an int
       * 
       * @return the (double) value of this Float, converted to an int
       */
00154       public final int intValue() {
            return (new Double(value)).intValue();
      }

      /**
       * returns the (double) value of this Float, converted to a long
       * 
       * @return the (double) value of this Float, converted to a long
       */
00163       public final long longValue() {
            return (new Double(value)).longValue();
      }

      /**
       * returns the (double) value of this Float, converted to a float
       * 
       * @return the (double) value of this Float, converted to a float
       */
00172       public final float floatValue() {
            return (new Double(value)).floatValue();
      }

      /**
       * returns the (double) value of this Float
       * 
       * @return the (double) value of this Float
       */
00181       public final double doubleValue() {
            return this.value;
      }

      /**
       * Returns a Prolog source text representation of this Float
       * 
       * @return  a Prolog source text representation of this Float
       */
00190       public String toString() {
            return "" + value + "";
      }

      /**
       * Two Floats are equal if they are the same object, or their values are equal
       * 
       * @param   obj  The Object to compare
       * @return  true if the Object satisfies the above condition
       */
00200       public final boolean equals(Object obj) {
            return this == obj || (obj instanceof Float && value == ((Float) obj).value);
      }
      
00204       public final int type() {
            return Prolog.FLOAT;
      }
      
00208       public String typeName(){
            return "Float";
      }
      
      //==================================================================/
      //  Methods (deprecated)
      //==================================================================/

      /**
       * The (nonexistent) args of this Float
       * 
       * @return the (nonexistent) args of this Float
       * @deprecated
       */
00222       public Term[] args() {
            return new Term[] {};
      }
      
      /**
       * The immutable value of this jpl.Float object, as a Java double
       * 
       * @return the Float's value
       * @deprecated
       */
00232       public double value() {
            return value;
      }

      /**
       * Returns a debug-friendly String representation of this Float
       * 
       * @return  a debug-friendly String representation of this Float
       * @deprecated
       */
00242       public String debugString() {
            return "(Float " + toString() + ")";
      }

      //==================================================================/
      //  Converting JPL Terms to Prolog terms
      //==================================================================/

      /**
       * To convert a JPL Float to a Prolog term, we put its value field into the
       * term_t as a float.
       * 
       * @param   varnames_to_vars  A Map from variable names to Prolog variables.
       * @param   term              A (previously created) term_t which is to be
       *                            set to a Prolog float corresponding to this Float's value
       */
00258       protected final void put(Map varnames_to_vars, term_t term) {
            Prolog.put_float(term, value);
      }

      //==================================================================/
      //  Converting Prolog terms to JPL Terms
      //==================================================================/

      /**
       * Converts a Prolog term (known to be a float) to a JPL Float.
       *
       * @param   vars_to_Vars     A Map from Prolog variables to JPL Variables
       * @param   term             The Prolog term (a float) to convert
       * @return                   A new Float instance
       */
00273       protected static Term getTerm(Map vars_to_Vars, term_t term) {
            DoubleHolder double_holder = new DoubleHolder();

            Prolog.get_float(term, double_holder); // assume it succeeds...
            return new jpl.Float(double_holder.value);
      }

      //==================================================================/
      //  Computing Substitutions
      //==================================================================/

      /**
       * Nothing needs to be done if the Term is an Atom, Integer or (as in this case) a Float
       * 
       * @param   varnames_to_Terms  A Map from variable names to JPL Terms
       * @param   vars_to_Vars       A Map from Prolog variables to JPL Variables
       */
00290       protected final void getSubst(Map varnames_to_Terms, Map vars_to_Vars) {
      }

}

//345678901234567890123456789012346578901234567890123456789012345678901234567890

Generated by  Doxygen 1.6.0   Back to index