TnSb/android-calculatorpp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use Real all the time

Browse Source
This commit is contained in:
serso 2016-04-09 21:12:15 +02:00
parent 1090ba856f
commit 29d4d77831
17 changed files with 994 additions and 1073 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/src/main/java/org/solovyev/android/calculator/converter/ConverterFragment.java
View File

@ -21,6 +21,7 @@ import android.widget.*;
import butterknife.Bind; import butterknife.Bind;
import butterknife.ButterKnife; import butterknife.ButterKnife;
import jscl.JsclMathEngine; import jscl.JsclMathEngine;
import jscl.NumeralBase;
import midpcalc.Real; import midpcalc.Real;
import org.solovyev.android.calculator.*; import org.solovyev.android.calculator.*;
@ -310,12 +311,13 @@ public class ConverterFragment extends BaseDialogFragment
if (!TextUtils.isEmpty(groupingSeparator)) { if (!TextUtils.isEmpty(groupingSeparator)) {
value = value.replace(groupingSeparator, ""); value = value.replace(groupingSeparator, "");
} }
return Double.longBitsToDouble(new Real(value).toDoubleBits()); final long bits = new Real(value).toDoubleBits();
return Double.longBitsToDouble(bits);
} }
@Nonnull @Nonnull
private String formatDouble(double toValue) { private String formatDouble(double toValue) {
return JsclMathEngine.getInstance().formatDec(toValue); return JsclMathEngine.getInstance().format(toValue, NumeralBase.dec);
} }
@Override @Override

113
jscl/src/main/java/jscl/JsclMathEngine.java
View File

