Open source framework That thing 14: teaching computer programs to solve math problems

Weekend, looking at the expert system of the book, which has about the rules of the content, suddenly think, can imitate people's learning way to improve computer program computing ability?

Imagine, a little child, he started nothing, first of all, you have to tell him what is the number, and then tell him what is to add, subtract, and then tell him what is multiply, divide, and tell him that the multiplication, in addition to calculate the multiplication first, and then introduced the parentheses, the parentheses are always the first to calculate parentheses. Thus, the more skills he has to tell him, the more he will be able to solve the problem.
So I tried to experiment with it.
The first step is to teach the computer to learn what numbers are.
The following regular expression, is to tell the "child", the number is the front may have "-" number, of course, may not, the next consecutive number 0-9, the number of the composition, there may also be a decimal point to start adding a heap of 0-9 numbers, of course, there is no relationship. So, it even knows how to recognize numbers.

[Java]View Plaincopy

2. Public Final class Mathnumber {
4. Private Mathnumber () {
6. }
10. public static String Numberpattern = "[-]?[ 0-9]+ ([.] [0-9]*)? ";
12. public static pattern pattern = Pattern.compile (Numberpattern);
16. public static Matcher match (string string) {
18. Matcher match = Pattern.matcher (string);
20. if (Match.find ()) {
22. return match;
24. }
26. throw New RuntimeException (string + "is not a number.");
28. }
30. }

The second step is to tell the child, the process of calculating the maths problem.
If there is a space on both sides, ignore it, then, see if it is already a number, if it is a number, it means that even if the result. If not, start with the highest priority and calculate if you find it. If you can't find it, it means there is a problem, not a valid mathematical formula.

[Java]View Plaincopy

2. Public static String eval (string string) {
4. string = String.Trim ();
6. While (!ismathnumber (String)) {//the same priority which first found which
8. System.out.println ("solution formula:" + string);
10. Boolean found = false;
12. For (Mathinterface math:mathlist) {
14. Matcher Matcher = Math.match (string);
16. if (Matcher.find ()) {
20. String exp = Matcher.group ();
22. String sig = "";
24. if (Exp.charat (0) = = '-' && matcher.start ()! = 0) {//If it is not the first number, the-number can only be used as an operator
26. sig = "+";
28. }
30. System.out.println ("Discovery formula:" + exp);
32. String Evalresult = Math.eval (exp);
34. String = String.substring (0, Matcher.start ()) + sig
36. + Evalresult + string.substring (Matcher.end ());
38. SYSTEM.OUT.PRINTLN (exp + "evaluates to:" + Evalresult + ", substituting back to original");
40. Found = true;
42. Break ;
44. }
46. }
48. if (!found) {
50. throw New RuntimeException (string + "not a valid mathematical expression");
52. }
54. }
56. return string;
58. }

From now on, the child has been able to solve the problem, but he still do not understand, he still do not know what is added, minus, multiply, except what, there is no way, the child stupid, as long as teach him more.
Below teaches him how to calculate, add, subtract, multiply, divide, remainder, parentheses, exponent.

[Java]View Plaincopy

2. Addmathexpression (new Add ());
4. Addmathexpression (new Subtract ());
6. Addmathexpression (new Multiply ());
8. Addmathexpression (new Devide ());
10. Addmathexpression (new Minus ());
12. Addmathexpression (new factorial ());
14. Addmathexpression (new Remainder ());
16. Addmathexpression (new bracket ());
18. Addmathexpression (new Power ());
20. Collections.sort (Mathlist, new Mathcomparator ());

Because of the same similarity, it is only the implementation of the addition and parentheses.
The addition implementation, its priority is 1, it is composed of two numbers in the middle plus a "+" number, the number and the plus sign in front of the space is useless, do not care about it. Calculate the time, is to add the way to add two numbers, this computer is stronger than people, hehe, tell him how to add will never be wrong. and understand that subtraction has an innate advantage.

[Java]View Plaincopy

