JMLNegativeInfinity.java

// @(#)$Id: JMLNegativeInfinity.java,v 1.14 2007/02/08 14:05:50 leavens Exp $

// Copyright (C) 2005 Iowa State University
//
// This file is part of the runtime library of the Java Modeling Language.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation; either version 2.1,
// 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with JML; see the file LesserGPL.txt.  If not, write to the Free
// Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
// 02110-1301  USA.


package org.jmlspecs.unfinished;

import java.math.BigInteger;

/** Negative Infinity.
 *
 * @version $Revision: 1.14 $
 * @author Gary T. Leavens
 * @see JMLPositiveInfinity
 */
//-@ immutable
public /*@ pure @*/ class JMLNegativeInfinity extends JMLInfiniteIntegerClass {

    //@ public represents is_infinite <- true;
    //@ public represents sign <- -1;

    //@ public invariant_redundantly is_infinite;
    //@ public invariant_redundantly sign == -1;

    //@ public invariant_redundantly !nonnegative;

    /** Initialize this object.
     */
    public JMLNegativeInfinity() {}

    /** Return the sign of this integer.
     */
    public int signum() { return -1; }

    /** Return false.
     */
    public boolean isFinite() { return false; }

    /** Throw an ArithmeticException.
     */
    public BigInteger finiteValue() throws ArithmeticException {
        throw new ArithmeticException();
    }

    /** Compare this to the given integer, returning a comparison code.
     */
    public int compareTo(JMLInfiniteInteger n) {
        //@ assume n != null;
        if (n instanceof JMLNegativeInfinity) {
            return 0;
        } else {
            return -1;
        }
    }

    /** Compare this to o, returning a comparison code.
     *  @param o the object this is compared to.
     *  @exception ClassCastException when o is not
     *             a JMLInfiniteInteger or a BigInteger.
     */
    public int compareTo(/*@ non_null @*/ Object o) throws ClassCastException { 
        if (o == null) {
            throw new NullPointerException();
        } else if (o instanceof JMLNegativeInfinity) {
            return 0;
        } else if (o instanceof JMLInfiniteInteger
                   || o instanceof BigInteger) {
            return -1;
        } else {
            throw new ClassCastException();
        }
    }

    /** Return a hash code for this object.
     */
    public int hashCode() { return Integer.MIN_VALUE; }

    /** Return positive infinity.
     */
    public JMLInfiniteInteger negate() {
        return new JMLPositiveInfinity();
    }

    /** Return the sum of this integer and the argument.
     */
    public JMLInfiniteInteger add(JMLInfiniteInteger n) {
        //@ assume n != null;
        if (n instanceof JMLPositiveInfinity) {
            return JMLFiniteInteger.ZERO;
        } else {
            return this;
        }
    }

    /** Return the difference between this integer and the argument.
     */
    public JMLInfiniteInteger subtract(JMLInfiniteInteger n) {
        //@ assume n != null;
        if (n instanceof JMLNegativeInfinity) {
            return JMLFiniteInteger.ZERO;
        } else {
            return this;
        }
    }

    /** Return the product of this integer and the argument.
     */
    public JMLInfiniteInteger multiply(JMLInfiniteInteger n) {
        //@ assume n != null;
        if (n.signum() == 0) {
            return JMLFiniteInteger.ZERO;
        } else if (n.signum() == -1) {
            return new JMLPositiveInfinity();
        } else {
            return this;
        }
    }

    /** Return the quotient of this integer divided by the argument.
     */
    public JMLInfiniteInteger divide(JMLInfiniteInteger n)
        throws ArithmeticException {
        //@ assume n != null;
        if (n.signum() == 0) {
            throw new ArithmeticException("division by zero");
        } else if (n instanceof JMLNegativeInfinity) {
            return JMLFiniteInteger.ONE;
        } else if (n instanceof JMLPositiveInfinity) {
            return JMLFiniteInteger.ONE.negate();
        } else if (n.signum() == -1) {
            return new JMLPositiveInfinity();
        } else {
            return this;
        }
    }

    /** Return the remainder of this integer divided by the argument.
     */
    public JMLInfiniteInteger remainder(JMLInfiniteInteger n)
        throws ArithmeticException {
        //@ assume n != null;
        if (n.signum() == 0) {
            throw new ArithmeticException("can't take remainder by zero");
        } else {
            return JMLFiniteInteger.ZERO;
        }
    }

    /** Return this integer modulo the argument.
     */
    public JMLInfiniteInteger mod(JMLInfiniteInteger n)
        throws ArithmeticException {
        //@ assume n != null;
        if (n.signum() <= 0) {
            throw new ArithmeticException("can't mod by zero"
                                          + " or negative number");
        } else {
            return JMLFiniteInteger.ZERO;
        }
    }

    /** Return this integer raised to the argument's power.
     */
    // @edu.umd.cs.findbugs.annotations.SuppressWarnings("IM_BAD_CHECK_FOR_ODD")
    public JMLInfiniteInteger pow(int n) throws ArithmeticException {
        if (n < 0) {
            throw new ArithmeticException();
        } else if (n == 0) {
            return JMLFiniteInteger.ONE;
        } else if (n % 2 == 1) {
            return this;
        } else {
            return this.negate();
        }
    }

    /** Return this integer approximated by a double.
     */
    public double doubleValue() { return Double.NEGATIVE_INFINITY; }

    /** Return this integer approximated by a float.
     */
    public float floatValue() { return Float.NEGATIVE_INFINITY; }

    /** Return the string "-Infinity".
     */
    public String toString() { return "-Infinity"; }

    /** Return the string "-Infinity".
     */
    public String toString(int radix) { return toString(); }
}