@ -9,7 +9,7 @@ import jscl.math.operator.Percent;
import jscl.math.operator.Rand; import jscl.math.operator.Rand;
import jscl.math.operator.matrix.OperatorsRegistry; import jscl.math.operator.matrix.OperatorsRegistry;
import jscl.text.ParseException; import jscl.text.ParseException;
import midpcalc.Real; import org.solovyev.common.NumberFormatter;
import org.solovyev.common.math.MathRegistry; import org.solovyev.common.math.MathRegistry;
import org.solovyev.common.msg.MessageRegistry; import org.solovyev.common.msg.MessageRegistry;
import org.solovyev.common.msg.Messages; import org.solovyev.common.msg.Messages;
@ -17,7 +17,6 @@ import org.solovyev.common.msg.Messages;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
import javax.annotation.Nullable; import javax.annotation.Nullable;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols; import java.text.DecimalFormatSymbols;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
@ -33,17 +32,10 @@ public class JsclMathEngine implements MathEngine {
@Nonnull @Nonnull
private final ConstantsRegistry constantsRegistry = new ConstantsRegistry(); private final ConstantsRegistry constantsRegistry = new ConstantsRegistry();
@Nonnull @Nonnull
private final ThreadLocal<DecimalFormat> defaultNumbersFormat = new ThreadLocal<DecimalFormat>() { private final ThreadLocal<NumberFormatter> numberFormatter = new ThreadLocal<NumberFormatter>() {
@Override @Override
protected DecimalFormat initialValue() { protected NumberFormatter initialValue() {
return new DecimalFormat(); return new NumberFormatter();
}
};
@Nonnull
private final ThreadLocal<DecimalFormat> smallNumbersFormat = new ThreadLocal<DecimalFormat>() {
@Override
protected DecimalFormat initialValue() {
return new DecimalFormat("##0.#####E0");
} }
}; };
@Nonnull @Nonnull
@ -165,18 +157,12 @@ public class JsclMathEngine implements MathEngine {
public String format(@Nonnull Double value, @Nonnull NumeralBase nb) throws NumeralBaseException { public String format(@Nonnull Double value, @Nonnull NumeralBase nb) throws NumeralBaseException {
if (value.isInfinite()) { if (value.isInfinite()) {
return formatInfinity(value); return formatInfinity(value);
} else if (value.isNaN()) { }
if (value.isNaN()) {
// return "NaN" // return "NaN"
return String.valueOf(value); return String.valueOf(value);
} else if (nb == NumeralBase.dec) {
return formatDec(value);
} else {
return convert(value, nb);
} }
} if (nb == NumeralBase.dec) {
@Nonnull
public String formatDec(@Nonnull Double value) {
if (value == 0d) { if (value == 0d) {
return "0"; return "0";
} }
@ -185,87 +171,16 @@ public class JsclMathEngine implements MathEngine {
if (constant != null) { if (constant != null) {
return constant.getName(); return constant.getName();
} }
}
final NumberFormatter nf = numberFormatter.get();
nf.setGroupingSeparator(useGroupingSeparator ? decimalGroupSymbols.getGroupingSeparator() : NumberFormatter.NO_GROUPING);
nf.setPrecision(roundResult ? precision : NumberFormatter.DEFAULT_PRECISION);
if (scienceNotation) { if (scienceNotation) {
return formatDecEngineering(value); nf.useEngineeringFormat(NumberFormatter.DEFAULT_MAGNITUDE);
}
return formatDecDefault(value);
}
@Nonnull
private String formatDecEngineering(@Nonnull Double value) {
final double absValue = Math.abs(value);
final boolean smallNumber = absValue < 1 && absValue >= 0.001;
final Real.NumberFormat nf = new Real.NumberFormat();
nf.fse = smallNumber ? Real.NumberFormat.FSE_FIX : Real.NumberFormat.FSE_ENG;
if (useGroupingSeparator) {
nf.thousand = decimalGroupSymbols.getGroupingSeparator();
}
if (roundResult) {
nf.precision = precision;
}
final Real real = new Real(Double.toString(value));
return stripTrailingZeros(real.toString(nf));
}
@Nonnull
private String stripTrailingZeros(@Nonnull String s) {
final int dot = s.indexOf('.');
if (dot < 0) {
// no dot - no trailing zeros
return s;
}
final int e = s.lastIndexOf('E');
final int start;
String exponent = "";
if (e > 0) {
exponent = s.substring(e);
if (exponent.length() == 2 && exponent.charAt(1) == '0') {
exponent = "";
}
start = e - 1;
} else { } else {
start = s.length() - 1; nf.useSimpleFormat();
} }
final int i = findLastNonZero(s, start); return nf.format(value, nb.radix).toString();
return s.substring(0, i == dot ? i : i + 1) + exponent;
}
private int findLastNonZero(String s, int start) {
int i = start;
for (; i >= 0; i--) {
if (s.charAt(i) != '0') {
break;
}
}
return i;
}
@Nonnull
private String formatDecDefault(@Nonnull Double value) {
final BigDecimal bd;
if (roundResult) {
bd = BigDecimal.valueOf(value).setScale(precision, BigDecimal.ROUND_HALF_UP);
} else {
bd = BigDecimal.valueOf(value);
}
value = bd.doubleValue();
if (value == 0) {
return "0";
}
final DecimalFormat df = Math.abs(value) < Math.pow(10, -5) ? smallNumbersFormat.get() : defaultNumbersFormat.get();
df.setDecimalFormatSymbols(decimalGroupSymbols);
df.setGroupingUsed(useGroupingSeparator);
df.setGroupingSize(NumeralBase.dec.getGroupingSize());
if (roundResult) {
df.setMaximumFractionDigits(precision);
} else {
// set maximum fraction digits high enough to show all fraction digits in case of no rounding
df.setMaximumFractionDigits(MAX_FRACTION_DIGITS);
}
return df.format(value);
} }
@Nullable @Nullable

846
jscl/src/main/java/midpcalc/Real.java
View File

File diff suppressed because it is too large Load Diff

136
jscl/src/main/java/org/solovyev/common/NumberFormatter.java Normal file
View File

@ -0,0 +1,136 @@
package org.solovyev.common;
import midpcalc.Real;
import javax.annotation.Nonnull;
import java.math.BigDecimal;
import static midpcalc.Real.NumberFormat.*;
public class NumberFormatter {
public static final int NO_GROUPING = 0;
public static final int DEFAULT_PRECISION = 16;
public static final int DEFAULT_MAGNITUDE = 5;
private final Real.NumberFormat numberFormat = new Real.NumberFormat();
private final Real real = new Real();
private int format = FSE_NONE;
private int simpleFormatMagnitude = DEFAULT_MAGNITUDE;
private int precision = DEFAULT_PRECISION;
private char groupingSeparator;
public void useEngineeringFormat(int simpleFormatMagnitude) {
this.format = FSE_ENG;
this.simpleFormatMagnitude = simpleFormatMagnitude;
}
public void useSimpleFormat() {
this.format = FSE_NONE;
this.simpleFormatMagnitude = DEFAULT_MAGNITUDE;
}
public void setPrecision(int precision) {
this.precision = precision;
}
public void setGroupingSeparator(char groupingSeparator) {
this.groupingSeparator = groupingSeparator;
}
@Nonnull
public CharSequence format(double value) {
return format(value, 10);
}
@Nonnull
public CharSequence format(double value, int radix) {
if (radix != 2 && radix != 8 && radix != 10 && radix != 16) {
throw new IllegalArgumentException("Unsupported radix: " + radix);
}
double absValue = Math.abs(value);
final boolean dec = radix == 10;
final boolean fixedFormat = !dec || format == FSE_NONE || Math.pow(10, -simpleFormatMagnitude) <= absValue && absValue < Math.pow(10, simpleFormatMagnitude);
if (fixedFormat) {
final int newScale = (int) (precision * Math.max(1, radix / 10f));
value = BigDecimal.valueOf(value).setScale(newScale, BigDecimal.ROUND_HALF_UP).doubleValue();
absValue = Math.abs(value);
}
numberFormat.fse = fixedFormat ? FSE_FIX : FSE_ENG;
numberFormat.thousand = groupingSeparator;
numberFormat.precision = precision;
numberFormat.base = radix;
numberFormat.maxwidth = fixedFormat ? 100 : 30;
if (radix == 2 && value < 0) {
return "-" + prepare(absValue);
}
return prepare(value);
}
@Nonnull
private CharSequence prepare(double value) {
return stripZeros(realFormat(value)).replace('e', 'E');
}
@Nonnull
private String realFormat(double value) {
real.assign(Double.toString(value));
return real.toString(numberFormat);
}
@Nonnull
private String stripZeros(@Nonnull String s) {
int dot = -1;
int firstNonZero = -1;
for (int i = 0; i < s.length(); i++) {
final char c = s.charAt(i);
if (c != '0' && c != groupingSeparator && firstNonZero == -1) {
firstNonZero = i;
}
if (c == '.') {
dot = i;
break;
}
}
if (firstNonZero == -1) {
// all zeros
return "";
}
if (dot < 0) {
// no dot - no trailing zeros
return s.substring(firstNonZero);
}
if (firstNonZero == dot) {
// one zero before dot must be kept
firstNonZero--;
}
final int e = s.lastIndexOf('e');
final int i = findLastNonZero(s, e);
final int end = i == dot ? i : i + 1;
return s.substring(firstNonZero, end) + getExponent(s, e);
}
@Nonnull
private String getExponent(@Nonnull String s, int e) {
String exponent = "";
if (e > 0) {
exponent = s.substring(e);
if (exponent.length() == 2 && exponent.charAt(1) == '0') {
exponent = "";
}
}
return exponent;
}
private int findLastNonZero(@Nonnull String s, int e) {
int i = e > 0 ? e - 1 : s.length() - 1;
for (; i >= 0; i--) {
if (s.charAt(i) != '0') {
break;
}
}
return i;
}
}

35
jscl/src/test/java/jscl/JsclMathEngineTest.java
View File

@ -35,23 +35,22 @@ public class JsclMathEngineTest {
assertEquals("111 1111 0011 0110", me.format(32566d, NumeralBase.bin)); assertEquals("111 1111 0011 0110", me.format(32566d, NumeralBase.bin));
assertEquals("100.0100110011", me.format(4.3d, NumeralBase.bin)); assertEquals("100.0100110011", me.format(4.3d, NumeralBase.bin));
assertEquals("1 0001 0101 0011.0101 0101 10", me.format(4435.33423d, NumeralBase.bin)); assertEquals("1 0001 0101 0011.010101011", me.format(4435.33423d, NumeralBase.bin));
assertEquals("1100.0101010101", me.format(12.3333d, NumeralBase.bin)); assertEquals("1100.0101010101", me.format(12.3333d, NumeralBase.bin));
assertEquals("1 0011 1101 1110 0100 0011 0101 0101.0001 1111 00", me.format(333333333.1212213321d, NumeralBase.bin)); assertEquals("1 0011 1101 1110 0100 0011 0101 0101.00011111", me.format(333333333.1212213321d, NumeralBase.bin));
assertEquals("0.EE EE EE EE EE", me.format(14d / 15d, NumeralBase.hex)); assertEquals("0.EEEEEEEEEF", me.format(14d / 15d, NumeralBase.hex));
assertEquals("7F 36", me.format(32566d, NumeralBase.hex)); assertEquals("7F 36", me.format(32566d, NumeralBase.hex));
assertEquals("24", me.format(36d, NumeralBase.hex)); assertEquals("24", me.format(36d, NumeralBase.hex));
assertEquals("8", me.format(8d, NumeralBase.hex)); assertEquals("8", me.format(8d, NumeralBase.hex));
assertEquals("1 3D", me.format(317d, NumeralBase.hex)); assertEquals("1 3D", me.format(317d, NumeralBase.hex));
assertEquals("13 DE 43 55.1F 08 5B EF 14", me.format(333333333.1212213321d, NumeralBase.hex)); assertEquals("13 DE 43 55.1F085BEF", me.format(333333333.1212213321d, NumeralBase.hex));
assertEquals("D 25 0F 77 0A.6F 73 18 FC 50", me.format(56456345354.43534534523459999d, NumeralBase.hex)); assertEquals("D 25 0F 77 0A.6F7319", me.format(56456345354.43534534523459999d, NumeralBase.hex));
assertEquals("3 E7.4C CC CC CC CC", me.format(999.3d, NumeralBase.hex)); assertEquals("3 E7.4CCCCCCCCD", me.format(999.3d, NumeralBase.hex));
me.setRoundResult(false); me.setRoundResult(false);
assertEquals("0.00 00 00 00 00 00 00 00 00 6C", me.format(0.00000000000000000000009d, NumeralBase.hex)); assertEquals("6.CCDA6A054226DB6E-19", me.format(0.00000000000000000000009d, NumeralBase.hex));
assertEquals("0.00 00 00 00 00 00 00 00 00 0A", me.format(0.000000000000000000000009d, NumeralBase.hex)); assertEquals("A.E15D766ED03E2BEE-20", me.format(0.000000000000000000000009d, NumeralBase.hex));
} finally { } finally {
me.setUseGroupingSeparator(false); me.setUseGroupingSeparator(false);
} }
@ -80,7 +79,7 @@ public class JsclMathEngineTest {
@Test @Test
public void testPiComputation() throws Exception { public void testPiComputation() throws Exception {
final JsclMathEngine me = JsclMathEngine.getInstance(); final JsclMathEngine me = JsclMathEngine.getInstance();
assertEquals("-1+122.46467991473532E-18*i", me.evaluate("exp(√(-1)*Π)")); assertEquals("-1+0.0000000000000001*i", me.evaluate("exp(√(-1)*Π)"));
} }
@Test @Test
@ -101,8 +100,8 @@ public class JsclMathEngineTest {
assertEquals("111E3", me.format(111000d)); assertEquals("111E3", me.format(111000d));
assertEquals("110E3", me.format(110000d)); assertEquals("110E3", me.format(110000d));
assertEquals("100E3", me.format(100000d)); assertEquals("100E3", me.format(100000d));
assertEquals("10E3", me.format(10000d)); assertEquals("10000", me.format(10000d));
assertEquals("1E3", me.format(1000d)); assertEquals("1000", me.format(1000d));
assertEquals("100", me.format(100d)); assertEquals("100", me.format(100d));
assertEquals("100.1", me.format(100.1d)); assertEquals("100.1", me.format(100.1d));
assertEquals("100.12", me.format(100.12d)); assertEquals("100.12", me.format(100.12d));
@ -122,8 +121,8 @@ public class JsclMathEngineTest {
assertEquals("0.001", me.format(0.001)); assertEquals("0.001", me.format(0.001));
assertEquals("0.001", me.format(0.00100000001)); assertEquals("0.001", me.format(0.00100000001));
assertEquals("0.0011", me.format(0.0011)); assertEquals("0.0011", me.format(0.0011));
assertEquals("999.999E-6", me.format(0.000999999)); assertEquals("0.001", me.format(0.000999999));
assertEquals("100E-6", me.format(0.0001)); assertEquals("0.0001", me.format(0.0001));
assertEquals("1E-6", me.format(0.000001)); assertEquals("1E-6", me.format(0.000001));
assertEquals("10E-9", me.format(0.00000001)); assertEquals("10E-9", me.format(0.00000001));
@ -156,8 +155,8 @@ public class JsclMathEngineTest {
assertEquals("111E3", me.format(111000d)); assertEquals("111E3", me.format(111000d));
assertEquals("110E3", me.format(110000d)); assertEquals("110E3", me.format(110000d));
assertEquals("100E3", me.format(100000d)); assertEquals("100E3", me.format(100000d));
assertEquals("10E3", me.format(10000d)); assertEquals("10000", me.format(10000d));
assertEquals("1E3", me.format(1000d)); assertEquals("1000", me.format(1000d));
assertEquals("100", me.format(100d)); assertEquals("100", me.format(100d));
assertEquals("100.1", me.format(100.1d)); assertEquals("100.1", me.format(100.1d));
assertEquals("100.12", me.format(100.12d)); assertEquals("100.12", me.format(100.12d));
@ -176,8 +175,8 @@ public class JsclMathEngineTest {
assertEquals("0.01", me.format(0.01)); assertEquals("0.01", me.format(0.01));
assertEquals("0.001", me.format(0.001)); assertEquals("0.001", me.format(0.001));
assertEquals("0.0011", me.format(0.0011)); assertEquals("0.0011", me.format(0.0011));
assertEquals("999.999E-6", me.format(0.000999999)); assertEquals("0.000999999", me.format(0.000999999));
assertEquals("100E-6", me.format(0.0001)); assertEquals("0.0001", me.format(0.0001));
assertEquals("100.001E3", me.format(100001d)); assertEquals("100.001E3", me.format(100001d));
assertEquals("111.111E3", me.format(111111d)); assertEquals("111.111E3", me.format(111111d));

61
jscl/src/test/java/jscl/NumeralBaseTest.java
View File

@ -4,25 +4,22 @@ import jscl.math.function.Constant;
import jscl.math.function.ExtendedConstant; import jscl.math.function.ExtendedConstant;
import jscl.math.function.IConstant; import jscl.math.function.IConstant;
import jscl.text.ParseException; import jscl.text.ParseException;
import junit.framework.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
/** import static org.junit.Assert.assertEquals;
* User: serso
* Date: 11/29/11
* Time: 12:20 PM
*/
public class NumeralBaseTest { public class NumeralBaseTest {
@Test @Test
public void testEvaluation() throws Exception { public void testEvaluation() throws Exception {
MathEngine me = JsclMathEngine.getInstance(); MathEngine me = JsclMathEngine.getInstance();
Assert.assertEquals("3", me.evaluate("0b:1+0b:10")); assertEquals("3", me.evaluate("0b:1+0b:10"));
Assert.assertEquals("5", me.evaluate("0b:1+0b:100")); assertEquals("5", me.evaluate("0b:1+0b:100"));
Assert.assertEquals("8", me.evaluate("0b:1+0b:100+(0b:1+0b:10)")); assertEquals("8", me.evaluate("0b:1+0b:100+(0b:1+0b:10)"));
Assert.assertEquals("18", me.evaluate("0b:1+0b:100+(0b:1+0b:10)+10")); assertEquals("18", me.evaluate("0b:1+0b:100+(0b:1+0b:10)+10"));
Assert.assertEquals("18.5", me.evaluate("0b:1+0b:100+(0b:1+0b:10)+10.5")); assertEquals("18.5", me.evaluate("0b:1+0b:100+(0b:1+0b:10)+10.5"));
try { try {
me.evaluate("0b:1+0b:100.+(0b:1+0b:10)+10.5"); me.evaluate("0b:1+0b:100.+(0b:1+0b:10)+10.5");
Assert.fail(); Assert.fail();
@ -35,7 +32,7 @@ public class NumeralBaseTest {
} catch (ParseException e) { } catch (ParseException e) {
} }
Assert.assertEquals("2748", me.evaluate("0x:ABC")); assertEquals("2748", me.evaluate("0x:ABC"));
try { try {
me.evaluate("0x:"); me.evaluate("0x:");
@ -43,15 +40,15 @@ public class NumeralBaseTest {
} catch (ParseException e) { } catch (ParseException e) {
} }
Assert.assertEquals("0", me.evaluate("0x:0")); assertEquals("0", me.evaluate("0x:0"));
IConstant constant = null; IConstant constant = null;
try { try {
final ExtendedConstant.Builder a = new ExtendedConstant.Builder(new Constant("a"), 2d); final ExtendedConstant.Builder a = new ExtendedConstant.Builder(new Constant("a"), 2d);
constant = me.getConstantsRegistry().addOrUpdate(a.create()); constant = me.getConstantsRegistry().addOrUpdate(a.create());
Assert.assertEquals("2748", me.evaluate("0x:ABC")); assertEquals("2748", me.evaluate("0x:ABC"));
Assert.assertEquals("5496", me.evaluate("0x:ABC*a")); assertEquals("5496", me.evaluate("0x:ABC*a"));
Assert.assertEquals("27480", me.evaluate("0x:ABC*0x:A")); assertEquals("27480", me.evaluate("0x:ABC*0x:A"));
} finally { } finally {
if (constant != null) { if (constant != null) {
final ExtendedConstant.Builder a = new ExtendedConstant.Builder(new Constant("a"), (String) null); final ExtendedConstant.Builder a = new ExtendedConstant.Builder(new Constant("a"), (String) null);
@ -67,24 +64,24 @@ public class NumeralBaseTest {
final NumeralBase defaultNumeralBase = me.getNumeralBase(); final NumeralBase defaultNumeralBase = me.getNumeralBase();
try { try {
me.setNumeralBase(NumeralBase.bin); me.setNumeralBase(NumeralBase.bin);
Assert.assertEquals("∞", me.evaluate("∞")); assertEquals("∞", me.evaluate("∞"));
Assert.assertEquals("-1011010+110101111.10000110101100011010*i", me.evaluate("asin(-1110100101)")); assertEquals("-1011010+110101111.100001101011001*i", me.evaluate("asin(-1110100101)"));
Assert.assertEquals("11", me.evaluate("0b:1+0b:10")); assertEquals("11", me.evaluate("0b:1+0b:10"));
Assert.assertEquals("10", me.evaluate("0d:2")); assertEquals("10", me.evaluate("0d:2"));
Assert.assertEquals("11", me.evaluate("0d:3")); assertEquals("11", me.evaluate("0d:3"));
Assert.assertEquals("100", me.evaluate("0d:4")); assertEquals("100", me.evaluate("0d:4"));
Assert.assertEquals("11111111", me.evaluate("0d:255")); assertEquals("11111111", me.evaluate("0d:255"));
Assert.assertEquals("11", me.evaluate("1+10")); assertEquals("11", me.evaluate("1+10"));
Assert.assertEquals("-1", me.evaluate("1-10")); assertEquals("-1", me.evaluate("1-10"));
Assert.assertEquals("11-i", me.evaluate("1+i+10-10*i")); assertEquals("11-i", me.evaluate("1+i+10-10*i"));
Assert.assertEquals("11111110", me.evaluate("111001+11000101")); assertEquals("11111110", me.evaluate("111001+11000101"));
Assert.assertEquals("1101100100101111", me.evaluate("11011001001011110/10")); assertEquals("1101100100101111", me.evaluate("11011001001011110/10"));
Assert.assertEquals("1001000011001010", me.evaluate("11011001001011110/11")); assertEquals("1001000011001010", me.evaluate("11011001001011110/11"));
Assert.assertEquals("0.10101010101010101010", me.evaluate("10/11")); assertEquals("0.1010101010101011", me.evaluate("10/11"));
me.setNumeralBase(NumeralBase.hex); me.setNumeralBase(NumeralBase.hex);
org.junit.Assert.assertEquals("637B", me.evaluate("56CE+CAD")); assertEquals("637B", me.evaluate("56CE+CAD"));
org.junit.Assert.assertEquals("637B", me.simplify("56CE+CAD")); assertEquals("637B", me.simplify("56CE+CAD"));
} finally { } finally {
me.setNumeralBase(defaultNumeralBase); me.setNumeralBase(defaultNumeralBase);

603
jscl/src/test/java/jscl/math/ExpressionTest.java
View File

@ -8,7 +8,6 @@ import jscl.math.function.Constant;
import jscl.math.function.ExtendedConstant; import jscl.math.function.ExtendedConstant;
import jscl.math.function.IConstant; import jscl.math.function.IConstant;
import jscl.text.ParseException; import jscl.text.ParseException;
import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
@ -21,9 +20,7 @@ import java.net.URL;
import java.net.URLConnection; import java.net.URLConnection;
import java.util.Set; import java.util.Set;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.*;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class ExpressionTest { public class ExpressionTest {
@ -102,7 +99,7 @@ public class ExpressionTest {
@Test @Test
public void testImag() throws Exception { public void testImag() throws Exception {
Assert.assertEquals("-i", Expression.valueOf("i^3").numeric().toString()); assertEquals("-i", Expression.valueOf("i^3").numeric().toString());
} }
@Test @Test
@ -127,9 +124,9 @@ public class ExpressionTest {
final Expression expression = Expression.valueOf("2*t_0+5*t_1"); final Expression expression = Expression.valueOf("2*t_0+5*t_1");
Assert.assertEquals("7", expression.substitute(new Constant("t_1"), Expression.valueOf(1.0)).numeric().toString()); assertEquals("7", expression.substitute(new Constant("t_1"), Expression.valueOf(1.0)).numeric().toString());
Assert.assertEquals("12", expression.substitute(new Constant("t_1"), Expression.valueOf(2.0)).numeric().toString()); assertEquals("12", expression.substitute(new Constant("t_1"), Expression.valueOf(2.0)).numeric().toString());
Assert.assertEquals("27", expression.substitute(new Constant("t_1"), Expression.valueOf(5.0)).numeric().toString()); assertEquals("27", expression.substitute(new Constant("t_1"), Expression.valueOf(5.0)).numeric().toString());
} finally { } finally {
if (constant != null) { if (constant != null) {
@ -141,138 +138,138 @@ public class ExpressionTest {
@Test @Test
public void testExpressions() throws Exception { public void testExpressions() throws Exception {
Assert.assertEquals("3", Expression.valueOf("3").numeric().toString()); assertEquals("3", Expression.valueOf("3").numeric().toString());
Assert.assertEquals("0.6931471805599453", Expression.valueOf("ln(2)").numeric().toString()); assertEquals("0.6931471805599453", Expression.valueOf("ln(2)").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("lg(10)").numeric().toString()); assertEquals("1", Expression.valueOf("lg(10)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("eq(0, 1)").numeric().toString()); assertEquals("0", Expression.valueOf("eq(0, 1)").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("eq(1, 1)").numeric().toString()); assertEquals("1", Expression.valueOf("eq(1, 1)").numeric().toString());
Assert.assertEquals("24", Expression.valueOf("4!").numeric().toString()); assertEquals("24", Expression.valueOf("4!").numeric().toString());
try { try {
Expression.valueOf("(-3+2)!").numeric().toString(); Expression.valueOf("(-3+2)!").numeric().toString();
fail(); fail();
} catch (ArithmeticException e) { } catch (ArithmeticException e) {
} }
Assert.assertEquals("24", Expression.valueOf("(2+2)!").numeric().toString()); assertEquals("24", Expression.valueOf("(2+2)!").numeric().toString());
Assert.assertEquals("120", Expression.valueOf("(2+2+1)!").numeric().toString()); assertEquals("120", Expression.valueOf("(2+2+1)!").numeric().toString());
Assert.assertEquals("24", Expression.valueOf("(2.0+2.0)!").numeric().toString()); assertEquals("24", Expression.valueOf("(2.0+2.0)!").numeric().toString());
Assert.assertEquals("24", Expression.valueOf("4.0!").numeric().toString()); assertEquals("24", Expression.valueOf("4.0!").numeric().toString());
Assert.assertEquals("48", Expression.valueOf("2*4.0!").numeric().toString()); assertEquals("48", Expression.valueOf("2*4.0!").numeric().toString());
Assert.assertEquals("40320", Expression.valueOf("(2*4.0)!").numeric().toString()); assertEquals("40320", Expression.valueOf("(2*4.0)!").numeric().toString());
final JsclMathEngine me = JsclMathEngine.getInstance(); final JsclMathEngine me = JsclMathEngine.getInstance();
final AngleUnit angleUnits = me.getAngleUnits(); final AngleUnit angleUnits = me.getAngleUnits();
try { try {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("-0.9055783620066238", Expression.valueOf("sin(4!)").numeric().toString()); assertEquals("-0.9055783620066238", Expression.valueOf("sin(4!)").numeric().toString());
} finally { } finally {
me.setAngleUnits(angleUnits); me.setAngleUnits(angleUnits);
} }
Assert.assertEquals("1", Expression.valueOf("(3.14/3.14)!").numeric().toString()); assertEquals("1", Expression.valueOf("(3.14/3.14)!").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("2/2!").numeric().toString()); assertEquals("1", Expression.valueOf("2/2!").numeric().toString());
try { try {
Assert.assertEquals("3.141592653589793!", Expression.valueOf("3.141592653589793!").numeric().toString()); assertEquals("3.141592653589793!", Expression.valueOf("3.141592653589793!").numeric().toString());
fail(); fail();
} catch (NotIntegerException e) { } catch (NotIntegerException e) {
} }
Assert.assertEquals("0.5235987755982988", Expression.valueOf("3.141592653589793/3!").numeric().toString()); assertEquals("0.5235987755982988", Expression.valueOf("3.141592653589793/3!").numeric().toString());
try { try {
Assert.assertEquals("3.141592653589793/3.141592653589793!", Expression.valueOf("3.141592653589793/3.141592653589793!").numeric().toString()); assertEquals("3.141592653589793/3.141592653589793!", Expression.valueOf("3.141592653589793/3.141592653589793!").numeric().toString());
fail(); fail();
} catch (ArithmeticException e) { } catch (ArithmeticException e) {
} }
try { try {
Assert.assertEquals("7.2!", Expression.valueOf("7.2!").numeric().toString()); assertEquals("7.2!", Expression.valueOf("7.2!").numeric().toString());
fail(); fail();
} catch (NotIntegerException e) { } catch (NotIntegerException e) {
} }
try { try {
Assert.assertEquals("ln(7.2!)", Expression.valueOf("ln(7.2!)").numeric().toString()); assertEquals("ln(7.2!)", Expression.valueOf("ln(7.2!)").numeric().toString());
fail(); fail();
} catch (NotIntegerException e) { } catch (NotIntegerException e) {
} }
Assert.assertEquals("ln(7.2!)", Expression.valueOf("ln(7.2!)").simplify().toString()); assertEquals("ln(7.2!)", Expression.valueOf("ln(7.2!)").simplify().toString());
Assert.assertEquals("36", Expression.valueOf("3!^2").numeric().toString()); assertEquals("36", Expression.valueOf("3!^2").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("(π/π)!").numeric().toString()); assertEquals("1", Expression.valueOf("(π/π)!").numeric().toString());
Assert.assertEquals("720", Expression.valueOf("(3!)!").numeric().toString()); assertEquals("720", Expression.valueOf("(3!)!").numeric().toString());
Assert.assertEquals("36", Expression.valueOf("3!*3!").numeric().toString()); assertEquals("36", Expression.valueOf("3!*3!").numeric().toString());
Assert.assertEquals("100", Expression.valueOf("0.1E3").numeric().toString()); assertEquals("100", Expression.valueOf("0.1E3").numeric().toString());
final AngleUnit defaultAngleUnits = me.getAngleUnits(); final AngleUnit defaultAngleUnits = me.getAngleUnits();
try { try {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("0.017453292519943295", Expression.valueOf("1°").numeric().toString()); assertEquals("0.0174532925199433", Expression.valueOf("1°").numeric().toString());
Assert.assertEquals("0.03490658503988659", Expression.valueOf("2°").numeric().toString()); assertEquals("0.0349065850398866", Expression.valueOf("2°").numeric().toString());
Assert.assertEquals("0.05235987755982989", Expression.valueOf("3°").numeric().toString()); assertEquals("0.0523598775598299", Expression.valueOf("3°").numeric().toString());
Assert.assertEquals("0.26179938779914946", Expression.valueOf("3°*5").numeric().toString()); assertEquals("0.2617993877991495", Expression.valueOf("3°*5").numeric().toString());
Assert.assertEquals("0.0027415567780803775", Expression.valueOf("3°^2").numeric().toString()); assertEquals("0.0027415567780804", Expression.valueOf("3°^2").numeric().toString());
Assert.assertEquals("0.01096622711232151", Expression.valueOf("3!°^2").numeric().toString()); assertEquals("0.0109662271123215", Expression.valueOf("3!°^2").numeric().toString());
Assert.assertEquals("0.0009138522593601259", Expression.valueOf("3°°").numeric().toString()); assertEquals("0.0009138522593601", Expression.valueOf("3°°").numeric().toString());
Assert.assertEquals("0.08726646259971647", Expression.valueOf("5°").numeric().toString()); assertEquals("0.0872664625997165", Expression.valueOf("5°").numeric().toString());
Assert.assertEquals("2.0523598775598297", Expression.valueOf("2+3°").numeric().toString()); assertEquals("2.05235987755983", Expression.valueOf("2+3°").numeric().toString());
} finally { } finally {
me.setAngleUnits(defaultAngleUnits); me.setAngleUnits(defaultAngleUnits);
} }
try { try {
me.setAngleUnits(AngleUnit.deg); me.setAngleUnits(AngleUnit.deg);
Assert.assertEquals("1", Expression.valueOf("1°").numeric().toString()); assertEquals("1", Expression.valueOf("1°").numeric().toString());
Assert.assertEquals("2", Expression.valueOf("2°").numeric().toString()); assertEquals("2", Expression.valueOf("2°").numeric().toString());
Assert.assertEquals("3", Expression.valueOf("3°").numeric().toString()); assertEquals("3", Expression.valueOf("3°").numeric().toString());
Assert.assertEquals("15", Expression.valueOf("3°*5").numeric().toString()); assertEquals("15", Expression.valueOf("3°*5").numeric().toString());
Assert.assertEquals("9", Expression.valueOf("3°^2").numeric().toString()); assertEquals("9", Expression.valueOf("3°^2").numeric().toString());
Assert.assertEquals("36", Expression.valueOf("3!°^2").numeric().toString()); assertEquals("36", Expression.valueOf("3!°^2").numeric().toString());
Assert.assertEquals("3", Expression.valueOf("3°°").numeric().toString()); assertEquals("3", Expression.valueOf("3°°").numeric().toString());
Assert.assertEquals("5", Expression.valueOf("5°").numeric().toString()); assertEquals("5", Expression.valueOf("5°").numeric().toString());
Assert.assertEquals("5", Expression.valueOf("2+3°").numeric().toString()); assertEquals("5", Expression.valueOf("2+3°").numeric().toString());
} finally { } finally {
me.setAngleUnits(defaultAngleUnits); me.setAngleUnits(defaultAngleUnits);
} }
Assert.assertEquals("6", Expression.valueOf("2*∂(3*x,x)").expand().toString()); assertEquals("6", Expression.valueOf("2*∂(3*x,x)").expand().toString());
Assert.assertEquals("3", Expression.valueOf("∂(3*x,x)").expand().toString()); assertEquals("3", Expression.valueOf("∂(3*x,x)").expand().toString());
Assert.assertEquals("12", Expression.valueOf("∂(x^3,x,2)").expand().toString()); assertEquals("12", Expression.valueOf("∂(x^3,x,2)").expand().toString());
Assert.assertEquals("3*a", Expression.valueOf("∂(3*x*a,x)").expand().toString()); assertEquals("3*a", Expression.valueOf("∂(3*x*a,x)").expand().toString());
Assert.assertEquals("0", Expression.valueOf("∂(3*x*a,x,0.011,2)").expand().toString()); assertEquals("0", Expression.valueOf("∂(3*x*a,x,0.011,2)").expand().toString());
Assert.assertEquals("0", Expression.valueOf("2*∂(3*x*a,x,0.011,2)").expand().toString()); assertEquals("0", Expression.valueOf("2*∂(3*x*a,x,0.011,2)").expand().toString());
Assert.assertEquals("ln(8)+lg(8)*ln(8)", Expression.valueOf("ln(8)*lg(8)+ln(8)").expand().toString()); assertEquals("ln(8)+lg(8)*ln(8)", Expression.valueOf("ln(8)*lg(8)+ln(8)").expand().toString());
Assert.assertEquals("3.9573643765059856", Expression.valueOf("ln(8)*lg(8)+ln(8)").numeric().toString()); assertEquals("3.957364376505986", Expression.valueOf("ln(8)*lg(8)+ln(8)").numeric().toString());
Assert.assertEquals("4!", Expression.valueOf("4.0!").simplify().toString()); assertEquals("4!", Expression.valueOf("4.0!").simplify().toString());
Assert.assertEquals("4°", Expression.valueOf("4.0°").simplify().toString()); assertEquals("4°", Expression.valueOf("4.0°").simplify().toString());
Assert.assertEquals("30°", Expression.valueOf("30°").simplify().toString()); assertEquals("30°", Expression.valueOf("30°").simplify().toString());
Assert.assertEquals("1", Expression.valueOf("abs(1)").numeric().toString()); assertEquals("1", Expression.valueOf("abs(1)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("abs(0)").numeric().toString()); assertEquals("0", Expression.valueOf("abs(0)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("abs(-0)").numeric().toString()); assertEquals("0", Expression.valueOf("abs(-0)").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("abs(-1)").numeric().toString()); assertEquals("1", Expression.valueOf("abs(-1)").numeric().toString());
Assert.assertEquals("∞", Expression.valueOf("abs(-∞)").numeric().toString()); assertEquals("∞", Expression.valueOf("abs(-∞)").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("abs(i)").numeric().toString()); assertEquals("1", Expression.valueOf("abs(i)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("abs(0+0*i)").numeric().toString()); assertEquals("0", Expression.valueOf("abs(0+0*i)").numeric().toString());
Assert.assertEquals("1", Expression.valueOf("abs(-i)").numeric().toString()); assertEquals("1", Expression.valueOf("abs(-i)").numeric().toString());
Assert.assertEquals("2.23606797749979", Expression.valueOf("abs(2-i)").numeric().toString()); assertEquals("2.23606797749979", Expression.valueOf("abs(2-i)").numeric().toString());
Assert.assertEquals("2.23606797749979", Expression.valueOf("abs(2+i)").numeric().toString()); assertEquals("2.23606797749979", Expression.valueOf("abs(2+i)").numeric().toString());
Assert.assertEquals("2.8284271247461903", Expression.valueOf("abs(2+2*i)").numeric().toString()); assertEquals("2.82842712474619", Expression.valueOf("abs(2+2*i)").numeric().toString());
Assert.assertEquals("2.8284271247461903", Expression.valueOf("abs(2-2*i)").numeric().toString()); assertEquals("2.82842712474619", Expression.valueOf("abs(2-2*i)").numeric().toString());
try { try {
final ExtendedConstant.Builder k = new ExtendedConstant.Builder(new Constant("k"), 2.8284271247461903); final ExtendedConstant.Builder k = new ExtendedConstant.Builder(new Constant("k"), 2.8284271247461903);
me.getConstantsRegistry().addOrUpdate(k.create()); me.getConstantsRegistry().addOrUpdate(k.create());
Assert.assertEquals("k", Expression.valueOf("k").numeric().toString()); assertEquals("k", Expression.valueOf("k").numeric().toString());
Assert.assertEquals("k", Expression.valueOf("k").simplify().toString()); assertEquals("k", Expression.valueOf("k").simplify().toString());
Assert.assertEquals("k", Expression.valueOf("k").simplify().toString()); assertEquals("k", Expression.valueOf("k").simplify().toString());
Assert.assertEquals("k^3", Expression.valueOf("k*k*k").simplify().toString()); assertEquals("k^3", Expression.valueOf("k*k*k").simplify().toString());
Assert.assertEquals("22.627416997969526", Expression.valueOf("k*k*k").numeric().toString()); assertEquals("22.62741699796953", Expression.valueOf("k*k*k").numeric().toString());
} finally { } finally {
final ExtendedConstant.Builder k = new ExtendedConstant.Builder(new Constant("k"), (String) null); final ExtendedConstant.Builder k = new ExtendedConstant.Builder(new Constant("k"), (String) null);
me.getConstantsRegistry().addOrUpdate(k.create()); me.getConstantsRegistry().addOrUpdate(k.create());
@ -281,9 +278,9 @@ public class ExpressionTest {
try { try {
final ExtendedConstant.Builder k_1 = new ExtendedConstant.Builder(new Constant("k_1"), 3d); final ExtendedConstant.Builder k_1 = new ExtendedConstant.Builder(new Constant("k_1"), 3d);
me.getConstantsRegistry().addOrUpdate(k_1.create()); me.getConstantsRegistry().addOrUpdate(k_1.create());
Assert.assertEquals("k_1", Expression.valueOf("k_1").numeric().toString()); assertEquals("k_1", Expression.valueOf("k_1").numeric().toString());
Assert.assertEquals("k_1", Expression.valueOf("k_1[0]").numeric().toString()); assertEquals("k_1", Expression.valueOf("k_1[0]").numeric().toString());
Assert.assertEquals("k_1", Expression.valueOf("k_1[2]").numeric().toString()); assertEquals("k_1", Expression.valueOf("k_1[2]").numeric().toString());
} finally { } finally {
final ExtendedConstant.Builder k_1 = new ExtendedConstant.Builder(new Constant("k_1"), (String) null); final ExtendedConstant.Builder k_1 = new ExtendedConstant.Builder(new Constant("k_1"), (String) null);
me.getConstantsRegistry().addOrUpdate(k_1.create()); me.getConstantsRegistry().addOrUpdate(k_1.create());
@ -291,67 +288,67 @@ public class ExpressionTest {
Generic expression = me.simplifyGeneric("cos(t)+∂(cos(t),t)"); Generic expression = me.simplifyGeneric("cos(t)+∂(cos(t),t)");
Generic substituted = expression.substitute(new Constant("t"), Expression.valueOf(100d)); Generic substituted = expression.substitute(new Constant("t"), Expression.valueOf(100d));
Assert.assertEquals("-1.1584559306791382", substituted.numeric().toString()); assertEquals("-1.158455930679138", substituted.numeric().toString());
expression = me.simplifyGeneric("abs(t)^2+2!"); expression = me.simplifyGeneric("abs(t)^2+2!");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("102", substituted.numeric().toString()); assertEquals("102", substituted.numeric().toString());
expression = me.simplifyGeneric("abs(t)^2+10%"); expression = me.simplifyGeneric("abs(t)^2+10%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("110", substituted.numeric().toString()); assertEquals("110", substituted.numeric().toString());
expression = me.simplifyGeneric("abs(t)^2-10%"); expression = me.simplifyGeneric("abs(t)^2-10%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("90", substituted.numeric().toString()); assertEquals("90", substituted.numeric().toString());
expression = me.simplifyGeneric("(abs(t)^2)*10%"); expression = me.simplifyGeneric("(abs(t)^2)*10%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("10", substituted.numeric().toString()); assertEquals("10", substituted.numeric().toString());
expression = me.simplifyGeneric("(abs(t)^2)/10%"); expression = me.simplifyGeneric("(abs(t)^2)/10%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("1000", substituted.numeric().toString()); assertEquals("1000", substituted.numeric().toString());
expression = me.simplifyGeneric("abs(t)^2+t%"); expression = me.simplifyGeneric("abs(t)^2+t%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("110", substituted.numeric().toString()); assertEquals("110", substituted.numeric().toString());
expression = me.simplifyGeneric("abs(t)^2-t%"); expression = me.simplifyGeneric("abs(t)^2-t%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("90", substituted.numeric().toString()); assertEquals("90", substituted.numeric().toString());
expression = me.simplifyGeneric("(abs(t)^2)*t%"); expression = me.simplifyGeneric("(abs(t)^2)*t%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("10", substituted.numeric().toString()); assertEquals("10", substituted.numeric().toString());
expression = me.simplifyGeneric("(abs(t)^2)/t%"); expression = me.simplifyGeneric("(abs(t)^2)/t%");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("1000", substituted.numeric().toString()); assertEquals("1000", substituted.numeric().toString());
expression = me.simplifyGeneric("Σ(t, t, 0, 10)"); expression = me.simplifyGeneric("Σ(t, t, 0, 10)");
Assert.assertEquals("55", expression.numeric().toString()); assertEquals("55", expression.numeric().toString());
expression = me.simplifyGeneric("Σ(t, t, 0, 10)"); expression = me.simplifyGeneric("Σ(t, t, 0, 10)");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("55", substituted.numeric().toString()); assertEquals("55", substituted.numeric().toString());
expression = me.simplifyGeneric("10*Σ(t, t, 0, 10)"); expression = me.simplifyGeneric("10*Σ(t, t, 0, 10)");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("550", substituted.numeric().toString()); assertEquals("550", substituted.numeric().toString());
expression = me.simplifyGeneric("t*Σ(t, t, 0, 10)"); expression = me.simplifyGeneric("t*Σ(t, t, 0, 10)");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("550", substituted.numeric().toString()); assertEquals("550", substituted.numeric().toString());
expression = me.simplifyGeneric("t*Σ(t+100%, t, 0, 10)"); expression = me.simplifyGeneric("t*Σ(t+100%, t, 0, 10)");
substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d)); substituted = expression.substitute(new Constant("t"), Expression.valueOf(10d));
Assert.assertEquals("1100", substituted.numeric().toString()); assertEquals("1100", substituted.numeric().toString());
Assert.assertEquals("i*t", Expression.valueOf("i*t").expand().simplify().toString()); assertEquals("i*t", Expression.valueOf("i*t").expand().simplify().toString());
Assert.assertEquals("t", Expression.valueOf("t").simplify().toString()); assertEquals("t", Expression.valueOf("t").simplify().toString());
Assert.assertEquals("t^3", Expression.valueOf("t*t*t").simplify().toString()); assertEquals("t^3", Expression.valueOf("t*t*t").simplify().toString());
try { try {
Expression.valueOf("t").numeric(); Expression.valueOf("t").numeric();
@ -367,60 +364,60 @@ public class ExpressionTest {
} catch (ArithmeticException e) { } catch (ArithmeticException e) {
} }
Assert.assertEquals("√(1+t)/(1+t)", Expression.valueOf("1/√(1+t)").simplify().toString()); assertEquals("√(1+t)/(1+t)", Expression.valueOf("1/√(1+t)").simplify().toString());
Assert.assertEquals("t", Expression.valueOf("t").simplify().toString()); assertEquals("t", Expression.valueOf("t").simplify().toString());
Assert.assertEquals("t^3", Expression.valueOf("t*t*t").simplify().toString()); assertEquals("t^3", Expression.valueOf("t*t*t").simplify().toString());
try { try {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("0.6931471805599453+Π*i", Expression.valueOf("ln(-2)").numeric().toString()); assertEquals("0.6931471805599453+Π*i", Expression.valueOf("ln(-2)").numeric().toString());
} finally { } finally {
me.setAngleUnits(AngleUnit.deg); me.setAngleUnits(AngleUnit.deg);
} }
Assert.assertEquals("-2/57", Expression.valueOf("1/(-57/2)").simplify().toString()); assertEquals("-2/57", Expression.valueOf("1/(-57/2)").simplify().toString());
Assert.assertEquals("sin(30)", Expression.valueOf("sin(30)").expand().toString()); assertEquals("sin(30)", Expression.valueOf("sin(30)").expand().toString());
Assert.assertEquals("sin(n)", Expression.valueOf("sin(n)").expand().toString()); assertEquals("sin(n)", Expression.valueOf("sin(n)").expand().toString());
Assert.assertEquals("sin(n!)", Expression.valueOf("sin(n!)").expand().toString()); assertEquals("sin(n!)", Expression.valueOf("sin(n!)").expand().toString());
Assert.assertEquals("sin(n°)", Expression.valueOf("sin(n°)").expand().toString()); assertEquals("sin(n°)", Expression.valueOf("sin(n°)").expand().toString());
Assert.assertEquals("sin(30°)", Expression.valueOf("sin(30°)").expand().toString()); assertEquals("sin(30°)", Expression.valueOf("sin(30°)").expand().toString());
Assert.assertEquals("0.49999999999999994", Expression.valueOf("sin(30°)").expand().numeric().toString()); assertEquals("0.4999999999999999", Expression.valueOf("sin(30°)").expand().numeric().toString());
Assert.assertEquals("sin(2!)", Expression.valueOf("sin(2!)").expand().toString()); assertEquals("sin(2!)", Expression.valueOf("sin(2!)").expand().toString());
Assert.assertEquals("12", Expression.valueOf("3*(3+1)").expand().toString()); assertEquals("12", Expression.valueOf("3*(3+1)").expand().toString());
Assert.assertEquals("114.59155902616465", Expression.valueOf("deg(2)").numeric().toString()); assertEquals("114.5915590261647", Expression.valueOf("deg(2)").numeric().toString());
try { try {
Assert.assertEquals("-0.1425465430742778", Expression.valueOf("∏(tan(3))").numeric().toString()); assertEquals("-0.1425465430742778", Expression.valueOf("∏(tan(3))").numeric().toString());
fail(); fail();
} catch (ParseException e) { } catch (ParseException e) {
} }
try { try {
Assert.assertEquals("-0.14255", Expression.valueOf("sin(2,2)").expand().numeric().toString()); assertEquals("-0.14255", Expression.valueOf("sin(2,2)").expand().numeric().toString());
fail(); fail();
} catch (ParseException e) { } catch (ParseException e) {
} }
try { try {
Assert.assertEquals("114.59155902616465", Expression.valueOf("deg(2,2)").numeric().toString()); assertEquals("114.59155902616465", Expression.valueOf("deg(2,2)").numeric().toString());
fail(); fail();
} catch (ParseException e) { } catch (ParseException e) {
} }
Assert.assertEquals("0.49999999999999994", Expression.valueOf("sin(30°)").numeric().toString()); assertEquals("0.4999999999999999", Expression.valueOf("sin(30°)").numeric().toString());
Assert.assertEquals("π", Expression.valueOf("√(π)^2").simplify().toString()); assertEquals("π", Expression.valueOf("√(π)^2").simplify().toString());
Assert.assertEquals("π", Expression.valueOf("√(π^2)").simplify().toString()); assertEquals("π", Expression.valueOf("√(π^2)").simplify().toString());
Assert.assertEquals("π^2", Expression.valueOf("√(π^2*π^2)").simplify().toString()); assertEquals("π^2", Expression.valueOf("√(π^2*π^2)").simplify().toString());
Assert.assertEquals("π^3", Expression.valueOf("√(π^4*π^2)").simplify().toString()); assertEquals("π^3", Expression.valueOf("√(π^4*π^2)").simplify().toString());
Assert.assertEquals("e*π^2", Expression.valueOf("√(π^4*e^2)").simplify().toString()); assertEquals("e*π^2", Expression.valueOf("√(π^4*e^2)").simplify().toString());
Assert.assertEquals("1", Expression.valueOf("(π/π)!").numeric().toString()); assertEquals("1", Expression.valueOf("(π/π)!").numeric().toString());
// in deg mode π=180 and factorial of 180 is calculating // in deg mode π=180 and factorial of 180 is calculating
Assert.assertEquals("0", Expression.valueOf("Π/Π!").numeric().toString()); assertEquals("0", Expression.valueOf("Π/Π!").numeric().toString());
Assert.assertEquals("122.46467991473532E-18*i", Expression.valueOf("exp((Π*i))+1").numeric().toString()); assertEquals("0.0000000000000001*i", Expression.valueOf("exp((Π*i))+1").numeric().toString());
Assert.assertEquals("20*x^3", Expression.valueOf("∂(5*x^4, x)").expand().simplify().toString()); assertEquals("20*x^3", Expression.valueOf("∂(5*x^4, x)").expand().simplify().toString());
Assert.assertEquals("25*x", Expression.valueOf("5*x*5").expand().simplify().toString()); assertEquals("25*x", Expression.valueOf("5*x*5").expand().simplify().toString());
Assert.assertEquals("20*x", Expression.valueOf("5*x*4").expand().simplify().toString()); assertEquals("20*x", Expression.valueOf("5*x*4").expand().simplify().toString());
try { try {
me.evaluate("0b:π"); me.evaluate("0b:π");
@ -439,11 +436,11 @@ public class ExpressionTest {
try { try {
me.setNumeralBase(NumeralBase.hex); me.setNumeralBase(NumeralBase.hex);
Assert.assertEquals("0.EEEEEEEEEEEEEC880AB7", me.evaluate("0x:E/0x:F")); assertEquals("0.EEEEEEEEEEEEEC88", me.evaluate("0x:E/0x:F"));
Assert.assertEquals("E/F", me.simplify("0x:E/0x:F")); assertEquals("E/F", me.simplify("0x:E/0x:F"));
Assert.assertEquals("0.EEEEEEEEEEEEEC880AB7", me.evaluate("E/F")); assertEquals("0.EEEEEEEEEEEEEC88", me.evaluate("E/F"));
Assert.assertEquals("E/F", me.simplify("E/F")); assertEquals("E/F", me.simplify("E/F"));
} finally { } finally {
me.setNumeralBase(NumeralBase.dec); me.setNumeralBase(NumeralBase.dec);
@ -451,58 +448,58 @@ public class ExpressionTest {
try { try {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("-1.5707963267948966+2.993222846126381*i", me.evaluate("asin(-10)")); assertEquals("-1.570796326794897+2.993222846126381*i", me.evaluate("asin(-10)"));
Assert.assertEquals("-1.5707963267948966+1.3169578969248166*i", me.evaluate("asin(-2)")); assertEquals("-1.570796326794897+1.316957896924817*i", me.evaluate("asin(-2)"));
Assert.assertEquals("-1.5707963267948966", me.evaluate("asin(-1)")); assertEquals("-1.570796326794897", me.evaluate("asin(-1)"));
Assert.assertEquals("0", me.evaluate("asin(0)")); assertEquals("0", me.evaluate("asin(0)"));
Assert.assertEquals("1.5707963267948966", me.evaluate("asin(1)")); assertEquals("1.570796326794897", me.evaluate("asin(1)"));
Assert.assertEquals("1.5707963267948966-1.3169578969248166*i", me.evaluate("asin(2)")); assertEquals("1.570796326794897-1.316957896924817*i", me.evaluate("asin(2)"));
Assert.assertEquals("1.5707963267948966-2.993222846126381*i", me.evaluate("asin(10)")); assertEquals("1.570796326794897-2.993222846126381*i", me.evaluate("asin(10)"));
Assert.assertEquals("Π-2.9932228461263786*i", me.evaluate("acos(-10)")); assertEquals("Π-2.993222846126379*i", me.evaluate("acos(-10)"));
Assert.assertEquals("Π-1.3169578969248164*i", me.evaluate("acos(-2)")); assertEquals("Π-1.316957896924816*i", me.evaluate("acos(-2)"));
Assert.assertEquals("Π", me.evaluate("acos(-1)")); assertEquals("Π", me.evaluate("acos(-1)"));
Assert.assertEquals("1.5707963267948966", me.evaluate("acos(0)")); assertEquals("1.570796326794897", me.evaluate("acos(0)"));
Assert.assertEquals("0", me.evaluate("acos(1)")); assertEquals("0", me.evaluate("acos(1)"));
Assert.assertEquals("1.3169578969248164*i", me.evaluate("acos(2)")); assertEquals("1.316957896924816*i", me.evaluate("acos(2)"));
Assert.assertEquals("2.9932228461263786*i", me.evaluate("acos(10)")); assertEquals("2.993222846126379*i", me.evaluate("acos(10)"));
Assert.assertEquals("-1.4711276743037347", me.evaluate("atan(-10)")); assertEquals("-1.471127674303735", me.evaluate("atan(-10)"));
Assert.assertEquals("-1.1071487177940904", me.evaluate("atan(-2)")); assertEquals("-1.10714871779409", me.evaluate("atan(-2)"));
Assert.assertEquals("-0.7853981633974483", me.evaluate("atan(-1)")); assertEquals("-0.7853981633974483", me.evaluate("atan(-1)"));
Assert.assertEquals("0", me.evaluate("atan(0)")); assertEquals("0", me.evaluate("atan(0)"));
Assert.assertEquals("0.7853981633974483", me.evaluate("atan(1)")); assertEquals("0.7853981633974483", me.evaluate("atan(1)"));
Assert.assertEquals("1.1071487177940904", me.evaluate("atan(2)")); assertEquals("1.10714871779409", me.evaluate("atan(2)"));
Assert.assertEquals("1.4711276743037347", me.evaluate("atan(10)")); assertEquals("1.471127674303735", me.evaluate("atan(10)"));
for (int i = -10; i < 10; i++) { for (int i = -10; i < 10; i++) {
Assert.assertEquals(me.evaluate("3.14159265358979323846/2 - atan(" + i + ")"), me.evaluate("acot(" + i + ")")); assertEquals(me.evaluate("3.14159265358979323846/2 - atan(" + i + ")"), me.evaluate("acot(" + i + ")"));
} }
Assert.assertEquals("3.0419240010986313", me.evaluate("3.14159265358979323846/2 - atan(-10)")); assertEquals("3.041924001098631", me.evaluate("3.14159265358979323846/2 - atan(-10)"));
Assert.assertEquals("3.0419240010986313", me.evaluate("acot(-10)")); assertEquals("3.041924001098631", me.evaluate("acot(-10)"));
Assert.assertEquals("1.5707963267948966", me.evaluate("acot(0)")); assertEquals("1.570796326794897", me.evaluate("acot(0)"));
Assert.assertEquals("2.677945044588987", me.evaluate("acot(-2)")); assertEquals("2.677945044588987", me.evaluate("acot(-2)"));
Assert.assertEquals("2.356194490192345", me.evaluate("acot(-1)")); assertEquals("2.356194490192345", me.evaluate("acot(-1)"));
Assert.assertEquals("0.7853981633974483", me.evaluate("acot(1)")); assertEquals("0.7853981633974483", me.evaluate("acot(1)"));
Assert.assertEquals("0.46364760900080615", me.evaluate("acot(2)")); assertEquals("0.4636476090008062", me.evaluate("acot(2)"));
Assert.assertEquals("0.09966865249116186", me.evaluate("acot(10)")); assertEquals("0.0996686524911619", me.evaluate("acot(10)"));
Assert.assertEquals("Π", me.evaluate("π")); assertEquals("Π", me.evaluate("π"));
Assert.assertEquals("Π", me.evaluate("3.14159265358979323846")); assertEquals("Π", me.evaluate("3.14159265358979323846"));
} finally { } finally {
me.setAngleUnits(AngleUnit.deg); me.setAngleUnits(AngleUnit.deg);
} }
Assert.assertEquals("180", me.evaluate("Π")); assertEquals("180", me.evaluate("Π"));
Assert.assertEquals("180", me.evaluate("200-10%")); assertEquals("180", me.evaluate("200-10%"));
Assert.assertEquals("∞", me.evaluate("1/0")); assertEquals("∞", me.evaluate("1/0"));
Assert.assertEquals("-∞", me.evaluate("-1/0")); assertEquals("-∞", me.evaluate("-1/0"));
Assert.assertEquals("-∞", me.evaluate("-1/0")); assertEquals("-∞", me.evaluate("-1/0"));
Assert.assertEquals("∞", me.evaluate("(1 + 2) / (5 - 3 - 2)")); assertEquals("∞", me.evaluate("(1 + 2) / (5 - 3 - 2)"));
Assert.assertEquals("∞", me.evaluate("(1 + 2) / (5.1 - 3.1 - 2.0 )")); assertEquals("∞", me.evaluate("(1 + 2) / (5.1 - 3.1 - 2.0 )"));
Assert.assertEquals("∞", me.evaluate("1/0")); assertEquals("∞", me.evaluate("1/0"));
} }
@Test @Test
@ -523,111 +520,111 @@ public class ExpressionTest {
try { try {
mathEngine.setAngleUnits(AngleUnit.rad); mathEngine.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("Π", mathEngine.evaluate("π")); assertEquals("Π", mathEngine.evaluate("π"));
Assert.assertEquals("π/2", mathEngine.simplify("π/2")); assertEquals("π/2", mathEngine.simplify("π/2"));
Assert.assertEquals(mathEngine.evaluate("0.9092974268256816953960198659117448427022549714478902683789"), mathEngine.evaluate("sin(2)")); assertEquals(mathEngine.evaluate("0.9092974268256816953960198659117448427022549714478902683789"), mathEngine.evaluate("sin(2)"));
Assert.assertEquals(mathEngine.evaluate("0.1411200080598672221007448028081102798469332642522655841518"), mathEngine.evaluate("sin(3)")); assertEquals(mathEngine.evaluate("0.1411200080598672221007448028081102798469332642522655841518"), mathEngine.evaluate("sin(3)"));
Assert.assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(0)")); assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(0)"));
Assert.assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(0)")); assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(0)"));
Assert.assertEquals(mathEngine.evaluate("0.8623188722876839341019385139508425355100840085355108292801"), mathEngine.evaluate("cos(100)")); assertEquals(mathEngine.evaluate("0.8623188722876839341019385139508425355100840085355108292801"), mathEngine.evaluate("cos(100)"));
Assert.assertEquals(mathEngine.evaluate("-0.416146836547142386997568229500762189766000771075544890755"), mathEngine.evaluate("cos(2)")); assertEquals(mathEngine.evaluate("-0.416146836547142386997568229500762189766000771075544890755"), mathEngine.evaluate("cos(2)"));
Assert.assertEquals(mathEngine.evaluate("-2.185039863261518991643306102313682543432017746227663164562"), mathEngine.evaluate("tan(2)")); assertEquals(mathEngine.evaluate("-2.185039863261518991643306102313682543432017746227663164562"), mathEngine.evaluate("tan(2)"));
Assert.assertEquals(mathEngine.evaluate("-0.142546543074277805295635410533913493226092284901804647633"), mathEngine.evaluate("tan(3)")); assertEquals(mathEngine.evaluate("-0.142546543074277805295635410533913493226092284901804647633"), mathEngine.evaluate("tan(3)"));
Assert.assertEquals(mathEngine.evaluate("0.6483608274590872"), mathEngine.evaluate("tan(10)")); assertEquals(mathEngine.evaluate("0.6483608274590872"), mathEngine.evaluate("tan(10)"));
Assert.assertEquals(mathEngine.evaluate("0.6420926159343306"), mathEngine.evaluate("cot(1)")); assertEquals(mathEngine.evaluate("0.6420926159343306"), mathEngine.evaluate("cot(1)"));
Assert.assertEquals(mathEngine.evaluate("-0.457657554360285763750277410432047276428486329231674329641"), mathEngine.evaluate("cot(2)")); assertEquals(mathEngine.evaluate("-0.457657554360285763750277410432047276428486329231674329641"), mathEngine.evaluate("cot(2)"));
Assert.assertEquals(mathEngine.evaluate("-7.015252551434533469428551379526476578293103352096353838156"), mathEngine.evaluate("cot(3)")); assertEquals(mathEngine.evaluate("-7.015252551434533469428551379526476578293103352096353838156"), mathEngine.evaluate("cot(3)"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
try { try {
mathEngine.setAngleUnits(AngleUnit.deg); mathEngine.setAngleUnits(AngleUnit.deg);
Assert.assertEquals(mathEngine.evaluate("0.9092974268256816953960198659117448427022549714478902683789"), mathEngine.evaluate("sin(deg(2))")); assertEquals(mathEngine.evaluate("0.9092974268256816953960198659117448427022549714478902683789"), mathEngine.evaluate("sin(deg(2))"));
Assert.assertEquals(mathEngine.evaluate("0.1411200080598672221007448028081102798469332642522655841518"), mathEngine.evaluate("sin(deg(3))")); assertEquals(mathEngine.evaluate("0.1411200080598672221007448028081102798469332642522655841518"), mathEngine.evaluate("sin(deg(3))"));
Assert.assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(deg(0))")); assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(deg(0))"));
Assert.assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(deg(0))")); assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(deg(0))"));
Assert.assertEquals(mathEngine.evaluate("0.8623188722876839341019385139508425355100840085355108292801"), mathEngine.evaluate("cos(deg(100))")); assertEquals(mathEngine.evaluate("0.8623188722876839341019385139508425355100840085355108292801"), mathEngine.evaluate("cos(deg(100))"));
Assert.assertEquals(mathEngine.evaluate("-0.416146836547142386997568229500762189766000771075544890755"), mathEngine.evaluate("cos(deg(2))")); assertEquals(mathEngine.evaluate("-0.416146836547142386997568229500762189766000771075544890755"), mathEngine.evaluate("cos(deg(2))"));
Assert.assertEquals(mathEngine.evaluate("-2.185039863261518991643306102313682543432017746227663164562"), mathEngine.evaluate("tan(deg(2))")); assertEquals(mathEngine.evaluate("-2.185039863261518991643306102313682543432017746227663164562"), mathEngine.evaluate("tan(deg(2))"));
Assert.assertEquals(mathEngine.evaluate("-0.142546543074277805295635410533913493226092284901804647633"), mathEngine.evaluate("tan(deg(3))")); assertEquals(mathEngine.evaluate("-0.142546543074277805295635410533913493226092284901804647633"), mathEngine.evaluate("tan(deg(3))"));
Assert.assertEquals(mathEngine.evaluate("0.6483608274590872"), mathEngine.evaluate("tan(deg(10))")); assertEquals(mathEngine.evaluate("0.6483608274590872"), mathEngine.evaluate("tan(deg(10))"));
Assert.assertEquals(mathEngine.evaluate("0.6420926159343306"), mathEngine.evaluate("cot(deg(1))")); assertEquals(mathEngine.evaluate("0.6420926159343306"), mathEngine.evaluate("cot(deg(1))"));
Assert.assertEquals(mathEngine.evaluate("-0.457657554360285763750277410432047276428486329231674329641"), mathEngine.evaluate("cot(deg(2))")); assertEquals(mathEngine.evaluate("-0.457657554360285763750277410432047276428486329231674329641"), mathEngine.evaluate("cot(deg(2))"));
Assert.assertEquals(mathEngine.evaluate("-7.015252551434533469428551379526476578293103352096353838156"), mathEngine.evaluate("cot(deg(3))")); assertEquals(mathEngine.evaluate("-7.015252551434533469428551379526476578293103352096353838156"), mathEngine.evaluate("cot(deg(3))"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
try { try {
mathEngine.setAngleUnits(AngleUnit.rad); mathEngine.setAngleUnits(AngleUnit.rad);
Assert.assertEquals(mathEngine.evaluate("-0.5235987755982989"), mathEngine.evaluate("asin(-0.5)")); assertEquals(mathEngine.evaluate("-0.5235987755982989"), mathEngine.evaluate("asin(-0.5)"));
Assert.assertEquals(mathEngine.evaluate("-0.47349551215005636"), mathEngine.evaluate("asin(-0.456)")); assertEquals(mathEngine.evaluate("-0.47349551215005636"), mathEngine.evaluate("asin(-0.456)"));
Assert.assertEquals(mathEngine.evaluate("0.32784124364198347"), mathEngine.evaluate("asin(0.322)")); assertEquals(mathEngine.evaluate("0.32784124364198347"), mathEngine.evaluate("asin(0.322)"));
Assert.assertEquals(mathEngine.evaluate("1.2429550831529133"), mathEngine.evaluate("acos(0.322)")); assertEquals(mathEngine.evaluate("1.2429550831529133"), mathEngine.evaluate("acos(0.322)"));
Assert.assertEquals(mathEngine.evaluate("1.5587960387762325"), mathEngine.evaluate("acos(0.012)")); assertEquals(mathEngine.evaluate("1.5587960387762325"), mathEngine.evaluate("acos(0.012)"));
Assert.assertEquals(mathEngine.evaluate("1.6709637479564563"), mathEngine.evaluate("acos(-0.1)")); assertEquals(mathEngine.evaluate("1.6709637479564563"), mathEngine.evaluate("acos(-0.1)"));
Assert.assertEquals(mathEngine.evaluate("0.3805063771123649"), mathEngine.evaluate("atan(0.4)")); assertEquals(mathEngine.evaluate("0.3805063771123649"), mathEngine.evaluate("atan(0.4)"));
Assert.assertEquals(mathEngine.evaluate("0.09966865249116204"), mathEngine.evaluate("atan(0.1)")); assertEquals(mathEngine.evaluate("0.09966865249116204"), mathEngine.evaluate("atan(0.1)"));
Assert.assertEquals(mathEngine.evaluate("-0.5404195002705842"), mathEngine.evaluate("atan(-0.6)")); assertEquals(mathEngine.evaluate("-0.5404195002705842"), mathEngine.evaluate("atan(-0.6)"));
Assert.assertEquals(mathEngine.evaluate("1.0603080048781206"), mathEngine.evaluate("acot(0.56)")); assertEquals(mathEngine.evaluate("1.0603080048781206"), mathEngine.evaluate("acot(0.56)"));
// todo serso: wolfram alpha returns -0.790423 instead of 2.3511694068615325 (-PI) // todo serso: wolfram alpha returns -0.790423 instead of 2.3511694068615325 (-PI)
Assert.assertEquals(mathEngine.evaluate("2.3511694068615325"), mathEngine.evaluate("acot(-0.99)")); assertEquals(mathEngine.evaluate("2.3511694068615325"), mathEngine.evaluate("acot(-0.99)"));
// todo serso: wolfram alpha returns -1.373401 instead of 1.7681918866447774 (-PI) // todo serso: wolfram alpha returns -1.373401 instead of 1.7681918866447774 (-PI)
Assert.assertEquals(mathEngine.evaluate("1.7681918866447774"), mathEngine.evaluate("acot(-0.2)")); assertEquals(mathEngine.evaluate("1.7681918866447774"), mathEngine.evaluate("acot(-0.2)"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
try { try {
mathEngine.setAngleUnits(AngleUnit.deg); mathEngine.setAngleUnits(AngleUnit.deg);
Assert.assertEquals(mathEngine.evaluate("deg(-0.5235987755982989)"), mathEngine.evaluate("asin(-0.5)")); assertEquals(mathEngine.evaluate("deg(-0.5235987755982989)"), mathEngine.evaluate("asin(-0.5)"));
Assert.assertEquals(mathEngine.evaluate("-27.129294464583623"), mathEngine.evaluate("asin(-0.456)")); assertEquals(mathEngine.evaluate("-27.129294464583623"), mathEngine.evaluate("asin(-0.456)"));
Assert.assertEquals(mathEngine.evaluate("18.783919611005786"), mathEngine.evaluate("asin(0.322)")); assertEquals(mathEngine.evaluate("18.783919611005786"), mathEngine.evaluate("asin(0.322)"));
Assert.assertEquals(mathEngine.evaluate("71.21608038899423"), mathEngine.evaluate("acos(0.322)")); assertEquals(mathEngine.evaluate("71.21608038899423"), mathEngine.evaluate("acos(0.322)"));
Assert.assertEquals(mathEngine.evaluate("89.31243414358914"), mathEngine.evaluate("acos(0.012)")); assertEquals(mathEngine.evaluate("89.31243414358914"), mathEngine.evaluate("acos(0.012)"));
Assert.assertEquals(mathEngine.evaluate("95.73917047726678"), mathEngine.evaluate("acos(-0.1)")); assertEquals(mathEngine.evaluate("95.73917047726678"), mathEngine.evaluate("acos(-0.1)"));
Assert.assertEquals(mathEngine.evaluate("deg(0.3805063771123649)"), mathEngine.evaluate("atan(0.4)")); assertEquals(mathEngine.evaluate("deg(0.3805063771123649)"), mathEngine.evaluate("atan(0.4)"));
Assert.assertEquals(mathEngine.evaluate("deg(0.09966865249116204)"), mathEngine.evaluate("atan(0.1)")); assertEquals(mathEngine.evaluate("deg(0.09966865249116204)"), mathEngine.evaluate("atan(0.1)"));
Assert.assertEquals(mathEngine.evaluate("deg(-0.5404195002705842)"), mathEngine.evaluate("atan(-0.6)")); assertEquals(mathEngine.evaluate("deg(-0.5404195002705842)"), mathEngine.evaluate("atan(-0.6)"));
Assert.assertEquals(mathEngine.evaluate("deg(1.0603080048781206)"), mathEngine.evaluate("acot(0.56)")); assertEquals(mathEngine.evaluate("deg(1.0603080048781206)"), mathEngine.evaluate("acot(0.56)"));
// todo serso: wolfram alpha returns -0.790423 instead of 2.3511694068615325 (-PI) // todo serso: wolfram alpha returns -0.790423 instead of 2.3511694068615325 (-PI)
Assert.assertEquals(mathEngine.evaluate("134.7120839334429"), mathEngine.evaluate("acot(-0.99)")); assertEquals(mathEngine.evaluate("134.7120839334429"), mathEngine.evaluate("acot(-0.99)"));
// todo serso: wolfram alpha returns -1.373401 instead of 1.7681918866447774 (-PI) // todo serso: wolfram alpha returns -1.373401 instead of 1.7681918866447774 (-PI)
Assert.assertEquals(mathEngine.evaluate("deg(1.7681918866447774)"), mathEngine.evaluate("acot(-0.2)")); assertEquals(mathEngine.evaluate("deg(1.7681918866447774)"), mathEngine.evaluate("acot(-0.2)"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
try { try {
mathEngine.setAngleUnits(AngleUnit.deg); mathEngine.setAngleUnits(AngleUnit.deg);
Assert.assertEquals(mathEngine.evaluate("0.0348994967025009716459951816253329373548245760432968714250"), mathEngine.evaluate("(sin(2))")); assertEquals(mathEngine.evaluate("0.0348994967025009716459951816253329373548245760432968714250"), mathEngine.evaluate("(sin(2))"));
Assert.assertEquals(mathEngine.evaluate("0.0523359562429438327221186296090784187310182539401649204835"), mathEngine.evaluate("(sin(3))")); assertEquals(mathEngine.evaluate("0.0523359562429438327221186296090784187310182539401649204835"), mathEngine.evaluate("(sin(3))"));
Assert.assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(0)")); assertEquals(mathEngine.evaluate("0"), mathEngine.evaluate("sin(0)"));
Assert.assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(0)")); assertEquals(mathEngine.evaluate("1"), mathEngine.evaluate("cos(0)"));
Assert.assertEquals(mathEngine.evaluate("-0.1736481776669303"), mathEngine.evaluate("(cos(100))")); assertEquals(mathEngine.evaluate("-0.1736481776669303"), mathEngine.evaluate("(cos(100))"));
Assert.assertEquals(mathEngine.evaluate("0.9993908270190958"), mathEngine.evaluate("(cos(2))")); assertEquals(mathEngine.evaluate("0.9993908270190958"), mathEngine.evaluate("(cos(2))"));
Assert.assertEquals(mathEngine.evaluate("0.03492076949174773"), mathEngine.evaluate("(tan(2))")); assertEquals(mathEngine.evaluate("0.03492076949174773"), mathEngine.evaluate("(tan(2))"));
Assert.assertEquals(mathEngine.evaluate("0.05240777928304121"), mathEngine.evaluate("(tan(3))")); assertEquals(mathEngine.evaluate("0.05240777928304121"), mathEngine.evaluate("(tan(3))"));
Assert.assertEquals(mathEngine.evaluate("0.17632698070846498"), mathEngine.evaluate("(tan(10))")); assertEquals(mathEngine.evaluate("0.17632698070846498"), mathEngine.evaluate("(tan(10))"));
Assert.assertEquals(mathEngine.evaluate("57.28996163075943"), mathEngine.evaluate("(cot(1))")); assertEquals(mathEngine.evaluate("57.28996163075943"), mathEngine.evaluate("(cot(1))"));
Assert.assertEquals(mathEngine.evaluate("28.636253282915604"), mathEngine.evaluate("(cot(2))")); assertEquals(mathEngine.evaluate("28.636253282915604"), mathEngine.evaluate("(cot(2))"));
Assert.assertEquals(mathEngine.evaluate("19.081136687728208"), mathEngine.evaluate("(cot(3))")); assertEquals(mathEngine.evaluate("19.081136687728208"), mathEngine.evaluate("(cot(3))"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
@ -640,7 +637,7 @@ public class ExpressionTest {
testSinEqualsToSinh(mathEngine, 6d); testSinEqualsToSinh(mathEngine, 6d);
testSinEqualsToSinh(mathEngine, -1d, "-0.8414709848078965"); testSinEqualsToSinh(mathEngine, -1d, "-0.8414709848078965");
testSinEqualsToSinh(mathEngine, -3.3d, "0.1577456941432482"); testSinEqualsToSinh(mathEngine, -3.3d, "0.1577456941432482");
testSinEqualsToSinh(mathEngine, -232.2d, "0.27429486373689577"); testSinEqualsToSinh(mathEngine, -232.2d, "0.2742948637368958");
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
@ -648,23 +645,23 @@ public class ExpressionTest {
try { try {
mathEngine.setAngleUnits(AngleUnit.deg); mathEngine.setAngleUnits(AngleUnit.deg);
testSinEqualsToSinh(mathEngine, 0d); testSinEqualsToSinh(mathEngine, 0d);
testSinEqualsToSinh(mathEngine, 1d, "0.01745240643728351"); testSinEqualsToSinh(mathEngine, 1d, "0.0174524064372835");
testSinEqualsToSinh(mathEngine, 3d, "0.052335956242943835"); testSinEqualsToSinh(mathEngine, 3d, "0.0523359562429438");
testSinEqualsToSinh(mathEngine, 6d, "0.10452846326765347"); testSinEqualsToSinh(mathEngine, 6d, "0.1045284632676535");
testSinEqualsToSinh(mathEngine, -1d, "-0.01745240643728351"); testSinEqualsToSinh(mathEngine, -1d, "-0.0174524064372835");
testSinEqualsToSinh(mathEngine, -3.3d, "-0.05756402695956728"); testSinEqualsToSinh(mathEngine, -3.3d, "-0.0575640269595673");
testSinEqualsToSinh(mathEngine, -232.2d, "0.7901550123756904"); testSinEqualsToSinh(mathEngine, -232.2d, "0.7901550123756904");
Assert.assertEquals("Π/2", mathEngine.simplify("Π/2")); assertEquals("Π/2", mathEngine.simplify("Π/2"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
try { try {
mathEngine.setAngleUnits(AngleUnit.rad); mathEngine.setAngleUnits(AngleUnit.rad);
Assert.assertEquals(mathEngine.evaluate("1.5707963267948966-0.8813735870195429*i"), mathEngine.evaluate("acos(i)")); assertEquals(mathEngine.evaluate("1.5707963267948966-0.8813735870195429*i"), mathEngine.evaluate("acos(i)"));
Assert.assertEquals(mathEngine.evaluate("0.9045568943023814-1.0612750619050357*i"), mathEngine.evaluate("acos(1+i)")); assertEquals(mathEngine.evaluate("0.9045568943023814-1.0612750619050357*i"), mathEngine.evaluate("acos(1+i)"));
Assert.assertEquals(mathEngine.evaluate("0.9999999999999999-0.9999999999999998*i"), mathEngine.evaluate("cos(acos(1-i))")); assertEquals(mathEngine.evaluate("0.9999999999999999-0.9999999999999998*i"), mathEngine.evaluate("cos(acos(1-i))"));
Assert.assertEquals(mathEngine.evaluate("-0.9045568943023814-1.0612750619050355*i"), mathEngine.evaluate("-acos(1-i)")); assertEquals(mathEngine.evaluate("-0.9045568943023814-1.0612750619050355*i"), mathEngine.evaluate("-acos(1-i)"));
} finally { } finally {
mathEngine.setAngleUnits(defaultAngleUnits); mathEngine.setAngleUnits(defaultAngleUnits);
} }
@ -677,12 +674,12 @@ public class ExpressionTest {
private void testSinEqualsToSinh(@Nonnull MathEngine mathEngine, @Nonnull Double x, @Nullable String expected) throws ParseException { private void testSinEqualsToSinh(@Nonnull MathEngine mathEngine, @Nonnull Double x, @Nullable String expected) throws ParseException {
if (expected == null) { if (expected == null) {
Assert.assertEquals(mathEngine.evaluate("sinh(i*" + x + ")/i"), mathEngine.evaluate("sin(" + x + ")")); assertEquals(mathEngine.evaluate("sinh(i*" + x + ")/i"), mathEngine.evaluate("sin(" + x + ")"));
// Assert.assertEquals(mathEngine.evaluate("exp("+x+")-sinh(" + x + ")"), mathEngine.evaluate("cosh(" + x + ")")); // Assert.assertEquals(mathEngine.evaluate("exp("+x+")-sinh(" + x + ")"), mathEngine.evaluate("cosh(" + x + ")"));
} else { } else {
Assert.assertEquals(expected, mathEngine.evaluate("sin(" + x + ")")); assertEquals(expected, mathEngine.evaluate("sin(" + x + ")"));
Assert.assertEquals(expected, mathEngine.evaluate("(exp(i * " + x + ") - cos(" + x + "))/i")); assertEquals(expected, mathEngine.evaluate("(exp(i * " + x + ") - cos(" + x + "))/i"));
Assert.assertEquals(expected, mathEngine.evaluate("(exp(i * " + x + ") - cos(" + x + "))/i")); assertEquals(expected, mathEngine.evaluate("(exp(i * " + x + ") - cos(" + x + "))/i"));
} }
} }
@ -693,32 +690,32 @@ public class ExpressionTest {
@Test @Test
public void testIntegrals() throws Exception { public void testIntegrals() throws Exception {
Assert.assertEquals("50", Expression.valueOf("∫ab(x, x, 0, 10)").expand().numeric().toString()); assertEquals("50", Expression.valueOf("∫ab(x, x, 0, 10)").expand().numeric().toString());
Assert.assertEquals("1/2*a^2", Expression.valueOf("∫ab(x, x, 0, a)").expand().toString()); assertEquals("1/2*a^2", Expression.valueOf("∫ab(x, x, 0, a)").expand().toString());
try { try {
Assert.assertEquals("∫ab(x, x, 0)", Expression.valueOf("∫ab(x, x, 0)").expand().toString()); assertEquals("∫ab(x, x, 0)", Expression.valueOf("∫ab(x, x, 0)").expand().toString());
fail(); fail();
} catch (ParseException e) { } catch (ParseException e) {
} }
try { try {
Assert.assertEquals("∫ab(x, x)", Expression.valueOf("∫ab(x, x)").expand().simplify().toString()); assertEquals("∫ab(x, x)", Expression.valueOf("∫ab(x, x)").expand().simplify().toString());
fail(); fail();
} catch (ParseException e) { } catch (ParseException e) {
} }
Assert.assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().simplify().toString()); assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().simplify().toString());
try { try {
Assert.assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().numeric().toString()); assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().numeric().toString());
fail(); fail();
} catch (ArithmeticException e) { } catch (ArithmeticException e) {
} }
Assert.assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().simplify().toString()); assertEquals("x^2/2", Expression.valueOf("∫(x, x)").expand().simplify().toString());
Assert.assertEquals("ln(x)", Expression.valueOf("∫(1/x, x)").expand().simplify().toString()); assertEquals("ln(x)", Expression.valueOf("∫(1/x, x)").expand().simplify().toString());
try { try {
JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad); JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad);
Assert.assertEquals("2*ln(2)+ln(cosh(x))", Expression.valueOf("∫(tanh(x), x)").expand().simplify().toString()); assertEquals("2*ln(2)+ln(cosh(x))", Expression.valueOf("∫(tanh(x), x)").expand().simplify().toString());
Assert.assertEquals("2*ln(2)+ln(sin(x))", Expression.valueOf("∫(cot(x), x)").expand().simplify().toString()); assertEquals("2*ln(2)+ln(sin(x))", Expression.valueOf("∫(cot(x), x)").expand().simplify().toString());
Assert.assertEquals("-2*ln(2)-ln(cos(x))", Expression.valueOf("∫(tan(x), x)").expand().simplify().toString()); assertEquals("-2*ln(2)-ln(cos(x))", Expression.valueOf("∫(tan(x), x)").expand().simplify().toString());
} finally { } finally {
JsclMathEngine.getInstance().setAngleUnits(AngleUnit.deg); JsclMathEngine.getInstance().setAngleUnits(AngleUnit.deg);
} }
@ -729,12 +726,12 @@ public class ExpressionTest {
final AngleUnit defaultAngleUnits = JsclMathEngine.getInstance().getAngleUnits(); final AngleUnit defaultAngleUnits = JsclMathEngine.getInstance().getAngleUnits();
try { try {
JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad); JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad);
Assert.assertEquals("-0.9092974268256817", Expression.valueOf("∂(cos(t),t,2)").numeric().toString()); assertEquals("-0.9092974268256817", Expression.valueOf("∂(cos(t),t,2)").numeric().toString());
Assert.assertEquals("∂(cos(t), t, 2, 1)", Expression.valueOf("∂(cos(t),t,2)").simplify().toString()); assertEquals("∂(cos(t), t, 2, 1)", Expression.valueOf("∂(cos(t),t,2)").simplify().toString());
Assert.assertEquals("-2.234741690198506", Expression.valueOf("∂(t*cos(t),t,2)").numeric().toString()); assertEquals("-2.234741690198506", Expression.valueOf("∂(t*cos(t),t,2)").numeric().toString());
Assert.assertEquals("-4.469483380397012", Expression.valueOf("2*∂(t*cos(t),t,2)").numeric().toString()); assertEquals("-4.469483380397012", Expression.valueOf("2*∂(t*cos(t),t,2)").numeric().toString());
Assert.assertEquals("-sin(2)", Expression.valueOf("∂(cos(t),t,2)").expand().toString()); assertEquals("-sin(2)", Expression.valueOf("∂(cos(t),t,2)").expand().toString());
Assert.assertEquals("-sin(t)", Expression.valueOf("∂(cos(t),t)").expand().toString()); assertEquals("-sin(t)", Expression.valueOf("∂(cos(t),t)").expand().toString());
assertEquals("-sin(t)", Expression.valueOf("∂(cos(t),t,t,1)").expand().simplify().toString()); assertEquals("-sin(t)", Expression.valueOf("∂(cos(t),t,t,1)").expand().simplify().toString());
assertEquals("∂(cos(t), t, t, 1°)", Expression.valueOf("∂(cos(t),t,t,1°)").expand().simplify().toString()); assertEquals("∂(cos(t), t, t, 1°)", Expression.valueOf("∂(cos(t),t,t,1°)").expand().simplify().toString());
} finally { } finally {
@ -746,18 +743,18 @@ public class ExpressionTest {
@Test @Test
public void testSum() throws Exception { public void testSum() throws Exception {
Assert.assertEquals("3", Expression.valueOf("Σ(n,n,1,2)").expand().toString()); assertEquals("3", Expression.valueOf("Σ(n,n,1,2)").expand().toString());
Assert.assertEquals("200", Expression.valueOf("Σ(n/n,n,1,200)").expand().toString()); assertEquals("200", Expression.valueOf("Σ(n/n,n,1,200)").expand().toString());
Assert.assertEquals("1/3", Expression.valueOf("Σ((n-1)/(n+1),n,1,2)").expand().toString()); assertEquals("1/3", Expression.valueOf("Σ((n-1)/(n+1),n,1,2)").expand().toString());
Assert.assertEquals("sin(1)", Expression.valueOf("Σ(sin(n),n,1,1)").expand().toString()); assertEquals("sin(1)", Expression.valueOf("Σ(sin(n),n,1,1)").expand().toString());
Assert.assertEquals("1/1!", Expression.valueOf("Σ(n/n!,n,1,1)").expand().toString()); assertEquals("1/1!", Expression.valueOf("Σ(n/n!,n,1,1)").expand().toString());
Assert.assertEquals("2", Expression.valueOf("Σ(n/n!,n,1,2)").expand().numeric().toString()); assertEquals("2", Expression.valueOf("Σ(n/n!,n,1,2)").expand().numeric().toString());
Assert.assertEquals("2.7182818284590455", Expression.valueOf("Σ(n/n!,n,1,200)").expand().numeric().toString()); assertEquals("2.718281828459046", Expression.valueOf("Σ(n/n!,n,1,200)").expand().numeric().toString());
Assert.assertEquals("2.718281828459046", Expression.valueOf("Σ(n/(2*n/2)!,n,1,200)").expand().numeric().toString()); assertEquals("2.718281828459046", Expression.valueOf("Σ(n/(2*n/2)!,n,1,200)").expand().numeric().toString());
Assert.assertEquals(Expression.valueOf("3").numeric().toString(), Expression.valueOf("Σ(n°,n,1,2)").expand().numeric().toString()); assertEquals(Expression.valueOf("3").numeric().toString(), Expression.valueOf("Σ(n°,n,1,2)").expand().numeric().toString());
Assert.assertEquals("200", Expression.valueOf("Σ(n°/n°,n,1,200)").expand().numeric().toString()); assertEquals("200", Expression.valueOf("Σ(n°/n°,n,1,200)").expand().numeric().toString());
Assert.assertEquals("-sin(1)-sin(2)", Expression.valueOf("Σ(∂(cos(t),t,n),n,1,2)").expand().toString()); assertEquals("-sin(1)-sin(2)", Expression.valueOf("Σ(∂(cos(t),t,n),n,1,2)").expand().toString());
Assert.assertEquals("-0.05235190313978448", Expression.valueOf("Σ(∂(cos(t),t,n),n,1,2)").expand().numeric().toString()); assertEquals("-0.0523519031397845", Expression.valueOf("Σ(∂(cos(t),t,n),n,1,2)").expand().numeric().toString());
} }
@Test @Test
@ -766,19 +763,19 @@ public class ExpressionTest {
//final NumeralBase defaultNumeralBase = me.getDefaultNumeralBase(); //final NumeralBase defaultNumeralBase = me.getDefaultNumeralBase();
try { try {
//me.setDefaultNumeralBase(NumeralBase.bin); //me.setDefaultNumeralBase(NumeralBase.bin);
Assert.assertEquals("10", me.evaluate("0b:01010")); assertEquals("10", me.evaluate("0b:01010"));
Assert.assertEquals("10", me.evaluate("0b:1010")); assertEquals("10", me.evaluate("0b:1010"));
Assert.assertEquals("520", me.evaluate("0o:1010")); assertEquals("520", me.evaluate("0o:1010"));
Assert.assertEquals("1010", me.evaluate("1010")); assertEquals("1010", me.evaluate("1010"));
Assert.assertEquals("1010.1", me.evaluate("1010.1")); assertEquals("1010.1", me.evaluate("1010.1"));
} finally { } finally {
//me.setDefaultNumeralBase(defaultNumeralBase); //me.setDefaultNumeralBase(defaultNumeralBase);
} }
try { try {
me.setNumeralBase(NumeralBase.hex); me.setNumeralBase(NumeralBase.hex);
Assert.assertEquals("22F", me.evaluate("22F*exp(F)/exp(F)")); assertEquals("22F", me.evaluate("22F*exp(F)/exp(F)"));
Assert.assertEquals("E", me.evaluate("E")); assertEquals("E", me.evaluate("E"));
} finally { } finally {
me.setNumeralBase(NumeralBase.dec); me.setNumeralBase(NumeralBase.dec);
@ -790,48 +787,48 @@ public class ExpressionTest {
final JsclMathEngine me = JsclMathEngine.getInstance(); final JsclMathEngine me = JsclMathEngine.getInstance();
try { try {
me.setUseGroupingSeparator(true); me.setUseGroupingSeparator(true);
Assert.assertEquals("123 456.7891011", Expression.valueOf("123456.7891011").numeric().toString()); assertEquals("123 456.7891011", Expression.valueOf("123456.7891011").numeric().toString());
Assert.assertEquals("123 456.7891011", Expression.valueOf("123456.7891011").simplify().toString()); assertEquals("123 456.7891011", Expression.valueOf("123456.7891011").simplify().toString());
Assert.assertEquals("123 456.78910111231", Expression.valueOf("123456.7891011123123123123123").simplify().toString()); assertEquals("123 456.7891011123", Expression.valueOf("123456.7891011123123123123123").simplify().toString());
Assert.assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString()); assertEquals("0.000001222", Expression.valueOf("1222/(10^9)").numeric().toString());
Assert.assertEquals("12 345", JsclInteger.valueOf(12345L).toString()); assertEquals("12 345", JsclInteger.valueOf(12345L).toString());
me.setScienceNotation(true); me.setScienceNotation(true);
Assert.assertEquals("0", Expression.valueOf("0.0").simplify().toString()); assertEquals("0", Expression.valueOf("0.0").simplify().toString());
Assert.assertEquals("1", Expression.valueOf("1.0").simplify().toString()); assertEquals("1", Expression.valueOf("1.0").simplify().toString());
Assert.assertEquals("100", Expression.valueOf("100.0").simplify().toString()); assertEquals("100", Expression.valueOf("100.0").simplify().toString());
me.setScienceNotation(false); me.setScienceNotation(false);
me.setRoundResult(true); me.setRoundResult(true);
me.setPrecision(5); me.setPrecision(5);
Assert.assertEquals("0", Expression.valueOf("1222/(10^9)").numeric().toString()); assertEquals("0", Expression.valueOf("1222/(10^9)").numeric().toString());
me.setScienceNotation(true); me.setScienceNotation(true);
me.setRoundResult(true); me.setRoundResult(true);
me.setPrecision(5); me.setPrecision(5);
Assert.assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString()); assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString());
me.setRoundResult(true); me.setRoundResult(true);
me.setPrecision(10); me.setPrecision(10);
Assert.assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString()); assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString());
me.setRoundResult(false); me.setRoundResult(false);
Assert.assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString()); assertEquals("1.222E-6", Expression.valueOf("1222/(10^9)").numeric().toString());
me.setScienceNotation(false); me.setScienceNotation(false);
Assert.assertEquals("0.3333333333333333", Expression.valueOf("1/3").numeric().toString()); assertEquals("0.3333333333333333", Expression.valueOf("1/3").numeric().toString());
me.setScienceNotation(true); me.setScienceNotation(true);
Assert.assertEquals("0.3333333333333333", Expression.valueOf("1/3").numeric().toString()); assertEquals("0.3333333333333333", Expression.valueOf("1/3").numeric().toString());
me.setRoundResult(true); me.setRoundResult(true);
me.setPrecision(10); me.setPrecision(10);
Assert.assertEquals("0.3333333333", Expression.valueOf("1/3").numeric().toString()); assertEquals("0.3333333333", Expression.valueOf("1/3").numeric().toString());
me.setScienceNotation(false); me.setScienceNotation(false);
me.setRoundResult(true); me.setRoundResult(true);
me.setPrecision(10); me.setPrecision(10);
Assert.assertEquals("0.3333333333", Expression.valueOf("1/3").numeric().toString()); assertEquals("0.3333333333", Expression.valueOf("1/3").numeric().toString());
} finally { } finally {
me.setUseGroupingSeparator(false); me.setUseGroupingSeparator(false);

118
jscl/src/test/java/jscl/math/function/CustomFunctionTest.java
View File

@ -9,6 +9,8 @@ import org.junit.Test;
import java.util.Arrays; import java.util.Arrays;
import static org.junit.Assert.assertEquals;
/** /**
* User: serso * User: serso
* Date: 11/15/11 * Date: 11/15/11
@ -20,20 +22,20 @@ public class CustomFunctionTest {
public void testLog() throws Exception { public void testLog() throws Exception {
JsclMathEngine mathEngine = JsclMathEngine.getInstance(); JsclMathEngine mathEngine = JsclMathEngine.getInstance();
Assert.assertEquals("∞", Expression.valueOf("1/0").numeric().toString()); assertEquals("∞", Expression.valueOf("1/0").numeric().toString());
Assert.assertEquals("∞", Expression.valueOf("ln(10)/ln(1)").numeric().toString()); assertEquals("∞", Expression.valueOf("ln(10)/ln(1)").numeric().toString());
// logarithm // logarithm
final CustomFunction.Builder jBuilder = new CustomFunction.Builder(true, "log", Arrays.asList("a", "b"), "ln(b)/ln(a)"); final CustomFunction.Builder jBuilder = new CustomFunction.Builder(true, "log", Arrays.asList("a", "b"), "ln(b)/ln(a)");
Function function = mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create()); Function function = mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create());
Assert.assertEquals("log(a, b)", function.toString()); assertEquals("log(a, b)", function.toString());
Assert.assertEquals("ln(b)/ln(a)", ((CustomFunction) mathEngine.getFunctionsRegistry().get("log")).getContent()); assertEquals("ln(b)/ln(a)", ((CustomFunction) mathEngine.getFunctionsRegistry().get("log")).getContent());
Assert.assertEquals("∞", Expression.valueOf("log(1, 10)").numeric().toString()); assertEquals("∞", Expression.valueOf("log(1, 10)").numeric().toString());
Assert.assertEquals("3.3219280948873626", Expression.valueOf("log(2, 10)").numeric().toString()); assertEquals("3.321928094887363", Expression.valueOf("log(2, 10)").numeric().toString());
Assert.assertEquals("1.4306765580733933", Expression.valueOf("log(5, 10)").numeric().toString()); assertEquals("1.430676558073393", Expression.valueOf("log(5, 10)").numeric().toString());
Assert.assertEquals("0.9602525677891275", Expression.valueOf("log(11, 10)").numeric().toString()); assertEquals("0.9602525677891275", Expression.valueOf("log(11, 10)").numeric().toString());
Assert.assertEquals("1/b*1/ln(a)", Expression.valueOf("∂(log(a, b), b)").expand().toString()); assertEquals("1/b*1/ln(a)", Expression.valueOf("∂(log(a, b), b)").expand().toString());
Assert.assertEquals("-1/a*(1/ln(a))^2*ln(b)", Expression.valueOf("∂(log(a, b), a)").expand().toString()); assertEquals("-1/a*(1/ln(a))^2*ln(b)", Expression.valueOf("∂(log(a, b), a)").expand().toString());
} }
@ -43,15 +45,15 @@ public class CustomFunctionTest {
final CustomFunction.Builder jBuilder = new CustomFunction.Builder("t1", Arrays.asList("a"), "sin(a)"); final CustomFunction.Builder jBuilder = new CustomFunction.Builder("t1", Arrays.asList("a"), "sin(a)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create());
Assert.assertEquals("1", Expression.valueOf("t1(90)").numeric().toString()); assertEquals("1", Expression.valueOf("t1(90)").numeric().toString());
Assert.assertEquals("cos(t)", Expression.valueOf("∂(t1(t), t)").expand().toString()); assertEquals("cos(t)", Expression.valueOf("∂(t1(t), t)").expand().toString());
Assert.assertEquals("0", Expression.valueOf("∂(t1(t), t2)").expand().toString()); assertEquals("0", Expression.valueOf("∂(t1(t), t2)").expand().toString());
Assert.assertEquals("cos(a)", Expression.valueOf("∂(t1(a), a)").expand().toString()); assertEquals("cos(a)", Expression.valueOf("∂(t1(a), a)").expand().toString());
Assert.assertEquals("1", Expression.valueOf("∂(t1(a), t1(a))").expand().toString()); assertEquals("1", Expression.valueOf("∂(t1(a), t1(a))").expand().toString());
final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("t2", Arrays.asList("a", "b"), "b*sin(a)"); final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("t2", Arrays.asList("a", "b"), "b*sin(a)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create());
Assert.assertEquals("y*cos(x)", Expression.valueOf("∂(t2(x, y), x)").expand().toString()); assertEquals("y*cos(x)", Expression.valueOf("∂(t2(x, y), x)").expand().toString());
Assert.assertEquals("sin(x)", Expression.valueOf("∂(t2(x, y), y)").expand().toString()); assertEquals("sin(x)", Expression.valueOf("∂(t2(x, y), y)").expand().toString());
} }
@Test @Test
@ -60,19 +62,19 @@ public class CustomFunctionTest {
final CustomFunction.Builder jBuilder = new CustomFunction.Builder("t1", Arrays.asList("a"), "sin(a)"); final CustomFunction.Builder jBuilder = new CustomFunction.Builder("t1", Arrays.asList("a"), "sin(a)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create());
Assert.assertEquals("1", Expression.valueOf("t1(90)").numeric().toString()); assertEquals("1", Expression.valueOf("t1(90)").numeric().toString());
try { try {
mathEngine.setAngleUnits(AngleUnit.rad); mathEngine.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("-cos(t)", Expression.valueOf("∫(t1(t), t)").expand().toString()); assertEquals("-cos(t)", Expression.valueOf("∫(t1(t), t)").expand().toString());
Assert.assertEquals("t2*sin(t)", Expression.valueOf("∫(t1(t), t2)").expand().toString()); assertEquals("t2*sin(t)", Expression.valueOf("∫(t1(t), t2)").expand().toString());
Assert.assertEquals("-cos(a)", Expression.valueOf("∫(t1(a), a)").expand().toString()); assertEquals("-cos(a)", Expression.valueOf("∫(t1(a), a)").expand().toString());
Assert.assertEquals("1/2*sin(a)^2", Expression.valueOf("∫(t1(a), t1(a))").expand().toString()); assertEquals("1/2*sin(a)^2", Expression.valueOf("∫(t1(a), t1(a))").expand().toString());
final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("t2", Arrays.asList("a", "b"), "b*sin(a)"); final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("t2", Arrays.asList("a", "b"), "b*sin(a)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create());
Assert.assertEquals("-y*cos(x)", Expression.valueOf("∫(t2(x, y), x)").expand().toString()); assertEquals("-y*cos(x)", Expression.valueOf("∫(t2(x, y), x)").expand().toString());
Assert.assertEquals("1/2*y^2*sin(x)", Expression.valueOf("∫(t2(x, y), y)").expand().toString()); assertEquals("1/2*y^2*sin(x)", Expression.valueOf("∫(t2(x, y), y)").expand().toString());
} finally { } finally {
mathEngine.setAngleUnits(AngleUnit.deg); mathEngine.setAngleUnits(AngleUnit.deg);
} }
@ -85,16 +87,16 @@ public class CustomFunctionTest {
final CustomFunction.Builder jBuilder = new CustomFunction.Builder("testFunction", Arrays.asList("a", "b", "c", "d"), "b*cos(a)/c+d"); final CustomFunction.Builder jBuilder = new CustomFunction.Builder("testFunction", Arrays.asList("a", "b", "c", "d"), "b*cos(a)/c+d");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder.create());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction(2, 3, 4, 6)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction(2, 3, 4, 6)").numeric().toString());
Assert.assertEquals("7.749543120264322", Expression.valueOf("testFunction(2, 3, 4, 7)").numeric().toString()); assertEquals("7.749543120264322", Expression.valueOf("testFunction(2, 3, 4, 7)").numeric().toString());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 4, 6)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 4, 6)").numeric().toString());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 4, 3!)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 4, 3!)").numeric().toString());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString());
Assert.assertEquals("testFunction(2, 3, 4, 3!)", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").simplify().toString()); assertEquals("testFunction(2, 3, 4, 3!)", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").simplify().toString());
Assert.assertEquals("3*cos(2)/4+3!", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").expand().toString()); assertEquals("3*cos(2)/4+3!", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").expand().toString());
Assert.assertEquals("3*(1/2*1/exp(2*i)+1/2*exp(2*i))/4+3!", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").elementary().toString()); assertEquals("3*(1/2*1/exp(2*i)+1/2*exp(2*i))/4+3!", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)").elementary().toString());
Assert.assertEquals("sin(t)^2*testFunction(2, 3, 4, 3!)", Expression.valueOf("sin(t)*testFunction(2*1, 3, 2^2-1+e^0, 3!)*sin(t)").simplify().toString()); assertEquals("sin(t)^2*testFunction(2, 3, 4, 3!)", Expression.valueOf("sin(t)*testFunction(2*1, 3, 2^2-1+e^0, 3!)*sin(t)").simplify().toString());
Assert.assertEquals("testFunction(2, 3, 4, 3!)^2", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)*testFunction(2, 3, 4, 3!)").simplify().toString()); assertEquals("testFunction(2, 3, 4, 3!)^2", Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)*testFunction(2, 3, 4, 3!)").simplify().toString());
try { try {
Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)*testFunction(2, 3, 4)"); Expression.valueOf("testFunction(2*1, 3, 2^2-1+e^0, 3!)*testFunction(2, 3, 4)");
Assert.fail(); Assert.fail();
@ -106,31 +108,31 @@ public class CustomFunctionTest {
mathEngine.getConstantsRegistry().addOrUpdate(a.create()); mathEngine.getConstantsRegistry().addOrUpdate(a.create());
final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("testFunction2", Arrays.asList("a", "b", "c", "d"), "b*cos(a)/c+d"); final CustomFunction.Builder jBuilder1 = new CustomFunction.Builder("testFunction2", Arrays.asList("a", "b", "c", "d"), "b*cos(a)/c+d");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder1.create());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2, 3, 4, 6)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2, 3, 4, 6)").numeric().toString());
Assert.assertEquals("7.749543120264322", Expression.valueOf("testFunction2(2, 3, 4, 7)").numeric().toString()); assertEquals("7.749543120264322", Expression.valueOf("testFunction2(2, 3, 4, 7)").numeric().toString());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2*1, 3, 4, 6)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2*1, 3, 4, 6)").numeric().toString());
Assert.assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString()); assertEquals("6.749543120264322", Expression.valueOf("testFunction2(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString());
final CustomFunction.Builder jBuilder2 = new CustomFunction.Builder("testFunction3", Arrays.asList("a", "b", "c", "d"), "testFunction2(a, b, c, d) - testFunction(a, b, c, d)"); final CustomFunction.Builder jBuilder2 = new CustomFunction.Builder("testFunction3", Arrays.asList("a", "b", "c", "d"), "testFunction2(a, b, c, d) - testFunction(a, b, c, d)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder2.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder2.create());
Assert.assertEquals("0", Expression.valueOf("testFunction3(2, 3, 4, 6)").numeric().toString()); assertEquals("0", Expression.valueOf("testFunction3(2, 3, 4, 6)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("testFunction3(2, 3, 4, 7)").numeric().toString()); assertEquals("0", Expression.valueOf("testFunction3(2, 3, 4, 7)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("testFunction3(2*1, 3, 4, 6)").numeric().toString()); assertEquals("0", Expression.valueOf("testFunction3(2*1, 3, 4, 6)").numeric().toString());
Assert.assertEquals("0", Expression.valueOf("testFunction3(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString()); assertEquals("0", Expression.valueOf("testFunction3(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString());
final CustomFunction.Builder jBuilder3 = new CustomFunction.Builder("testFunction4", Arrays.asList("a", "b", "c", "d"), "testFunction2(a, b/2, c/3, d/4) - testFunction(a, b!, c, d)"); final CustomFunction.Builder jBuilder3 = new CustomFunction.Builder("testFunction4", Arrays.asList("a", "b", "c", "d"), "testFunction2(a, b/2, c/3, d/4) - testFunction(a, b!, c, d)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder3.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder3.create());
Assert.assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2, 3, 4, 6)").numeric().toString()); assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2, 3, 4, 6)").numeric().toString());
Assert.assertEquals("-5.624771560132161", Expression.valueOf("testFunction4(2, 3, 4, 7)").numeric().toString()); assertEquals("-5.624771560132161", Expression.valueOf("testFunction4(2, 3, 4, 7)").numeric().toString());
Assert.assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2*1, 3, 4, 6)").numeric().toString()); assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2*1, 3, 4, 6)").numeric().toString());
Assert.assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString()); assertEquals("-4.874771560132161", Expression.valueOf("testFunction4(2*1, 3, 2^2-1+e^0, 3!)").numeric().toString());
final CustomFunction.Builder jBuilder4 = new CustomFunction.Builder("testFunction5", Arrays.asList("a", "b"), "testFunction2(a, b/2, 2, 1) - testFunction(a, b!, 4!, 1)"); final CustomFunction.Builder jBuilder4 = new CustomFunction.Builder("testFunction5", Arrays.asList("a", "b"), "testFunction2(a, b/2, 2, 1) - testFunction(a, b!, 4!, 1)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder4.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder4.create());
Assert.assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2, 3)").numeric().toString()); assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2, 3)").numeric().toString());
Assert.assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2, 3)").numeric().toString()); assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2, 3)").numeric().toString());
Assert.assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2*1, 3)").numeric().toString()); assertEquals("0.4996954135095478", Expression.valueOf("testFunction5(2*1, 3)").numeric().toString());
Assert.assertEquals("-111.02230246251565E-18", Expression.valueOf("testFunction5(2*1, 2^2-1+e^0)").numeric().toString()); assertEquals("-0.0000000000000001", Expression.valueOf("testFunction5(2*1, 2^2-1+e^0)").numeric().toString());
try { try {
Expression.valueOf("testFunction5(2, 3.5)").numeric(); Expression.valueOf("testFunction5(2, 3.5)").numeric();
@ -141,19 +143,19 @@ public class CustomFunctionTest {
final CustomFunction.Builder jBuilder5 = new CustomFunction.Builder("testFunction6", Arrays.asList("a", "b"), "testFunction(a, b!, 4!, Π)"); final CustomFunction.Builder jBuilder5 = new CustomFunction.Builder("testFunction6", Arrays.asList("a", "b"), "testFunction(a, b!, 4!, Π)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder5.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder5.create());
Assert.assertEquals("180.24984770675476", Expression.valueOf("testFunction6(2, 3)").numeric().toString()); assertEquals("180.2498477067548", Expression.valueOf("testFunction6(2, 3)").numeric().toString());
final ExtendedConstant.Builder e = new ExtendedConstant.Builder(new Constant("e"), 181d); final ExtendedConstant.Builder e = new ExtendedConstant.Builder(new Constant("e"), 181d);
mathEngine.getConstantsRegistry().addOrUpdate(e.create()); mathEngine.getConstantsRegistry().addOrUpdate(e.create());
final CustomFunction.Builder jBuilder6 = new CustomFunction.Builder("testFunction7", Arrays.asList("a", "b"), "testFunction(a, b!, 4!, e)"); final CustomFunction.Builder jBuilder6 = new CustomFunction.Builder("testFunction7", Arrays.asList("a", "b"), "testFunction(a, b!, 4!, e)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder6.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder6.create());
Assert.assertEquals("181.24984770675476", Expression.valueOf("testFunction7(2, 3)").numeric().toString()); assertEquals("181.2498477067548", Expression.valueOf("testFunction7(2, 3)").numeric().toString());
final ExtendedConstant.Builder e1 = new ExtendedConstant.Builder(new Constant("e"), 181d); final ExtendedConstant.Builder e1 = new ExtendedConstant.Builder(new Constant("e"), 181d);
mathEngine.getConstantsRegistry().addOrUpdate(e1.create()); mathEngine.getConstantsRegistry().addOrUpdate(e1.create());
final CustomFunction.Builder jBuilder7 = new CustomFunction.Builder("testFunction8", Arrays.asList("a", "b"), "testFunction(sin(a), b!, 4!, e)"); final CustomFunction.Builder jBuilder7 = new CustomFunction.Builder("testFunction8", Arrays.asList("a", "b"), "testFunction(sin(a), b!, 4!, e)");
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder7.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder7.create());
Assert.assertEquals("181.24999995362296", Expression.valueOf("testFunction8(2, 3)").numeric().toString()); assertEquals("181.249999953623", Expression.valueOf("testFunction8(2, 3)").numeric().toString());
} }
@ -169,17 +171,17 @@ public class CustomFunctionTest {
mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder2.create()); mathEngine.getFunctionsRegistry().addOrUpdate(jBuilder2.create());
try { try {
Assert.assertEquals("1", Expression.valueOf("f(1, 1)").numeric().toString()); assertEquals("1", Expression.valueOf("f(1, 1)").numeric().toString());
Assert.fail(); Assert.fail();
} catch (ArithmeticException e) { } catch (ArithmeticException e) {
//ok //ok
} }
Assert.assertEquals("1.4142135623730951", Expression.valueOf("f2(1, 1)").numeric().toString()); assertEquals("1.414213562373095", Expression.valueOf("f2(1, 1)").numeric().toString());
Assert.assertEquals("5", Expression.valueOf("f2(4, 3)").numeric().toString()); assertEquals("5", Expression.valueOf("f2(4, 3)").numeric().toString());
Assert.assertEquals("2*z1", Expression.valueOf("∂(f3(z1, z2), z1)").expand().toString()); assertEquals("2*z1", Expression.valueOf("∂(f3(z1, z2), z1)").expand().toString());
Assert.assertEquals("2*z2", Expression.valueOf("∂(f3(z1, z2), z2)").expand().toString()); assertEquals("2*z2", Expression.valueOf("∂(f3(z1, z2), z2)").expand().toString());
// test symbols // test symbols
final CustomFunction.Builder jBuilder3 = new CustomFunction.Builder("f4", Arrays.asList("x", "y"), "2 000*x^2+y^2"); final CustomFunction.Builder jBuilder3 = new CustomFunction.Builder("f4", Arrays.asList("x", "y"), "2 000*x^2+y^2");

34
jscl/src/test/java/jscl/math/function/RadTest.java
View File

@ -1,34 +1,30 @@
package jscl.math.function; package jscl.math.function;
import jscl.JsclMathEngine; import jscl.JsclMathEngine;
import junit.framework.Assert;
import org.junit.Test; import org.junit.Test;
/** import static org.junit.Assert.assertEquals;
* User: serso
* Date: 11/12/11
* Time: 4:00 PM
*/
public class RadTest { public class RadTest {
@Test @Test
public void testRad() throws Exception { public void testRad() throws Exception {
final JsclMathEngine mathEngine = JsclMathEngine.getInstance(); final JsclMathEngine mathEngine = new JsclMathEngine();
Assert.assertEquals("0.03490658503988659", mathEngine.evaluate("rad(2)")); assertEquals("0.0349065850398866", mathEngine.evaluate("rad(2)"));
Assert.assertEquals("0.03490658503988659", mathEngine.evaluate("rad(1+1)")); assertEquals("0.0349065850398866", mathEngine.evaluate("rad(1+1)"));
Assert.assertEquals("-0.03490658503988659", mathEngine.evaluate("rad(-2)")); assertEquals("-0.0349065850398866", mathEngine.evaluate("rad(-2)"));
Assert.assertEquals("-0.03490658503988659", mathEngine.evaluate("rad(-1-1)")); assertEquals("-0.0349065850398866", mathEngine.evaluate("rad(-1-1)"));
Assert.assertEquals("π", mathEngine.evaluate("rad(180)")); assertEquals("π", mathEngine.evaluate("rad(180)"));
Assert.assertEquals(String.valueOf(-Math.PI), mathEngine.evaluate("rad(-180)")); assertEquals(String.valueOf(-Math.PI), mathEngine.evaluate("rad(-180)"));
// todo serso: think about zeroes // todo serso: think about zeroes
Assert.assertEquals("rad(-180, 0, 0)", mathEngine.simplify("rad(-180)")); assertEquals("rad(-180, 0, 0)", mathEngine.simplify("rad(-180)"));
Assert.assertEquals("rad(2, 0, 0)", mathEngine.simplify("rad(1+1)")); assertEquals("rad(2, 0, 0)", mathEngine.simplify("rad(1+1)"));
Assert.assertEquals("rad(-180, 0, 0)", mathEngine.elementary("rad(-180)")); assertEquals("rad(-180, 0, 0)", mathEngine.elementary("rad(-180)"));
Assert.assertEquals("rad(2, 0, 0)", mathEngine.elementary("rad(1+1)")); assertEquals("rad(2, 0, 0)", mathEngine.elementary("rad(1+1)"));
Assert.assertEquals(mathEngine.evaluate("rad(43.1025)"), mathEngine.evaluate("rad(43,6,9)")); assertEquals(mathEngine.evaluate("rad(43.1025)"), mathEngine.evaluate("rad(43,6,9)"));
Assert.assertEquals(mathEngine.evaluate("rad(102.765)"), mathEngine.evaluate("rad(102, 45, 54)")); assertEquals(mathEngine.evaluate("rad(102.765)"), mathEngine.evaluate("rad(102, 45, 54)"));
} }
} }

16
jscl/src/test/java/jscl/math/function/SqrtTest.java
View File

@ -2,14 +2,10 @@ package jscl.math.function;
import jscl.AngleUnit; import jscl.AngleUnit;
import jscl.JsclMathEngine; import jscl.JsclMathEngine;
import junit.framework.Assert;
import org.junit.Test; import org.junit.Test;
/** import static org.junit.Assert.assertEquals;
* User: serso
* Date: 5/14/12
* Time: 1:15 PM
*/
public class SqrtTest { public class SqrtTest {
@Test @Test
@ -17,13 +13,13 @@ public class SqrtTest {
final JsclMathEngine me = JsclMathEngine.getInstance(); final JsclMathEngine me = JsclMathEngine.getInstance();
final AngleUnit defaultAngleUnits = me.getAngleUnits(); final AngleUnit defaultAngleUnits = me.getAngleUnits();
Assert.assertEquals("0.9999060498015505+0.013707354604707477*i", me.evaluate("√(√(-1))")); assertEquals("0.9999060498015505+0.0137073546047075*i", me.evaluate("√(√(-1))"));
Assert.assertEquals("0.9984971498638638+0.05480366514878954*i", me.evaluate("√(√(-1))^4")); assertEquals("0.9984971498638638+0.0548036651487895*i", me.evaluate("√(√(-1))^4"));
try { try {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("0.7071067811865476+0.7071067811865475*i", me.evaluate("√(√(-1))")); assertEquals("0.7071067811865476+0.7071067811865475*i", me.evaluate("√(√(-1))"));
Assert.assertEquals("-1+277.55575615628914E-18*i", me.evaluate("√(√(-1))^4")); assertEquals("-1+0.0000000000000003*i", me.evaluate("√(√(-1))^4"));
} finally { } finally {
me.setAngleUnits(defaultAngleUnits); me.setAngleUnits(defaultAngleUnits);
} }

6
jscl/src/test/java/jscl/math/function/trigonometric/CosTest.java
View File

@ -20,9 +20,9 @@ public class CosTest {
me.getConstantsRegistry().addOrUpdate(t.create()); me.getConstantsRegistry().addOrUpdate(t.create());
Assert.assertEquals("-sin(t)", me.simplify("∂(cos(t),t,t,1)")); Assert.assertEquals("-sin(t)", me.simplify("∂(cos(t),t,t,1)"));
Assert.assertEquals("∂(cos(t), t, t, 1°)", me.simplify("∂(cos(t),t,t,1°)")); Assert.assertEquals("∂(cos(t), t, t, 1°)", me.simplify("∂(cos(t),t,t,1°)"));
Assert.assertEquals("-0.17364817766693033", me.evaluate("∂(cos(t),t,t,1)")); Assert.assertEquals("-0.1736481776669303", me.evaluate("∂(cos(t),t,t,1)"));
Assert.assertEquals("∂(cos(t), t, t, 1°)", me.evaluate("∂(cos(t),t,t,1°)")); Assert.assertEquals("∂(cos(t), t, t, 1°)", me.evaluate("∂(cos(t),t,t,1°)"));
Assert.assertEquals("-0.17364817766693033", me.evaluate("∂(cos(t),t,t,2-1)")); Assert.assertEquals("-0.1736481776669303", me.evaluate("∂(cos(t),t,t,2-1)"));
Assert.assertEquals("-0.17364817766693033", me.evaluate("∂(cos(t),t,t,2^5-31)")); Assert.assertEquals("-0.1736481776669303", me.evaluate("∂(cos(t),t,t,2^5-31)"));
} }
} }

2
jscl/src/test/java/jscl/math/function/trigonometric/SinTest.java
View File

@ -28,7 +28,7 @@ public class SinTest {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
Assert.assertEquals("0.5403023058681398", me.evaluate("cos(1)")); Assert.assertEquals("0.5403023058681398", me.evaluate("cos(1)"));
Assert.assertEquals("0.3623577544766736", me.evaluate("cos(1.2)")); Assert.assertEquals("0.3623577544766736", me.evaluate("cos(1.2)"));
Assert.assertEquals("0.17794455139146614", me.evaluate("∫ab(sin(x), x, 1, 1.2)")); Assert.assertEquals("0.1779445513914661", me.evaluate("∫ab(sin(x), x, 1, 1.2)"));
} finally { } finally {
me.setAngleUnits(AngleUnit.deg); me.setAngleUnits(AngleUnit.deg);
} }

4
jscl/src/test/java/jscl/math/function/trigonometric/TanTest.java
View File

@ -29,9 +29,9 @@ public class TanTest {
me.setAngleUnits(AngleUnit.rad); me.setAngleUnits(AngleUnit.rad);
assertEquals("-2*ln(2)-ln(cos(x))", me.simplify("∫(tan(x), x)")); assertEquals("-2*ln(2)-ln(cos(x))", me.simplify("∫(tan(x), x)"));
assertEquals("-(2*ln(2)+ln(cos(x*π)))/π", me.simplify("∫(tan(π*x), x)")); assertEquals("-(2*ln(2)+ln(cos(x*π)))/π", me.simplify("∫(tan(π*x), x)"));
assertEquals("-0.015308831465985804", me.evaluate("ln(cos(10*π/180))")); assertEquals("-0.0153088314659858", me.evaluate("ln(cos(10*π/180))"));
assertEquals("-0.1438410362258904", me.evaluate("ln(cos(30*π/180))")); assertEquals("-0.1438410362258904", me.evaluate("ln(cos(30*π/180))"));
assertEquals("0.12853220475990468", me.evaluate("∫ab(tan(x), x, 10*π/180, 30*π/180)")); assertEquals("0.1285322047599047", me.evaluate("∫ab(tan(x), x, 10*π/180, 30*π/180)"));
} finally { } finally {
me.setAngleUnits(AngleUnit.deg); me.setAngleUnits(AngleUnit.deg);
} }

17
jscl/src/test/java/jscl/math/numeric/ComplexTest.java
View File

@ -7,17 +7,12 @@ import org.junit.Test;
import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertEquals;
/**
* User: serso
* Date: 5/14/12
* Time: 2:24 PM
*/
public class ComplexTest { public class ComplexTest {
@Test @Test
public void testSmallImag() throws Exception { public void testSmallImag() throws Exception {
assertEquals("1+100E-18*i", Complex.valueOf(1, 0.0000000000000001).toString()); assertEquals("1+0.0000000000000001*i", Complex.valueOf(1, 0.0000000000000001).toString());
assertEquals("1-100E-18*i", Complex.valueOf(1, -0.0000000000000001).toString()); assertEquals("1-0.0000000000000001*i", Complex.valueOf(1, -0.0000000000000001).toString());
} }
@Test @Test
@ -25,10 +20,10 @@ public class ComplexTest {
try { try {
JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad); JsclMathEngine.getInstance().setAngleUnits(AngleUnit.rad);
assertEquals("1.543080634815244", Expression.valueOf("cos(i)").numeric().toString()); assertEquals("1.543080634815244", Expression.valueOf("cos(i)").numeric().toString());
assertEquals("1.1752011936438014*i", Expression.valueOf("sin(i)").numeric().toString()); assertEquals("1.175201193643801*i", Expression.valueOf("sin(i)").numeric().toString());
assertEquals("11013.232874703395*i", Expression.valueOf("sin(10*i)").numeric().toString()); assertEquals("11013.2328747034*i", Expression.valueOf("sin(10*i)").numeric().toString());
assertEquals("11013.232920103324", Expression.valueOf("cos(10*i)").numeric().toString()); assertEquals("11013.23292010332", Expression.valueOf("cos(10*i)").numeric().toString());
assertEquals("0.46211715726000974*i", Expression.valueOf("tan(i/2)").numeric().toString()); assertEquals("0.4621171572600097*i", Expression.valueOf("tan(i/2)").numeric().toString());
assertEquals("-2.163953413738653*i", Expression.valueOf("cot(i/2)").numeric().toString()); assertEquals("-2.163953413738653*i", Expression.valueOf("cot(i/2)").numeric().toString());
} finally { } finally {
JsclMathEngine.getInstance().setAngleUnits(JsclMathEngine.DEFAULT_ANGLE_UNITS); JsclMathEngine.getInstance().setAngleUnits(JsclMathEngine.DEFAULT_ANGLE_UNITS);

2
jscl/src/test/java/jscl/math/operator/PercentTest.java
View File

@ -48,7 +48,7 @@ public class PercentTest {
Assert.assertEquals("-49", mathEngine.evaluate("1-(100-50%)")); Assert.assertEquals("-49", mathEngine.evaluate("1-(100-50%)"));
Assert.assertEquals("50", mathEngine.evaluate("100-50%")); Assert.assertEquals("50", mathEngine.evaluate("100-50%"));
Assert.assertEquals("2600", mathEngine.evaluate("100+50%^2")); Assert.assertEquals("2600", mathEngine.evaluate("100+50%^2"));
Assert.assertEquals("101.08138265680029", mathEngine.evaluate("100+50^2%")); Assert.assertEquals("101.0813826568003", mathEngine.evaluate("100+50^2%"));
Assert.assertEquals("22500", mathEngine.evaluate("(100+50%)^2")); Assert.assertEquals("22500", mathEngine.evaluate("(100+50%)^2"));
Assert.assertEquals("225", mathEngine.evaluate("(100+50%)+50%")); Assert.assertEquals("225", mathEngine.evaluate("(100+50%)+50%"));
Assert.assertEquals("225", mathEngine.evaluate("(100+50%)+(abs(-50)+10-10)%")); Assert.assertEquals("225", mathEngine.evaluate("(100+50%)+(abs(-50)+10-10)%"));

12
jscl/src/test/java/jscl/math/operator/SumTest.java
View File

@ -3,14 +3,10 @@ package jscl.math.operator;
import jscl.JsclMathEngine; import jscl.JsclMathEngine;
import jscl.math.function.Constant; import jscl.math.function.Constant;
import jscl.math.function.ExtendedConstant; import jscl.math.function.ExtendedConstant;
import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
/** import static org.junit.Assert.assertEquals;
* User: serso
* Date: 1/30/12
* Time: 4:17 PM
*/
public class SumTest { public class SumTest {
@Test @Test
@ -20,7 +16,7 @@ public class SumTest {
me.getConstantsRegistry().addOrUpdate(x.create()); me.getConstantsRegistry().addOrUpdate(x.create());
final ExtendedConstant.Builder i = new ExtendedConstant.Builder(new Constant("i"), (String) null); final ExtendedConstant.Builder i = new ExtendedConstant.Builder(new Constant("i"), (String) null);
me.getConstantsRegistry().addOrUpdate(i.create()); me.getConstantsRegistry().addOrUpdate(i.create());
Assert.assertEquals("51.735296462438285", me.evaluate("Σ((1+x/i)^i, i, 1, 10)")); assertEquals("51.73529646243829", me.evaluate("Σ((1+x/i)^i, i, 1, 10)"));
Assert.assertEquals("686.0048440525586", me.evaluate("Σ((1+x/i)^i, i, 1, 100)")); assertEquals("686.0048440525586", me.evaluate("Σ((1+x/i)^i, i, 1, 100)"));
} }
} }

36
jscl/src/test/java/org/solovyev/common/NumberFormatterTest.java Normal file
View File

@ -0,0 +1,36 @@
package org.solovyev.common;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class NumberFormatterTest {
private NumberFormatter numberFormatter;
@Before
public void setUp() throws Exception {
numberFormatter = new NumberFormatter();
}
@Test
public void testEngineeringFormat() throws Exception {
numberFormatter.useEngineeringFormat(5);
assertEquals("0.1", numberFormatter.format(0.1d));
assertEquals("0.01", numberFormatter.format(0.01d));
assertEquals("0.001", numberFormatter.format(0.001d));
assertEquals("5", numberFormatter.format(5d));
assertEquals("5000", numberFormatter.format(5000d));
}
@Test
public void testSimpleFormat() throws Exception {
numberFormatter.useSimpleFormat();
assertEquals("5000000000000000000", numberFormatter.format(5000000000000000000d));
assertEquals("5000000000000000000", numberFormatter.format(5000000000000000001d));
assertEquals("5999999999999994900", numberFormatter.format(5999999999999994999d));
assertEquals("5E19", numberFormatter.format(50000000000000000000d));
assertEquals("5E40", numberFormatter.format(50000000000000000000000000000000000000000d));
}
}