0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017: /*
0018: * Created on May 23, 2005
0019: *
0020: */
0021: package org.apache.poi.hssf.record.formula.functions;
0022:
0023: /**
0024: * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
0025: *
0026: */
0027: public class TestMathX extends AbstractNumericTestCase {
0028:
0029: public void testAcosh() {
0030: double d = 0;
0031:
0032: d = MathX.acosh(0);
0033: assertTrue("Acosh 0 is NaN", Double.isNaN(d));
0034:
0035: d = MathX.acosh(1);
0036: assertEquals("Acosh 1 ", 0, d);
0037:
0038: d = MathX.acosh(-1);
0039: assertTrue("Acosh -1 is NaN", Double.isNaN(d));
0040:
0041: d = MathX.acosh(100);
0042: assertEquals("Acosh 100 ", 5.298292366d, d);
0043:
0044: d = MathX.acosh(101.001);
0045: assertEquals("Acosh 101.001 ", 5.308253091d, d);
0046:
0047: d = MathX.acosh(200000);
0048: assertEquals("Acosh 200000 ", 12.89921983d, d);
0049:
0050: }
0051:
0052: public void testAsinh() {
0053: double d = 0;
0054:
0055: d = MathX.asinh(0);
0056: assertEquals("asinh 0", d, 0);
0057:
0058: d = MathX.asinh(1);
0059: assertEquals("asinh 1 ", 0.881373587, d);
0060:
0061: d = MathX.asinh(-1);
0062: assertEquals("asinh -1 ", -0.881373587, d);
0063:
0064: d = MathX.asinh(-100);
0065: assertEquals("asinh -100 ", -5.298342366, d);
0066:
0067: d = MathX.asinh(100);
0068: assertEquals("asinh 100 ", 5.298342366, d);
0069:
0070: d = MathX.asinh(200000);
0071: assertEquals("asinh 200000", 12.899219826096400, d);
0072:
0073: d = MathX.asinh(-200000);
0074: assertEquals("asinh -200000 ", -12.899223853137, d);
0075:
0076: }
0077:
0078: public void testAtanh() {
0079: double d = 0;
0080: d = MathX.atanh(0);
0081: assertEquals("atanh 0", d, 0);
0082:
0083: d = MathX.atanh(1);
0084: assertEquals("atanh 1 ", Double.POSITIVE_INFINITY, d);
0085:
0086: d = MathX.atanh(-1);
0087: assertEquals("atanh -1 ", Double.NEGATIVE_INFINITY, d);
0088:
0089: d = MathX.atanh(-100);
0090: assertEquals("atanh -100 ", Double.NaN, d);
0091:
0092: d = MathX.atanh(100);
0093: assertEquals("atanh 100 ", Double.NaN, d);
0094:
0095: d = MathX.atanh(200000);
0096: assertEquals("atanh 200000", Double.NaN, d);
0097:
0098: d = MathX.atanh(-200000);
0099: assertEquals("atanh -200000 ", Double.NaN, d);
0100:
0101: d = MathX.atanh(0.1);
0102: assertEquals("atanh 0.1", 0.100335348, d);
0103:
0104: d = MathX.atanh(-0.1);
0105: assertEquals("atanh -0.1 ", -0.100335348, d);
0106:
0107: }
0108:
0109: public void testCosh() {
0110: double d = 0;
0111: d = MathX.cosh(0);
0112: assertEquals("cosh 0", 1, d);
0113:
0114: d = MathX.cosh(1);
0115: assertEquals("cosh 1 ", 1.543080635, d);
0116:
0117: d = MathX.cosh(-1);
0118: assertEquals("cosh -1 ", 1.543080635, d);
0119:
0120: d = MathX.cosh(-100);
0121: assertEquals("cosh -100 ", 1.344058570908070E+43, d);
0122:
0123: d = MathX.cosh(100);
0124: assertEquals("cosh 100 ", 1.344058570908070E+43, d);
0125:
0126: d = MathX.cosh(15);
0127: assertEquals("cosh 15", 1634508.686, d);
0128:
0129: d = MathX.cosh(-15);
0130: assertEquals("cosh -15 ", 1634508.686, d);
0131:
0132: d = MathX.cosh(0.1);
0133: assertEquals("cosh 0.1", 1.005004168, d);
0134:
0135: d = MathX.cosh(-0.1);
0136: assertEquals("cosh -0.1 ", 1.005004168, d);
0137:
0138: }
0139:
0140: public void testTanh() {
0141: double d = 0;
0142: d = MathX.tanh(0);
0143: assertEquals("tanh 0", 0, d);
0144:
0145: d = MathX.tanh(1);
0146: assertEquals("tanh 1 ", 0.761594156, d);
0147:
0148: d = MathX.tanh(-1);
0149: assertEquals("tanh -1 ", -0.761594156, d);
0150:
0151: d = MathX.tanh(-100);
0152: assertEquals("tanh -100 ", -1, d);
0153:
0154: d = MathX.tanh(100);
0155: assertEquals("tanh 100 ", 1, d);
0156:
0157: d = MathX.tanh(15);
0158: assertEquals("tanh 15", 1, d);
0159:
0160: d = MathX.tanh(-15);
0161: assertEquals("tanh -15 ", -1, d);
0162:
0163: d = MathX.tanh(0.1);
0164: assertEquals("tanh 0.1", 0.099667995, d);
0165:
0166: d = MathX.tanh(-0.1);
0167: assertEquals("tanh -0.1 ", -0.099667995, d);
0168:
0169: }
0170:
0171: public void testMax() {
0172: double[] d = new double[100];
0173: d[0] = 1.1;
0174: d[1] = 2.1;
0175: d[2] = 3.1;
0176: d[3] = 4.1;
0177: d[4] = 5.1;
0178: d[5] = 6.1;
0179: d[6] = 7.1;
0180: d[7] = 8.1;
0181: d[8] = 9.1;
0182: d[9] = 10.1;
0183: d[10] = 11.1;
0184: d[11] = 12.1;
0185: d[12] = 13.1;
0186: d[13] = 14.1;
0187: d[14] = 15.1;
0188: d[15] = 16.1;
0189: d[16] = 17.1;
0190: d[17] = 18.1;
0191: d[18] = 19.1;
0192: d[19] = 20.1;
0193:
0194: double m = MathX.max(d);
0195: assertEquals("Max ", 20.1, m);
0196:
0197: d = new double[1000];
0198: m = MathX.max(d);
0199: assertEquals("Max ", 0, m);
0200:
0201: d[0] = -1.1;
0202: d[1] = 2.1;
0203: d[2] = -3.1;
0204: d[3] = 4.1;
0205: d[4] = -5.1;
0206: d[5] = 6.1;
0207: d[6] = -7.1;
0208: d[7] = 8.1;
0209: d[8] = -9.1;
0210: d[9] = 10.1;
0211: d[10] = -11.1;
0212: d[11] = 12.1;
0213: d[12] = -13.1;
0214: d[13] = 14.1;
0215: d[14] = -15.1;
0216: d[15] = 16.1;
0217: d[16] = -17.1;
0218: d[17] = 18.1;
0219: d[18] = -19.1;
0220: d[19] = 20.1;
0221: m = MathX.max(d);
0222: assertEquals("Max ", 20.1, m);
0223:
0224: d = new double[20];
0225: d[0] = -1.1;
0226: d[1] = -2.1;
0227: d[2] = -3.1;
0228: d[3] = -4.1;
0229: d[4] = -5.1;
0230: d[5] = -6.1;
0231: d[6] = -7.1;
0232: d[7] = -8.1;
0233: d[8] = -9.1;
0234: d[9] = -10.1;
0235: d[10] = -11.1;
0236: d[11] = -12.1;
0237: d[12] = -13.1;
0238: d[13] = -14.1;
0239: d[14] = -15.1;
0240: d[15] = -16.1;
0241: d[16] = -17.1;
0242: d[17] = -18.1;
0243: d[18] = -19.1;
0244: d[19] = -20.1;
0245: m = MathX.max(d);
0246: assertEquals("Max ", -1.1, m);
0247:
0248: }
0249:
0250: public void testMin() {
0251: double[] d = new double[100];
0252: d[0] = 1.1;
0253: d[1] = 2.1;
0254: d[2] = 3.1;
0255: d[3] = 4.1;
0256: d[4] = 5.1;
0257: d[5] = 6.1;
0258: d[6] = 7.1;
0259: d[7] = 8.1;
0260: d[8] = 9.1;
0261: d[9] = 10.1;
0262: d[10] = 11.1;
0263: d[11] = 12.1;
0264: d[12] = 13.1;
0265: d[13] = 14.1;
0266: d[14] = 15.1;
0267: d[15] = 16.1;
0268: d[16] = 17.1;
0269: d[17] = 18.1;
0270: d[18] = 19.1;
0271: d[19] = 20.1;
0272:
0273: double m = MathX.min(d);
0274: assertEquals("Min ", 0, m);
0275:
0276: d = new double[20];
0277: d[0] = 1.1;
0278: d[1] = 2.1;
0279: d[2] = 3.1;
0280: d[3] = 4.1;
0281: d[4] = 5.1;
0282: d[5] = 6.1;
0283: d[6] = 7.1;
0284: d[7] = 8.1;
0285: d[8] = 9.1;
0286: d[9] = 10.1;
0287: d[10] = 11.1;
0288: d[11] = 12.1;
0289: d[12] = 13.1;
0290: d[13] = 14.1;
0291: d[14] = 15.1;
0292: d[15] = 16.1;
0293: d[16] = 17.1;
0294: d[17] = 18.1;
0295: d[18] = 19.1;
0296: d[19] = 20.1;
0297:
0298: m = MathX.min(d);
0299: assertEquals("Min ", 1.1, m);
0300:
0301: d = new double[1000];
0302: m = MathX.min(d);
0303: assertEquals("Min ", 0, m);
0304:
0305: d[0] = -1.1;
0306: d[1] = 2.1;
0307: d[2] = -3.1;
0308: d[3] = 4.1;
0309: d[4] = -5.1;
0310: d[5] = 6.1;
0311: d[6] = -7.1;
0312: d[7] = 8.1;
0313: d[8] = -9.1;
0314: d[9] = 10.1;
0315: d[10] = -11.1;
0316: d[11] = 12.1;
0317: d[12] = -13.1;
0318: d[13] = 14.1;
0319: d[14] = -15.1;
0320: d[15] = 16.1;
0321: d[16] = -17.1;
0322: d[17] = 18.1;
0323: d[18] = -19.1;
0324: d[19] = 20.1;
0325: m = MathX.min(d);
0326: assertEquals("Min ", -19.1, m);
0327:
0328: d = new double[20];
0329: d[0] = -1.1;
0330: d[1] = -2.1;
0331: d[2] = -3.1;
0332: d[3] = -4.1;
0333: d[4] = -5.1;
0334: d[5] = -6.1;
0335: d[6] = -7.1;
0336: d[7] = -8.1;
0337: d[8] = -9.1;
0338: d[9] = -10.1;
0339: d[10] = -11.1;
0340: d[11] = -12.1;
0341: d[12] = -13.1;
0342: d[13] = -14.1;
0343: d[14] = -15.1;
0344: d[15] = -16.1;
0345: d[16] = -17.1;
0346: d[17] = -18.1;
0347: d[18] = -19.1;
0348: d[19] = -20.1;
0349: m = MathX.min(d);
0350: assertEquals("Min ", -20.1, m);
0351: }
0352:
0353: public void testProduct() {
0354: double[] d = new double[100];
0355: d[0] = 1.1;
0356: d[1] = 2.1;
0357: d[2] = 3.1;
0358: d[3] = 4.1;
0359: d[4] = 5.1;
0360: d[5] = 6.1;
0361: d[6] = 7.1;
0362: d[7] = 8.1;
0363: d[8] = 9.1;
0364: d[9] = 10.1;
0365: d[10] = 11.1;
0366: d[11] = 12.1;
0367: d[12] = 13.1;
0368: d[13] = 14.1;
0369: d[14] = 15.1;
0370: d[15] = 16.1;
0371: d[16] = 17.1;
0372: d[17] = 18.1;
0373: d[18] = 19.1;
0374: d[19] = 20.1;
0375:
0376: double m = MathX.min(d);
0377: assertEquals("Min ", 0, m);
0378:
0379: d = new double[20];
0380: d[0] = 1.1;
0381: d[1] = 2.1;
0382: d[2] = 3.1;
0383: d[3] = 4.1;
0384: d[4] = 5.1;
0385: d[5] = 6.1;
0386: d[6] = 7.1;
0387: d[7] = 8.1;
0388: d[8] = 9.1;
0389: d[9] = 10.1;
0390: d[10] = 11.1;
0391: d[11] = 12.1;
0392: d[12] = 13.1;
0393: d[13] = 14.1;
0394: d[14] = 15.1;
0395: d[15] = 16.1;
0396: d[16] = 17.1;
0397: d[17] = 18.1;
0398: d[18] = 19.1;
0399: d[19] = 20.1;
0400:
0401: m = MathX.min(d);
0402: assertEquals("Min ", 1.1, m);
0403:
0404: d = new double[1000];
0405: m = MathX.min(d);
0406: assertEquals("Min ", 0, m);
0407:
0408: d[0] = -1.1;
0409: d[1] = 2.1;
0410: d[2] = -3.1;
0411: d[3] = 4.1;
0412: d[4] = -5.1;
0413: d[5] = 6.1;
0414: d[6] = -7.1;
0415: d[7] = 8.1;
0416: d[8] = -9.1;
0417: d[9] = 10.1;
0418: d[10] = -11.1;
0419: d[11] = 12.1;
0420: d[12] = -13.1;
0421: d[13] = 14.1;
0422: d[14] = -15.1;
0423: d[15] = 16.1;
0424: d[16] = -17.1;
0425: d[17] = 18.1;
0426: d[18] = -19.1;
0427: d[19] = 20.1;
0428: m = MathX.min(d);
0429: assertEquals("Min ", -19.1, m);
0430:
0431: d = new double[20];
0432: d[0] = -1.1;
0433: d[1] = -2.1;
0434: d[2] = -3.1;
0435: d[3] = -4.1;
0436: d[4] = -5.1;
0437: d[5] = -6.1;
0438: d[6] = -7.1;
0439: d[7] = -8.1;
0440: d[8] = -9.1;
0441: d[9] = -10.1;
0442: d[10] = -11.1;
0443: d[11] = -12.1;
0444: d[12] = -13.1;
0445: d[13] = -14.1;
0446: d[14] = -15.1;
0447: d[15] = -16.1;
0448: d[16] = -17.1;
0449: d[17] = -18.1;
0450: d[18] = -19.1;
0451: d[19] = -20.1;
0452: m = MathX.min(d);
0453: assertEquals("Min ", -20.1, m);
0454: }
0455:
0456: public void testMod() {
0457: }
0458:
0459: public void testNChooseK() {
0460: int n = 100;
0461: int k = 50;
0462: double d = MathX.nChooseK(n, k);
0463: assertEquals("NChooseK ", 1.00891344545564E29, d);
0464:
0465: n = -1;
0466: k = 1;
0467: d = MathX.nChooseK(n, k);
0468: assertEquals("NChooseK ", Double.NaN, d);
0469:
0470: n = 1;
0471: k = -1;
0472: d = MathX.nChooseK(n, k);
0473: assertEquals("NChooseK ", Double.NaN, d);
0474:
0475: n = 0;
0476: k = 1;
0477: d = MathX.nChooseK(n, k);
0478: assertEquals("NChooseK ", Double.NaN, d);
0479:
0480: n = 1;
0481: k = 0;
0482: d = MathX.nChooseK(n, k);
0483: assertEquals("NChooseK ", 1, d);
0484:
0485: n = 10;
0486: k = 9;
0487: d = MathX.nChooseK(n, k);
0488: assertEquals("NChooseK ", 10, d);
0489:
0490: n = 10;
0491: k = 10;
0492: d = MathX.nChooseK(n, k);
0493: assertEquals("NChooseK ", 1, d);
0494:
0495: n = 10;
0496: k = 1;
0497: d = MathX.nChooseK(n, k);
0498: assertEquals("NChooseK ", 10, d);
0499:
0500: n = 1000;
0501: k = 1;
0502: d = MathX.nChooseK(n, k);
0503: assertEquals("NChooseK ", 1000, d); // awesome ;)
0504:
0505: n = 1000;
0506: k = 2;
0507: d = MathX.nChooseK(n, k);
0508: assertEquals("NChooseK ", 499500, d); // awesome ;)
0509:
0510: n = 13;
0511: k = 7;
0512: d = MathX.nChooseK(n, k);
0513: assertEquals("NChooseK ", 1716, d);
0514:
0515: }
0516:
0517: public void testSign() {
0518: final short minus = -1;
0519: final short zero = 0;
0520: final short plus = 1;
0521: double d = 0;
0522:
0523: assertEquals("Sign ", minus, MathX.sign(minus));
0524: assertEquals("Sign ", plus, MathX.sign(plus));
0525: assertEquals("Sign ", zero, MathX.sign(zero));
0526:
0527: d = 0;
0528: assertEquals("Sign ", zero, MathX.sign(d));
0529:
0530: d = -1.000001;
0531: assertEquals("Sign ", minus, MathX.sign(d));
0532:
0533: d = -.000001;
0534: assertEquals("Sign ", minus, MathX.sign(d));
0535:
0536: d = -1E-200;
0537: assertEquals("Sign ", minus, MathX.sign(d));
0538:
0539: d = Double.NEGATIVE_INFINITY;
0540: assertEquals("Sign ", minus, MathX.sign(d));
0541:
0542: d = -200.11;
0543: assertEquals("Sign ", minus, MathX.sign(d));
0544:
0545: d = -2000000000000.11;
0546: assertEquals("Sign ", minus, MathX.sign(d));
0547:
0548: d = 1.000001;
0549: assertEquals("Sign ", plus, MathX.sign(d));
0550:
0551: d = .000001;
0552: assertEquals("Sign ", plus, MathX.sign(d));
0553:
0554: d = 1E-200;
0555: assertEquals("Sign ", plus, MathX.sign(d));
0556:
0557: d = Double.POSITIVE_INFINITY;
0558: assertEquals("Sign ", plus, MathX.sign(d));
0559:
0560: d = 200.11;
0561: assertEquals("Sign ", plus, MathX.sign(d));
0562:
0563: d = 2000000000000.11;
0564: assertEquals("Sign ", plus, MathX.sign(d));
0565:
0566: }
0567:
0568: public void testSinh() {
0569: double d = 0;
0570: d = MathX.sinh(0);
0571: assertEquals("sinh 0", 0, d);
0572:
0573: d = MathX.sinh(1);
0574: assertEquals("sinh 1 ", 1.175201194, d);
0575:
0576: d = MathX.sinh(-1);
0577: assertEquals("sinh -1 ", -1.175201194, d);
0578:
0579: d = MathX.sinh(-100);
0580: assertEquals("sinh -100 ", -1.344058570908070E+43, d);
0581:
0582: d = MathX.sinh(100);
0583: assertEquals("sinh 100 ", 1.344058570908070E+43, d);
0584:
0585: d = MathX.sinh(15);
0586: assertEquals("sinh 15", 1634508.686, d);
0587:
0588: d = MathX.sinh(-15);
0589: assertEquals("sinh -15 ", -1634508.686, d);
0590:
0591: d = MathX.sinh(0.1);
0592: assertEquals("sinh 0.1", 0.10016675, d);
0593:
0594: d = MathX.sinh(-0.1);
0595: assertEquals("sinh -0.1 ", -0.10016675, d);
0596:
0597: }
0598:
0599: public void testSum() {
0600: double[] d = new double[100];
0601: d[0] = 1.1;
0602: d[1] = 2.1;
0603: d[2] = 3.1;
0604: d[3] = 4.1;
0605: d[4] = 5.1;
0606: d[5] = 6.1;
0607: d[6] = 7.1;
0608: d[7] = 8.1;
0609: d[8] = 9.1;
0610: d[9] = 10.1;
0611: d[10] = 11.1;
0612: d[11] = 12.1;
0613: d[12] = 13.1;
0614: d[13] = 14.1;
0615: d[14] = 15.1;
0616: d[15] = 16.1;
0617: d[16] = 17.1;
0618: d[17] = 18.1;
0619: d[18] = 19.1;
0620: d[19] = 20.1;
0621:
0622: double s = MathX.sum(d);
0623: assertEquals("Sum ", 212, s);
0624:
0625: d = new double[1000];
0626: s = MathX.sum(d);
0627: assertEquals("Sum ", 0, s);
0628:
0629: d[0] = -1.1;
0630: d[1] = 2.1;
0631: d[2] = -3.1;
0632: d[3] = 4.1;
0633: d[4] = -5.1;
0634: d[5] = 6.1;
0635: d[6] = -7.1;
0636: d[7] = 8.1;
0637: d[8] = -9.1;
0638: d[9] = 10.1;
0639: d[10] = -11.1;
0640: d[11] = 12.1;
0641: d[12] = -13.1;
0642: d[13] = 14.1;
0643: d[14] = -15.1;
0644: d[15] = 16.1;
0645: d[16] = -17.1;
0646: d[17] = 18.1;
0647: d[18] = -19.1;
0648: d[19] = 20.1;
0649: s = MathX.sum(d);
0650: assertEquals("Sum ", 10, s);
0651:
0652: d[0] = -1.1;
0653: d[1] = -2.1;
0654: d[2] = -3.1;
0655: d[3] = -4.1;
0656: d[4] = -5.1;
0657: d[5] = -6.1;
0658: d[6] = -7.1;
0659: d[7] = -8.1;
0660: d[8] = -9.1;
0661: d[9] = -10.1;
0662: d[10] = -11.1;
0663: d[11] = -12.1;
0664: d[12] = -13.1;
0665: d[13] = -14.1;
0666: d[14] = -15.1;
0667: d[15] = -16.1;
0668: d[16] = -17.1;
0669: d[17] = -18.1;
0670: d[18] = -19.1;
0671: d[19] = -20.1;
0672: s = MathX.sum(d);
0673: assertEquals("Sum ", -212, s);
0674:
0675: }
0676:
0677: public void testSumproduct() {
0678: double d = 0;
0679: double[][] darr = new double[][] { { 0, 0.11, 23.23 },
0680: { 1, 0.22, 46.46 }, { 2, 0.33, 69.69 },
0681: { 3, 0.44, 92.92 }, { 4, 0.55, 116.15 },
0682: { 5, 0.66, 139.38 }, { 6, 0.77, 162.61 },
0683: { 7, 0.88, 185.84 }, { 8, 0.99, 209.07 },
0684: { 9, 1.1, 232.3 }, { 10, 1.21, 255.53 } };
0685: d = MathX.sumproduct(darr);
0686: assertEquals("Sumproduct ", 4.243234425E+22, d);
0687: darr = new double[][] { { 0, 0.11, 23.23 }, { 0, 0.22, 46.46 },
0688: { 0, 0.33, 69.69 }, { 0, 0.44, 92.92 },
0689: { 0, 0.55, 116.15 }, { 0, 0.66, 139.38 },
0690: { 0, 0.77, 162.61 }, { 0, 0.88, 185.84 },
0691: { 0, 0.99, 209.07 }, { 0, 1.1, 232.3 },
0692: { 0, 1.21, 255.53 } };
0693: d = MathX.sumproduct(darr);
0694: assertEquals("Sumproduct ", 4.243234425E+22, d);
0695:
0696: darr = new double[][] {
0697: { 0, 0, 0, 0, 0, 0, 0, 0 },
0698: { 0.11, 0.22, 0.33, 0.44, 0.55, 0.66, 0.77, 0.88 },
0699: { 23.23, 46.46, 69.69, 92.92, 116.15, 139.38, 162.61,
0700: 185.84 } };
0701: d = MathX.sumproduct(darr);
0702: assertEquals("Sumproduct ", 0, d);
0703:
0704: darr = new double[][] {
0705: { 0, 1, 2, 3, 4, 5, 6, 7 },
0706: { 0.11, 0.22, 0.33, 0.44, 0.55, 0.66, 0.77, 0.88 },
0707: { 23.23, 46.46, 69.69, 92.92, 116.15, 139.38, 162.61,
0708: 185.84 } };
0709: d = MathX.sumproduct(darr);
0710: assertEquals("Sumproduct ", 2790.3876, d);
0711:
0712: }
0713:
0714: public void testSumsq() {
0715: double[] d = new double[100];
0716: d[0] = 1.1;
0717: d[1] = 2.1;
0718: d[2] = 3.1;
0719: d[3] = 4.1;
0720: d[4] = 5.1;
0721: d[5] = 6.1;
0722: d[6] = 7.1;
0723: d[7] = 8.1;
0724: d[8] = 9.1;
0725: d[9] = 10.1;
0726: d[10] = 11.1;
0727: d[11] = 12.1;
0728: d[12] = 13.1;
0729: d[13] = 14.1;
0730: d[14] = 15.1;
0731: d[15] = 16.1;
0732: d[16] = 17.1;
0733: d[17] = 18.1;
0734: d[18] = 19.1;
0735: d[19] = 20.1;
0736:
0737: double s = MathX.sumsq(d);
0738: assertEquals("Sumsq ", 2912.2, s);
0739:
0740: d = new double[1000];
0741: s = MathX.sumsq(d);
0742: assertEquals("Sumsq ", 0, s);
0743:
0744: d[0] = -1.1;
0745: d[1] = 2.1;
0746: d[2] = -3.1;
0747: d[3] = 4.1;
0748: d[4] = -5.1;
0749: d[5] = 6.1;
0750: d[6] = -7.1;
0751: d[7] = 8.1;
0752: d[8] = -9.1;
0753: d[9] = 10.1;
0754: d[10] = -11.1;
0755: d[11] = 12.1;
0756: d[12] = -13.1;
0757: d[13] = 14.1;
0758: d[14] = -15.1;
0759: d[15] = 16.1;
0760: d[16] = -17.1;
0761: d[17] = 18.1;
0762: d[18] = -19.1;
0763: d[19] = 20.1;
0764: s = MathX.sumsq(d);
0765: assertEquals("Sumsq ", 2912.2, s);
0766:
0767: d[0] = -1.1;
0768: d[1] = -2.1;
0769: d[2] = -3.1;
0770: d[3] = -4.1;
0771: d[4] = -5.1;
0772: d[5] = -6.1;
0773: d[6] = -7.1;
0774: d[7] = -8.1;
0775: d[8] = -9.1;
0776: d[9] = -10.1;
0777: d[10] = -11.1;
0778: d[11] = -12.1;
0779: d[12] = -13.1;
0780: d[13] = -14.1;
0781: d[14] = -15.1;
0782: d[15] = -16.1;
0783: d[16] = -17.1;
0784: d[17] = -18.1;
0785: d[18] = -19.1;
0786: d[19] = -20.1;
0787: s = MathX.sumsq(d);
0788: assertEquals("Sumsq ", 2912.2, s);
0789: }
0790:
0791: public void testFactorial() {
0792: int n = 0;
0793: double s = 0;
0794:
0795: n = 0;
0796: s = MathX.factorial(n);
0797: assertEquals("Factorial ", 1, s);
0798:
0799: n = 1;
0800: s = MathX.factorial(n);
0801: assertEquals("Factorial ", 1, s);
0802:
0803: n = 10;
0804: s = MathX.factorial(n);
0805: assertEquals("Factorial ", 3628800, s);
0806:
0807: n = 99;
0808: s = MathX.factorial(n);
0809: assertEquals("Factorial ", 9.33262154439E+155, s);
0810:
0811: n = -1;
0812: s = MathX.factorial(n);
0813: assertEquals("Factorial ", Double.NaN, s);
0814:
0815: n = Integer.MAX_VALUE;
0816: s = MathX.factorial(n);
0817: assertEquals("Factorial ", Double.POSITIVE_INFINITY, s);
0818: }
0819:
0820: public void testSumx2my2() {
0821: double d = 0;
0822: double[] xarr = null;
0823: double[] yarr = null;
0824:
0825: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0826: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0827: d = MathX.sumx2my2(xarr, yarr);
0828: assertEquals("sumx2my2 ", 100, d);
0829:
0830: xarr = new double[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 };
0831: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0832: d = MathX.sumx2my2(xarr, yarr);
0833: assertEquals("sumx2my2 ", 100, d);
0834:
0835: xarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0836: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0837: d = MathX.sumx2my2(xarr, yarr);
0838: assertEquals("sumx2my2 ", -100, d);
0839:
0840: xarr = new double[] { 10 };
0841: yarr = new double[] { 9 };
0842: d = MathX.sumx2my2(xarr, yarr);
0843: assertEquals("sumx2my2 ", 19, d);
0844:
0845: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0846: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0847: d = MathX.sumx2my2(xarr, yarr);
0848: assertEquals("sumx2my2 ", 0, d);
0849:
0850: }
0851:
0852: public void testSumx2py2() {
0853: double d = 0;
0854: double[] xarr = null;
0855: double[] yarr = null;
0856:
0857: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0858: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0859: d = MathX.sumx2py2(xarr, yarr);
0860: assertEquals("sumx2py2 ", 670, d);
0861:
0862: xarr = new double[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 };
0863: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0864: d = MathX.sumx2py2(xarr, yarr);
0865: assertEquals("sumx2py2 ", 670, d);
0866:
0867: xarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0868: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0869: d = MathX.sumx2py2(xarr, yarr);
0870: assertEquals("sumx2py2 ", 670, d);
0871:
0872: xarr = new double[] { 10 };
0873: yarr = new double[] { 9 };
0874: d = MathX.sumx2py2(xarr, yarr);
0875: assertEquals("sumx2py2 ", 181, d);
0876:
0877: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0878: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0879: d = MathX.sumx2py2(xarr, yarr);
0880: assertEquals("sumx2py2 ", 770, d);
0881: }
0882:
0883: public void testSumxmy2() {
0884: double d = 0;
0885: double[] xarr = null;
0886: double[] yarr = null;
0887:
0888: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0889: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0890: d = MathX.sumxmy2(xarr, yarr);
0891: assertEquals("sumxmy2 ", 10, d);
0892:
0893: xarr = new double[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 };
0894: yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0895: d = MathX.sumxmy2(xarr, yarr);
0896: assertEquals("sumxmy2 ", 1330, d);
0897:
0898: xarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
0899: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0900: d = MathX.sumxmy2(xarr, yarr);
0901: assertEquals("sumxmy2 ", 10, d);
0902:
0903: xarr = new double[] { 10 };
0904: yarr = new double[] { 9 };
0905: d = MathX.sumxmy2(xarr, yarr);
0906: assertEquals("sumxmy2 ", 1, d);
0907:
0908: xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0909: yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
0910: d = MathX.sumxmy2(xarr, yarr);
0911: assertEquals("sumxmy2 ", 0, d);
0912: }
0913:
0914: public void testRound() {
0915: double d = 0;
0916: int p = 0;
0917:
0918: d = 0;
0919: p = 0;
0920: assertEquals("round ", 0, MathX.round(d, p));
0921:
0922: d = 10;
0923: p = 0;
0924: assertEquals("round ", 10, MathX.round(d, p));
0925:
0926: d = 123.23;
0927: p = 0;
0928: assertEquals("round ", 123, MathX.round(d, p));
0929:
0930: d = -123.23;
0931: p = 0;
0932: assertEquals("round ", -123, MathX.round(d, p));
0933:
0934: d = 123.12;
0935: p = 2;
0936: assertEquals("round ", 123.12, MathX.round(d, p));
0937:
0938: d = 88.123459;
0939: p = 5;
0940: assertEquals("round ", 88.12346, MathX.round(d, p));
0941:
0942: d = 0;
0943: p = 2;
0944: assertEquals("round ", 0, MathX.round(d, p));
0945:
0946: d = 0;
0947: p = -1;
0948: assertEquals("round ", 0, MathX.round(d, p));
0949:
0950: d = 0.01;
0951: p = -1;
0952: assertEquals("round ", 0, MathX.round(d, p));
0953:
0954: d = 123.12;
0955: p = -2;
0956: assertEquals("round ", 100, MathX.round(d, p));
0957:
0958: d = 88.123459;
0959: p = -3;
0960: assertEquals("round ", 0, MathX.round(d, p));
0961:
0962: d = 49.00000001;
0963: p = -1;
0964: assertEquals("round ", 50, MathX.round(d, p));
0965:
0966: d = 149.999999;
0967: p = -2;
0968: assertEquals("round ", 100, MathX.round(d, p));
0969:
0970: d = 150.0;
0971: p = -2;
0972: assertEquals("round ", 200, MathX.round(d, p));
0973: }
0974:
0975: public void testRoundDown() {
0976: double d = 0;
0977: int p = 0;
0978:
0979: d = 0;
0980: p = 0;
0981: assertEquals("roundDown ", 0, MathX.roundDown(d, p));
0982:
0983: d = 10;
0984: p = 0;
0985: assertEquals("roundDown ", 10, MathX.roundDown(d, p));
0986:
0987: d = 123.99;
0988: p = 0;
0989: assertEquals("roundDown ", 123, MathX.roundDown(d, p));
0990:
0991: d = -123.99;
0992: p = 0;
0993: assertEquals("roundDown ", -123, MathX.roundDown(d, p));
0994:
0995: d = 123.99;
0996: p = 2;
0997: assertEquals("roundDown ", 123.99, MathX.roundDown(d, p));
0998:
0999: d = 88.123459;
1000: p = 5;
1001: assertEquals("roundDown ", 88.12345, MathX.roundDown(d, p));
1002:
1003: d = 0;
1004: p = 2;
1005: assertEquals("roundDown ", 0, MathX.roundDown(d, p));
1006:
1007: d = 0;
1008: p = -1;
1009: assertEquals("roundDown ", 0, MathX.roundDown(d, p));
1010:
1011: d = 0.01;
1012: p = -1;
1013: assertEquals("roundDown ", 0, MathX.roundDown(d, p));
1014:
1015: d = 199.12;
1016: p = -2;
1017: assertEquals("roundDown ", 100, MathX.roundDown(d, p));
1018:
1019: d = 88.123459;
1020: p = -3;
1021: assertEquals("roundDown ", 0, MathX.roundDown(d, p));
1022:
1023: d = 99.00000001;
1024: p = -1;
1025: assertEquals("roundDown ", 90, MathX.roundDown(d, p));
1026:
1027: d = 100.00001;
1028: p = -2;
1029: assertEquals("roundDown ", 100, MathX.roundDown(d, p));
1030:
1031: d = 150.0;
1032: p = -2;
1033: assertEquals("roundDown ", 100, MathX.roundDown(d, p));
1034: }
1035:
1036: public void testRoundUp() {
1037: double d = 0;
1038: int p = 0;
1039:
1040: d = 0;
1041: p = 0;
1042: assertEquals("roundUp ", 0, MathX.roundUp(d, p));
1043:
1044: d = 10;
1045: p = 0;
1046: assertEquals("roundUp ", 10, MathX.roundUp(d, p));
1047:
1048: d = 123.23;
1049: p = 0;
1050: assertEquals("roundUp ", 124, MathX.roundUp(d, p));
1051:
1052: d = -123.23;
1053: p = 0;
1054: assertEquals("roundUp ", -124, MathX.roundUp(d, p));
1055:
1056: d = 123.12;
1057: p = 2;
1058: assertEquals("roundUp ", 123.12, MathX.roundUp(d, p));
1059:
1060: d = 88.123459;
1061: p = 5;
1062: assertEquals("roundUp ", 88.12346, MathX.roundUp(d, p));
1063:
1064: d = 0;
1065: p = 2;
1066: assertEquals("roundUp ", 0, MathX.roundUp(d, p));
1067:
1068: d = 0;
1069: p = -1;
1070: assertEquals("roundUp ", 0, MathX.roundUp(d, p));
1071:
1072: d = 0.01;
1073: p = -1;
1074: assertEquals("roundUp ", 10, MathX.roundUp(d, p));
1075:
1076: d = 123.12;
1077: p = -2;
1078: assertEquals("roundUp ", 200, MathX.roundUp(d, p));
1079:
1080: d = 88.123459;
1081: p = -3;
1082: assertEquals("roundUp ", 1000, MathX.roundUp(d, p));
1083:
1084: d = 49.00000001;
1085: p = -1;
1086: assertEquals("roundUp ", 50, MathX.roundUp(d, p));
1087:
1088: d = 149.999999;
1089: p = -2;
1090: assertEquals("roundUp ", 200, MathX.roundUp(d, p));
1091:
1092: d = 150.0;
1093: p = -2;
1094: assertEquals("roundUp ", 200, MathX.roundUp(d, p));
1095: }
1096:
1097: public void testCeiling() {
1098: double d = 0;
1099: double s = 0;
1100:
1101: d = 0;
1102: s = 0;
1103: assertEquals("ceiling ", 0, MathX.ceiling(d, s));
1104:
1105: d = 1;
1106: s = 0;
1107: assertEquals("ceiling ", 0, MathX.ceiling(d, s));
1108:
1109: d = 0;
1110: s = 1;
1111: assertEquals("ceiling ", 0, MathX.ceiling(d, s));
1112:
1113: d = -1;
1114: s = 0;
1115: assertEquals("ceiling ", 0, MathX.ceiling(d, s));
1116:
1117: d = 0;
1118: s = -1;
1119: assertEquals("ceiling ", 0, MathX.ceiling(d, s));
1120:
1121: d = 10;
1122: s = 1.11;
1123: assertEquals("ceiling ", 11.1, MathX.ceiling(d, s));
1124:
1125: d = 11.12333;
1126: s = 0.03499;
1127: assertEquals("ceiling ", 11.12682, MathX.ceiling(d, s));
1128:
1129: d = -11.12333;
1130: s = 0.03499;
1131: assertEquals("ceiling ", Double.NaN, MathX.ceiling(d, s));
1132:
1133: d = 11.12333;
1134: s = -0.03499;
1135: assertEquals("ceiling ", Double.NaN, MathX.ceiling(d, s));
1136:
1137: d = -11.12333;
1138: s = -0.03499;
1139: assertEquals("ceiling ", -11.12682, MathX.ceiling(d, s));
1140:
1141: d = 100;
1142: s = 0.001;
1143: assertEquals("ceiling ", 100, MathX.ceiling(d, s));
1144:
1145: d = -0.001;
1146: s = -9.99;
1147: assertEquals("ceiling ", -9.99, MathX.ceiling(d, s));
1148:
1149: d = 4.42;
1150: s = 0.05;
1151: assertEquals("ceiling ", 4.45, MathX.ceiling(d, s));
1152:
1153: d = 0.05;
1154: s = 4.42;
1155: assertEquals("ceiling ", 4.42, MathX.ceiling(d, s));
1156:
1157: d = 0.6666;
1158: s = 3.33;
1159: assertEquals("ceiling ", 3.33, MathX.ceiling(d, s));
1160:
1161: d = 2d / 3;
1162: s = 3.33;
1163: assertEquals("ceiling ", 3.33, MathX.ceiling(d, s));
1164: }
1165:
1166: public void testFloor() {
1167: double d = 0;
1168: double s = 0;
1169:
1170: d = 0;
1171: s = 0;
1172: assertEquals("floor ", 0, MathX.floor(d, s));
1173:
1174: d = 1;
1175: s = 0;
1176: assertEquals("floor ", Double.NaN, MathX.floor(d, s));
1177:
1178: d = 0;
1179: s = 1;
1180: assertEquals("floor ", 0, MathX.floor(d, s));
1181:
1182: d = -1;
1183: s = 0;
1184: assertEquals("floor ", Double.NaN, MathX.floor(d, s));
1185:
1186: d = 0;
1187: s = -1;
1188: assertEquals("floor ", 0, MathX.floor(d, s));
1189:
1190: d = 10;
1191: s = 1.11;
1192: assertEquals("floor ", 9.99, MathX.floor(d, s));
1193:
1194: d = 11.12333;
1195: s = 0.03499;
1196: assertEquals("floor ", 11.09183, MathX.floor(d, s));
1197:
1198: d = -11.12333;
1199: s = 0.03499;
1200: assertEquals("floor ", Double.NaN, MathX.floor(d, s));
1201:
1202: d = 11.12333;
1203: s = -0.03499;
1204: assertEquals("floor ", Double.NaN, MathX.floor(d, s));
1205:
1206: d = -11.12333;
1207: s = -0.03499;
1208: assertEquals("floor ", -11.09183, MathX.floor(d, s));
1209:
1210: d = 100;
1211: s = 0.001;
1212: assertEquals("floor ", 100, MathX.floor(d, s));
1213:
1214: d = -0.001;
1215: s = -9.99;
1216: assertEquals("floor ", 0, MathX.floor(d, s));
1217:
1218: d = 4.42;
1219: s = 0.05;
1220: assertEquals("floor ", 4.4, MathX.floor(d, s));
1221:
1222: d = 0.05;
1223: s = 4.42;
1224: assertEquals("floor ", 0, MathX.floor(d, s));
1225:
1226: d = 0.6666;
1227: s = 3.33;
1228: assertEquals("floor ", 0, MathX.floor(d, s));
1229:
1230: d = 2d / 3;
1231: s = 3.33;
1232: assertEquals("floor ", 0, MathX.floor(d, s));
1233: }
1234:
1235: }
|