001/**
002 * AbstractDoublePrimitive.java
003 * 
004 * Copyright (c) 2004-2012, Nicole C. Tedesco. All rights reserved.
005 * 
006 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
007 * use this file except in compliance with the License. You may obtain a copy of
008 * the License at:
009 * 
010 * http://www.apache.org/licenses/LICENSE-2.0
011 * 
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
014 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
015 * License for the specific language governing permissions and limitations under
016 * the License.
017 */
018
019package net.sf.jaccumulator.doubles;
020
021import java.math.BigDecimal;
022import java.math.BigInteger;
023import java.util.NoSuchElementException;
024
025import net.sf.jaccumulator.Domain;
026import net.sf.jaccumulator.lex.To;
027import net.sf.jaccumulator.primitives.AbstractNumericPrimitive;
028import net.sf.jaccumulator.primitives.Constant;
029import net.sf.jaccumulator.primitives.Primitive;
030import net.sf.jaccumulator.primitives.SealedPrimitive;
031import net.sf.jaccumulator.reals.Real;
032import net.sf.jaccumulator.reals.SealedReal;
033import net.sf.jaccumulator.scalars.NumericPrecision;
034import net.sf.jaccumulator.scalars.RoundingStrategy;
035import net.sf.jaccumulator.scalars.Scalar;
036import net.sf.jaccumulator.scalars.SealedScalar;
037
038/**
039 * Abstract {@code double} precision {@link Primitive primitive} implementation
040 * 
041 * @param <PRIMITIVE>
042 *        this primitive type (used to facilitate operation chaining on write
043 *        operations)
044 * @since JAccumulator 4.0
045 * @author Nicole Tedesco (<a
046 *         href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>)
047 */
048public abstract class AbstractDoublePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
049    extends
050        AbstractNumericPrimitive<PRIMITIVE>
051{
052    private static final long serialVersionUID = -7949047588533785197L;
053
054    public AbstractDoublePrimitive()
055    {
056        super(NumericPrecision.DOUBLE);
057    }
058
059    public AbstractDoublePrimitive( final Domain aDomain )
060    {
061        super(aDomain, NumericPrecision.DOUBLE);
062    }
063
064    @Override
065    public final PRIMITIVE absoluteValue()
066        throws UnsupportedOperationException,
067            ArithmeticException,
068            IllegalArgumentException
069    {
070        return this.setScalar(Math.abs(this.doubleValue()));
071    }
072
073    @Override
074    public final PRIMITIVE and( final BigInteger aValue )
075        throws UnsupportedOperationException,
076            IllegalArgumentException,
077            ArithmeticException
078    {
079        return this.setReal(this.toUnlimitedInteger().and(aValue));
080    }
081
082    @Override
083    public final PRIMITIVE and( final boolean aValue )
084        throws UnsupportedOperationException,
085            IllegalArgumentException,
086            ArithmeticException
087    {
088        return this.and(Constant.toUnlimitedInteger(aValue));
089    }
090
091    @Override
092    public final PRIMITIVE and( final byte aValue )
093        throws UnsupportedOperationException,
094            IllegalArgumentException,
095            ArithmeticException
096    {
097        return this.and(BigInteger.valueOf(aValue));
098    }
099
100    @Override
101    public final PRIMITIVE and( final char aValue )
102        throws UnsupportedOperationException,
103            IllegalArgumentException,
104            ArithmeticException
105    {
106        return this.and(BigInteger.valueOf(aValue));
107    }
108
109    @Override
110    public final PRIMITIVE and( final int aValue )
111        throws UnsupportedOperationException,
112            IllegalArgumentException,
113            ArithmeticException
114    {
115        return this.and(BigInteger.valueOf(aValue));
116    }
117
118    @Override
119    public final PRIMITIVE and( final long aValue )
120        throws UnsupportedOperationException,
121            IllegalArgumentException,
122            ArithmeticException
123    {
124        return this.and(BigInteger.valueOf(aValue));
125    }
126
127    @Override
128    public final PRIMITIVE and( final short aValue )
129        throws UnsupportedOperationException,
130            IllegalArgumentException,
131            ArithmeticException
132    {
133        return this.and(BigInteger.valueOf(aValue));
134    }
135
136    @Override
137    public final boolean booleanPostDecrement()
138        throws UnsupportedOperationException,
139            ArithmeticException,
140            IllegalArgumentException
141    {
142        return To.booleanValue(this.doublePostDecrement());
143    }
144
145    @Override
146    public final boolean booleanPostIncrement()
147        throws UnsupportedOperationException,
148            ArithmeticException,
149            IllegalArgumentException
150    {
151        return To.booleanValue(this.doublePostIncrement());
152    }
153
154    @Override
155    public final boolean booleanValue()
156    {
157        return To.booleanValue(this.doubleValue());
158    }
159
160    @Override
161    public final byte bytePostDecrement()
162        throws UnsupportedOperationException,
163            ArithmeticException,
164            IllegalArgumentException
165    {
166        return (byte)this.doublePostDecrement();
167    }
168
169    @Override
170    public final byte bytePostIncrement()
171        throws UnsupportedOperationException,
172            ArithmeticException,
173            IllegalArgumentException
174    {
175        return (byte)this.doublePostIncrement();
176    }
177
178    @Override
179    public final byte byteValue()
180    {
181        return (byte)this.doubleValue();
182    }
183
184    @Override
185    public final char charPostDecrement()
186        throws UnsupportedOperationException,
187            ArithmeticException,
188            IllegalArgumentException
189    {
190        return (char)this.doublePostDecrement();
191    }
192
193    @Override
194    public final char charPostIncrement()
195        throws UnsupportedOperationException,
196            ArithmeticException,
197            IllegalArgumentException
198    {
199        return (char)this.doublePostIncrement();
200    }
201
202    @Override
203    public final char charValue()
204    {
205        return (char)this.doubleValue();
206    }
207
208    @Override
209    public final PRIMITIVE copyUsing( final BigDecimal aValue )
210    {
211        return this.copyUsing(aValue.doubleValue());
212    }
213
214    @Override
215    public final PRIMITIVE copyUsing( final BigInteger aValue )
216    {
217        return this.copyUsing(aValue.doubleValue());
218    }
219
220    @Override
221    public final PRIMITIVE copyUsing( final boolean aValue )
222    {
223        return this.copyUsing(To.doubleValue(aValue));
224    }
225
226    @Override
227    public final PRIMITIVE copyUsing( final byte aValue )
228    {
229        return this.copyUsing((double)aValue);
230    }
231
232    @Override
233    public final PRIMITIVE copyUsing( final char aValue )
234    {
235        return this.copyUsing((double)aValue);
236    }
237
238    @Override
239    public final PRIMITIVE copyUsing( final float aValue )
240    {
241        return this.copyUsing((double)aValue);
242    }
243
244    @Override
245    public final PRIMITIVE copyUsing( final int aValue )
246    {
247        return this.copyUsing((double)aValue);
248    }
249
250    @Override
251    public final PRIMITIVE copyUsing( final long aValue )
252    {
253        return this.copyUsing((double)aValue);
254    }
255
256    @Override
257    public final PRIMITIVE copyUsing( final short aValue )
258    {
259        return this.copyUsing((double)aValue);
260    }
261
262    @Override
263    public final PRIMITIVE copyUsingPrimitive( final SealedPrimitive<?> aValue )
264    {
265        return this.copyUsing(aValue.doubleValue());
266    }
267
268    @Override
269    public final PRIMITIVE copyUsingReal( final SealedReal<?> aValue )
270    {
271        return this.copyUsing(aValue.doubleValue());
272    }
273
274    @Override
275    public final PRIMITIVE copyUsingScalar( final SealedScalar<?> aValue )
276    {
277        return this.copyUsing(aValue.doubleValue());
278    }
279
280    @Override
281    public final PRIMITIVE cube()
282        throws UnsupportedOperationException,
283            IllegalArgumentException,
284            ArithmeticException
285    {
286        final double myValue = this.doubleValue();
287        return this.setScalar(myValue * myValue * myValue);
288    }
289
290    @Override
291    public final PRIMITIVE difference( final BigDecimal aValue )
292        throws UnsupportedOperationException,
293            IllegalArgumentException,
294            ArithmeticException
295    {
296        return this.setReal(this.toUnlimitedDecimal().subtract(aValue));
297    }
298
299    @Override
300    public final PRIMITIVE difference( final BigInteger aValue )
301        throws UnsupportedOperationException,
302            IllegalArgumentException,
303            ArithmeticException
304    {
305        return this.difference(Constant.toUnlimitedDecimal(aValue));
306    }
307
308    @Override
309    public final PRIMITIVE difference( final boolean aValue )
310        throws UnsupportedOperationException,
311            IllegalArgumentException,
312            ArithmeticException
313    {
314        return this.difference(To.doubleValue(aValue));
315    }
316
317    @Override
318    public final PRIMITIVE difference( final byte aValue )
319        throws UnsupportedOperationException,
320            IllegalArgumentException,
321            ArithmeticException
322    {
323        return this.setScalar(this.doubleValue() - aValue);
324    }
325
326    @Override
327    public final PRIMITIVE difference( final char aValue )
328        throws UnsupportedOperationException,
329            IllegalArgumentException,
330            ArithmeticException
331    {
332        return this.setScalar(this.doubleValue() - aValue);
333    }
334
335    @Override
336    public final PRIMITIVE difference( final float aValue )
337        throws UnsupportedOperationException,
338            IllegalArgumentException,
339            ArithmeticException
340    {
341        return this.setScalar(this.doubleValue() - aValue);
342    }
343
344    @Override
345    public final PRIMITIVE difference( final int aValue )
346        throws UnsupportedOperationException,
347            IllegalArgumentException,
348            ArithmeticException
349    {
350        return this.setScalar(this.doubleValue() - aValue);
351    }
352
353    @Override
354    public final PRIMITIVE difference( final long aValue )
355        throws UnsupportedOperationException,
356            IllegalArgumentException,
357            ArithmeticException
358    {
359        return this.setScalar(this.doubleValue() - aValue);
360    }
361
362    @Override
363    public final PRIMITIVE difference( final short aValue )
364        throws UnsupportedOperationException,
365            IllegalArgumentException,
366            ArithmeticException
367    {
368        return this.setScalar(this.doubleValue() - aValue);
369    }
370
371    @Override
372    public final float floatPostDecrement()
373        throws UnsupportedOperationException,
374            ArithmeticException,
375            IllegalArgumentException
376    {
377        return (float)this.doublePostDecrement();
378    }
379
380    @Override
381    public final float floatPostIncrement()
382        throws UnsupportedOperationException,
383            ArithmeticException,
384            IllegalArgumentException
385    {
386        return (float)this.doublePostIncrement();
387    }
388
389    @Override
390    public final float floatValue()
391    {
392        return (float)this.doubleValue();
393    }
394
395    @Override
396    @SuppressWarnings( "unchecked" )
397    public final <S extends Scalar<?>> S inducePostDecrement( final S aTarget )
398        throws NullPointerException,
399            NoSuchElementException,
400            UnsupportedOperationException,
401            IllegalStateException
402    {
403        return (S)aTarget.setScalar(this.doublePostDecrement());
404    }
405
406    @Override
407    @SuppressWarnings( "unchecked" )
408    public final <S extends Scalar<?>> S inducePostIncrement( final S aTarget )
409        throws NullPointerException,
410            NoSuchElementException,
411            UnsupportedOperationException,
412            IllegalStateException
413    {
414        return (S)aTarget.setScalar(this.doublePostIncrement());
415    }
416
417    @Override
418    public final <REAL extends Real<?>> REAL induceRealMaximum(
419        final REAL aTarget )
420        throws NullPointerException,
421            NoSuchElementException,
422            UnsupportedOperationException,
423            IllegalStateException
424    {
425        return this.induceScalarMaximum(aTarget);
426    }
427
428    @Override
429    public final <REAL extends Real<?>> REAL induceRealMinimum(
430        final REAL aTarget )
431        throws NullPointerException,
432            NoSuchElementException,
433            UnsupportedOperationException,
434            IllegalStateException
435    {
436        return this.induceScalarMinimum(aTarget);
437    }
438
439    @Override
440    public final <REAL extends Real<?>> REAL induceRealValue( final REAL aTarget )
441        throws NullPointerException,
442            NoSuchElementException,
443            UnsupportedOperationException,
444            IllegalStateException
445    {
446        return this.induceScalarValue(aTarget);
447    }
448
449    @Override
450    @SuppressWarnings( "unchecked" )
451    public final <S extends Scalar<?>> S induceScalarMaximum( final S aTarget )
452    {
453        return (S)aTarget.setScalar(Double.MAX_VALUE);
454    }
455
456    @Override
457    @SuppressWarnings( "unchecked" )
458    public final <S extends Scalar<?>> S induceScalarMinimum( final S aTarget )
459    {
460        return (S)aTarget.setScalar(Double.MIN_VALUE);
461    }
462
463    @Override
464    @SuppressWarnings( "unchecked" )
465    public final <S extends Scalar<?>> S induceScalarValue( final S aTarget )
466    {
467        return (S)aTarget.setScalar(this.doubleValue());
468    }
469
470    @Override
471    public final int intPostDecrement()
472        throws UnsupportedOperationException,
473            ArithmeticException,
474            IllegalArgumentException
475    {
476        return (int)this.doublePostDecrement();
477    }
478
479    @Override
480    public final int intPostIncrement()
481        throws UnsupportedOperationException,
482            ArithmeticException,
483            IllegalArgumentException
484    {
485        return (int)this.doublePostIncrement();
486    }
487
488    @Override
489    public final int intValue()
490    {
491        return (int)this.doubleValue();
492    }
493
494    @Override
495    public final PRIMITIVE invalidate()
496        throws UnsupportedOperationException,
497            ArithmeticException,
498            IllegalArgumentException
499    {
500        return this.setScalar(Double.NaN);
501    }
502
503    @Override
504    public final PRIMITIVE inverse()
505        throws UnsupportedOperationException,
506            ArithmeticException,
507            IllegalArgumentException
508    {
509        return this.setScalar(1.0D / this.doubleValue());
510    }
511
512    @Override
513    public final boolean isInfinity()
514    {
515        return Double.isInfinite(this.doubleValue());
516    }
517
518    @Override
519    public final boolean isInvalid()
520    {
521        return Double.isNaN(this.doubleValue());
522    }
523
524    @Override
525    public final boolean isMaximum()
526    {
527        return Double.compare(this.doubleValue(), Double.MAX_VALUE) == 0;
528    }
529
530    @Override
531    public final boolean isMinimum()
532    {
533        return Double.compare(this.doubleValue(), Double.MIN_VALUE) == 0;
534    }
535
536    @Override
537    public final boolean isModulo()
538    {
539        return false;
540    }
541
542    @Override
543    public final boolean isNegative()
544    {
545        return Double.compare(this.doubleValue(), 0.0D) < 0;
546    }
547
548    @Override
549    public final boolean isNegativeFinite()
550    {
551        final double myValue = this.doubleValue();
552        if (Double.isNaN(myValue)) return false;
553        if (Double.isInfinite(myValue)) return false;
554        return myValue < 0.0D;
555    }
556
557    @Override
558    public final boolean isNegativeInfinity()
559    {
560        return this.doubleValue() == Double.NEGATIVE_INFINITY;
561    }
562
563    @Override
564    public final boolean isPositive()
565    {
566        return 0 < Double.compare(this.doubleValue(), 0.0D);
567    }
568
569    @Override
570    public final boolean isPositiveFinite()
571    {
572        final double myValue = this.doubleValue();
573        if (Double.isNaN(myValue)) return false;
574        if (Double.isInfinite(myValue)) return false;
575        return 0.0D < myValue;
576    }
577
578    @Override
579    public final boolean isPositiveInfinity()
580    {
581        return this.doubleValue() == Double.POSITIVE_INFINITY;
582    }
583
584    @Override
585    public final boolean isReal()
586    {
587        return true;
588    }
589
590    @Override
591    public final boolean isUnity()
592    {
593        return Double.compare(this.doubleValue(), 1.0D) == 0;
594    }
595
596    @Override
597    public final boolean isZero()
598    {
599        return Double.compare(this.doubleValue(), 0.0D) == 0;
600    }
601
602    @Override
603    public final long longPostDecrement()
604        throws UnsupportedOperationException,
605            ArithmeticException,
606            IllegalArgumentException
607    {
608        return (long)this.doublePostDecrement();
609    }
610
611    @Override
612    public final long longPostIncrement()
613        throws UnsupportedOperationException,
614            ArithmeticException,
615            IllegalArgumentException
616    {
617        return (long)this.doublePostIncrement();
618    }
619
620    @Override
621    public final long longValue()
622    {
623        return (long)this.doubleValue();
624    }
625
626    @Override
627    public final PRIMITIVE negate()
628        throws UnsupportedOperationException,
629            ArithmeticException,
630            IllegalArgumentException
631    {
632        return this.setScalar(-this.doubleValue());
633    }
634
635    @Override
636    public final PRIMITIVE not()
637        throws UnsupportedOperationException,
638            IllegalArgumentException,
639            ArithmeticException
640    {
641        return this.setReal(this.toUnlimitedInteger().not());
642    }
643
644    @Override
645    public final PRIMITIVE or( final BigInteger aValue )
646        throws UnsupportedOperationException,
647            IllegalArgumentException,
648            ArithmeticException
649    {
650        return this.setReal(this.toUnlimitedInteger().or(aValue));
651    }
652
653    @Override
654    public final PRIMITIVE or( final boolean aValue )
655        throws UnsupportedOperationException,
656            IllegalArgumentException,
657            ArithmeticException
658    {
659        return this.or(Constant.toUnlimitedInteger(aValue));
660    }
661
662    @Override
663    public final PRIMITIVE or( final byte aValue )
664        throws UnsupportedOperationException,
665            IllegalArgumentException,
666            ArithmeticException
667    {
668        return this.or(BigInteger.valueOf(aValue));
669    }
670
671    @Override
672    public final PRIMITIVE or( final char aValue )
673        throws UnsupportedOperationException,
674            IllegalArgumentException,
675            ArithmeticException
676    {
677        return this.or(BigInteger.valueOf(aValue));
678    }
679
680    @Override
681    public final PRIMITIVE or( final int aValue )
682        throws UnsupportedOperationException,
683            IllegalArgumentException,
684            ArithmeticException
685    {
686        return this.or(BigInteger.valueOf(aValue));
687    }
688
689    @Override
690    public final PRIMITIVE or( final long aValue )
691        throws UnsupportedOperationException,
692            IllegalArgumentException,
693            ArithmeticException
694    {
695        return this.or(BigInteger.valueOf(aValue));
696    }
697
698    @Override
699    public final PRIMITIVE or( final short aValue )
700        throws UnsupportedOperationException,
701            IllegalArgumentException,
702            ArithmeticException
703    {
704        return this.or(BigInteger.valueOf(aValue));
705    }
706
707    @Override
708    public final PRIMITIVE product( final BigDecimal aValue )
709        throws UnsupportedOperationException,
710            IllegalArgumentException,
711            ArithmeticException
712    {
713        return this.setReal(this.toUnlimitedDecimal().multiply(aValue));
714    }
715
716    @Override
717    public final PRIMITIVE product( final BigInteger aValue )
718        throws UnsupportedOperationException,
719            IllegalArgumentException,
720            ArithmeticException
721    {
722        return this.product(Constant.toUnlimitedDecimal(aValue));
723    }
724
725    @Override
726    public final PRIMITIVE product( final boolean aValue )
727        throws UnsupportedOperationException,
728            IllegalArgumentException,
729            ArithmeticException
730    {
731        return this.product(To.doubleValue(aValue));
732    }
733
734    @Override
735    public final PRIMITIVE product( final byte aValue )
736        throws UnsupportedOperationException,
737            IllegalArgumentException,
738            ArithmeticException
739    {
740        return this.setScalar(this.doubleValue() * aValue);
741    }
742
743    @Override
744    public final PRIMITIVE product( final char aValue )
745        throws UnsupportedOperationException,
746            IllegalArgumentException,
747            ArithmeticException
748    {
749        return this.setScalar(this.doubleValue() * aValue);
750    }
751
752    @Override
753    public final PRIMITIVE product( final float aValue )
754        throws UnsupportedOperationException,
755            IllegalArgumentException,
756            ArithmeticException
757    {
758        return this.setScalar(this.doubleValue() * aValue);
759    }
760
761    @Override
762    public final PRIMITIVE product( final int aValue )
763        throws UnsupportedOperationException,
764            IllegalArgumentException,
765            ArithmeticException
766    {
767        return this.setScalar(this.doubleValue() * aValue);
768    }
769
770    @Override
771    public final PRIMITIVE product( final long aValue )
772        throws UnsupportedOperationException,
773            IllegalArgumentException,
774            ArithmeticException
775    {
776        return this.setScalar(this.doubleValue() * aValue);
777    }
778
779    @Override
780    public final PRIMITIVE product( final short aValue )
781        throws UnsupportedOperationException,
782            IllegalArgumentException,
783            ArithmeticException
784    {
785        return this.setScalar(this.doubleValue() * aValue);
786    }
787
788    @Override
789    public final PRIMITIVE quotient( final BigDecimal aValue )
790        throws UnsupportedOperationException,
791            IllegalArgumentException,
792            ArithmeticException
793    {
794        return this.setReal(this.toUnlimitedDecimal().divide(aValue));
795    }
796
797    @Override
798    public final PRIMITIVE quotient( final BigInteger aValue )
799        throws UnsupportedOperationException,
800            IllegalArgumentException,
801            ArithmeticException
802    {
803        return this.quotient(Constant.toUnlimitedDecimal(aValue));
804    }
805
806    @Override
807    public final PRIMITIVE quotient( final boolean aValue )
808        throws UnsupportedOperationException,
809            IllegalArgumentException,
810            ArithmeticException
811    {
812        return this.quotient(To.doubleValue(aValue));
813    }
814
815    @Override
816    public final PRIMITIVE quotient( final byte aValue )
817        throws UnsupportedOperationException,
818            IllegalArgumentException,
819            ArithmeticException
820    {
821        return this.setScalar(this.doubleValue() / aValue);
822    }
823
824    @Override
825    public final PRIMITIVE quotient( final char aValue )
826        throws UnsupportedOperationException,
827            IllegalArgumentException,
828            ArithmeticException
829    {
830        return this.setScalar(this.doubleValue() / aValue);
831    }
832
833    @Override
834    public final PRIMITIVE quotient( final float aValue )
835        throws UnsupportedOperationException,
836            IllegalArgumentException,
837            ArithmeticException
838    {
839        return this.setScalar(this.doubleValue() / aValue);
840    }
841
842    @Override
843    public final PRIMITIVE quotient( final int aValue )
844        throws UnsupportedOperationException,
845            IllegalArgumentException,
846            ArithmeticException
847    {
848        return this.setScalar(this.doubleValue() / aValue);
849    }
850
851    @Override
852    public final PRIMITIVE quotient( final long aValue )
853        throws UnsupportedOperationException,
854            IllegalArgumentException,
855            ArithmeticException
856    {
857        return this.setScalar(this.doubleValue() / aValue);
858    }
859
860    @Override
861    public final PRIMITIVE quotient( final short aValue )
862        throws UnsupportedOperationException,
863            IllegalArgumentException,
864            ArithmeticException
865    {
866        return this.setScalar(this.doubleValue() / aValue);
867    }
868
869    @Override
870    public final PRIMITIVE round( final RoundingStrategy aRoundingStrategy )
871        throws UnsupportedOperationException,
872            IllegalArgumentException,
873            ArithmeticException,
874            NullPointerException
875    {
876        return this.setScalar(aRoundingStrategy.doubleValue(this.doubleValue()));
877    }
878
879    @Override
880    public final PRIMITIVE setMaximum()
881        throws UnsupportedOperationException,
882            ArithmeticException,
883            IllegalArgumentException
884    {
885        return this.setScalar(Double.MAX_VALUE);
886    }
887
888    @Override
889    public final PRIMITIVE setMinimum()
890        throws UnsupportedOperationException,
891            ArithmeticException,
892            IllegalArgumentException
893    {
894        return this.setScalar(Double.MIN_VALUE);
895    }
896
897    @Override
898    public final PRIMITIVE setNegativeInfinity()
899        throws UnsupportedOperationException,
900            ArithmeticException,
901            IllegalArgumentException
902    {
903        return this.setScalar(Double.NEGATIVE_INFINITY);
904    }
905
906    @Override
907    public final PRIMITIVE setNumber( final Number aValue )
908        throws UnsupportedOperationException,
909            IllegalArgumentException,
910            ArithmeticException,
911            NullPointerException
912    {
913        return this.setScalar(aValue.doubleValue());
914    }
915
916    @Override
917    public final PRIMITIVE setPositiveInfinity()
918        throws UnsupportedOperationException,
919            ArithmeticException,
920            IllegalArgumentException
921    {
922        return this.setScalar(Double.POSITIVE_INFINITY);
923    }
924
925    @Override
926    public final PRIMITIVE setPrimitive( final SealedPrimitive<?> aValue )
927        throws UnsupportedOperationException,
928            IllegalArgumentException,
929            ArithmeticException,
930            NullPointerException
931    {
932        return this.setScalar(aValue.doubleValue());
933    }
934
935    @Override
936    public final PRIMITIVE setReal( final BigDecimal aValue )
937        throws UnsupportedOperationException,
938            IllegalArgumentException,
939            ArithmeticException,
940            NullPointerException
941    {
942        return this.setScalar(aValue.doubleValue());
943    }
944
945    @Override
946    public final PRIMITIVE setReal( final BigInteger aValue )
947        throws UnsupportedOperationException,
948            IllegalArgumentException,
949            ArithmeticException,
950            NullPointerException
951    {
952        return this.setScalar(aValue.doubleValue());
953    }
954
955    @Override
956    public final PRIMITIVE setReal( final SealedReal<?> aValue )
957        throws UnsupportedOperationException,
958            IllegalArgumentException,
959            ArithmeticException,
960            NullPointerException
961    {
962        return this.setScalar(aValue.doubleValue());
963    }
964
965    @Override
966    public final PRIMITIVE setScalar( final boolean aValue )
967        throws UnsupportedOperationException,
968            IllegalArgumentException,
969            ArithmeticException
970    {
971        return this.setScalar(To.doubleValue(aValue));
972    }
973
974    @Override
975    public final PRIMITIVE setScalar( final byte aValue )
976        throws UnsupportedOperationException,
977            IllegalArgumentException,
978            ArithmeticException
979    {
980        return this.setScalar((double)aValue);
981    }
982
983    @Override
984    public final PRIMITIVE setScalar( final char aValue )
985        throws UnsupportedOperationException,
986            IllegalArgumentException,
987            ArithmeticException
988    {
989        return this.setScalar((double)aValue);
990    }
991
992    @Override
993    public final PRIMITIVE setScalar( final float aValue )
994        throws UnsupportedOperationException,
995            IllegalArgumentException,
996            ArithmeticException
997    {
998        return this.setScalar((double)aValue);
999    }
1000
1001    @Override
1002    public final PRIMITIVE setScalar( final int aValue )
1003        throws UnsupportedOperationException,
1004            IllegalArgumentException,
1005            ArithmeticException
1006    {
1007        return this.setScalar((double)aValue);
1008    }
1009
1010    @Override
1011    public final PRIMITIVE setScalar( final long aValue )
1012        throws UnsupportedOperationException,
1013            IllegalArgumentException,
1014            ArithmeticException
1015    {
1016        return this.setScalar((double)aValue);
1017    }
1018
1019    @Override
1020    public final PRIMITIVE setScalar( final SealedScalar<?> aValue )
1021        throws UnsupportedOperationException,
1022            IllegalArgumentException,
1023            ArithmeticException,
1024            NullPointerException
1025    {
1026        return this.setScalar(aValue.doubleValue());
1027    }
1028
1029    @Override
1030    public final PRIMITIVE setScalar( final short aValue )
1031        throws UnsupportedOperationException,
1032            IllegalArgumentException,
1033            ArithmeticException
1034    {
1035        return this.setScalar((double)aValue);
1036    }
1037
1038    @Override
1039    public final PRIMITIVE setUnity()
1040        throws UnsupportedOperationException,
1041            IllegalArgumentException,
1042            ArithmeticException
1043    {
1044        return this.setScalar(1.0D);
1045    }
1046
1047    @Override
1048    public final PRIMITIVE setZero()
1049        throws UnsupportedOperationException,
1050            IllegalArgumentException,
1051            ArithmeticException
1052    {
1053        return this.setScalar(0.0D);
1054    }
1055
1056    @Override
1057    public PRIMITIVE shiftLeft( final int count )
1058        throws UnsupportedOperationException,
1059            IllegalArgumentException,
1060            ArithmeticException
1061    {
1062        long myValue = Double.doubleToRawLongBits(this.doubleValue());
1063        myValue <<= count;
1064        return this.setScalar(Double.longBitsToDouble(myValue));
1065    }
1066
1067    @Override
1068    public PRIMITIVE shiftRight( final int count )
1069        throws UnsupportedOperationException,
1070            IllegalArgumentException,
1071            ArithmeticException
1072    {
1073        long myValue = Double.doubleToRawLongBits(this.doubleValue());
1074        myValue >>= count;
1075        return this.setScalar(Double.longBitsToDouble(myValue));
1076    }
1077
1078    @Override
1079    public PRIMITIVE shiftRightExtendZero( final int count )
1080        throws UnsupportedOperationException,
1081            IllegalArgumentException,
1082            ArithmeticException
1083    {
1084        long myValue = Double.doubleToRawLongBits(this.doubleValue());
1085        myValue >>>= count;
1086        return this.setScalar(Double.longBitsToDouble(myValue));
1087    }
1088
1089    @Override
1090    public final short shortPostDecrement()
1091        throws UnsupportedOperationException,
1092            ArithmeticException,
1093            IllegalArgumentException
1094    {
1095        return (short)this.doublePostDecrement();
1096    }
1097
1098    @Override
1099    public final short shortPostIncrement()
1100        throws UnsupportedOperationException,
1101            ArithmeticException,
1102            IllegalArgumentException
1103    {
1104        return (short)this.doublePostIncrement();
1105    }
1106
1107    @Override
1108    public final short shortValue()
1109    {
1110        return (short)this.doubleValue();
1111    }
1112
1113    @Override
1114    public final int signum()
1115    {
1116        return (int)Math.signum(this.doubleValue());
1117    }
1118
1119    @Override
1120    public final PRIMITIVE square()
1121        throws UnsupportedOperationException,
1122            IllegalArgumentException,
1123            ArithmeticException
1124    {
1125        final double myValue = this.doubleValue();
1126        return this.setScalar(myValue * myValue);
1127    }
1128
1129    @Override
1130    public final PRIMITIVE sum( final BigDecimal aValue )
1131        throws UnsupportedOperationException,
1132            IllegalArgumentException,
1133            ArithmeticException
1134    {
1135        return this.setReal(this.toUnlimitedDecimal().add(aValue));
1136    }
1137
1138    @Override
1139    public final PRIMITIVE sum( final BigInteger aValue )
1140        throws UnsupportedOperationException,
1141            IllegalArgumentException,
1142            ArithmeticException
1143    {
1144        return this.sum(Constant.toUnlimitedDecimal(aValue));
1145    }
1146
1147    @Override
1148    public final PRIMITIVE sum( final boolean aValue )
1149        throws UnsupportedOperationException,
1150            IllegalArgumentException,
1151            ArithmeticException
1152    {
1153        return this.sum(To.doubleValue(aValue));
1154    }
1155
1156    @Override
1157    public final PRIMITIVE sum( final byte aValue )
1158        throws UnsupportedOperationException,
1159            IllegalArgumentException,
1160            ArithmeticException
1161    {
1162        return this.setScalar(this.doubleValue() + aValue);
1163    }
1164
1165    @Override
1166    public final PRIMITIVE sum( final char aValue )
1167        throws UnsupportedOperationException,
1168            IllegalArgumentException,
1169            ArithmeticException
1170    {
1171        return this.setScalar(this.doubleValue() + aValue);
1172    }
1173
1174    @Override
1175    public final PRIMITIVE sum( final float aValue )
1176        throws UnsupportedOperationException,
1177            IllegalArgumentException,
1178            ArithmeticException
1179    {
1180        return this.setScalar(this.doubleValue() + aValue);
1181    }
1182
1183    @Override
1184    public final PRIMITIVE sum( final int aValue )
1185        throws UnsupportedOperationException,
1186            IllegalArgumentException,
1187            ArithmeticException
1188    {
1189        return this.setScalar(this.doubleValue() + aValue);
1190    }
1191
1192    @Override
1193    public final PRIMITIVE sum( final long aValue )
1194        throws UnsupportedOperationException,
1195            IllegalArgumentException,
1196            ArithmeticException
1197    {
1198        return this.setScalar(this.doubleValue() + aValue);
1199    }
1200
1201    @Override
1202    public final PRIMITIVE sum( final short aValue )
1203        throws UnsupportedOperationException,
1204            IllegalArgumentException,
1205            ArithmeticException
1206    {
1207        return this.setScalar(this.doubleValue() + aValue);
1208    }
1209
1210    @Override
1211    public final PRIMITIVE swapPrimitives( final Primitive<?> aPrimitive )
1212    {
1213        final double myValue = this.doubleValue();
1214        final double aValue = aPrimitive.doubleValue();
1215        aPrimitive.setScalar(myValue);
1216        return this.setScalar(aValue);
1217    }
1218
1219    @Override
1220    public final Number toNumber()
1221    {
1222        return Double.valueOf(this.doubleValue());
1223    }
1224
1225    @Override
1226    public final String toString()
1227    {
1228        return String.valueOf(this.doubleValue());
1229    }
1230
1231    @Override
1232    public final BigDecimal toUnlimitedDecimal()
1233    {
1234        return new BigDecimal(this.toString());
1235    }
1236
1237    @Override
1238    public final BigInteger toUnlimitedInteger()
1239    {
1240        return this.toUnlimitedDecimal().toBigInteger();
1241    }
1242
1243    @Override
1244    public final BigDecimal unlimitedDecimalPostDecrement()
1245        throws UnsupportedOperationException,
1246            ArithmeticException,
1247            IllegalArgumentException
1248    {
1249        return Constant.toUnlimitedDecimal(this.doublePostDecrement());
1250    }
1251
1252    @Override
1253    public final BigDecimal unlimitedDecimalPostIncrement()
1254        throws UnsupportedOperationException,
1255            ArithmeticException,
1256            IllegalArgumentException
1257    {
1258        return Constant.toUnlimitedDecimal(this.doublePostIncrement());
1259    }
1260
1261    @Override
1262    public final BigInteger unlimitedIntegerPostDecrement()
1263        throws UnsupportedOperationException,
1264            ArithmeticException,
1265            IllegalArgumentException
1266    {
1267        return Constant.toUnlimitedDecimal(this.doublePostDecrement()).toBigInteger();
1268    }
1269
1270    @Override
1271    public final BigInteger unlimitedIntegerPostIncrement()
1272        throws UnsupportedOperationException,
1273            ArithmeticException,
1274            IllegalArgumentException
1275    {
1276        return Constant.toUnlimitedDecimal(this.doublePostIncrement()).toBigInteger();
1277    }
1278
1279    @Override
1280    public final PRIMITIVE xor( final BigInteger aValue )
1281        throws UnsupportedOperationException,
1282            IllegalArgumentException,
1283            ArithmeticException
1284    {
1285        return this.setReal(this.toUnlimitedInteger().xor(aValue));
1286    }
1287
1288    @Override
1289    public final PRIMITIVE xor( final boolean aValue )
1290        throws UnsupportedOperationException,
1291            IllegalArgumentException,
1292            ArithmeticException
1293    {
1294        return this.xor(Constant.toUnlimitedInteger(aValue));
1295    }
1296
1297    @Override
1298    public final PRIMITIVE xor( final byte aValue )
1299        throws UnsupportedOperationException,
1300            IllegalArgumentException,
1301            ArithmeticException
1302    {
1303        return this.xor(BigInteger.valueOf(aValue));
1304    }
1305
1306    @Override
1307    public final PRIMITIVE xor( final char aValue )
1308        throws UnsupportedOperationException,
1309            IllegalArgumentException,
1310            ArithmeticException
1311    {
1312        return this.xor(BigInteger.valueOf(aValue));
1313    }
1314
1315    @Override
1316    public final PRIMITIVE xor( final int aValue )
1317        throws UnsupportedOperationException,
1318            IllegalArgumentException,
1319            ArithmeticException
1320    {
1321        return this.xor(BigInteger.valueOf(aValue));
1322    }
1323
1324    @Override
1325    public final PRIMITIVE xor( final long aValue )
1326        throws UnsupportedOperationException,
1327            IllegalArgumentException,
1328            ArithmeticException
1329    {
1330        return this.xor(BigInteger.valueOf(aValue));
1331    }
1332
1333    @Override
1334    public final PRIMITIVE xor( final short aValue )
1335        throws UnsupportedOperationException,
1336            IllegalArgumentException,
1337            ArithmeticException
1338    {
1339        return this.xor(BigInteger.valueOf(aValue));
1340    }
1341}