001package hw4.test; 002 003import static org.hamcrest.CoreMatchers.not; 004import static org.junit.Assert.*; 005 006import org.junit.Before; 007 008import hw4.RatNum; 009import hw4.RatTerm; 010 011import org.junit.Test; 012 013/** 014 * This class contains a set of test cases that can be used to test the 015 * implementation of the RatPoly class. 016 */ 017@SuppressWarnings("nullness") 018public final class RatTermTest { 019 020 /** 021 * checks that Java asserts are enabled, and exits if not 022 */ 023 @Before 024 public void testAssertsEnabled() { 025 SpecificationTests.checkAssertsEnabled(); 026 } 027 028 // Get a RatNum for in an integer 029 private static RatNum num(int i) { 030 return new RatNum(i); 031 } 032 033 private static RatNum num(int i, int j) { 034 return new RatNum(i, j); 035 } 036 037 private static final RatNum nanNum = (num(1)).div(num(0)); 038 private static final RatTerm nanTerm = new RatTerm(nanNum, 3); 039 private static final RatTerm zeroTerm = RatTerm.ZERO; 040 private static final RatTerm one = new RatTerm(new RatNum(1),0); 041 042 // Convenient way to make a RatTerm equals to coeff*x^expt. 043 private static RatTerm term(int coeff, int expt) { 044 return new RatTerm(num(coeff), expt); 045 } 046 047 // Convenient way to make a RatTerm equals to num/denom*x^expt. 048 private static RatTerm term(int numer, int denom, int expt) { 049 return new RatTerm(num(numer, denom), expt); 050 } 051 052 /////////////////////////////////////////////////////////////////////////////////////// 053 //// Constructor 054 /////////////////////////////////////////////////////////////////////////////////////// 055 056 // Is it good style to include these constructor tests? Explicit constructor 057 // tests are often not needed. Generally we advise you to have at 058 // least one assertion in every test unless testing that an exception IS 059 // thrown (via the "expected" test parameter). The constructor tests below 060 // violate this rule, but we chose to include them in this assignment in 061 // case they help you isolate constructor errors as you write your code. 062 @Test 063 public void testCtor() { 064 assertEquals(RatTerm.valueOf("1"), term(1, 0)); 065 assertEquals(RatTerm.valueOf("2*x^3"), term(2, 3)); 066 assertEquals(RatTerm.valueOf("4/3*x^6"), term(4, 3, 6)); 067 assertEquals(RatTerm.valueOf("-2/7*x^3"), term(-2, 7, 3)); 068 } 069 070 @Test 071 public void testCtorZeroCoeff() { 072 assertEquals(RatTerm.ZERO, term(0, 0)); 073 assertEquals(RatTerm.ZERO, term(0, 1)); 074 } 075 076 @Test 077 public void testCtorNaN() { 078 assertEquals(RatTerm.NaN, term(3, 0, 0)); 079 } 080 081 /////////////////////////////////////////////////////////////////////////////////////// 082 //// Get Coefficient 083 /////////////////////////////////////////////////////////////////////////////////////// 084 085 @Test 086 public void testGetCoeffRegular() { 087 // Simple cases 088 assertEquals(num(3), term(3, 1).getCoeff()); 089 assertEquals(num(2, 5), term(2, 5, 2).getCoeff()); 090 } 091 092 @Test 093 public void testGetCoeffZero() { 094 // Check zero 095 assertEquals(num(0), term(0, 0).getCoeff()); 096 } 097 098 @Test 099 public void testGetCoeffNegative() { 100 // Check negative coeff 101 assertEquals(num(-2, 3), term(-2, 3, 2).getCoeff()); 102 } 103 104 @Test 105 public void testGetCoeffNaN() { 106 // Check NaN 107 assertEquals(nanNum, term(3, 0, 4).getCoeff()); 108 } 109 110 /////////////////////////////////////////////////////////////////////////////////////// 111 //// Get Coefficient 112 /////////////////////////////////////////////////////////////////////////////////////// 113 114 @Test 115 public void testGetExptRegular() { 116 // Simple 117 assertEquals(4, term(2, 4).getExpt()); 118 } 119 120 @Test 121 public void testGetExptZero() { 122 // Zero always have zero expt 123 assertEquals(0, term(0, 0).getExpt()); 124 assertEquals(0, term(0, 1).getExpt()); 125 } 126 127 /////////////////////////////////////////////////////////////////////////////////////// 128 //// isNaN Test 129 /////////////////////////////////////////////////////////////////////////////////////// 130 131 @Test 132 public void testIsNaNZeroDenomRegNumer() { 133 // Check that 5/0*x^0 isNaN instead of zero 134 assertTrue(term(5, 0, 0).isNaN()); 135 } 136 137 @Test 138 public void testIsNaNZeroDenomZeroNumer() { 139 // Check that 0/0*x^4 isNaN instead of zero 140 assertTrue(term(0, 0, 4).isNaN()); 141 } 142 143 @Test 144 public void testIsNaNFalse() { 145 // Check for false positives 146 assertFalse(term(2, 3, 2).isNaN()); 147 } 148 149 /////////////////////////////////////////////////////////////////////////////////////// 150 //// isZero Test 151 /////////////////////////////////////////////////////////////////////////////////////// 152 153 @Test 154 public void testIsZeroNumAndDen() { 155 assertTrue(term(0, 0).isZero()); 156 } 157 158 @Test 159 public void testIsZeroNum() { 160 assertTrue(term(0, 1).isZero()); 161 assertTrue(term(0, 4, 3).isZero()); 162 assertTrue(term(0, -2, 2).isZero()); 163 } 164 165 @Test 166 public void testIsZeroFalsoPos() { 167 // Check for false positives 168 assertFalse(term(1, 3, 0).isZero()); 169 } 170 171 @Test 172 public void testIsNaNNotTerm() { 173 // Check that 0/0*x^4 is not zero 174 assertFalse(term(0, 0, 4).isZero()); 175 } 176 177 /////////////////////////////////////////////////////////////////////////////////////// 178 //// eval Test 179 /////////////////////////////////////////////////////////////////////////////////////// 180 181 @Test 182 public void testEvalZero() { 183 assertEquals(0.0, term(0, 0).eval(5.0), 0.0000001); 184 assertEquals(0.0, term(0, 5).eval(1.2), 0.0000001); 185 } 186 187 @Test 188 public void testEvalSmallFrac() { 189 assertEquals(.125, term(1, 2, 2).eval(.5), 0.0000001); 190 } 191 192 @Test 193 public void testEvalSmallWhole() { 194 assertEquals(2.0, term(2, 0).eval(3.1), 0.0000001); 195 assertEquals(1.0, term(1, 0).eval(100.0), 0.0000001); 196 assertEquals(1.0, term(-1, 1).eval(-1.0), 0.0000001); 197 assertEquals(2.0, term(1, 2, 2).eval(2.0), 0.0000001); 198 } 199 200 @Test 201 public void testEvalLarge() { 202 assertEquals(35.0, term(5, 1).eval(7.0), 0.0000001); 203 assertEquals(12.0, term(3, 2).eval(2.0), 0.0000001); 204 } 205 206 @Test 207 public void testEvalNegative() { 208 assertEquals(-16.0, term(-2, 3).eval(2.0), 0.0000001); 209 assertEquals(-3.0, term(3, 3).eval(-1.0), 0.0000001); 210 } 211 212 @Test 213 public void testEvalNaN() { 214 // To understand the use of "new Double(Double.NaN)" instead of 215 // "Double.NaN", see the Javadoc for Double.equals(). 216 assertEquals(new Double(Double.NaN), 217 new Double(term(3, 0, 2).eval(1.0))); 218 } 219 220 /////////////////////////////////////////////////////////////////////////////////////// 221 //// Equals Test 222 /////////////////////////////////////////////////////////////////////////////////////// 223 224 @Test 225 public void testEquals() { 226 assertEquals(term(3, 5), term(3, 5)); 227 assertEquals(term(1, 2, 4), term(1, 2, 4)); 228 assertEquals(term(-2, 4, 2), term(1, -2, 2)); 229 } 230 @Test 231 public void testNotEqualsReg() { 232 assertThat(term(4, 6), not(term(7, 8))); 233 } 234 235 @Test 236 public void testEqualsZeroCoeff() { 237 assertEquals(term(0, 0), term(0, 0)); 238 assertEquals(term(0, 1), term(0, 0)); 239 } 240 241 @Test 242 public void testEqualsNotZeroCoeff() { 243 assertThat(term(0, 0), not(term(3, 5))); 244 } 245 246 @Test 247 public void testEqualsNaNCoeff() { 248 assertEquals(nanTerm, term(19, 0, 0)); 249 assertEquals(nanTerm, term(0, 0, 0)); 250 } 251 252 @Test 253 public void testEqualsNotNaNCoeff() { 254 assertThat(nanTerm, not(term(3, 5))); 255 assertThat(term(0, 3), not(nanTerm)); 256 } 257 258 /////////////////////////////////////////////////////////////////////////////////////// 259 //// ValueOf Test 260 /////////////////////////////////////////////////////////////////////////////////////// 261 262 // All tests below depend on constructor and equals. 263 264 private void testValueOf(String actual, RatTerm target) { 265 assertEquals(target, RatTerm.valueOf(actual)); 266 } 267 268 @Test 269 public void testValueOfSimple() { 270 testValueOf("x", term(1, 1)); 271 testValueOf("-x", term(-1, 1)); 272 } 273 274 @Test 275 public void testValueOfConst() { 276 testValueOf("2", term(2, 0)); 277 testValueOf("3/4", term(3, 4, 0)); 278 testValueOf("-4", term(-4, 0)); 279 testValueOf("-7/5", term(-7, 5, 0)); 280 } 281 282 @Test 283 public void testValueOfLeadingCoeff() { 284 testValueOf("2*x", term(2, 1)); 285 testValueOf("3/7*x", term(3, 7, 1)); 286 testValueOf("-4/3*x", term(-4, 3, 1)); 287 } 288 289 @Test 290 public void testValueOfPow() { 291 testValueOf("x^3", term(1, 3)); 292 testValueOf("-x^4", term(-1, 4)); 293 } 294 295 @Test 296 public void testValueOfFull() { 297 testValueOf("4*x^2", term(4, 2)); 298 testValueOf("2/5*x^6", term(2, 5, 6)); 299 testValueOf("-3/2*x^2", term(-3, 2, 2)); 300 } 301 302 @Test 303 public void testValueOfNaN() { 304 testValueOf("NaN", term(1, 0, 0)); 305 } 306 307 @Test 308 public void testValueOfZero() { 309 testValueOf("0", term(0, 0)); 310 } 311 312 /////////////////////////////////////////////////////////////////////////////////////// 313 //// toString Test 314 /////////////////////////////////////////////////////////////////////////////////////// 315 316 private void testToString(String target, RatTerm actual) { 317 assertEquals(target, actual.toString()); 318 } 319 320 @Test 321 public void testToStringSimple() { 322 testToString("x", term(1, 1)); 323 testToString("-x", term(-1, 1)); 324 } 325 326 @Test 327 public void testToStringConst() { 328 testToString("2", term(2, 0)); 329 testToString("3/4", term(3, 4, 0)); 330 testToString("-4", term(-4, 0)); 331 testToString("-7/5", term(-7, 5, 0)); 332 } 333 334 @Test 335 public void testToStringLeadingCoeff() { 336 testToString("2*x", term(2, 1)); 337 testToString("3/7*x", term(3, 7, 1)); 338 testToString("-4/3*x", term(-4, 3, 1)); 339 } 340 341 @Test 342 public void testToStringPow() { 343 testToString("x^3", term(1, 3)); 344 testToString("-x^4", term(-1, 4)); 345 } 346 347 @Test 348 public void testToStringFull() { 349 testToString("4*x^2", term(4, 2)); 350 testToString("2/5*x^6", term(2, 5, 6)); 351 testToString("-3/2*x^2", term(-3, 2, 2)); 352 } 353 354 @Test 355 public void testToStringNaN() { 356 testToString("NaN", term(1, 0, 0)); 357 } 358 359 @Test 360 public void testToStringZero() { 361 testToString("0", term(0, 0)); 362 } 363 364 /////////////////////////////////////////////////////////////////////////////////////// 365 //// Add Test 366 /////////////////////////////////////////////////////////////////////////////////////// 367 //Relies on RatTerm equals method and RatNum add method is correct 368 369 @Test // Addition with Whole Number Coefficient 370 public void testAddWholeNumCoeff() { 371 assertEquals(term(3, 0), term(1, 0).add(term(2, 0))); //Zero Exponent Value 372 assertEquals(term(4, 2), term(3, 2).add(term(1, 2))); //Non Zero Exponent 373 } 374 375 @Test // Addition with Fractional Number Coefficient 376 public void testAddFracNumCoeff() { 377 assertEquals(term(1, 2, 3), term(1, 6, 3).add(term(1, 3, 3))); 378 assertEquals(term(1, 8, 1), term(1, 4, 1).add(term(-1, 8, 1))); 379 assertEquals(term(-1, 8, 1), term(-1, 4, 1).add(term(1, 8, 1))); 380 } 381 382 @Test // Addition Associativity 383 public void testAddAssociativity() { 384 //Whole Number Coefficient 385 assertEquals(term(6, 0), term(1, 0).add(term(2, 0)).add(term(3,0))); 386 assertEquals(term(6, 0), term(3, 0).add(term(2, 0)).add(term(1,0))); 387 388 //Fractional Number Coefficient 389 assertEquals(term(7, 8, 3), term(1, 8, 3).add(term(1, 4, 3)).add(term(1, 2, 3))); 390 assertEquals(term(7, 8, 3), term(1, 2, 3).add(term(1, 4, 3)).add(term(1, 8, 3))); 391 } 392 393 @Test // Addition Commutative 394 public void testAddCommutativity() { 395 assertEquals(term(1, 2, 3), term(1, 3, 3).add(term(1, 6, 3))); 396 assertEquals(term(3, 0), term(2, 0).add(term(1, 0))); 397 } 398 399 @Test // Zero Term + Zero Term == Zero Term 400 public void testAddZeroToZero() { 401 assertEquals(zeroTerm, zeroTerm.add(zeroTerm)); 402 } 403 404 @Test // t + Zero Term == t && Zero Term + t == t 405 public void testAddZeroToNonZero() { 406 RatTerm t = term(-2, 3); 407 assertEquals(t, zeroTerm.add(t)); 408 assertEquals(t, t.add(zeroTerm)); 409 } 410 411 @Test // NaN + NaN == NaN 412 public void testAddNaNtoNaN() { 413 assertEquals(nanTerm, nanTerm.add(nanTerm)); 414 } 415 416 @Test // t + NaN == NaN 417 public void testAddNaNtoNonNaN() { 418 assertEquals(nanTerm, nanTerm.add(term(3, 4))); 419 assertEquals(nanTerm, term(3, 4).add(nanTerm)); 420 } 421 422 /////////////////////////////////////////////////////////////////////////////////////// 423 //// Subtract Test 424 /////////////////////////////////////////////////////////////////////////////////////// 425 426 //Also Tests Addition inverse property 427 428 @Test // Subtraction with Whole Number Coefficient 429 public void testSubtractWholeNumCoeff() { 430 assertEquals(term(1, 0), term(2, 0).sub(term(1, 0))); 431 assertEquals(term(-1, 0), term(1, 0).sub(term(2, 0))); 432 assertEquals(term(2, 2), term(3, 2).sub(term(1, 2))); 433 } 434 435 @Test // Subtraction with Fractional Number Coefficient 436 public void testSubtractFractionalNumCoeff() { 437 assertEquals(term(-1, 6, 3), term(1, 6, 3).sub(term(1, 3, 3))); 438 assertEquals(term(3, 8, 1), term(1, 4, 1).sub(term(-1, 8, 1))); 439 assertEquals(term(-3, 8, 1), term(-1, 4, 1).sub(term(1, 8, 1))); 440 } 441 442 @Test // Zero Term - Zero Term == Zero Term 443 public void testSubtractZeroFromZero() { 444 assertEquals(zeroTerm, zeroTerm.sub(zeroTerm)); 445 } 446 447 //Following test method depends on correctness of negate 448 @Test // t - Zero Term == t && Zero Term - t == -t 449 public void testSubtractZeroAndNonZero() { 450 RatTerm t = term(-2, 3); 451 assertEquals(t.negate(), zeroTerm.sub(t)); 452 assertEquals(t, t.sub(zeroTerm)); 453 } 454 455 @Test // NaN - NaN == NaN 456 public void testSubtractNaNtoNaN() { 457 assertEquals(nanTerm, nanTerm.sub(nanTerm)); 458 } 459 460 @Test // t - NaN == NaN && NaN - t == NaN 461 public void testSubtractNaNtoNonNaN() { 462 assertEquals(nanTerm, nanTerm.sub(term(3, 4))); 463 assertEquals(nanTerm, term(3, 4).sub(nanTerm)); 464 } 465 466 /////////////////////////////////////////////////////////////////////////////////////// 467 //// Multiplication Test 468 /////////////////////////////////////////////////////////////////////////////////////// 469 470 @Test // Multiplication with Whole Number Coefficient 471 public void testMultiplicationWholeNumCoeff() { 472 assertEquals(term(2, 0), term(1, 0).mul(term(2, 0))); //Zero Exponent Value 473 assertEquals(term(30, 4), term(3, 2).mul(term(10, 2))); //Non Zero Exponent 474 } 475 476 @Test // Multiplication with Fractional Number Coefficient 477 public void testMultiplicationFracNumCoeff() { 478 assertEquals(term(1, 18, 6), term(1, 6, 3).mul(term(1, 3, 3))); 479 assertEquals(term(-1, 32, 2), term(1, 4, 1).mul(term(-1, 8, 1))); 480 } 481 482 @Test // Multiplication with different Exponent Values 483 public void testMultiplicationDifferentExpVal() { 484 assertEquals(term(3*2, 6*3, 9+3), term(3, 6, 9).mul(term(2, 3, 3))); 485 assertEquals(term(1*-1, 8*4, -1+1), term(1, 4, -1).mul(term(-1, 8, 1))); 486 assertEquals(term(-1*1, 4*8, 100+10), term(-1, 4, 100).mul(term(1, 8, 10))); 487 } 488 489 @Test // Multiplication Associativity 490 public void testMultiplicationAssociativity() { 491 //Whole Number Coefficient 492 assertEquals(term(12,5).mul(term(11, 4)).mul(term(10, 3)), 493 term(10, 3).mul(term(11, 4)).mul(term(12,5))); 494 495 //Fractional Number Coefficient 496 assertEquals(term(4, 9, 3).mul(term(2, 9, 2)).mul(term(1, 3, 1)), 497 term(1, 3, 1).mul(term(2, 9, 2)).mul(term(4, 9, 3))); 498 } 499 500 @Test // Multiplication Commutative 501 public void testMultiplicationCommutativity() { 502 //Whole Number Coefficient 503 assertEquals(term(7, 1).mul(term(3, 9)), term(3, 9).mul(term(7, 1))); 504 505 //Fractional Number Coefficient 506 assertEquals(term(1, 6, 3).mul(term(1, 3, 3)), term(1, 3, 3).mul(term(1, 6, 3))); 507 } 508 509 @Test // Zero Term * Zero Term == Zero Term 510 public void testMultiplicationZeroToZero() { 511 assertEquals(zeroTerm, zeroTerm.mul(zeroTerm)); 512 } 513 514 @Test // t * Zero Term == Zero Term && Zero Term * t == Zero Term 515 public void testMultiplicationZeroToNonZero() { 516 RatTerm t = term(-2, 3); 517 assertEquals(zeroTerm, zeroTerm.mul(t)); 518 assertEquals(zeroTerm, t.mul(zeroTerm)); 519 } 520 521 @Test // NaN * NaN == NaN 522 public void testMultiplicationNaNtoNaN() { 523 assertEquals(nanTerm, nanTerm.mul(nanTerm)); 524 } 525 526 @Test // t * NaN == NaN 527 public void testMultiplicationNaNtoNonNaN() { 528 assertEquals(nanTerm, nanTerm.mul(term(3, 4))); 529 assertEquals(nanTerm, term(3, 4).mul(nanTerm)); 530 } 531 532 @Test // a * 1 == a 533 public void testMultiplicationIdentity() { 534 assertEquals(term(4, 3), term(4, 3).mul(one)); 535 } 536 537 /////////////////////////////////////////////////////////////////////////////////////// 538 //// Division Test 539 /////////////////////////////////////////////////////////////////////////////////////// 540 541 @Test // Division with Whole Number Coefficient 542 public void testDivisionWholeNumCoeff() { 543 assertEquals(term(3, 0), term(3, 2).div(term(1, 2))); 544 assertEquals(term(2, 1), term(2, 1).div(term(1, 0))); 545 assertEquals(term(8, 3), term(-16, 5).div(term(-2, 2))); 546 } 547 548 @Test // Division with Fractional Number Coefficient 549 public void testDivisionFractionalNumCoeff() { 550 assertEquals(term(1, 2, 0), term(1, 0).div(term(2, 0))); 551 assertEquals(term(1, 2, 0), term(1, 6, 3).div(term(1, 3, 3))); 552 assertEquals(term(-2, 0), term(1, 4, 1).div(term(-1, 8, 1))); 553 } 554 555 @Test // Zero Term / Zero Term == NaN 556 public void testDivisionZeroFromZero() { 557 assertEquals(nanTerm, zeroTerm.div(zeroTerm)); 558 } 559 560 //Following test method depends on correctness of negate 561 @Test // t / Zero Term == NaN && Zero Term / t == 0 562 public void testDivisionZeroAndNonZero() { 563 RatTerm t = term(-2, 3); 564 assertEquals(zeroTerm, zeroTerm.div(t)); 565 assertEquals(nanTerm, t.div(zeroTerm)); 566 } 567 568 @Test // NaN / NaN == NaN 569 public void testDivisionNaNtoNaN() { 570 assertEquals(nanTerm, nanTerm.div(nanTerm)); 571 } 572 573 @Test // t / NaN == NaN && NaN / t == NaN 574 public void testDivisionNaNtoNonNaN() { 575 assertEquals(nanTerm, nanTerm.div(term(3, 4))); 576 assertEquals(nanTerm, term(3, 4).div(nanTerm)); 577 } 578 579 @Test // a / 1 == a 580 public void testDivisionByOne() { 581 assertEquals(term(4, 3), term(4, 3).div(one)); 582 } 583 584 /////////////////////////////////////////////////////////////////////////////////////// 585 //// Differentiation Test 586 /////////////////////////////////////////////////////////////////////////////////////// 587 //As stated in specification for any term b is assumed >= 0 588 //Note : Derivative of f = f' 589 590 // (NaN)' = NaN 591 @Test 592 public void testDifferentiateNaN(){ 593 assertEquals(nanTerm, nanTerm.differentiate()); 594 assertEquals(nanTerm, (new RatTerm(RatNum.NaN, 0)).differentiate()); 595 } 596 597 // (RatTerm.ZERO)' = RatTerm.ZERO 598 @Test 599 public void testDifferentiateZero(){ 600 assertEquals(term(0, 0), term(0, 0).differentiate()); 601 } 602 603 // constant a => (a)' = 0 604 @Test 605 public void testDifferentiateConstantNonZero(){ 606 assertEquals(term(0, 0), term(99, 0).differentiate()); 607 assertEquals(term(0, 0), term(1, 0).differentiate()); 608 } 609 610 // Constant Multiple Rule (af)' = af' 611 @Test 612 public void testDifferentiateMultiplicationRule(){ 613 // Whole Number Coefficient 614 assertEquals(term(5, 0).mul(term(1,3).differentiate()), 615 (term(5, 0).mul(term(1,3))).differentiate()); 616 617 // Fractional Number Coefficient 618 assertEquals(term(2,3,0).mul(term(1,4,3).differentiate()), 619 (term(2,3,0).mul(term(1,4,3))).differentiate()); 620 } 621 622 // Polynomial Power Rule (ax^b) = (a*b)*x^(b-1) 623 @Test 624 public void testDifferentiatePowerRule(){ 625 assertEquals(term(1, 0), term(1, 1).differentiate()); 626 assertEquals(term(5, 0), term(5, 1).differentiate()); 627 assertEquals(term(14, 1), term(7, 2).differentiate()); 628 assertEquals(term(-2, 3), term(-1, 2, 4).differentiate()); 629 } 630 631 // Sum rule (f + g)' = f' + g' 632 @Test 633 public void testDifferentiateSumRule(){ 634 // Whole Number Coefficient 635 assertEquals(((term(5, 2)).add(term(1,2))).differentiate(), 636 (term(5, 2).differentiate()).add(term(1,2).differentiate())); 637 638 // Fractional Number Coefficient 639 assertEquals(((term(5, 2, 7)).add(term(1,3, 7))).differentiate(), 640 (term(5, 2, 7).differentiate()).add(term(1,3, 7).differentiate())); 641 } 642 643 // Subtraction rule (f - g)' = f' - g' 644 @Test 645 public void testDifferentiateSubtractionRule(){ 646 // Whole Number Coefficient 647 assertEquals(((term(5, 2)).sub(term(1,2))).differentiate(), 648 (term(5, 2).differentiate()).sub(term(1,2).differentiate())); 649 650 // Fractional Number Coefficient 651 assertEquals(((term(5, 2, 7)).sub(term(1,3, 7))).differentiate(), 652 (term(5, 2, 7).differentiate()).sub(term(1,3, 7).differentiate())); 653 } 654 655 // Product Rule h(x) = f(x)*g(x) => h'(x) = f'(x)g(x) + f(x)g'(x) 656 @Test 657 public void testDifferentiateProductRule(){ 658 // Whole Number Coefficient 659 RatTerm init_product = term(12, 4).mul(term(5,4)); 660 RatTerm deriv_pt1 = (term(12, 4).differentiate()).mul(term(5,4)); 661 RatTerm deriv_pt2 = term(12, 4).mul(term(5,4).differentiate()); 662 663 assertEquals(init_product.differentiate() , deriv_pt1.add(deriv_pt2)); 664 665 // Fractional Number Coefficient 666 init_product = term(1,2, 4).mul(term(2,3,4)); 667 deriv_pt1 = (term(1,2, 4).differentiate()).mul(term(2,3,4)); 668 deriv_pt2 = term(1,2, 4).mul(term(2,3,4).differentiate()); 669 670 assertEquals(init_product.differentiate() , deriv_pt1.add(deriv_pt2)); 671 } 672 673 /////////////////////////////////////////////////////////////////////////////////////// 674 //// AntiDifferentiation Test 675 /////////////////////////////////////////////////////////////////////////////////////// 676 //As stated in specification for any term b is assumed >= 0 and Integration Constant is Zero 677 //Note : AntiDerivative of f(x) = F(x) , f = F 678 //Note : c = Arbitrary Constant 679 680 // Constant Rule f(x) = c => F = c*x 681 @Test 682 public void testAntiDifferentiateConstantRule() { 683 // Zero 684 assertEquals(zeroTerm, zeroTerm.antiDifferentiate()); 685 686 // Non Zero constant 687 assertEquals(term(3,1), term(3,0).antiDifferentiate()); 688 } 689 690 // Constant Multiple Rule f(x) = c*g(x) => F = c*G(x) 691 @Test 692 public void testAntiDifferentiateConstantMultipleRule() { 693 // Whole Number Coefficient 694 assertEquals(((term(5, 0)).mul(term(1,2))).antiDifferentiate(), 695 term(5, 0).mul(term(1,2).antiDifferentiate())); 696 697 // Fraction Coefficient 698 assertEquals(((term(1,500, 0)).mul(term(1,2,3))).antiDifferentiate(), 699 term(1,500, 0).mul(term(1,2,3).antiDifferentiate())); 700 } 701 702 // Power Rule f(x) = x^a => F = (x^(a+1))/(a+1) 703 @Test 704 public void testAntiDifferentiatePowerRule() { 705 assertEquals(term(1, 2), term(2, 1).antiDifferentiate()); 706 assertEquals(term(4, 3, 3), term(4, 2).antiDifferentiate()); 707 } 708 709 // Sum Rule if h(x) = f(x) + g(x) => H(x) = F(x) + G(x) 710 @Test 711 public void testAntiDifferentiateSumRule() { 712 // Whole Number Coefficient 713 assertEquals((term(1, 2).add(term(3,2))).antiDifferentiate(), 714 term(1, 2).antiDifferentiate().add(term(3,2).antiDifferentiate())); 715 716 // Fraction Coefficient 717 assertEquals((term(3,4,5).add(term(1,2,5))).antiDifferentiate(), 718 term(3,4,5).antiDifferentiate().add(term(1,2,5).antiDifferentiate())); 719 } 720 721 // Difference Rule if h(x) = f(x) - g(x) => H(x) = F(x) - G(x) 722 @Test 723 public void testAntiDifferentiateDifferenceRule() { 724 // Whole Number Coefficient 725 assertEquals((term(1, 2).sub(term(3,2))).antiDifferentiate(), 726 term(1, 2).antiDifferentiate().sub(term(3,2).antiDifferentiate())); 727 728 // Fraction Coefficient 729 assertEquals((term(3,4,5).sub(term(1,2,5))).antiDifferentiate(), 730 term(3,4,5).antiDifferentiate().sub(term(1,2,5).antiDifferentiate())); 731 } 732 733 /////////////////////////////////////////////////////////////////////////////////////// 734 //// HashCode Test 735 /////////////////////////////////////////////////////////////////////////////////////// 736 737 // Same Object same hashcode after multiple queries 738 @Test 739 public void testHashCodeSameObject() { 740 RatTerm t = term(23,45); 741 for (int i = 0; i < 25 ; i++){ //Verify Non random Hascode 742 assertEquals(t.hashCode(), t.hashCode()); 743 } 744 } 745 746 // Equals Objects same hashcode 747 @Test 748 public void testHashCodeEqualDiffObjects() { 749 RatTerm t = term(23,45); 750 RatTerm t2 = term(23,45); 751 assertEquals(t.hashCode(), t2.hashCode()); 752 } 753 754 // Non Equal Object different hashcode 755 @Test 756 public void testHashCodeNonEqualObjects() { 757 RatTerm t = term(1,2); 758 RatTerm t2 = term(3,2); 759 RatTerm t3 = term(1,3); 760 assertFalse(t.hashCode() == t2.hashCode()); 761 assertFalse(t.hashCode() == t3.hashCode()); 762 } 763}