Coverage Report

Coverage Report - jaggregate.internal.number.OperableBigInteger

Classes in this File

Line Coverage

Branch Coverage

Complexity

OperableBigInteger

100%

22/22

100%

6/6

OperableBigInteger$1

100%

2/2

N/A

 /*
  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.
  Licensed under the Academic Free License version 3.0
  */
 
 package jaggregate.internal.number;
 
 import java.math.BigInteger;
 
 /**
  * Wrapper for a {@code BigInteger}.
  *
  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
  * @version $Id: OperableBigInteger.java,v 1.1 2008/03/26 18:01:24 pholser Exp $
  */
 public class OperableBigInteger extends OperableNumber<BigInteger> {
     private static final long serialVersionUID = -1L;
 
     private static final OperableBigInteger ONE =
         new OperableBigInteger( BigInteger.ONE ) {
             private static final long serialVersionUID = -1L;
 
             @Override
             public void incrementBy( OperableNumber<BigInteger> increment ) {
                 throw new UnsupportedOperationException();
             }
         };
 
     /**
      * Creates a wrapper for the given number.
      *
      * @param wrapped the wrapped number
      */
     public OperableBigInteger( BigInteger wrapped ) {
         super( wrapped );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isZero() {
         return unwrapped().equals( BigInteger.ZERO );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger plus( BigInteger addend ) {
         return new OperableBigInteger( unwrapped().add( addend ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger plus( int addend ) {
         return new OperableBigInteger( unwrapped().add( BigInteger.valueOf( addend ) ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger minus( BigInteger subtrahend ) {
         return new OperableBigInteger( unwrapped().subtract( subtrahend ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger times( BigInteger multiplier ) {
         return new OperableBigInteger( unwrapped().multiply( multiplier ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger times( int multiplier ) {
         return new OperableBigInteger(
             unwrapped().multiply( BigInteger.valueOf( multiplier ) ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger dividedBy( BigInteger divisor ) {
         return new OperableBigInteger( unwrapped().divide( divisor ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger modulo( BigInteger divisor ) {
         return new OperableBigInteger( unwrapped().remainder( divisor ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isPositive() {
         return unwrapped().signum() > 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isNegative() {
         return unwrapped().signum() < 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThan( BigInteger comparand ) {
         return unwrapped().compareTo( comparand ) > 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThanOrEqualTo( BigInteger comparand ) {
         return unwrapped().compareTo( comparand ) >= 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThan( BigInteger comparand ) {
         return unwrapped().compareTo( comparand ) < 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThanOrEqualTo( BigInteger comparand ) {
         return unwrapped().compareTo( comparand ) <= 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableBigInteger negated() {
         return new OperableBigInteger( unwrapped().negate() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void incrementBy( OperableNumber<BigInteger> increment ) {
         update( unwrapped().add( increment.unwrapped() ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableNumber<BigInteger> one() {
         return ONE;
     }
 }

1		/*
2		Copyright 2004-2008 Paul R. Holser, Jr. All rights reserved.
3		Licensed under the Academic Free License version 3.0
4		*/
5
6		package jaggregate.internal.number;
7
8		import java.math.BigInteger;
9
10		/**
11		* Wrapper for a {@code BigInteger}.
12		*
13		* @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
14		* @version $Id: OperableBigInteger.java,v 1.1 2008/03/26 18:01:24 pholser Exp $
15		*/
16	11041	public class OperableBigInteger extends OperableNumber<BigInteger> {
17		private static final long serialVersionUID = -1L;
18
19	1	private static final OperableBigInteger ONE =
20		new OperableBigInteger( BigInteger.ONE ) {
21		private static final long serialVersionUID = -1L;
22
23		@Override
24	204	public void incrementBy( OperableNumber<BigInteger> increment ) {
25	1	throw new UnsupportedOperationException();
26		}
27		};
28
29		/**
30		* Creates a wrapper for the given number.
31		*
32		* @param wrapped the wrapped number
33		*/
34		public OperableBigInteger( BigInteger wrapped ) {
35	8629	super( wrapped );
36	8629	}
37
38		/**
39		* {@inheritDoc}
40		*/
41		@Override
42		public boolean isZero() {
43	809	return unwrapped().equals( BigInteger.ZERO );
44		}
45
46		/**
47		* {@inheritDoc}
48		*/
49		@Override
50		public OperableBigInteger plus( BigInteger addend ) {
51	1595	return new OperableBigInteger( unwrapped().add( addend ) );
52		}
53
54		/**
55		* {@inheritDoc}
56		*/
57		@Override
58		public OperableBigInteger plus( int addend ) {
59	633	return new OperableBigInteger( unwrapped().add( BigInteger.valueOf( addend ) ) );
60		}
61
62		/**
63		* {@inheritDoc}
64		*/
65		@Override
66		public OperableBigInteger minus( BigInteger subtrahend ) {
67	1266	return new OperableBigInteger( unwrapped().subtract( subtrahend ) );
68		}
69
70		/**
71		* {@inheritDoc}
72		*/
73		@Override
74		public OperableBigInteger times( BigInteger multiplier ) {
75	633	return new OperableBigInteger( unwrapped().multiply( multiplier ) );
76		}
77
78		/**
79		* {@inheritDoc}
80		*/
81		@Override
82		public OperableBigInteger times( int multiplier ) {
83	847	return new OperableBigInteger(
84		unwrapped().multiply( BigInteger.valueOf( multiplier ) ) );
85		}
86
87		/**
88		* {@inheritDoc}
89		*/
90		@Override
91		public OperableBigInteger dividedBy( BigInteger divisor ) {
92	1266	return new OperableBigInteger( unwrapped().divide( divisor ) );
93		}
94
95		/**
96		* {@inheritDoc}
97		*/
98		@Override
99		public OperableBigInteger modulo( BigInteger divisor ) {
100	79	return new OperableBigInteger( unwrapped().remainder( divisor ) );
101		}
102
103		/**
104		* {@inheritDoc}
105		*/
106		@Override
107		public boolean isPositive() {
108	2239	return unwrapped().signum() > 0;
109		}
110
111		/**
112		* {@inheritDoc}
113		*/
114		@Override
115		public boolean isNegative() {
116	1078	return unwrapped().signum() < 0;
117		}
118
119		/**
120		* {@inheritDoc}
121		*/
122		@Override
123		public boolean greaterThan( BigInteger comparand ) {
124	2094	return unwrapped().compareTo( comparand ) > 0;
125		}
126
127		/**
128		* {@inheritDoc}
129		*/
130		@Override
131		public boolean greaterThanOrEqualTo( BigInteger comparand ) {
132	385	return unwrapped().compareTo( comparand ) >= 0;
133		}
134
135		/**
136		* {@inheritDoc}
137		*/
138		@Override
139		public boolean lessThan( BigInteger comparand ) {
140	1920	return unwrapped().compareTo( comparand ) < 0;
141		}
142
143		/**
144		* {@inheritDoc}
145		*/
146		@Override
147		public boolean lessThanOrEqualTo( BigInteger comparand ) {
148	429	return unwrapped().compareTo( comparand ) <= 0;
149		}
150
151		/**
152		* {@inheritDoc}
153		*/
154		@Override
155		public OperableBigInteger negated() {
156	97	return new OperableBigInteger( unwrapped().negate() );
157		}
158
159		/**
160		* {@inheritDoc}
161		*/
162		@Override
163		public void incrementBy( OperableNumber<BigInteger> increment ) {
164	596	update( unwrapped().add( increment.unwrapped() ) );
165	596	}
166
167		/**
168		* {@inheritDoc}
169		*/
170		@Override
171		public OperableNumber<BigInteger> one() {
172	181	return ONE;
173		}
174		}