Join the DZone community and get the full member experience.
Join For FreeMXReflection is a Java math framework based on mXparser library capabilities.
You can calculate complex mathematical operations and functions with Java, just by using class-related fields. MXReflection reads values from the assigned fields and injects the results in the @Expression annotated fields.
Installation
Maven
XML
x
1
<dependency>
2
<groupId>com.github.ismail-mekni</groupId>
3
<artifactId>mxreflection</artifactId>
4
<version>1.0.1</version>
5
</dependency>
Gradle
Java
xxxxxxxxxx
1
1
dependencies {
2
compile group: 'com.github.ismail-mekni', name: 'mxreflection', version: '1.0.1'
3
}
How to Use It
You just need two Java annotations:
- With an
@Argvalue, we can assign customized argument names to be used in the target function. - An
@Expressionannotation value contains the function expression with the arguments.
First example:
Java
x
35
1
package com.ismail.mxreflection.example;
2
3
import com.ismail.mxreflection.annotations.Arg;
4
import com.ismail.mxreflection.annotations.Expression;
5
import com.ismail.mxreflection.core.Calculator;
6
import com.ismail.mxreflection.factory.MXFactory;
7
import org.junit.Test;
8
9
public class Example1Test {
10
11
class Example1 {
12
13
("f1")
14
String field1;
15
16
("f2")
17
int field2;
18
19
("f1 * sin(f2) * log2(f1 + f2) + der(cos(f1), f1) * pi + int(tan(f2), f2, 0, e)")
20
double field3;
21
22
}
23
24
25
public void example1Test() {
26
Example1 example1 = new Example1();
27
example1.field1 = "2.2";
28
example1.field2 = 5;
29
30
Calculator<Example1> calculator = MXFactory.createCalculator(Example1.class);
31
calculator.calculate(example1);
32
System.out.println("Field 3 result: " + example1.field3);
33
}
34
35
}
Output:
Field 3 result: -34.32819235851987
Supported Math Collections
MXReflection supports the math collection available in the mXparser math library:
- Operators (+, -, *, /, #, !, ^)
- Binary Relations (=, ==, =<, =>, <, >, <>, !=, ~=)
- Boolean Operators (&, &&, /, ~&, ~&&, ~/, |, ||…)
- Bitwise Operators (@~, @&, @^, @|, @<<, @>>)
- Unary Functions (sin, cos, tan, tg, ctan, ctg, cot, sec,…)
- Binary Functions (log, mod, C, Bern, Stirl1, Stirl2, …)
- 3-args Functions (if, chi, CHi, Chi, cHi, pUni, cUni, qUni, pNor, cNor, qNor)
- Variadic Functions (iff, min, max, ConFrac, ConPol, gcd, …)
- Iterated Operators (sum, prod, avg, vari, stdi, mini, maxi)
- Calculus Operators (int, der, der-, der+, dern, diff, difb)
- Math Constants (pi, e, [gam], [phi], [PN], [B*], [F’d], [F’a], …)
- Physical Constants ([c], [G.], [g], [hP], [h-], [lP], [mP], [tP])
- Astronomical Constants ([ly], [au], [pc], [kpc], [Earth-R-eq], …)
- Random Variables ([Uni], [Int], [Int1], [Int2], [Int3], [Int4], …)
- Metric prefixes ([%], [%%], [Y], [sept], [Z], [sext], [E], …)
- Parser Symbols ((, ), ,, ;)
- Units
MXReflection Parsing
Argument Parsing
MXReflection supports all field data types with numeric content as an argument. You can use all Java types with toString implementations that return numeric results.
Result Parsing
Supported result field java types:
- Double
- double
- Long
- long
- String
- BigInteger
Note that for long, Long, and BigInteger, MXReflection uses Math.round to parse the final result before injecting it. It is recommended to be sure that the expression returns an integer type.
Result Reuse
With MXReflection, you can use function results as arguments for other results:
Second example:
Java
xxxxxxxxxx
1
58
1
package com.ismail.mxreflection.example;
2
3
import com.ismail.mxreflection.annotations.Arg;
4
import com.ismail.mxreflection.annotations.Expression;
5
import com.ismail.mxreflection.core.Calculator;
6
import com.ismail.mxreflection.factory.MXFactory;
7
import org.junit.Test;
8
9
public class Example2Test {
10
11
public class Example2{
12
13
("f1")
14
private String field1;
15
16
("f2")
17
private Long field2;
18
19
("f2 - f1")
20
("f3")
21
private double field3;
22
23
("f3 - f2")
24
("f4")
25
private double field4;
26
27
("f1 - f2")
28
("f5")
29
private Double field5;
30
31
("f4-f5")
32
("f6")
33
private String field6;
34
35
("f6-f5")
36
("f7")
37
private long field7;
38
39
("f7+5")
40
private Long field8;
41
}
42
43
44
public void exampleTest() {
45
Example2 example2 = new Example2();
46
example2.field1 = "2.2";
47
example2.field2 = 5L;
48
49
Calculator<Example2> calculator = MXFactory.createCalculator(Example2.class);
50
calculator.calculate(example2);
51
System.out.println("Field 3 result: " + example2.field3);
52
System.out.println("Field 4 result: " + example2.field4);
53
System.out.println("Field 5 result: " + example2.field5);
54
System.out.println("Field 6 result: " + example2.field6);
55
System.out.println("Field 7 result: " + example2.field7);
56
System.out.println("Field 8 result: " + example2.field8);
57
}
58
}
Output:
Field 3 result: 2.8
Field 4 result: -2.2
Field 5 result: -2.8
Field 6 result: 0.6
Field 7 result: 3
Field 8 result: 8
MXReflection resolves a graph of dependencies between functions and arguments. It makes sure that there is no cycle in the field dependency.
Links
Topics:
java,
framework,
math,
mxreflection
Published at DZone with permission of Ismail Mekni. See the original article here.
Opinions expressed by DZone contributors are their own.
Comments