001/** 002 * MutableScalar.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"); 007 * you may not use this file except in compliance with the License. 008 * You may obtain a copy of 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, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018 019package net.sf.jaccumulator.scalars; 020 021import java.math.BigInteger; 022 023import net.sf.jaccumulator.MutableKernel; 024import net.sf.jaccumulator.booleans.MutableBooleanValue; 025import net.sf.jaccumulator.bytes.MutableByteValue; 026import net.sf.jaccumulator.characters.MutableCharacterValue; 027import net.sf.jaccumulator.doubles.MutableDoubleValue; 028import net.sf.jaccumulator.floats.MutableFloatValue; 029import net.sf.jaccumulator.integers.MutableIntegerValue; 030import net.sf.jaccumulator.longs.MutableLongValue; 031import net.sf.jaccumulator.shorts.MutableShortValue; 032import net.sf.jaccumulator.unlimiteds.UnlimitedDecimalPrimitive; 033import net.sf.jaccumulator.unlimiteds.UnlimitedIntegerPrimitive; 034 035/** 036 * Write operations for all system supported "scalar" values, or binary vectors 037 * optimized for processing and generally participate in arithmetic operators 038 * supported by the host programming language 039 * 040 * @param <SCALAR> 041 * this scalar type (used to facilitate operation chaining) 042 * @since JAccumulator 4.0 043 * @author Nicole Tedesco (<a 044 * href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>) 045 */ 046public interface MutableScalar<SCALAR extends MutableScalar<SCALAR>> 047 extends 048 MutableScalarDomain<SCALAR>, 049 MutableKernel<SCALAR>, 050 MutableBooleanValue<SCALAR>, 051 MutableByteValue<SCALAR>, 052 MutableCharacterValue<SCALAR>, 053 MutableDoubleValue<SCALAR>, 054 MutableFloatValue<SCALAR>, 055 MutableIntegerValue<SCALAR>, 056 MutableLongValue<SCALAR>, 057 MutableShortValue<SCALAR> 058{ 059 /** 060 * Replace the current value with the absolute value of itself 061 * 062 * @return this object (facilitates operation chaining) 063 * @throws UnsupportedOperationException 064 * if this object's value cannot be changed 065 * @throws IllegalArgumentException 066 * if the new value was incommensurate with this object's 067 * specification 068 * @throws ArithmeticException 069 * the new numeric value was incompatible with with algebraic 070 * interpretation of this object 071 */ 072 public SCALAR absoluteValue() 073 throws UnsupportedOperationException, 074 ArithmeticException, 075 IllegalArgumentException; 076 077 /** 078 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 079 * vector equivalent of this value and the specified integral boolean vector 080 * 081 * @param aValue 082 * an integral boolean vector 083 * @return this object (facilitates operation chaining) 084 * @throws UnsupportedOperationException 085 * if this object's value cannot be changed 086 * @throws IllegalArgumentException 087 * if the new value was incommensurate with this object's 088 * specification 089 * @throws ArithmeticException 090 * the new numeric value was incompatible with with algebraic 091 * interpretation of this object 092 */ 093 public SCALAR and( final boolean aValue ) 094 throws UnsupportedOperationException, 095 IllegalArgumentException, 096 ArithmeticException; 097 098 /** 099 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 100 * vector equivalent of this value and the specified integral boolean vector 101 * 102 * @param aValue 103 * an integral boolean vector 104 * @return this object (facilitates operation chaining) 105 * @throws UnsupportedOperationException 106 * if this object's value cannot be changed 107 * @throws IllegalArgumentException 108 * if the new value was incommensurate with this object's 109 * specification 110 * @throws ArithmeticException 111 * the new numeric value was incompatible with with algebraic 112 * interpretation of this object 113 */ 114 public SCALAR and( final byte aValue ) 115 throws UnsupportedOperationException, 116 IllegalArgumentException, 117 ArithmeticException; 118 119 /** 120 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 121 * vector equivalent of this value and the specified integral boolean vector 122 * 123 * @param aValue 124 * an integral boolean vector 125 * @return this object (facilitates operation chaining) 126 * @throws UnsupportedOperationException 127 * if this object's value cannot be changed 128 * @throws IllegalArgumentException 129 * if the new value was incommensurate with this object's 130 * specification 131 * @throws ArithmeticException 132 * the new numeric value was incompatible with with algebraic 133 * interpretation of this object 134 */ 135 public SCALAR and( final char aValue ) 136 throws UnsupportedOperationException, 137 IllegalArgumentException, 138 ArithmeticException; 139 140 /** 141 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 142 * vector equivalent of this value and the specified integral boolean vector 143 * 144 * @param aValue 145 * an integral boolean vector 146 * @return this object (facilitates operation chaining) 147 * @throws UnsupportedOperationException 148 * if this object's value cannot be changed 149 * @throws IllegalArgumentException 150 * if the new value was incommensurate with this object's 151 * specification 152 * @throws ArithmeticException 153 * the new numeric value was incompatible with with algebraic 154 * interpretation of this object 155 */ 156 public SCALAR and( final int aValue ) 157 throws UnsupportedOperationException, 158 IllegalArgumentException, 159 ArithmeticException; 160 161 /** 162 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 163 * vector equivalent of this value and the specified integral boolean vector 164 * 165 * @param aValue 166 * an integral boolean vector 167 * @return this object (facilitates operation chaining) 168 * @throws UnsupportedOperationException 169 * if this object's value cannot be changed 170 * @throws IllegalArgumentException 171 * if the new value was incommensurate with this object's 172 * specification 173 * @throws ArithmeticException 174 * the new numeric value was incompatible with with algebraic 175 * interpretation of this object 176 */ 177 public SCALAR and( final long aValue ) 178 throws UnsupportedOperationException, 179 IllegalArgumentException, 180 ArithmeticException; 181 182 /** 183 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 184 * vector equivalent of this value and the specified integral boolean vector 185 * 186 * @param aValue 187 * an integral boolean vector 188 * @return this object (facilitates operation chaining) 189 * @throws UnsupportedOperationException 190 * if this object's value cannot be changed 191 * @throws IllegalArgumentException 192 * if the new value was incommensurate with this object's 193 * specification 194 * @throws ArithmeticException 195 * the new numeric value was incompatible with with algebraic 196 * interpretation of this object 197 */ 198 public SCALAR and( final short aValue ) 199 throws UnsupportedOperationException, 200 IllegalArgumentException, 201 ArithmeticException; 202 203 /** 204 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 205 * vector equivalent of this value and the specified integral boolean vector 206 * 207 * @param aValue 208 * an integral boolean vector 209 * @return this object (facilitates operation chaining) 210 * @throws UnsupportedOperationException 211 * if this object's value cannot be changed 212 * @throws IllegalArgumentException 213 * if the new value was incommensurate with this object's 214 * specification 215 * @throws ArithmeticException 216 * the new numeric value was incompatible with with algebraic 217 * interpretation of this object 218 */ 219 public SCALAR andOfNumber( final Number aValue ) 220 throws UnsupportedOperationException, 221 IllegalArgumentException, 222 ArithmeticException; 223 224 /** 225 * Set this value to the bit <b>and</b> of the <i>integral</i> boolean 226 * vector equivalent of this value and the specified integral boolean vector 227 * 228 * @param aValue 229 * an integral boolean vector 230 * @return this object (facilitates operation chaining) 231 * @throws UnsupportedOperationException 232 * if this object's value cannot be changed 233 * @throws IllegalArgumentException 234 * if the new value was incommensurate with this object's 235 * specification 236 * @throws ArithmeticException 237 * the new numeric value was incompatible with with algebraic 238 * interpretation of this object 239 */ 240 public SCALAR andOfScalar( final SealedScalar<?> aValue ) 241 throws UnsupportedOperationException, 242 IllegalArgumentException, 243 ArithmeticException; 244 245 /** 246 * Set this value to the angle formed by the rectangular coordinates given 247 * by the current value, <i>x</i>, and the specified value, <i>y</i>. In 248 * other words returns the angle <i>theta</i> from the conversion of 249 * rectangular coordinates (x,y) to polar coordinates (r,<i>theta</i>). 250 * 251 * @param y 252 * a <i>y</i> coordinate value 253 * @return this object (facilitates operation chaining) 254 * @throws UnsupportedOperationException 255 * if this object's value cannot be changed 256 * @throws IllegalArgumentException 257 * if the new value was incommensurate with this object's 258 * specification 259 * @throws ArithmeticException 260 * the new numeric value was incompatible with with algebraic 261 * interpretation of this object 262 * @see Math#atan2(double, double) 263 */ 264 public SCALAR angleWith( final double y ) 265 throws UnsupportedOperationException, 266 IllegalArgumentException, 267 ArithmeticException; 268 269 /** 270 * Set this value to the angle formed by the rectangular coordinates given 271 * by the current value, <i>x</i>, and the specified value, <i>y</i>. In 272 * other words returns the angle <i>theta</i> from the conversion of 273 * rectangular coordinates (x,y) to polar coordinates (r,<i>theta</i>). 274 * 275 * @param y 276 * a <i>y</i> coordinate value 277 * @return this object (facilitates operation chaining) 278 * @throws UnsupportedOperationException 279 * if this object's value cannot be changed 280 * @throws IllegalArgumentException 281 * if the new value was incommensurate with this object's 282 * specification 283 * @throws ArithmeticException 284 * the new numeric value was incompatible with with algebraic 285 * interpretation of this object 286 * @see Math#atan2(double, double) 287 */ 288 public SCALAR angleWithNumber( final Number y ) 289 throws UnsupportedOperationException, 290 IllegalArgumentException, 291 ArithmeticException; 292 293 /** 294 * Set this value to the angle formed by the rectangular coordinates given 295 * by the current value, <i>x</i>, and the specified value, <i>y</i>. In 296 * other words returns the angle <i>theta</i> from the conversion of 297 * rectangular coordinates (x,y) to polar coordinates (r,<i>theta</i>). 298 * 299 * @param y 300 * a <i>y</i> coordinate value 301 * @return this object (facilitates operation chaining) 302 * @throws UnsupportedOperationException 303 * if this object's value cannot be changed 304 * @throws IllegalArgumentException 305 * if the new value was incommensurate with this object's 306 * specification 307 * @throws ArithmeticException 308 * the new numeric value was incompatible with with algebraic 309 * interpretation of this object 310 * @see Math#atan2(double, double) 311 */ 312 public SCALAR angleWithScalar( final SealedScalar<?> y ) 313 throws UnsupportedOperationException, 314 IllegalArgumentException, 315 ArithmeticException; 316 317 /** 318 * Replace the current value with its arc {@link Math#acos(double) cosine} 319 * 320 * @return this object (facilitates operation chaining) 321 * @throws UnsupportedOperationException 322 * if this object's value cannot be changed 323 * @throws IllegalArgumentException 324 * if the new value was incommensurate with this object's 325 * specification 326 * @throws ArithmeticException 327 * the new numeric value was incompatible with with algebraic 328 * interpretation of this object 329 */ 330 public SCALAR arcCosine() 331 throws UnsupportedOperationException, 332 IllegalArgumentException, 333 ArithmeticException; 334 335 /** 336 * Replace the current value with its arc {@link Math#asin(double) sine} 337 * 338 * @return this object (facilitates operation chaining) 339 * @throws UnsupportedOperationException 340 * if this object's value cannot be changed 341 * @throws IllegalArgumentException 342 * if the new value was incommensurate with this object's 343 * specification 344 * @throws ArithmeticException 345 * the new numeric value was incompatible with with algebraic 346 * interpretation of this object 347 */ 348 public SCALAR arcSine() 349 throws UnsupportedOperationException, 350 IllegalArgumentException, 351 ArithmeticException; 352 353 /** 354 * Replace the current value with its arc {@link Math#atan(double) tangent} 355 * 356 * @return this object (facilitates operation chaining) 357 * @throws UnsupportedOperationException 358 * if this object's value cannot be changed 359 * @throws IllegalArgumentException 360 * if the new value was incommensurate with this object's 361 * specification 362 * @throws ArithmeticException 363 * the new numeric value was incompatible with with algebraic 364 * interpretation of this object 365 */ 366 public SCALAR arcTangent() 367 throws UnsupportedOperationException, 368 IllegalArgumentException, 369 ArithmeticException; 370 371 /** 372 * Replace the current value with its base 10 logarithm 373 * 374 * @return this object (facilitates operation chaining) 375 * @throws UnsupportedOperationException 376 * if this object's value cannot be changed 377 * @throws IllegalArgumentException 378 * if the new value was incommensurate with this object's 379 * specification 380 * @throws ArithmeticException 381 * the new numeric value was incompatible with with algebraic 382 * interpretation of this object 383 */ 384 public SCALAR base10Log() 385 throws UnsupportedOperationException, 386 IllegalArgumentException, 387 ArithmeticException; 388 389 /** 390 * Replace the current value with the smallest (closest to negative 391 * infinity) value that is greater than or equal to the current value and is 392 * equal to a mathematical integer 393 * 394 * @return this object (facilitates operation chaining) 395 * @throws UnsupportedOperationException 396 * if this object's value cannot be changed 397 * @throws IllegalArgumentException 398 * if the new value was incommensurate with this object's 399 * specification 400 * @throws ArithmeticException 401 * the new numeric value was incompatible with with algebraic 402 * interpretation of this object 403 */ 404 public SCALAR ceiling() 405 throws UnsupportedOperationException, 406 IllegalArgumentException, 407 ArithmeticException; 408 409 /** 410 * Replace the current value, assumed to be an angle in radians, to its 411 * {@link Math#cos(double) cosine} 412 * 413 * @return this object (facilitates operation chaining) 414 * @throws UnsupportedOperationException 415 * if this object's value cannot be changed 416 * @throws IllegalArgumentException 417 * if the new value was incommensurate with this object's 418 * specification 419 * @throws ArithmeticException 420 * the new numeric value was incompatible with with algebraic 421 * interpretation of this object 422 */ 423 public SCALAR cosine() 424 throws UnsupportedOperationException, 425 IllegalArgumentException, 426 ArithmeticException; 427 428 /** 429 * Replace the current value with the cube of itself 430 * 431 * @return this object (facilitates operation chaining) 432 * @throws UnsupportedOperationException 433 * if this object's value cannot be changed 434 * @throws IllegalArgumentException 435 * if the new value was incommensurate with this object's 436 * specification 437 * @throws ArithmeticException 438 * the new numeric value was incompatible with with algebraic 439 * interpretation of this object 440 */ 441 public SCALAR cube() 442 throws UnsupportedOperationException, 443 IllegalArgumentException, 444 ArithmeticException; 445 446 /** 447 * Replace the current value with the cube root of itself 448 * 449 * @return this object (facilitates operation chaining) 450 * @throws UnsupportedOperationException 451 * if this object's value cannot be changed 452 * @throws IllegalArgumentException 453 * if the new value was incommensurate with this object's 454 * specification 455 * @throws ArithmeticException 456 * the new numeric value was incompatible with with algebraic 457 * interpretation of this object 458 */ 459 public SCALAR cubeRoot() 460 throws UnsupportedOperationException, 461 IllegalArgumentException, 462 ArithmeticException; 463 464 /** 465 * Replace the current value with the current value minus unity (one) 466 * 467 * @return this object (facilitates operation chaining) 468 * @throws UnsupportedOperationException 469 * if this object's value cannot be changed 470 * @throws IllegalArgumentException 471 * if the new value was incommensurate with this object's 472 * specification 473 * @throws ArithmeticException 474 * the new numeric value was incompatible with with algebraic 475 * interpretation of this object 476 */ 477 public SCALAR decrement() 478 throws UnsupportedOperationException, 479 IllegalArgumentException, 480 ArithmeticException; 481 482 /** 483 * Replace the current value, assumed to be an angle in radians, to its 484 * equivalent angle in degrees 485 * 486 * @return this object (facilitates operation chaining) 487 * @throws UnsupportedOperationException 488 * if this object's value cannot be changed 489 * @throws IllegalArgumentException 490 * if the new value was incommensurate with this object's 491 * specification 492 * @throws ArithmeticException 493 * the new numeric value was incompatible with with algebraic 494 * interpretation of this object 495 */ 496 public SCALAR degrees() 497 throws UnsupportedOperationException, 498 IllegalArgumentException, 499 ArithmeticException; 500 501 /** 502 * Set the value of this scalar to the <i>mathematical</i> difference 503 * between its current value and the specified value 504 * 505 * @param aValue 506 * a subtrahend 507 * @return this object (facilitates operation chaining) 508 * @throws UnsupportedOperationException 509 * if this object's value cannot be changed 510 * @throws IllegalArgumentException 511 * if the new value was incommensurate with this object's 512 * specification 513 * @throws ArithmeticException 514 * the new numeric value was incompatible with with algebraic 515 * interpretation of this object 516 */ 517 public SCALAR difference( final boolean aValue ) 518 throws UnsupportedOperationException, 519 IllegalArgumentException, 520 ArithmeticException; 521 522 /** 523 * Set the value of this scalar to the <i>mathematical</i> difference 524 * between its current value and the specified value 525 * 526 * @param aValue 527 * a subtrahend 528 * @return this object (facilitates operation chaining) 529 * @throws UnsupportedOperationException 530 * if this object's value cannot be changed 531 * @throws IllegalArgumentException 532 * if the new value was incommensurate with this object's 533 * specification 534 * @throws ArithmeticException 535 * the new numeric value was incompatible with with algebraic 536 * interpretation of this object 537 */ 538 public SCALAR difference( final byte aValue ) 539 throws UnsupportedOperationException, 540 IllegalArgumentException, 541 ArithmeticException; 542 543 /** 544 * Set the value of this scalar to the <i>mathematical</i> difference 545 * between its current value and the specified value 546 * 547 * @param aValue 548 * a subtrahend 549 * @return this object (facilitates operation chaining) 550 * @throws UnsupportedOperationException 551 * if this object's value cannot be changed 552 * @throws IllegalArgumentException 553 * if the new value was incommensurate with this object's 554 * specification 555 * @throws ArithmeticException 556 * the new numeric value was incompatible with with algebraic 557 * interpretation of this object 558 */ 559 public SCALAR difference( final char aValue ) 560 throws UnsupportedOperationException, 561 IllegalArgumentException, 562 ArithmeticException; 563 564 /** 565 * Set the value of this scalar to the <i>mathematical</i> difference 566 * between its current value and the specified value 567 * 568 * @param aValue 569 * a subtrahend 570 * @return this object (facilitates operation chaining) 571 * @throws UnsupportedOperationException 572 * if this object's value cannot be changed 573 * @throws IllegalArgumentException 574 * if the new value was incommensurate with this object's 575 * specification 576 * @throws ArithmeticException 577 * the new numeric value was incompatible with with algebraic 578 * interpretation of this object 579 */ 580 public SCALAR difference( final double aValue ) 581 throws UnsupportedOperationException, 582 IllegalArgumentException, 583 ArithmeticException; 584 585 /** 586 * Set the value of this scalar to the <i>mathematical</i> difference 587 * between its current value and the specified value 588 * 589 * @param aValue 590 * a subtrahend 591 * @return this object (facilitates operation chaining) 592 * @throws UnsupportedOperationException 593 * if this object's value cannot be changed 594 * @throws IllegalArgumentException 595 * if the new value was incommensurate with this object's 596 * specification 597 * @throws ArithmeticException 598 * the new numeric value was incompatible with with algebraic 599 * interpretation of this object 600 */ 601 public SCALAR difference( final float aValue ) 602 throws UnsupportedOperationException, 603 IllegalArgumentException, 604 ArithmeticException; 605 606 /** 607 * Set the value of this scalar to the <i>mathematical</i> difference 608 * between its current value and the specified value 609 * 610 * @param aValue 611 * a subtrahend 612 * @return this object (facilitates operation chaining) 613 * @throws UnsupportedOperationException 614 * if this object's value cannot be changed 615 * @throws IllegalArgumentException 616 * if the new value was incommensurate with this object's 617 * specification 618 * @throws ArithmeticException 619 * the new numeric value was incompatible with with algebraic 620 * interpretation of this object 621 */ 622 public SCALAR difference( final int aValue ) 623 throws UnsupportedOperationException, 624 IllegalArgumentException, 625 ArithmeticException; 626 627 /** 628 * Set the value of this scalar to the <i>mathematical</i> difference 629 * between its current value and the specified value 630 * 631 * @param aValue 632 * a subtrahend 633 * @return this object (facilitates operation chaining) 634 * @throws UnsupportedOperationException 635 * if this object's value cannot be changed 636 * @throws IllegalArgumentException 637 * if the new value was incommensurate with this object's 638 * specification 639 * @throws ArithmeticException 640 * the new numeric value was incompatible with with algebraic 641 * interpretation of this object 642 */ 643 public SCALAR difference( final long aValue ) 644 throws UnsupportedOperationException, 645 IllegalArgumentException, 646 ArithmeticException; 647 648 /** 649 * Set the value of this scalar to the <i>mathematical</i> difference 650 * between its current value and the specified value 651 * 652 * @param aValue 653 * a subtrahend 654 * @return this object (facilitates operation chaining) 655 * @throws UnsupportedOperationException 656 * if this object's value cannot be changed 657 * @throws IllegalArgumentException 658 * if the new value was incommensurate with this object's 659 * specification 660 * @throws ArithmeticException 661 * the new numeric value was incompatible with with algebraic 662 * interpretation of this object 663 */ 664 public SCALAR difference( final short aValue ) 665 throws UnsupportedOperationException, 666 IllegalArgumentException, 667 ArithmeticException; 668 669 /** 670 * Set the value of this scalar to the <i>mathematical</i> difference 671 * between its current value and the specified value 672 * 673 * @param aValue 674 * a subtrahend 675 * @return this object (facilitates operation chaining) 676 * @throws UnsupportedOperationException 677 * if this object's value cannot be changed 678 * @throws IllegalArgumentException 679 * if the new value was incommensurate with this object's 680 * specification 681 * @throws ArithmeticException 682 * the new numeric value was incompatible with with algebraic 683 * interpretation of this object 684 */ 685 public SCALAR differenceOfNumber( final Number aValue ) 686 throws UnsupportedOperationException, 687 IllegalArgumentException, 688 ArithmeticException; 689 690 /** 691 * Set the value of this scalar to the <i>mathematical</i> difference 692 * between its current value and the specified value 693 * 694 * @param aValue 695 * a subtrahend 696 * @return this object (facilitates operation chaining) 697 * @throws UnsupportedOperationException 698 * if this object's value cannot be changed 699 * @throws IllegalArgumentException 700 * if the new value was incommensurate with this object's 701 * specification 702 * @throws ArithmeticException 703 * the new numeric value was incompatible with with algebraic 704 * interpretation of this object 705 */ 706 public SCALAR differenceOfScalar( final SealedScalar<?> aValue ) 707 throws UnsupportedOperationException, 708 IllegalArgumentException, 709 ArithmeticException; 710 711 /** 712 * Round the current value towards zero (truncate) 713 * 714 * @return this object (facilitates operation chaining) 715 * @throws UnsupportedOperationException 716 * if this object's value cannot be changed 717 * @throws IllegalArgumentException 718 * if the new value was incommensurate with this object's 719 * specification 720 * @throws ArithmeticException 721 * the new numeric value was incompatible with with algebraic 722 * interpretation of this object 723 */ 724 public SCALAR down() 725 throws UnsupportedOperationException, 726 IllegalArgumentException, 727 ArithmeticException; 728 729 /** 730 * Replace the current value with <i>e</i> (Napier's constant) raised to the 731 * current value (<i>e</i><sup><tt>n</tt></sup>) 732 * 733 * @return this object (facilitates operation chaining) 734 * @throws UnsupportedOperationException 735 * if this object's value cannot be changed 736 * @throws IllegalArgumentException 737 * if the new value was incommensurate with this object's 738 * specification 739 * @throws ArithmeticException 740 * the new numeric value was incompatible with with algebraic 741 * interpretation of this object 742 * @see <a 743 * href="http://en.wikipedia.org/wiki/E_%28mathematical_constant%29">e</a> 744 * (Wikipedia) 745 */ 746 public SCALAR exponential() 747 throws UnsupportedOperationException, 748 IllegalArgumentException, 749 ArithmeticException; 750 751 /** 752 * Replace the current value with <i>e</i> (Napier's constant) raised to the 753 * current value, less 1 (<i>e</i><sup><tt>n</tt></sup>-1) 754 * 755 * @return this object (facilitates operation chaining) 756 * @throws UnsupportedOperationException 757 * if this object's value cannot be changed 758 * @throws IllegalArgumentException 759 * if the new value was incommensurate with this object's 760 * specification 761 * @throws ArithmeticException 762 * the new numeric value was incompatible with with algebraic 763 * interpretation of this object 764 * @see <a 765 * href="http://en.wikipedia.org/wiki/E_%28mathematical_constant%29">e</a> 766 * (Wikipedia) 767 */ 768 public SCALAR exponentialLessOne() 769 throws UnsupportedOperationException, 770 IllegalArgumentException, 771 ArithmeticException; 772 773 /** 774 * Replace the current value with the largest (closest to positive infinity) 775 * value that is less than or equal to the current value and is equal to a 776 * mathematical integer 777 * 778 * @return this object (facilitates operation chaining) 779 * @throws UnsupportedOperationException 780 * if this object's value cannot be changed 781 * @throws IllegalArgumentException 782 * if the new value was incommensurate with this object's 783 * specification 784 * @throws ArithmeticException 785 * the new numeric value was incompatible with with algebraic 786 * interpretation of this object 787 */ 788 public SCALAR floor() 789 throws UnsupportedOperationException, 790 IllegalArgumentException, 791 ArithmeticException; 792 793 /** 794 * Replace the current value with the greatest common factor between this 795 * value and the specific one 796 * 797 * @param aValue 798 * a value 799 * @return this object (facilitates operation chaining) 800 * @throws UnsupportedOperationException 801 * if this object's value cannot be changed 802 * @throws IllegalArgumentException 803 * if the new value was incommensurate with this object's 804 * specification 805 * @throws ArithmeticException 806 * the new numeric value was incompatible with with algebraic 807 * interpretation of this object 808 */ 809 public SCALAR gcd( final byte aValue ) 810 throws UnsupportedOperationException, 811 ArithmeticException, 812 IllegalArgumentException; 813 814 /** 815 * Replace the current value with the greatest common factor between this 816 * value and the specific one 817 * 818 * @param aValue 819 * a value 820 * @return this object (facilitates operation chaining) 821 * @throws UnsupportedOperationException 822 * if this object's value cannot be changed 823 * @throws IllegalArgumentException 824 * if the new value was incommensurate with this object's 825 * specification 826 * @throws ArithmeticException 827 * the new numeric value was incompatible with with algebraic 828 * interpretation of this object 829 */ 830 public SCALAR gcd( final char aValue ) 831 throws UnsupportedOperationException, 832 ArithmeticException, 833 IllegalArgumentException; 834 835 /** 836 * Replace the current value with the greatest common factor between this 837 * value and the specific one 838 * 839 * @param aValue 840 * a value 841 * @return this object (facilitates operation chaining) 842 * @throws UnsupportedOperationException 843 * if this object's value cannot be changed 844 * @throws IllegalArgumentException 845 * if the new value was incommensurate with this object's 846 * specification 847 * @throws ArithmeticException 848 * the new numeric value was incompatible with with algebraic 849 * interpretation of this object 850 */ 851 public SCALAR gcd( final int aValue ) 852 throws UnsupportedOperationException, 853 ArithmeticException, 854 IllegalArgumentException; 855 856 /** 857 * Replace the current value with the greatest common factor between this 858 * value and the specific one 859 * 860 * @param aValue 861 * a value 862 * @return this object (facilitates operation chaining) 863 * @throws UnsupportedOperationException 864 * if this object's value cannot be changed 865 * @throws IllegalArgumentException 866 * if the new value was incommensurate with this object's 867 * specification 868 * @throws ArithmeticException 869 * the new numeric value was incompatible with with algebraic 870 * interpretation of this object 871 */ 872 public SCALAR gcd( final long aValue ) 873 throws UnsupportedOperationException, 874 ArithmeticException, 875 IllegalArgumentException; 876 877 /** 878 * Replace the current value with the greatest common factor between this 879 * value and the specific one 880 * 881 * @param aValue 882 * a value 883 * @return this object (facilitates operation chaining) 884 * @throws UnsupportedOperationException 885 * if this object's value cannot be changed 886 * @throws IllegalArgumentException 887 * if the new value was incommensurate with this object's 888 * specification 889 * @throws ArithmeticException 890 * the new numeric value was incompatible with with algebraic 891 * interpretation of this object 892 */ 893 public SCALAR gcd( final short aValue ) 894 throws UnsupportedOperationException, 895 ArithmeticException, 896 IllegalArgumentException; 897 898 /** 899 * Replace the current value with the greatest common factor between this 900 * value and the specific one 901 * 902 * @param aValue 903 * a value 904 * @return this object (facilitates operation chaining) 905 * @throws UnsupportedOperationException 906 * if this object's value cannot be changed 907 * @throws IllegalArgumentException 908 * if the new value was incommensurate with this object's 909 * specification 910 * @throws ArithmeticException 911 * the new numeric value was incompatible with with algebraic 912 * interpretation of this object 913 */ 914 public SCALAR gcdOfNumber( final Number aNumber ) 915 throws UnsupportedOperationException, 916 ArithmeticException, 917 IllegalArgumentException; 918 919 /** 920 * Replace the current value with the greatest common factor between this 921 * value and the specific one 922 * 923 * @param aValue 924 * a value 925 * @return this object (facilitates operation chaining) 926 * @throws UnsupportedOperationException 927 * if this object's value cannot be changed 928 * @throws IllegalArgumentException 929 * if the new value was incommensurate with this object's 930 * specification 931 * @throws ArithmeticException 932 * the new numeric value was incompatible with with algebraic 933 * interpretation of this object 934 */ 935 public SCALAR gcdOfScalar( final Scalar<?> aScalar ) 936 throws UnsupportedOperationException, 937 ArithmeticException, 938 IllegalArgumentException; 939 940 /** 941 * Round towards "nearest neighbor" unless both neighbors are equidistant, 942 * in which case round down 943 * 944 * @return this object (facilitates operation chaining) 945 * @throws UnsupportedOperationException 946 * if this object's value cannot be changed 947 * @throws IllegalArgumentException 948 * if the new value was incommensurate with this object's 949 * specification 950 * @throws ArithmeticException 951 * the new numeric value was incompatible with with algebraic 952 * interpretation of this object 953 */ 954 public SCALAR halfDown() 955 throws UnsupportedOperationException, 956 IllegalArgumentException, 957 ArithmeticException; 958 959 /** 960 * Round towards "nearest neighbor" unless both neighbors are equidistant, 961 * in which case round to the even neighbor 962 * 963 * @return this object (facilitates operation chaining) 964 * @throws UnsupportedOperationException 965 * if this object's value cannot be changed 966 * @throws IllegalArgumentException 967 * if the new value was incommensurate with this object's 968 * specification 969 * @throws ArithmeticException 970 * the new numeric value was incompatible with with algebraic 971 * interpretation of this object 972 */ 973 public SCALAR halfEven() 974 throws UnsupportedOperationException, 975 IllegalArgumentException, 976 ArithmeticException; 977 978 /** 979 * Round towards "nearest neighbor" unless both neighbors are equidistant, 980 * in which case round up 981 * 982 * @return this object (facilitates operation chaining) 983 * @throws UnsupportedOperationException 984 * if this object's value cannot be changed 985 * @throws IllegalArgumentException 986 * if the new value was incommensurate with this object's 987 * specification 988 * @throws ArithmeticException 989 * the new numeric value was incompatible with with algebraic 990 * interpretation of this object 991 */ 992 public SCALAR halfUp() 993 throws UnsupportedOperationException, 994 IllegalArgumentException, 995 ArithmeticException; 996 997 /** 998 * Replace the current value, assumed to be an angle in radians, to its 999 * hyperbolic {@link Math#cosh(double) cosine} 1000 * 1001 * @return this object (facilitates operation chaining) 1002 * @throws UnsupportedOperationException 1003 * if this object's value cannot be changed 1004 * @throws IllegalArgumentException 1005 * if the new value was incommensurate with this object's 1006 * specification 1007 * @throws ArithmeticException 1008 * the new numeric value was incompatible with with algebraic 1009 * interpretation of this object 1010 */ 1011 public SCALAR hyperbolicCosine() 1012 throws UnsupportedOperationException, 1013 IllegalArgumentException, 1014 ArithmeticException; 1015 1016 /** 1017 * Replace the current value, assumed to be an angle in radians, to its 1018 * hyperbolic {@link Math#sinh(double) sine} 1019 * 1020 * @return this object (facilitates operation chaining) 1021 * @throws UnsupportedOperationException 1022 * if this object's value cannot be changed 1023 * @throws IllegalArgumentException 1024 * if the new value was incommensurate with this object's 1025 * specification 1026 * @throws ArithmeticException 1027 * the new numeric value was incompatible with with algebraic 1028 * interpretation of this object 1029 */ 1030 public SCALAR hyperbolicSine() 1031 throws UnsupportedOperationException, 1032 IllegalArgumentException, 1033 ArithmeticException; 1034 1035 /** 1036 * Replace the current value, assumed to be an angle in radians, to its 1037 * hyperbolic {@link Math#tanh(double) tangent} 1038 * 1039 * @return this object (facilitates operation chaining) 1040 * @throws UnsupportedOperationException 1041 * if this object's value cannot be changed 1042 * @throws IllegalArgumentException 1043 * if the new value was incommensurate with this object's 1044 * specification 1045 * @throws ArithmeticException 1046 * the new numeric value was incompatible with with algebraic 1047 * interpretation of this object 1048 */ 1049 public SCALAR hyperbolicTangent() 1050 throws UnsupportedOperationException, 1051 IllegalArgumentException, 1052 ArithmeticException; 1053 1054 /** 1055 * Set this value to the hypotenuse formed by the square root of the sum of 1056 * the square of the current value, <i>x</i>, and the square of the 1057 * specified value, <i>y</i>, without intermediate overflow or underflow 1058 * 1059 * @param y 1060 * a <i>y</i> value 1061 * @return this object (facilitates operation chaining) 1062 * @throws UnsupportedOperationException 1063 * if this object's value cannot be changed 1064 * @throws IllegalArgumentException 1065 * if the new value was incommensurate with this object's 1066 * specification 1067 * @throws ArithmeticException 1068 * the new numeric value was incompatible with with algebraic 1069 * interpretation of this object 1070 * @see Math#hypot(double, double) 1071 */ 1072 public SCALAR hypotenuseWith( final double y ) 1073 throws UnsupportedOperationException, 1074 IllegalArgumentException, 1075 ArithmeticException; 1076 1077 /** 1078 * Set this value to the hypotenuse formed by the square root of the sum of 1079 * the square of the current value, <i>x</i>, and the square of the 1080 * specified value, <i>y</i>, without intermediate overflow or underflow 1081 * 1082 * @param y 1083 * a <i>y</i> value 1084 * @return this object (facilitates operation chaining) 1085 * @throws UnsupportedOperationException 1086 * if this object's value cannot be changed 1087 * @throws IllegalArgumentException 1088 * if the new value was incommensurate with this object's 1089 * specification 1090 * @throws ArithmeticException 1091 * the new numeric value was incompatible with with algebraic 1092 * interpretation of this object 1093 * @see Math#hypot(double, double) 1094 */ 1095 public SCALAR hypotenuseWithNumber( final Number y ) 1096 throws UnsupportedOperationException, 1097 IllegalArgumentException, 1098 ArithmeticException; 1099 1100 /** 1101 * Set this value to the hypotenuse formed by the square root of the sum of 1102 * the square of the current value, <i>x</i>, and the square of the 1103 * specified value, <i>y</i>, without intermediate overflow or underflow 1104 * 1105 * @param y 1106 * a <i>y</i> value 1107 * @return this object (facilitates operation chaining) 1108 * @throws UnsupportedOperationException 1109 * if this object's value cannot be changed 1110 * @throws IllegalArgumentException 1111 * if the new value was incommensurate with this object's 1112 * specification 1113 * @throws ArithmeticException 1114 * the new numeric value was incompatible with with algebraic 1115 * interpretation of this object 1116 * @see Math#hypot(double, double) 1117 */ 1118 public SCALAR hypotenuseWithScalar( final SealedScalar<?> y ) 1119 throws UnsupportedOperationException, 1120 IllegalArgumentException, 1121 ArithmeticException; 1122 1123 /** 1124 * Replace the current value with the current value plus unity (one) 1125 * 1126 * @return this object (facilitates operation chaining) 1127 * @throws UnsupportedOperationException 1128 * if this object's value cannot be changed 1129 * @throws IllegalArgumentException 1130 * if the new value was incommensurate with this object's 1131 * specification 1132 * @throws ArithmeticException 1133 * the new numeric value was incompatible with with algebraic 1134 * interpretation of this object 1135 */ 1136 public SCALAR increment() 1137 throws UnsupportedOperationException, 1138 ArithmeticException, 1139 IllegalArgumentException; 1140 1141 /** 1142 * Replace the current value an invalid value such {@link Double#NaN 1143 * INVALID} if possible, otherwise replace it with zero 1144 * 1145 * @return this object (facilitates operation chaining) 1146 * @throws UnsupportedOperationException 1147 * if this object's value cannot be changed 1148 * @throws IllegalArgumentException 1149 * if the new value was incommensurate with this object's 1150 * specification 1151 * @throws ArithmeticException 1152 * the new numeric value was incompatible with with algebraic 1153 * interpretation of this object 1154 */ 1155 public SCALAR invalidate() 1156 throws UnsupportedOperationException, 1157 IllegalArgumentException, 1158 ArithmeticException; 1159 1160 /** 1161 * Replace the current value its multiplicative inverse ({@code 1/x}) 1162 * 1163 * @return this object (facilitates operation chaining) 1164 * @throws UnsupportedOperationException 1165 * if this object's value cannot be changed 1166 * @throws IllegalArgumentException 1167 * if the new value was incommensurate with this object's 1168 * specification 1169 * @throws ArithmeticException 1170 * the new numeric value was incompatible with with algebraic 1171 * interpretation of this object 1172 */ 1173 public SCALAR inverse() 1174 throws UnsupportedOperationException, 1175 ArithmeticException, 1176 IllegalArgumentException; 1177 1178 /** 1179 * Set the value of this object to the current millisecond-precision system 1180 * {@link System#currentTimeMillis() time} 1181 * 1182 * @return this object (facilitates operation chaining) 1183 * @throws UnsupportedOperationException 1184 * if this object's value cannot be changed 1185 */ 1186 public SCALAR milliseconds() throws UnsupportedOperationException; 1187 1188 /** 1189 * Set the value of this scalar to its current value <i>modulo</i> of the 1190 * specified value 1191 * 1192 * @param aValue 1193 * a modulus 1194 * @return this object (facilitates operation chaining) 1195 * @throws UnsupportedOperationException 1196 * if this object's value cannot be changed 1197 * @throws IllegalArgumentException 1198 * if the new value was incommensurate with this object's 1199 * specification 1200 * @throws ArithmeticException 1201 * the new numeric value was incompatible with with algebraic 1202 * interpretation of this object 1203 */ 1204 public SCALAR mod( final boolean aValue ) 1205 throws UnsupportedOperationException, 1206 IllegalArgumentException, 1207 ArithmeticException; 1208 1209 /** 1210 * Set the value of this scalar to its current value <i>modulo</i> of the 1211 * specified value 1212 * 1213 * @param aValue 1214 * a modulus 1215 * @return this object (facilitates operation chaining) 1216 * @throws UnsupportedOperationException 1217 * if this object's value cannot be changed 1218 * @throws IllegalArgumentException 1219 * if the new value was incommensurate with this object's 1220 * specification 1221 * @throws ArithmeticException 1222 * the new numeric value was incompatible with with algebraic 1223 * interpretation of this object 1224 */ 1225 public SCALAR mod( final byte aValue ) 1226 throws UnsupportedOperationException, 1227 IllegalArgumentException, 1228 ArithmeticException; 1229 1230 /** 1231 * Set the value of this scalar to its current value <i>modulo</i> of the 1232 * specified value 1233 * 1234 * @param aValue 1235 * a modulus 1236 * @return this object (facilitates operation chaining) 1237 * @throws UnsupportedOperationException 1238 * if this object's value cannot be changed 1239 * @throws IllegalArgumentException 1240 * if the new value was incommensurate with this object's 1241 * specification 1242 * @throws ArithmeticException 1243 * the new numeric value was incompatible with with algebraic 1244 * interpretation of this object 1245 */ 1246 public SCALAR mod( final char aValue ) 1247 throws UnsupportedOperationException, 1248 IllegalArgumentException, 1249 ArithmeticException; 1250 1251 /** 1252 * Set the value of this scalar to its current value <i>modulo</i> of the 1253 * specified value 1254 * 1255 * @param aValue 1256 * a modulus 1257 * @return this object (facilitates operation chaining) 1258 * @throws UnsupportedOperationException 1259 * if this object's value cannot be changed 1260 * @throws IllegalArgumentException 1261 * if the new value was incommensurate with this object's 1262 * specification 1263 * @throws ArithmeticException 1264 * the new numeric value was incompatible with with algebraic 1265 * interpretation of this object 1266 */ 1267 public SCALAR mod( final double aValue ) 1268 throws UnsupportedOperationException, 1269 IllegalArgumentException, 1270 ArithmeticException; 1271 1272 /** 1273 * Set the value of this scalar to its current value <i>modulo</i> of the 1274 * specified value 1275 * 1276 * @param aValue 1277 * a modulus 1278 * @return this object (facilitates operation chaining) 1279 * @throws UnsupportedOperationException 1280 * if this object's value cannot be changed 1281 * @throws IllegalArgumentException 1282 * if the new value was incommensurate with this object's 1283 * specification 1284 * @throws ArithmeticException 1285 * the new numeric value was incompatible with with algebraic 1286 * interpretation of this object 1287 */ 1288 public SCALAR mod( final float aValue ) 1289 throws UnsupportedOperationException, 1290 IllegalArgumentException, 1291 ArithmeticException; 1292 1293 /** 1294 * Set the value of this scalar to its current value <i>modulo</i> of the 1295 * specified value 1296 * 1297 * @param aValue 1298 * a modulus 1299 * @return this object (facilitates operation chaining) 1300 * @throws UnsupportedOperationException 1301 * if this object's value cannot be changed 1302 * @throws IllegalArgumentException 1303 * if the new value was incommensurate with this object's 1304 * specification 1305 * @throws ArithmeticException 1306 * the new numeric value was incompatible with with algebraic 1307 * interpretation of this object 1308 */ 1309 public SCALAR mod( final int aValue ) 1310 throws UnsupportedOperationException, 1311 IllegalArgumentException, 1312 ArithmeticException; 1313 1314 /** 1315 * Set the value of this scalar to its current value <i>modulo</i> of the 1316 * specified value 1317 * 1318 * @param aValue 1319 * a modulus 1320 * @return this object (facilitates operation chaining) 1321 * @throws UnsupportedOperationException 1322 * if this object's value cannot be changed 1323 * @throws IllegalArgumentException 1324 * if the new value was incommensurate with this object's 1325 * specification 1326 * @throws ArithmeticException 1327 * the new numeric value was incompatible with with algebraic 1328 * interpretation of this object 1329 */ 1330 public SCALAR mod( final long aValue ) 1331 throws UnsupportedOperationException, 1332 IllegalArgumentException, 1333 ArithmeticException; 1334 1335 /** 1336 * Set the value of this scalar to its current value <i>modulo</i> of the 1337 * specified value 1338 * 1339 * @param aValue 1340 * a modulus 1341 * @return this object (facilitates operation chaining) 1342 * @throws UnsupportedOperationException 1343 * if this object's value cannot be changed 1344 * @throws IllegalArgumentException 1345 * if the new value was incommensurate with this object's 1346 * specification 1347 * @throws ArithmeticException 1348 * the new numeric value was incompatible with with algebraic 1349 * interpretation of this object 1350 */ 1351 public SCALAR mod( final short aValue ) 1352 throws UnsupportedOperationException, 1353 IllegalArgumentException, 1354 ArithmeticException; 1355 1356 /** 1357 * Set the value of this scalar to its current value <i>modulo</i> of the 1358 * specified value 1359 * 1360 * @param aValue 1361 * a modulus 1362 * @return this object (facilitates operation chaining) 1363 * @throws UnsupportedOperationException 1364 * if this object's value cannot be changed 1365 * @throws IllegalArgumentException 1366 * if the new value was incommensurate with this object's 1367 * specification 1368 * @throws ArithmeticException 1369 * the new numeric value was incompatible with with algebraic 1370 * interpretation of this object 1371 */ 1372 public SCALAR modOfNumber( final Number aValue ) 1373 throws UnsupportedOperationException, 1374 IllegalArgumentException, 1375 ArithmeticException; 1376 1377 /** 1378 * Set the value of this scalar to its current value <i>modulo</i> of the 1379 * specified value 1380 * 1381 * @param aValue 1382 * a modulus 1383 * @return this object (facilitates operation chaining) 1384 * @throws UnsupportedOperationException 1385 * if this object's value cannot be changed 1386 * @throws IllegalArgumentException 1387 * if the new value was incommensurate with this object's 1388 * specification 1389 * @throws ArithmeticException 1390 * the new numeric value was incompatible with with algebraic 1391 * interpretation of this object 1392 */ 1393 public SCALAR modOfScalar( final SealedScalar<?> aValue ) 1394 throws UnsupportedOperationException, 1395 IllegalArgumentException, 1396 ArithmeticException; 1397 1398 /** 1399 * Set the value of this object to the current nanosecond-precision system 1400 * {@link System#nanoTime() time} 1401 * 1402 * @return this object (facilitates operation chaining) 1403 * @throws UnsupportedOperationException 1404 * if this object's value cannot be changed 1405 */ 1406 public SCALAR nanoseconds() throws UnsupportedOperationException; 1407 1408 /** 1409 * Replace the current value with its base <i>e</i> (Napier's constant) 1410 * logarithm (log<sub><i>e</i></sub>(<tt>n</tt>)) 1411 * 1412 * @return this object (facilitates operation chaining) 1413 * @throws UnsupportedOperationException 1414 * if this object's value cannot be changed 1415 * @throws IllegalArgumentException 1416 * if the new value was incommensurate with this object's 1417 * specification 1418 * @throws ArithmeticException 1419 * the new numeric value was incompatible with with algebraic 1420 * interpretation of this object 1421 * @see <a 1422 * href="http://en.wikipedia.org/wiki/E_%28mathematical_constant%29">e</a> 1423 * (Wikipedia) 1424 */ 1425 public SCALAR naturalLog() 1426 throws UnsupportedOperationException, 1427 IllegalArgumentException, 1428 ArithmeticException; 1429 1430 /** 1431 * Replace the current value, plus 1, with its base <i>e</i> (Napier's 1432 * constant) logarithm (log<sub><i>e</i></sub>(<tt>n</tt>+1)) 1433 * 1434 * @return this object (facilitates operation chaining) 1435 * @throws UnsupportedOperationException 1436 * if this object's value cannot be changed 1437 * @throws IllegalArgumentException 1438 * if the new value was incommensurate with this object's 1439 * specification 1440 * @throws ArithmeticException 1441 * the new numeric value was incompatible with with algebraic 1442 * interpretation of this object 1443 * @see <a 1444 * href="http://en.wikipedia.org/wiki/E_%28mathematical_constant%29">e</a> 1445 * (Wikipedia) 1446 */ 1447 public SCALAR naturalLogPlusOne() 1448 throws UnsupportedOperationException, 1449 IllegalArgumentException, 1450 ArithmeticException; 1451 1452 /** 1453 * Replace the current value with the additive inverse (sign negation) of 1454 * itself, that is transform it into a number that when added to the 1455 * original yields zero. (Though additive inverses for non-zero 1456 * {@code boolean} and {@code char} values do not exist, these 1457 * implementations will simply fail silently.) 1458 * 1459 * @return this object (facilitates operation chaining) 1460 * @throws UnsupportedOperationException 1461 * if this object's value cannot be changed 1462 * @throws IllegalArgumentException 1463 * if the new value was incommensurate with this object's 1464 * specification (optional) 1465 * @throws ArithmeticException 1466 * the new numeric value was incompatible with with algebraic 1467 * interpretation of this object (optional) 1468 */ 1469 public SCALAR negate() 1470 throws UnsupportedOperationException, 1471 ArithmeticException, 1472 IllegalArgumentException; 1473 1474 /** 1475 * Replace the current <i>integral binary vector</i> with its one's 1476 * complement. Decimal values, such as {@code double}, will be first 1477 * converted to unlimited {@link BigInteger integers} before their bits are 1478 * reversed. 1479 * 1480 * @return this object (facilitates operation chaining) 1481 * @throws UnsupportedOperationException 1482 * if this object's value cannot be changed 1483 * @throws IllegalArgumentException 1484 * if the new value was incommensurate with this object's 1485 * specification 1486 * @throws ArithmeticException 1487 * the new numeric value was incompatible with with algebraic 1488 * interpretation of this object 1489 */ 1490 public SCALAR not() 1491 throws UnsupportedOperationException, 1492 IllegalArgumentException, 1493 ArithmeticException; 1494 1495 /** 1496 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1497 * equivalent of this value and the specified integral boolean vector 1498 * 1499 * @param aValue 1500 * an integral boolean vector 1501 * @return this object (facilitates operation chaining) 1502 * @throws UnsupportedOperationException 1503 * if this object's value cannot be changed 1504 * @throws IllegalArgumentException 1505 * if the new value was incommensurate with this object's 1506 * specification 1507 * @throws ArithmeticException 1508 * the new numeric value was incompatible with with algebraic 1509 * interpretation of this object 1510 */ 1511 public SCALAR or( final boolean aValue ) 1512 throws UnsupportedOperationException, 1513 IllegalArgumentException, 1514 ArithmeticException; 1515 1516 /** 1517 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1518 * equivalent of this value and the specified integral boolean vector 1519 * 1520 * @param aValue 1521 * an integral boolean vector 1522 * @return this object (facilitates operation chaining) 1523 * @throws UnsupportedOperationException 1524 * if this object's value cannot be changed 1525 * @throws IllegalArgumentException 1526 * if the new value was incommensurate with this object's 1527 * specification 1528 * @throws ArithmeticException 1529 * the new numeric value was incompatible with with algebraic 1530 * interpretation of this object 1531 */ 1532 public SCALAR or( final byte aValue ) 1533 throws UnsupportedOperationException, 1534 IllegalArgumentException, 1535 ArithmeticException; 1536 1537 /** 1538 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1539 * equivalent of this value and the specified integral boolean vector 1540 * 1541 * @param aValue 1542 * an integral boolean vector 1543 * @return this object (facilitates operation chaining) 1544 * @throws UnsupportedOperationException 1545 * if this object's value cannot be changed 1546 * @throws IllegalArgumentException 1547 * if the new value was incommensurate with this object's 1548 * specification 1549 * @throws ArithmeticException 1550 * the new numeric value was incompatible with with algebraic 1551 * interpretation of this object 1552 */ 1553 public SCALAR or( final char aValue ) 1554 throws UnsupportedOperationException, 1555 IllegalArgumentException, 1556 ArithmeticException; 1557 1558 /** 1559 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1560 * equivalent of this value and the specified integral boolean vector 1561 * 1562 * @param aValue 1563 * an integral boolean vector 1564 * @return this object (facilitates operation chaining) 1565 * @throws UnsupportedOperationException 1566 * if this object's value cannot be changed 1567 * @throws IllegalArgumentException 1568 * if the new value was incommensurate with this object's 1569 * specification 1570 * @throws ArithmeticException 1571 * the new numeric value was incompatible with with algebraic 1572 * interpretation of this object 1573 */ 1574 public SCALAR or( final int aValue ) 1575 throws UnsupportedOperationException, 1576 IllegalArgumentException, 1577 ArithmeticException; 1578 1579 /** 1580 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1581 * equivalent of this value and the specified integral boolean vector 1582 * 1583 * @param aValue 1584 * an integral boolean vector 1585 * @return this object (facilitates operation chaining) 1586 * @throws UnsupportedOperationException 1587 * if this object's value cannot be changed 1588 * @throws IllegalArgumentException 1589 * if the new value was incommensurate with this object's 1590 * specification 1591 * @throws ArithmeticException 1592 * the new numeric value was incompatible with with algebraic 1593 * interpretation of this object 1594 */ 1595 public SCALAR or( final long aValue ) 1596 throws UnsupportedOperationException, 1597 IllegalArgumentException, 1598 ArithmeticException; 1599 1600 /** 1601 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1602 * equivalent of this value and the specified integral boolean vector 1603 * 1604 * @param aValue 1605 * an integral boolean vector 1606 * @return this object (facilitates operation chaining) 1607 * @throws UnsupportedOperationException 1608 * if this object's value cannot be changed 1609 * @throws IllegalArgumentException 1610 * if the new value was incommensurate with this object's 1611 * specification 1612 * @throws ArithmeticException 1613 * the new numeric value was incompatible with with algebraic 1614 * interpretation of this object 1615 */ 1616 public SCALAR or( final short aValue ) 1617 throws UnsupportedOperationException, 1618 IllegalArgumentException, 1619 ArithmeticException; 1620 1621 /** 1622 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1623 * equivalent of this value and the specified integral boolean vector 1624 * 1625 * @param aValue 1626 * an integral boolean vector 1627 * @return this object (facilitates operation chaining) 1628 * @throws UnsupportedOperationException 1629 * if this object's value cannot be changed 1630 * @throws IllegalArgumentException 1631 * if the new value was incommensurate with this object's 1632 * specification 1633 * @throws ArithmeticException 1634 * the new numeric value was incompatible with with algebraic 1635 * interpretation of this object 1636 */ 1637 public SCALAR orOfNumber( final Number aValue ) 1638 throws UnsupportedOperationException, 1639 IllegalArgumentException, 1640 ArithmeticException; 1641 1642 /** 1643 * Set this value to the bit <b>or</b> of the <i>integral</i> boolean vector 1644 * equivalent of this value and the specified integral boolean vector 1645 * 1646 * @param aValue 1647 * an integral boolean vector 1648 * @return this object (facilitates operation chaining) 1649 * @throws UnsupportedOperationException 1650 * if this object's value cannot be changed 1651 * @throws IllegalArgumentException 1652 * if the new value was incommensurate with this object's 1653 * specification 1654 * @throws ArithmeticException 1655 * the new numeric value was incompatible with with algebraic 1656 * interpretation of this object 1657 */ 1658 public SCALAR orOfScalar( final SealedScalar<?> aValue ) 1659 throws UnsupportedOperationException, 1660 IllegalArgumentException, 1661 ArithmeticException; 1662 1663 /** 1664 * Set this value to the current value, <i>x</i>, raised to the specified 1665 * exponent, <i>n</i>, or <i>x<sup>n</sup></i> 1666 * 1667 * @param n 1668 * an exponent 1669 * @return this object (facilitates operation chaining) 1670 * @throws UnsupportedOperationException 1671 * if this object's value cannot be changed 1672 * @throws IllegalArgumentException 1673 * if the new value was incommensurate with this object's 1674 * specification 1675 * @throws ArithmeticException 1676 * the new numeric value was incompatible with with algebraic 1677 * interpretation of this object 1678 */ 1679 public SCALAR power( final double n ) 1680 throws UnsupportedOperationException, 1681 IllegalArgumentException, 1682 ArithmeticException; 1683 1684 /** 1685 * Set this value to the current value, <i>x</i>, raised to the specified 1686 * exponent, <i>n</i>, or <i>x<sup>n</sup></i> 1687 * 1688 * @param n 1689 * an exponent 1690 * @return this object (facilitates operation chaining) 1691 * @throws UnsupportedOperationException 1692 * if this object's value cannot be changed 1693 * @throws IllegalArgumentException 1694 * if the new value was incommensurate with this object's 1695 * specification 1696 * @throws ArithmeticException 1697 * the new numeric value was incompatible with with algebraic 1698 * interpretation of this object 1699 */ 1700 public SCALAR power( final int n ) 1701 throws UnsupportedOperationException, 1702 IllegalArgumentException, 1703 ArithmeticException; 1704 1705 /** 1706 * Set this value to the current value, <i>x</i>, raised to the specified 1707 * exponent, <i>n</i>, or <i>x<sup>n</sup></i> 1708 * 1709 * @param n 1710 * an exponent 1711 * @return this object (facilitates operation chaining) 1712 * @throws UnsupportedOperationException 1713 * if this object's value cannot be changed 1714 * @throws IllegalArgumentException 1715 * if the new value was incommensurate with this object's 1716 * specification 1717 * @throws ArithmeticException 1718 * the new numeric value was incompatible with with algebraic 1719 * interpretation of this object 1720 */ 1721 public SCALAR powerOfNumber( final Number n ) 1722 throws UnsupportedOperationException, 1723 IllegalArgumentException, 1724 ArithmeticException; 1725 1726 /** 1727 * Set this value to the current value, <i>x</i>, raised to the specified 1728 * exponent, <i>n</i>, or <i>x<sup>n</sup></i> 1729 * 1730 * @param aValue 1731 * an exponent 1732 * @return this object (facilitates operation chaining) 1733 * @throws UnsupportedOperationException 1734 * if this object's value cannot be changed 1735 * @throws IllegalArgumentException 1736 * if the new value was incommensurate with this object's 1737 * specification 1738 * @throws ArithmeticException 1739 * the new numeric value was incompatible with with algebraic 1740 * interpretation of this object 1741 */ 1742 public SCALAR powerOfScalar( final SealedScalar<?> aValue ) 1743 throws UnsupportedOperationException, 1744 IllegalArgumentException, 1745 ArithmeticException; 1746 1747 /** 1748 * Set the value of this scalar to the <i>mathematical</i> product of its 1749 * current value and the specified value 1750 * 1751 * @param aValue 1752 * a multiplicand 1753 * @return this object (facilitates operation chaining) 1754 * @throws UnsupportedOperationException 1755 * if this object's value cannot be changed 1756 * @throws IllegalArgumentException 1757 * if the new value was incommensurate with this object's 1758 * specification 1759 * @throws ArithmeticException 1760 * the new numeric value was incompatible with with algebraic 1761 * interpretation of this object 1762 */ 1763 public SCALAR product( final boolean aValue ) 1764 throws UnsupportedOperationException, 1765 IllegalArgumentException, 1766 ArithmeticException; 1767 1768 /** 1769 * Set the value of this scalar to the <i>mathematical</i> product of its 1770 * current value and the specified value 1771 * 1772 * @param aValue 1773 * a multiplicand 1774 * @return this object (facilitates operation chaining) 1775 * @throws UnsupportedOperationException 1776 * if this object's value cannot be changed 1777 * @throws IllegalArgumentException 1778 * if the new value was incommensurate with this object's 1779 * specification 1780 * @throws ArithmeticException 1781 * the new numeric value was incompatible with with algebraic 1782 * interpretation of this object 1783 */ 1784 public SCALAR product( final byte aValue ) 1785 throws UnsupportedOperationException, 1786 IllegalArgumentException, 1787 ArithmeticException; 1788 1789 /** 1790 * Set the value of this scalar to the <i>mathematical</i> product of its 1791 * current value and the specified value 1792 * 1793 * @param aValue 1794 * a multiplicand 1795 * @return this object (facilitates operation chaining) 1796 * @throws UnsupportedOperationException 1797 * if this object's value cannot be changed 1798 * @throws IllegalArgumentException 1799 * if the new value was incommensurate with this object's 1800 * specification 1801 * @throws ArithmeticException 1802 * the new numeric value was incompatible with with algebraic 1803 * interpretation of this object 1804 */ 1805 public SCALAR product( final char aValue ) 1806 throws UnsupportedOperationException, 1807 IllegalArgumentException, 1808 ArithmeticException; 1809 1810 /** 1811 * Set the value of this scalar to the <i>mathematical</i> product of its 1812 * current value and the specified value 1813 * 1814 * @param aValue 1815 * a multiplicand 1816 * @return this object (facilitates operation chaining) 1817 * @throws UnsupportedOperationException 1818 * if this object's value cannot be changed 1819 * @throws IllegalArgumentException 1820 * if the new value was incommensurate with this object's 1821 * specification 1822 * @throws ArithmeticException 1823 * the new numeric value was incompatible with with algebraic 1824 * interpretation of this object 1825 */ 1826 public SCALAR product( final double aValue ) 1827 throws UnsupportedOperationException, 1828 IllegalArgumentException, 1829 ArithmeticException; 1830 1831 /** 1832 * Set the value of this scalar to the <i>mathematical</i> product of its 1833 * current value and the specified value 1834 * 1835 * @param aValue 1836 * a multiplicand 1837 * @return this object (facilitates operation chaining) 1838 * @throws UnsupportedOperationException 1839 * if this object's value cannot be changed 1840 * @throws IllegalArgumentException 1841 * if the new value was incommensurate with this object's 1842 * specification 1843 * @throws ArithmeticException 1844 * the new numeric value was incompatible with with algebraic 1845 * interpretation of this object 1846 */ 1847 public SCALAR product( final float aValue ) 1848 throws UnsupportedOperationException, 1849 IllegalArgumentException, 1850 ArithmeticException; 1851 1852 /** 1853 * Set the value of this scalar to the <i>mathematical</i> product of its 1854 * current value and the specified value 1855 * 1856 * @param aValue 1857 * a multiplicand 1858 * @return this object (facilitates operation chaining) 1859 * @throws UnsupportedOperationException 1860 * if this object's value cannot be changed 1861 * @throws IllegalArgumentException 1862 * if the new value was incommensurate with this object's 1863 * specification 1864 * @throws ArithmeticException 1865 * the new numeric value was incompatible with with algebraic 1866 * interpretation of this object 1867 */ 1868 public SCALAR product( final int aValue ) 1869 throws UnsupportedOperationException, 1870 IllegalArgumentException, 1871 ArithmeticException; 1872 1873 /** 1874 * Set the value of this scalar to the <i>mathematical</i> product of its 1875 * current value and the specified value 1876 * 1877 * @param aValue 1878 * a multiplicand 1879 * @return this object (facilitates operation chaining) 1880 * @throws UnsupportedOperationException 1881 * if this object's value cannot be changed 1882 * @throws IllegalArgumentException 1883 * if the new value was incommensurate with this object's 1884 * specification 1885 * @throws ArithmeticException 1886 * the new numeric value was incompatible with with algebraic 1887 * interpretation of this object 1888 */ 1889 public SCALAR product( final long aValue ) 1890 throws UnsupportedOperationException, 1891 IllegalArgumentException, 1892 ArithmeticException; 1893 1894 /** 1895 * Set the value of this scalar to the <i>mathematical</i> product of its 1896 * current value and the specified value 1897 * 1898 * @param aValue 1899 * a multiplicand 1900 * @return this object (facilitates operation chaining) 1901 * @throws UnsupportedOperationException 1902 * if this object's value cannot be changed 1903 * @throws IllegalArgumentException 1904 * if the new value was incommensurate with this object's 1905 * specification 1906 * @throws ArithmeticException 1907 * the new numeric value was incompatible with with algebraic 1908 * interpretation of this object 1909 */ 1910 public SCALAR product( final short aValue ) 1911 throws UnsupportedOperationException, 1912 IllegalArgumentException, 1913 ArithmeticException; 1914 1915 /** 1916 * Set the value of this scalar to the <i>mathematical</i> product of its 1917 * current value and the specified value 1918 * 1919 * @param aValue 1920 * a multiplicand 1921 * @return this object (facilitates operation chaining) 1922 * @throws UnsupportedOperationException 1923 * if this object's value cannot be changed 1924 * @throws IllegalArgumentException 1925 * if the new value was incommensurate with this object's 1926 * specification 1927 * @throws ArithmeticException 1928 * the new numeric value was incompatible with with algebraic 1929 * interpretation of this object 1930 */ 1931 public SCALAR productOfNumber( final Number aValue ) 1932 throws UnsupportedOperationException, 1933 IllegalArgumentException, 1934 ArithmeticException; 1935 1936 /** 1937 * Set the value of this scalar to the <i>mathematical</i> product of its 1938 * current value and the specified value 1939 * 1940 * @param aValue 1941 * a multiplicand 1942 * @return this object (facilitates operation chaining) 1943 * @throws UnsupportedOperationException 1944 * if this object's value cannot be changed 1945 * @throws IllegalArgumentException 1946 * if the new value was incommensurate with this object's 1947 * specification 1948 * @throws ArithmeticException 1949 * the new numeric value was incompatible with with algebraic 1950 * interpretation of this object 1951 */ 1952 public SCALAR productOfScalar( final SealedScalar<?> aValue ) 1953 throws UnsupportedOperationException, 1954 IllegalArgumentException, 1955 ArithmeticException; 1956 1957 /** 1958 * Set the value of this scalar to the <i>mathematical</i> quotient between 1959 * its current value and the specified value 1960 * 1961 * @param aValue 1962 * a divisor 1963 * @return this object (facilitates operation chaining) 1964 * @throws UnsupportedOperationException 1965 * if this object's value cannot be changed 1966 * @throws IllegalArgumentException 1967 * if the new value was incommensurate with this object's 1968 * specification 1969 * @throws ArithmeticException 1970 * the new numeric value was incompatible with with algebraic 1971 * interpretation of this object 1972 */ 1973 public SCALAR quotient( final boolean aValue ) 1974 throws UnsupportedOperationException, 1975 IllegalArgumentException, 1976 ArithmeticException; 1977 1978 /** 1979 * Set the value of this scalar to the <i>mathematical</i> quotient of its 1980 * current value and the specified value 1981 * 1982 * @param aValue 1983 * a divisor 1984 * @return this object (facilitates operation chaining) 1985 * @throws UnsupportedOperationException 1986 * if this object's value cannot be changed 1987 * @throws IllegalArgumentException 1988 * if the new value was incommensurate with this object's 1989 * specification 1990 * @throws ArithmeticException 1991 * the new numeric value was incompatible with with algebraic 1992 * interpretation of this object 1993 */ 1994 public SCALAR quotient( final byte aValue ) 1995 throws UnsupportedOperationException, 1996 IllegalArgumentException, 1997 ArithmeticException; 1998 1999 /** 2000 * Set the value of this scalar to the <i>mathematical</i> quotient between 2001 * its current value and the specified value 2002 * 2003 * @param aValue 2004 * a divisor 2005 * @return this object (facilitates operation chaining) 2006 * @throws UnsupportedOperationException 2007 * if this object's value cannot be changed 2008 * @throws IllegalArgumentException 2009 * if the new value was incommensurate with this object's 2010 * specification 2011 * @throws ArithmeticException 2012 * the new numeric value was incompatible with with algebraic 2013 * interpretation of this object 2014 */ 2015 public SCALAR quotient( final char aValue ) 2016 throws UnsupportedOperationException, 2017 IllegalArgumentException, 2018 ArithmeticException; 2019 2020 /** 2021 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2022 * current value and the specified value 2023 * 2024 * @param aValue 2025 * a divisor 2026 * @return this object (facilitates operation chaining) 2027 * @throws UnsupportedOperationException 2028 * if this object's value cannot be changed 2029 * @throws IllegalArgumentException 2030 * if the new value was incommensurate with this object's 2031 * specification 2032 * @throws ArithmeticException 2033 * the new numeric value was incompatible with with algebraic 2034 * interpretation of this object 2035 */ 2036 public SCALAR quotient( final double aValue ) 2037 throws UnsupportedOperationException, 2038 IllegalArgumentException, 2039 ArithmeticException; 2040 2041 /** 2042 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2043 * current value and the specified value 2044 * 2045 * @param aValue 2046 * a divisor 2047 * @return this object (facilitates operation chaining) 2048 * @throws UnsupportedOperationException 2049 * if this object's value cannot be changed 2050 * @throws IllegalArgumentException 2051 * if the new value was incommensurate with this object's 2052 * specification 2053 * @throws ArithmeticException 2054 * the new numeric value was incompatible with with algebraic 2055 * interpretation of this object 2056 */ 2057 public SCALAR quotient( final float aValue ) 2058 throws UnsupportedOperationException, 2059 IllegalArgumentException, 2060 ArithmeticException; 2061 2062 /** 2063 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2064 * current value and the specified value 2065 * 2066 * @param aValue 2067 * a divisor 2068 * @return this object (facilitates operation chaining) 2069 * @throws UnsupportedOperationException 2070 * if this object's value cannot be changed 2071 * @throws IllegalArgumentException 2072 * if the new value was incommensurate with this object's 2073 * specification 2074 * @throws ArithmeticException 2075 * the new numeric value was incompatible with with algebraic 2076 * interpretation of this object 2077 */ 2078 public SCALAR quotient( final int aValue ) 2079 throws UnsupportedOperationException, 2080 IllegalArgumentException, 2081 ArithmeticException; 2082 2083 /** 2084 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2085 * current value and the specified value 2086 * 2087 * @param aValue 2088 * a divisor 2089 * @return this object (facilitates operation chaining) 2090 * @throws UnsupportedOperationException 2091 * if this object's value cannot be changed 2092 * @throws IllegalArgumentException 2093 * if the new value was incommensurate with this object's 2094 * specification 2095 * @throws ArithmeticException 2096 * the new numeric value was incompatible with with algebraic 2097 * interpretation of this object 2098 */ 2099 public SCALAR quotient( final long aValue ) 2100 throws UnsupportedOperationException, 2101 IllegalArgumentException, 2102 ArithmeticException; 2103 2104 /** 2105 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2106 * current value and the specified value 2107 * 2108 * @param aValue 2109 * a divisor 2110 * @return this object (facilitates operation chaining) 2111 * @throws UnsupportedOperationException 2112 * if this object's value cannot be changed 2113 * @throws IllegalArgumentException 2114 * if the new value was incommensurate with this object's 2115 * specification 2116 * @throws ArithmeticException 2117 * the new numeric value was incompatible with with algebraic 2118 * interpretation of this object 2119 */ 2120 public SCALAR quotient( final short aValue ) 2121 throws UnsupportedOperationException, 2122 IllegalArgumentException, 2123 ArithmeticException; 2124 2125 /** 2126 * Set the value of this scalar to the <i>mathematical</i> quotient of its 2127 * current value and the specified value 2128 * 2129 * @param aValue 2130 * a divisor 2131 * @return this object (facilitates operation chaining) 2132 * @throws UnsupportedOperationException 2133 * if this object's value cannot be changed 2134 * @throws IllegalArgumentException 2135 * if the new value was incommensurate with this object's 2136 * specification 2137 * @throws ArithmeticException 2138 * the new numeric value was incompatible with with algebraic 2139 * interpretation of this object 2140 */ 2141 public SCALAR quotientOfNumber( final Number aValue ) 2142 throws UnsupportedOperationException, 2143 IllegalArgumentException, 2144 ArithmeticException; 2145 2146 /** 2147 * Set the value of this scalar to the <i>mathematical</i> quotient between 2148 * its current value and the specified value 2149 * 2150 * @param aValue 2151 * a divisor 2152 * @return this object (facilitates operation chaining) 2153 * @throws UnsupportedOperationException 2154 * if this object's value cannot be changed 2155 * @throws IllegalArgumentException 2156 * if the new value was incommensurate with this object's 2157 * specification 2158 * @throws ArithmeticException 2159 * the new numeric value was incompatible with with algebraic 2160 * interpretation of this object 2161 */ 2162 public SCALAR quotientOfScalar( final SealedScalar<?> aValue ) 2163 throws UnsupportedOperationException, 2164 IllegalArgumentException, 2165 ArithmeticException; 2166 2167 /** 2168 * Replace the current value, assumed to be an angle in degrees, to its 2169 * equivalent angle in radians 2170 * 2171 * @return this object (facilitates operation chaining) 2172 * @throws UnsupportedOperationException 2173 * if this object's value cannot be changed 2174 * @throws IllegalArgumentException 2175 * if the new value was incommensurate with this object's 2176 * specification 2177 * @throws ArithmeticException 2178 * the new numeric value was incompatible with with algebraic 2179 * interpretation of this object 2180 */ 2181 public SCALAR radians() 2182 throws UnsupportedOperationException, 2183 IllegalArgumentException, 2184 ArithmeticException; 2185 2186 /** 2187 * Replace the current value with an evenly-distributed 2188 * {@link Math#random() random} value between zero (inclusive) and unity 2189 * (exclusive for floating point, inclusive for integrals) 2190 * 2191 * @return this object (facilitates operation chaining) 2192 * @throws UnsupportedOperationException 2193 * if this object's value cannot be changed 2194 */ 2195 public SCALAR random() throws UnsupportedOperationException; 2196 2197 /** 2198 * Round the current value using the specified rounding 2199 * {@link RoundingStrategy strategy} 2200 * 2201 * @return this object (facilitates operation chaining) 2202 * @throws UnsupportedOperationException 2203 * if this object's value cannot be changed 2204 * @throws IllegalArgumentException 2205 * if the new value was incommensurate with this object's 2206 * specification 2207 * @throws ArithmeticException 2208 * the new numeric value was incompatible with with algebraic 2209 * interpretation of this object 2210 */ 2211 public SCALAR round( final RoundingStrategy aRoundingStrategy ) 2212 throws UnsupportedOperationException, 2213 IllegalArgumentException, 2214 ArithmeticException, 2215 NullPointerException; 2216 2217 /** 2218 * Replace the current value with <i>e</i>, or Napier's constant 2219 * 2220 * @return this object (facilitates operation chaining) 2221 * @throws UnsupportedOperationException 2222 * if this object's value cannot be changed 2223 * @throws IllegalArgumentException 2224 * if the new value was incommensurate with this object's 2225 * specification 2226 * @throws ArithmeticException 2227 * the new numeric value was incompatible with with algebraic 2228 * interpretation of this object 2229 * @see <a 2230 * href="http://en.wikipedia.org/wiki/E_%28mathematical_constant%29">e</a> 2231 * (Wikipedia) 2232 */ 2233 public SCALAR setE() 2234 throws UnsupportedOperationException, 2235 IllegalArgumentException, 2236 ArithmeticException; 2237 2238 /** 2239 * Match the value of this object with the identity of the specified 2240 * {@link Enum enumeration} instance, then answer this object (facilitates 2241 * chaining) 2242 * 2243 * @param aValue 2244 * a system-supported {@link Enum enumeration} 2245 * @return this object (facilitates operation chaining) 2246 * @throws UnsupportedOperationException 2247 * if this object's value cannot be changed 2248 * @throws IllegalArgumentException 2249 * if the specified value was incommensurate with this object's 2250 * specification 2251 * @throws ArithmeticException 2252 * the numeric value provided was incompatible with with algebraic 2253 * interpretation of this object 2254 * @throws NullPointerException 2255 * a {@code null} value was provided though this object does not 2256 * accept {@code null} values 2257 */ 2258 public <E extends Enum<E>> SCALAR setEnumeration( final E aValue ) 2259 throws UnsupportedOperationException, 2260 ArithmeticException, 2261 IllegalArgumentException, 2262 NullPointerException; 2263 2264 /** 2265 * Replace the current value with maximum value available for the 2266 * implementation's numeric {@link NumericPrecision precision}. Unlimited 2267 * values will be replaced with the maximum value available for the most 2268 * precise system scalar appropriate for the implementation, that is 2269 * unlimited {@link UnlimitedIntegerPrimitive integer} primitives will set 2270 * themselves to the {@link Long#MAX_VALUE maximum} {@code long} value and 2271 * unlimited {@link UnlimitedDecimalPrimitive decimal} primitives will set 2272 * themselves to the {@link Double#MAX_VALUE maximum} {@code double} value. 2273 * 2274 * @return this object (facilitates operation chaining) 2275 * @throws UnsupportedOperationException 2276 * if this object's value cannot be changed 2277 * @throws IllegalArgumentException 2278 * if the new value was incommensurate with this object's 2279 * specification 2280 * @throws ArithmeticException 2281 * the new numeric value was incompatible with with algebraic 2282 * interpretation of this object 2283 */ 2284 public SCALAR setMaximum() 2285 throws UnsupportedOperationException, 2286 ArithmeticException, 2287 IllegalArgumentException; 2288 2289 /** 2290 * Replace the current value with minimum value available for the 2291 * implementation's numeric {@link NumericPrecision precision}. Unlimited 2292 * values will be replaced with the minimum value available for the most 2293 * precise system scalar appropriate for the implementation, that is 2294 * unlimited {@link UnlimitedIntegerPrimitive integer} primitives will set 2295 * themselves to the {@link Long#MIN_VALUE minimum} {@code long} value and 2296 * unlimited {@link UnlimitedDecimalPrimitive decimal} primitives will set 2297 * themselves to the {@link Double#MIN_VALUE minimum} {@code double} value. 2298 * 2299 * @return this object (facilitates operation chaining) 2300 * @throws UnsupportedOperationException 2301 * if this object's value cannot be changed 2302 * @throws IllegalArgumentException 2303 * if the new value was incommensurate with this object's 2304 * specification 2305 * @throws ArithmeticException 2306 * the new numeric value was incompatible with with algebraic 2307 * interpretation of this object 2308 */ 2309 public SCALAR setMinimum() 2310 throws UnsupportedOperationException, 2311 ArithmeticException, 2312 IllegalArgumentException; 2313 2314 /** 2315 * Replace the current value with a representation of negative infinity, if 2316 * available, otherwise replace with the implementation's 2317 * {@link #setMinimum() minimum} value 2318 * 2319 * @return this object (facilitates operation chaining) 2320 * @throws UnsupportedOperationException 2321 * if this object's value cannot be changed 2322 * @throws IllegalArgumentException 2323 * if the new value was incommensurate with this object's 2324 * specification 2325 * @throws ArithmeticException 2326 * the new numeric value was incompatible with with algebraic 2327 * interpretation of this object 2328 */ 2329 public SCALAR setNegativeInfinity() 2330 throws UnsupportedOperationException, 2331 ArithmeticException, 2332 IllegalArgumentException; 2333 2334 /** 2335 * Set this object to the specified system-supported {@link Number} and 2336 * answer this object (facilitates chaining) 2337 * 2338 * @param aValue 2339 * a system-supported {@link Number} 2340 * @return this object (facilitates operation chaining) 2341 * @throws UnsupportedOperationException 2342 * if this object's value cannot be changed 2343 * @throws IllegalArgumentException 2344 * if the specified value was incommensurate with this object's 2345 * specification 2346 * @throws ArithmeticException 2347 * the numeric value provided was incompatible with with algebraic 2348 * interpretation of this object 2349 * @throws NullPointerException 2350 * a {@code null} value was provided though this object does not 2351 * accept {@code null} values 2352 */ 2353 public SCALAR setNumber( final Number aValue ) 2354 throws UnsupportedOperationException, 2355 IllegalArgumentException, 2356 ArithmeticException, 2357 NullPointerException; 2358 2359 /** 2360 * Replace the current value with Pi 2361 * 2362 * @return this object (facilitates operation chaining) 2363 * @throws UnsupportedOperationException 2364 * if this object's value cannot be changed 2365 * @throws IllegalArgumentException 2366 * if the new value was incommensurate with this object's 2367 * specification 2368 * @throws ArithmeticException 2369 * the new numeric value was incompatible with with algebraic 2370 * interpretation of this object 2371 */ 2372 public SCALAR setPi() 2373 throws UnsupportedOperationException, 2374 IllegalArgumentException, 2375 ArithmeticException; 2376 2377 /** 2378 * Replace the current value with a representation of positive infinity, if 2379 * available, otherwise replace with the implementation's 2380 * {@link #setMaximum() maximum} value 2381 * 2382 * @return this object (facilitates operation chaining) 2383 * @throws UnsupportedOperationException 2384 * if this object's value cannot be changed 2385 * @throws IllegalArgumentException 2386 * if the new value was incommensurate with this object's 2387 * specification 2388 * @throws ArithmeticException 2389 * the new numeric value was incompatible with with algebraic 2390 * interpretation of this object 2391 */ 2392 public SCALAR setPositiveInfinity() 2393 throws UnsupportedOperationException, 2394 IllegalArgumentException, 2395 ArithmeticException; 2396 2397 /** 2398 * Set this object to the specified scalar 2399 * 2400 * @param aValue 2401 * a scalar 2402 * @return this object (facilitates operation chaining) 2403 * @throws UnsupportedOperationException 2404 * if this object's value cannot be changed 2405 * @throws IllegalArgumentException 2406 * if the specified value was incommensurate with this object's 2407 * specification 2408 * @throws ArithmeticException 2409 * the numeric value provided was incompatible with with algebraic 2410 * interpretation of this object 2411 * @throws NullPointerException 2412 * a {@code null} value was provided though this object does not 2413 * accept {@code null} values 2414 */ 2415 public SCALAR setScalar( final SealedScalar<?> aValue ) 2416 throws UnsupportedOperationException, 2417 IllegalArgumentException, 2418 ArithmeticException, 2419 NullPointerException; 2420 2421 /** 2422 * Replace the current value with the multiplicative identity appropriate 2423 * for the implementation (one) 2424 * 2425 * @return this object (facilitates operation chaining) 2426 * @throws UnsupportedOperationException 2427 * if this object's value cannot be changed 2428 * @throws IllegalArgumentException 2429 * if the new value was incommensurate with this object's 2430 * specification 2431 * @throws ArithmeticException 2432 * the new numeric value was incompatible with with algebraic 2433 * interpretation of this object 2434 */ 2435 public SCALAR setUnity() 2436 throws UnsupportedOperationException, 2437 IllegalArgumentException, 2438 ArithmeticException; 2439 2440 /** 2441 * Replace the current value with the additive identity appropriate for the 2442 * implementation (zero) 2443 * 2444 * @return this object (facilitates operation chaining) 2445 * @throws UnsupportedOperationException 2446 * if this object's value cannot be changed 2447 * @throws IllegalArgumentException 2448 * if the new value was incommensurate with this object's 2449 * specification 2450 * @throws ArithmeticException 2451 * the new numeric value was incompatible with with algebraic 2452 * interpretation of this object 2453 */ 2454 public SCALAR setZero() 2455 throws UnsupportedOperationException, 2456 IllegalArgumentException, 2457 ArithmeticException; 2458 2459 /** 2460 * Attempt to shift the elements of this tuple to the "left" the specified 2461 * number of ordinal positions. In a bit sequence this functions resorts to 2462 * the familiar "left shift" process (e.g., Java {@code <<}). In other 2463 * sequences, the specified number of default values will be prepended to 2464 * the beginning of the sequence, increasing the ordinal position of all 2465 * existing elements by the specified count. 2466 * 2467 * @param count 2468 * the number of default values to be prepended to this sequence 2469 * @return this structure (facilitates chaining) 2470 * @throws UnsupportedOperationException 2471 * if this object's value cannot be changed or if this structure is 2472 * not an algebraic tuple 2473 * @throws IllegalArgumentException 2474 * if the specified value was incommensurate with this structure's 2475 * specification 2476 * @throws ArithmeticException 2477 * the numeric value provided was incompatible with with algebraic 2478 * interpretation of this structure 2479 */ 2480 public SCALAR shiftLeft( final int count ) 2481 throws UnsupportedOperationException, 2482 IllegalArgumentException, 2483 ArithmeticException; 2484 2485 /** 2486 * Attempt to shift the elements of this tuple to the "right" the specified 2487 * number of ordinal positions. In a bit sequence this functions resorts to 2488 * the familiar "right shift" process, with sign extension (e.g., the Java 2489 * {@code >>} operator). In other sequences, the specified number of values 2490 * will be removed from the beginning of the sequence, decreasing the 2491 * ordinal position of all remaining elements by the specified count. 2492 * 2493 * @param count 2494 * the number of values to be removed from the beginning of this 2495 * sequence 2496 * @return this structure (facilitates chaining) 2497 * @throws UnsupportedOperationException 2498 * if this object's value cannot be changed or if this structure is 2499 * not an algebraic tuple 2500 * @throws IllegalArgumentException 2501 * if the specified value was incommensurate with this structure's 2502 * specification 2503 * @throws ArithmeticException 2504 * the numeric value provided was incompatible with with algebraic 2505 * interpretation of this structure 2506 */ 2507 public SCALAR shiftRight( final int count ) 2508 throws UnsupportedOperationException, 2509 IllegalArgumentException, 2510 ArithmeticException; 2511 2512 /** 2513 * Attempt to shift the elements of this tuple to the "right" the specified 2514 * number of ordinal positions <i>without sign extension</i>. In a bit 2515 * sequence this functions resorts to the familiar "right shift" process, 2516 * with zero extension (e.g., the Java {@code >>>} operator). In other 2517 * sequences, the specified number of values will be removed from the 2518 * beginning of the sequence, decreasing the ordinal position of all 2519 * remaining elements by the specified count. 2520 * 2521 * @param count 2522 * the number of values to be removed from the beginning of this 2523 * sequence 2524 * @return this structure (facilitates chaining) 2525 * @throws UnsupportedOperationException 2526 * if this object's value cannot be changed or if this structure is 2527 * not an algebraic tuple 2528 * @throws IllegalArgumentException 2529 * if the specified value was incommensurate with this structure's 2530 * specification 2531 * @throws ArithmeticException 2532 * the numeric value provided was incompatible with with algebraic 2533 * interpretation of this structure 2534 */ 2535 public SCALAR shiftRightExtendZero( final int count ) 2536 throws UnsupportedOperationException, 2537 IllegalArgumentException, 2538 ArithmeticException; 2539 2540 /** 2541 * Replace the current value, assumed to be an angle in radians, to its 2542 * {@link Math#sin(double) sine} 2543 * 2544 * @return this object (facilitates operation chaining) 2545 * @throws UnsupportedOperationException 2546 * if this object's value cannot be changed 2547 * @throws IllegalArgumentException 2548 * if the new value was incommensurate with this object's 2549 * specification 2550 * @throws ArithmeticException 2551 * the new numeric value was incompatible with with algebraic 2552 * interpretation of this object 2553 */ 2554 public SCALAR sine() 2555 throws UnsupportedOperationException, 2556 IllegalArgumentException, 2557 ArithmeticException; 2558 2559 /** 2560 * Replace the current value with the square of itself 2561 * 2562 * @return this object (facilitates operation chaining) 2563 * @throws UnsupportedOperationException 2564 * if this object's value cannot be changed 2565 * @throws IllegalArgumentException 2566 * if the new value was incommensurate with this object's 2567 * specification 2568 * @throws ArithmeticException 2569 * the new numeric value was incompatible with with algebraic 2570 * interpretation of this object 2571 */ 2572 public SCALAR square() 2573 throws UnsupportedOperationException, 2574 IllegalArgumentException, 2575 ArithmeticException; 2576 2577 /** 2578 * Replace the current value with the square root of itself 2579 * 2580 * @return this object (facilitates operation chaining) 2581 * @throws UnsupportedOperationException 2582 * if this object's value cannot be changed 2583 * @throws IllegalArgumentException 2584 * if the new value was incommensurate with this object's 2585 * specification 2586 * @throws ArithmeticException 2587 * the new numeric value was incompatible with with algebraic 2588 * interpretation of this object 2589 */ 2590 public SCALAR squareRoot() 2591 throws UnsupportedOperationException, 2592 IllegalArgumentException, 2593 ArithmeticException; 2594 2595 /** 2596 * Set the value of this scalar to the <i>mathematical</i> sum of its 2597 * current value and the specified value 2598 * 2599 * @param aValue 2600 * an addend 2601 * @return this object (facilitates operation chaining) 2602 * @throws UnsupportedOperationException 2603 * if this object's value cannot be changed 2604 * @throws IllegalArgumentException 2605 * if the new value was incommensurate with this object's 2606 * specification 2607 * @throws ArithmeticException 2608 * the new numeric value was incompatible with with algebraic 2609 * interpretation of this object 2610 */ 2611 public SCALAR sum( final boolean aValue ) 2612 throws UnsupportedOperationException, 2613 IllegalArgumentException, 2614 ArithmeticException; 2615 2616 /** 2617 * Set the value of this scalar to the <i>mathematical</i> sum of its 2618 * current value and the specified value 2619 * 2620 * @param aValue 2621 * an addend 2622 * @return this object (facilitates operation chaining) 2623 * @throws UnsupportedOperationException 2624 * if this object's value cannot be changed 2625 * @throws IllegalArgumentException 2626 * if the new value was incommensurate with this object's 2627 * specification 2628 * @throws ArithmeticException 2629 * the new numeric value was incompatible with with algebraic 2630 * interpretation of this object 2631 */ 2632 public SCALAR sum( final byte aValue ) 2633 throws UnsupportedOperationException, 2634 IllegalArgumentException, 2635 ArithmeticException; 2636 2637 /** 2638 * Set the value of this scalar to the <i>mathematical</i> sum of its 2639 * current value and the specified value 2640 * 2641 * @param aValue 2642 * an addend 2643 * @return this object (facilitates operation chaining) 2644 * @throws UnsupportedOperationException 2645 * if this object's value cannot be changed 2646 * @throws IllegalArgumentException 2647 * if the new value was incommensurate with this object's 2648 * specification 2649 * @throws ArithmeticException 2650 * the new numeric value was incompatible with with algebraic 2651 * interpretation of this object 2652 */ 2653 public SCALAR sum( final char aValue ) 2654 throws UnsupportedOperationException, 2655 IllegalArgumentException, 2656 ArithmeticException; 2657 2658 /** 2659 * Set the value of this scalar to the <i>mathematical</i> sum of its 2660 * current value and the specified value 2661 * 2662 * @param aValue 2663 * an addend 2664 * @return this object (facilitates operation chaining) 2665 * @throws UnsupportedOperationException 2666 * if this object's value cannot be changed 2667 * @throws IllegalArgumentException 2668 * if the new value was incommensurate with this object's 2669 * specification 2670 * @throws ArithmeticException 2671 * the new numeric value was incompatible with with algebraic 2672 * interpretation of this object 2673 */ 2674 public SCALAR sum( final double aValue ) 2675 throws UnsupportedOperationException, 2676 IllegalArgumentException, 2677 ArithmeticException; 2678 2679 /** 2680 * Set the value of this scalar to the <i>mathematical</i> sum of its 2681 * current value and the specified value 2682 * 2683 * @param aValue 2684 * an addend 2685 * @return this object (facilitates operation chaining) 2686 * @throws UnsupportedOperationException 2687 * if this object's value cannot be changed 2688 * @throws IllegalArgumentException 2689 * if the new value was incommensurate with this object's 2690 * specification 2691 * @throws ArithmeticException 2692 * the new numeric value was incompatible with with algebraic 2693 * interpretation of this object 2694 */ 2695 public SCALAR sum( final float aValue ) 2696 throws UnsupportedOperationException, 2697 IllegalArgumentException, 2698 ArithmeticException; 2699 2700 /** 2701 * Set the value of this scalar to the <i>mathematical</i> sum of its 2702 * current value and the specified value 2703 * 2704 * @param aValue 2705 * an addend 2706 * @return this object (facilitates operation chaining) 2707 * @throws UnsupportedOperationException 2708 * if this object's value cannot be changed 2709 * @throws IllegalArgumentException 2710 * if the new value was incommensurate with this object's 2711 * specification 2712 * @throws ArithmeticException 2713 * the new numeric value was incompatible with with algebraic 2714 * interpretation of this object 2715 */ 2716 public SCALAR sum( final int aValue ) 2717 throws UnsupportedOperationException, 2718 IllegalArgumentException, 2719 ArithmeticException; 2720 2721 /** 2722 * Set the value of this scalar to the <i>mathematical</i> sum of its 2723 * current value and the specified value 2724 * 2725 * @param aValue 2726 * an addend 2727 * @return this object (facilitates operation chaining) 2728 * @throws UnsupportedOperationException 2729 * if this object's value cannot be changed 2730 * @throws IllegalArgumentException 2731 * if the new value was incommensurate with this object's 2732 * specification 2733 * @throws ArithmeticException 2734 * the new numeric value was incompatible with with algebraic 2735 * interpretation of this object 2736 */ 2737 public SCALAR sum( final long aValue ) 2738 throws UnsupportedOperationException, 2739 IllegalArgumentException, 2740 ArithmeticException; 2741 2742 /** 2743 * Set the value of this scalar to the <i>mathematical</i> sum of its 2744 * current value and the specified value 2745 * 2746 * @param aValue 2747 * an addend 2748 * @return this object (facilitates operation chaining) 2749 * @throws UnsupportedOperationException 2750 * if this object's value cannot be changed 2751 * @throws IllegalArgumentException 2752 * if the new value was incommensurate with this object's 2753 * specification 2754 * @throws ArithmeticException 2755 * the new numeric value was incompatible with with algebraic 2756 * interpretation of this object 2757 */ 2758 public SCALAR sum( final short aValue ) 2759 throws UnsupportedOperationException, 2760 IllegalArgumentException, 2761 ArithmeticException; 2762 2763 /** 2764 * Set the value of this scalar to the <i>mathematical</i> sum of its 2765 * current value and the specified value 2766 * 2767 * @param aValue 2768 * an addend 2769 * @return this object (facilitates operation chaining) 2770 * @throws UnsupportedOperationException 2771 * if this object's value cannot be changed 2772 * @throws IllegalArgumentException 2773 * if the new value was incommensurate with this object's 2774 * specification 2775 * @throws ArithmeticException 2776 * the new numeric value was incompatible with with algebraic 2777 * interpretation of this object 2778 */ 2779 public SCALAR sumOfNumber( final Number aValue ) 2780 throws UnsupportedOperationException, 2781 IllegalArgumentException, 2782 ArithmeticException; 2783 2784 /** 2785 * Set the value of this scalar to the <i>mathematical</i> sum of its 2786 * current value and the specified value 2787 * 2788 * @param aValue 2789 * an addend 2790 * @return this object (facilitates operation chaining) 2791 * @throws UnsupportedOperationException 2792 * if this object's value cannot be changed 2793 * @throws IllegalArgumentException 2794 * if the new value was incommensurate with this object's 2795 * specification 2796 * @throws ArithmeticException 2797 * the new numeric value was incompatible with with algebraic 2798 * interpretation of this object 2799 */ 2800 public SCALAR sumOfScalar( final SealedScalar<?> aValue ) 2801 throws UnsupportedOperationException, 2802 IllegalArgumentException, 2803 ArithmeticException; 2804 2805 /** 2806 * Replace the current value, assumed to be an angle in radians, to its 2807 * {@link Math#tan(double) tangent} 2808 * 2809 * @return this object (facilitates operation chaining) 2810 * @throws UnsupportedOperationException 2811 * if this object's value cannot be changed 2812 * @throws IllegalArgumentException 2813 * if the new value was incommensurate with this object's 2814 * specification 2815 * @throws ArithmeticException 2816 * the new numeric value was incompatible with with algebraic 2817 * interpretation of this object 2818 */ 2819 public SCALAR tangent() 2820 throws UnsupportedOperationException, 2821 IllegalArgumentException, 2822 ArithmeticException; 2823 2824 /** 2825 * Round away from zero 2826 * 2827 * @return this object (facilitates operation chaining) 2828 * @throws UnsupportedOperationException 2829 * if this object's value cannot be changed 2830 * @throws IllegalArgumentException 2831 * if the new value was incommensurate with this object's 2832 * specification 2833 * @throws ArithmeticException 2834 * the new numeric value was incompatible with with algebraic 2835 * interpretation of this object 2836 */ 2837 public SCALAR up() 2838 throws UnsupportedOperationException, 2839 IllegalArgumentException, 2840 ArithmeticException; 2841 2842 /** 2843 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2844 * boolean vector equivalent of this value and the specified integral 2845 * boolean vector 2846 * 2847 * @param aValue 2848 * an integral boolean vector 2849 * @return this object (facilitates operation chaining) 2850 * @throws UnsupportedOperationException 2851 * if this object's value cannot be changed 2852 * @throws IllegalArgumentException 2853 * if the new value was incommensurate with this object's 2854 * specification 2855 * @throws ArithmeticException 2856 * the new numeric value was incompatible with with algebraic 2857 * interpretation of this object 2858 */ 2859 public SCALAR xor( final boolean aValue ) 2860 throws UnsupportedOperationException, 2861 IllegalArgumentException, 2862 ArithmeticException; 2863 2864 /** 2865 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2866 * boolean vector equivalent of this value and the specified integral 2867 * boolean vector 2868 * 2869 * @param aValue 2870 * an integral boolean vector 2871 * @return this object (facilitates operation chaining) 2872 * @throws UnsupportedOperationException 2873 * if this object's value cannot be changed 2874 * @throws IllegalArgumentException 2875 * if the new value was incommensurate with this object's 2876 * specification 2877 * @throws ArithmeticException 2878 * the new numeric value was incompatible with with algebraic 2879 * interpretation of this object 2880 */ 2881 public SCALAR xor( final byte aValue ) 2882 throws UnsupportedOperationException, 2883 IllegalArgumentException, 2884 ArithmeticException; 2885 2886 /** 2887 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2888 * boolean vector equivalent of this value and the specified integral 2889 * boolean vector 2890 * 2891 * @param aValue 2892 * an integral boolean vector 2893 * @return this object (facilitates operation chaining) 2894 * @throws UnsupportedOperationException 2895 * if this object's value cannot be changed 2896 * @throws IllegalArgumentException 2897 * if the new value was incommensurate with this object's 2898 * specification 2899 * @throws ArithmeticException 2900 * the new numeric value was incompatible with with algebraic 2901 * interpretation of this object 2902 */ 2903 public SCALAR xor( final char aValue ) 2904 throws UnsupportedOperationException, 2905 IllegalArgumentException, 2906 ArithmeticException; 2907 2908 /** 2909 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2910 * boolean vector equivalent of this value and the specified integral 2911 * boolean vector 2912 * 2913 * @param aValue 2914 * an integral boolean vector 2915 * @return this object (facilitates operation chaining) 2916 * @throws UnsupportedOperationException 2917 * if this object's value cannot be changed 2918 * @throws IllegalArgumentException 2919 * if the new value was incommensurate with this object's 2920 * specification 2921 * @throws ArithmeticException 2922 * the new numeric value was incompatible with with algebraic 2923 * interpretation of this object 2924 */ 2925 public SCALAR xor( final int aValue ) 2926 throws UnsupportedOperationException, 2927 IllegalArgumentException, 2928 ArithmeticException; 2929 2930 /** 2931 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2932 * boolean vector equivalent of this value and the specified integral 2933 * boolean vector 2934 * 2935 * @param aValue 2936 * an integral boolean vector 2937 * @return this object (facilitates operation chaining) 2938 * @throws UnsupportedOperationException 2939 * if this object's value cannot be changed 2940 * @throws IllegalArgumentException 2941 * if the new value was incommensurate with this object's 2942 * specification 2943 * @throws ArithmeticException 2944 * the new numeric value was incompatible with with algebraic 2945 * interpretation of this object 2946 */ 2947 public SCALAR xor( final long aValue ) 2948 throws UnsupportedOperationException, 2949 IllegalArgumentException, 2950 ArithmeticException; 2951 2952 /** 2953 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2954 * boolean vector equivalent of this value and the specified integral 2955 * boolean vector 2956 * 2957 * @param aValue 2958 * an integral boolean vector 2959 * @return this object (facilitates operation chaining) 2960 * @throws UnsupportedOperationException 2961 * if this object's value cannot be changed 2962 * @throws IllegalArgumentException 2963 * if the new value was incommensurate with this object's 2964 * specification 2965 * @throws ArithmeticException 2966 * the new numeric value was incompatible with with algebraic 2967 * interpretation of this object 2968 */ 2969 public SCALAR xor( final short aValue ) 2970 throws UnsupportedOperationException, 2971 IllegalArgumentException, 2972 ArithmeticException; 2973 2974 /** 2975 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2976 * boolean vector equivalent of this value and the specified integral 2977 * boolean vector 2978 * 2979 * @param aValue 2980 * an integral boolean vector 2981 * @return this object (facilitates operation chaining) 2982 * @throws UnsupportedOperationException 2983 * if this object's value cannot be changed 2984 * @throws IllegalArgumentException 2985 * if the new value was incommensurate with this object's 2986 * specification 2987 * @throws ArithmeticException 2988 * the new numeric value was incompatible with with algebraic 2989 * interpretation of this object 2990 */ 2991 public SCALAR xorOfNumber( final Number aValue ) 2992 throws UnsupportedOperationException, 2993 IllegalArgumentException, 2994 ArithmeticException; 2995 2996 /** 2997 * Set this value to the bit <b>exclusive-or</b> of the <i>integral</i> 2998 * boolean vector equivalent of this value and the specified integral 2999 * boolean vector 3000 * 3001 * @param aValue 3002 * an integral boolean vector 3003 * @return this object (facilitates operation chaining) 3004 * @throws UnsupportedOperationException 3005 * if this object's value cannot be changed 3006 * @throws IllegalArgumentException 3007 * if the new value was incommensurate with this object's 3008 * specification 3009 * @throws ArithmeticException 3010 * the new numeric value was incompatible with with algebraic 3011 * interpretation of this object 3012 */ 3013 public SCALAR xorOfScalar( final SealedScalar<?> aValue ) 3014 throws UnsupportedOperationException, 3015 IllegalArgumentException, 3016 ArithmeticException; 3017}