2. Public class Add implements Mathinterface {
4. static String Pluspattern = blank + mathnumber.numberpattern + blank
6. + "[+]{1}" + blank + mathnumber.numberpattern + blank;
8. static Pattern pattern = Pattern.compile (Pluspattern);
10. static Pattern plus = Pattern.compile (BLANK + "\\+");
14. @Override
16. Public Matcher Match (String string) {
18. return Pattern.matcher (string);
20. }
24. @Override
26. Public int priority () {
28. return 1;
30. }
34. @Override
36. Public String eval (string expression) {
38. Matcher a = MathNumber.pattern.matcher (expression);
40. if (A.find ()) {
42. expression = expression.substring (A.end ());
44. }
46. Matcher p = plus.matcher (expression);
48. if (P.find ()) {
50. expression = expression.substring (P.end ());
52. }
54. Matcher B = MathNumber.pattern.matcher (expression);
56. if (B.find ()) {
60. }
62. return New BigDecimal (A.group ()). Add (new BigDecimal (B.group () ))
64. . toString ();
66. }
70. }

Next is the parentheses, the parentheses are the highest priority, as long as it should be calculated first. Of course, the contents of the inner parentheses are calculated first. Parentheses in the content, when the calculation, you can first pull out, no tube outside the content, calculated, put back on it.

[Java]View Plaincopy

2. Public class Bracket implements Mathinterface {
6. static String Bracketpattern = blank + "[(]{1}[^ (]*?[)]" + blank;
8. static Pattern pattern = Pattern.compile (Bracketpattern);
12. @Override
14. Public Matcher Match (String string) {
16. return Pattern.matcher (string);
18. }
22. @Override
24. Public int priority () {
26. return integer.max_value;
28. }
32. @Override
34. Public String eval (string expression) {
36. expression = Expression.trim ();
38. return Mathevaluation.eval (expression.substring (1,
40. Expression.length ()- 1));
42. }
46. }

So far, our program "Baby" has learned mathematical calculations, a question let Iraq try.

[Java]View Plaincopy

1. Public static void Main (string[] args) {
2. String string = "1+2^ (4/2) +5%2";
3. System.out.println ("The result is:" + mathevaluation.eval (string));
4. }

The procedure for your baby's problem is as follows:

[Java]View Plaincopy

2. Solution equation:1+2^ (4/2) +5%2
4. Discovery Formula: (4/2)
6. Solve equation:4/2
8. Discovery equation:4/2
10. 4/2 calculated as:2.00, back to the original type
12. (4/2) calculated as:2.00, back to the original type
14. Solution equation:1+2^2.00+5%2
16. Discovery formula:2^2.00
18. 2^2.00 Calculates the result:4, substituting the original type
20. Solution equation:1+4+5%2
22. Discovery formula:5%2
24. 5%2 Calculates the result:1, substituting the original type
26. Solution equation:1+4+1
28. Discovery formula:1+4
30. 1+4 Calculates the result:5, substituting the original type
32. Solution equation:5+1
34. Discovery formula:5+1
36. 5+1 Calculates the result:6, substituting the original type
38. The result is:6

Hehe, the program baby's problem-solving process is very consistent with the process of human being, and the implementation of the program is very easy to understand. God horse compilation principle, God horse infix expression is not used. (Execution efficiency is not necessarily high compared to other algorithms, and is only used to verify that the program's processing power is enhanced through rules, and that the regular expressions and program logic are not rigorously written without deep validation due to no in-depth testing)

In fact, although the program is very simple, but, in fact, is a simple rule of the prototype engine.
First, he loads a lot of business processing rules, plus, minus, multiply, divide, interpolate, index, remainder and so on.
Second, his business rules can be extended continuously.
Thirdly, as long as the facts are given, finally, by the constant application of the rules, he will eventually export the result, either the correct result or the fact that it is wrong.

For children who need the source code, please go to git and get the codes directly.

Git address: http://git.oschina.net/tinyframework/mathexp.git

Open source framework That thing 14: teaching computer programs to solve math problems