View Javadoc

1   /*
2    * Copyright (c) 2001, Zoltan Farkas All Rights Reserved.
3    *
4    * This library is free software; you can redistribute it and/or
5    * modify it under the terms of the GNU Lesser General Public
6    * License as published by the Free Software Foundation; either
7    * version 2.1 of the License, or (at your option) any later version.
8    *
9    * This library is distributed in the hope that it will be useful,
10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   * GNU General Public License for more details.
13   *
14   * You should have received a copy of the GNU Lesser General Public
15   * License along with this program; if not, write to the Free Software
16   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17   */
18  package net.sf.zel.nr;
19  
20  import java.math.BigDecimal;
21  import java.math.BigInteger;
22  import javax.annotation.concurrent.Immutable;
23  import net.sf.zel.nr.ExtendedNumber.Type;
24  
25  @Immutable
26  public final class OperableInteger extends OperableNumber
27  {
28  
29      private static final long serialVersionUID = -872451649272370777L;
30      public static final OperableInteger ZERO = new OperableInteger(0);
31      public static final OperableInteger ONE = new OperableInteger(1);
32      public static final OperableInteger MINUSONE = new OperableInteger(-1);
33  
34      private final int number;
35  
36      public OperableInteger(final int n)
37      {
38          number = n;
39      }
40  
41      public OperableInteger(final String val)
42      {
43          number = Integer.parseInt(val);
44      }
45  
46  
47      public OperableInteger(final Integer n)
48      {
49          number = n.intValue();
50      }
51  
52  
53      @Override
54      public OperableInteger zero()
55      {
56          return ZERO;
57      }
58  
59      @Override
60      public OperableNumber add(OperableNumber addend)
61      {
62          if (addend.getType() == Type.REAL)
63              return addend.add(this);
64          else
65          {
66              int b = addend.intValue();
67              int result = number + b;
68              if (((number ^ result) & (b ^ result)) < 0)
69              {
70                  return new OperableLong(addend.longValue() + number);
71              } else
72              {
73                  return new OperableInteger(result);
74              }
75          }
76      }
77  
78      @Override
79      public OperableNumber subtract(OperableNumber subtrahend)
80      {
81          if (subtrahend.getType() == Type.REAL)
82          {
83              return subtrahend.convert(this).subtract(subtrahend);
84          } else
85          {
86  
87              int b = subtrahend.intValue();
88              int result = number - b;
89              if (((number ^ result) & ((-b) ^ result)) < 0)
90              {
91                  return new OperableLong(((long) number) - subtrahend.longValue());
92              } else
93              {
94                  return new OperableInteger(result);
95              }
96          }
97      }
98  
99  
100     @Override
101     public OperableNumber multiply(OperableNumber multiplier)
102     {
103         if (multiplier.getType() == Type.REAL)
104         {
105             return multiplier.multiply(this);
106         } else
107         {
108             return new OperableLong(((long)number) * multiplier.longValue());
109         }
110     }
111 
112     @Override
113     public OperableNumber divide(OperableNumber divisor)
114     {
115         if (divisor.getType() == Type.REAL)
116         {
117             return divisor.convert(this).divide(divisor);
118         }
119         else
120             return new OperableLong(((long)number) / divisor.longValue());
121     }
122 
123     @Override
124     public OperableNumber mod(OperableNumber divisor)
125     {
126         return new OperableLong(((long)number) % divisor.longValue());
127     }
128 
129     @Override
130     public BigDecimal bigDecimalValue()
131     {
132         return BigDecimal.valueOf(number);
133     }
134 
135     @Override
136     public BigInteger bigIntegerValue()
137     {
138         return BigInteger.valueOf(number);
139     }
140 
141     @Override
142     public Type getType()
143     {
144         return Type.INTEGER;
145     }
146 
147     @Override
148     public OperableGNUBigInteger gnuBigIntegerValue() {
149         return new OperableGNUBigInteger(Integer.toString(number));
150     }
151 
152     @Override
153     public int intValue()
154     {
155         return number;
156     }
157 
158     @Override
159     public long longValue()
160     {
161         return (long) number;
162     }
163 
164     @Override
165     public float floatValue()
166     {
167         return (float) number;
168     }
169 
170     @Override
171     public double doubleValue()
172     {
173         return (double) number;
174     }
175 
176 
177     @Override
178     public int compareTo(final Object o)
179     {
180         return number - ((OperableNumber)o).intValue();
181     }
182 
183     @Override
184     public String toString()
185     {
186         return Integer.toString(number);
187     }
188 
189     @Override
190     public boolean equals(Object obj)
191     {
192         if (obj == null)
193         {
194             return false;
195         }
196         if (getClass() != obj.getClass())
197         {
198             return false;
199         }
200         final OperableInteger other = (OperableInteger) obj;
201         if (this.number != other.number)
202         {
203             return false;
204         }
205         return true;
206     }
207 
208     @Override
209     public int hashCode()
210     {
211         return number;
212     }
213 
214     @Override
215     public OperableGNUBigFloat gnuBigFloatValue()
216     {
217         return new OperableGNUBigFloat(toString());
218     }
219 
220     @Override
221     public int getPrecision()
222     {
223         return 32;
224     }
225 
226     @Override
227     public OperableNumber create(final String val)
228     {
229         if ("0".equals(val))
230             return ZERO;
231         else
232             return new OperableInteger(val);
233     }
234 
235     @Override
236     public ExtendedNumber one()
237     {
238         return ONE;
239     }
240 
241     @Override
242     public OperableNumber convert(ExtendedNumber val)
243     {
244         return new OperableInteger(val.intValue());
245     }
246 
247 
248 
249 }