Advertisement
Guest User

Untitled

a guest
Dec 5th, 2016
61
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.64 KB | None | 0 0
  1. public class CalculatorFrameA {
  2. ActionListener button_eqListener = new ActionListener(){
  3. @Override
  4. public void actionPerformed(ActionEvent e){
  5. label2.setText(bracket(splitLabel(label.getText())));
  6. }
  7. };
  8.  
  9. public ArrayList<String> splitLabel(String val){
  10. ArrayList<String> label_split = new ArrayList<String>();
  11. String value = "";
  12. String op = "";
  13.  
  14. for (int i = 0; i< val.length(); i++){
  15. boolean isDigit = Character.toString(val.charAt(i)).matches("[0123456789.]+");
  16. boolean isOperator = Character.toString(val.charAt(i)).matches("[+*/^-]+");
  17. boolean isSin = (Character.toString(val.charAt(i)).equals("s") && Character.toString(val.charAt(i+1)).equals("i") && Character.toString(val.charAt(i+2)).equals("n"));
  18. boolean isCos = (Character.toString(val.charAt(i)).equals("c") && Character.toString(val.charAt(i+1)).equals("o") && Character.toString(val.charAt(i+2)).equals("s"));
  19. boolean isTan = (Character.toString(val.charAt(i)).equals("t") && Character.toString(val.charAt(i+1)).equals("a") && Character.toString(val.charAt(i+2)).equals("n"));
  20. boolean isOpBracket = Character.toString(val.charAt(i)).equals("(");
  21. boolean isClBracket = Character.toString(val.charAt(i)).equals(")");
  22.  
  23. while (isDigit){
  24. value = value + Character.toString(val.charAt(i));
  25. }
  26.  
  27. if (isOperator && !value.equals("")){
  28. op = Character.toString(val.charAt(i));
  29. label_split.add(value);
  30. label_split.add(op);
  31. op = "";
  32. value = "";
  33. } else if (isOperator && value.equals("")){
  34. if (Character.toString(val.charAt(i)).equals("-")){
  35. value = Character.toString(val.charAt(i));
  36. }
  37. } else if (isSin){
  38. label_split.add("sin");
  39. }else if (isCos){
  40. label_split.add("cos");
  41. }else if (isTan){
  42. label_split.add("tan");
  43. } else if (isOpBracket && !value.equals("")){
  44. label_split.add(value);
  45. label_split.add("(");
  46. value = "";
  47. } else if (isOpBracket && value.equals("")){
  48. label_split.add("(");
  49. } else if (isClBracket && !value.equals("")){
  50. label_split.add(value);
  51. label_split.add(")");
  52. value = "";
  53. }
  54. if (i== val.length()-1 && !value.equals("")){
  55. label_split.add(value);
  56. } else if (i== val.length()-1 && Character.toString(val.charAt(i)).equals(")")){
  57. label_split.add(")");
  58. }
  59. } return label_split;
  60. }
  61. public String bracket(ArrayList<String> label_split){
  62. ArrayList<Integer> opBra = new ArrayList<Integer>();
  63. ArrayList<Integer> clBra = new ArrayList<Integer>();
  64. ArrayList<String> calculation = new ArrayList<String>();
  65. int counter = 0;
  66. int counter1 = 0;
  67.  
  68. if (label_split.contains("(") && label_split.contains(")")){
  69. for (int j=0; j<label_split.size(); j++){
  70. if (label_split.get(j).equals("(")){
  71. counter = counter + 1;
  72. opBra.add(j);
  73. } else if (label_split.get(j).equals(")")){
  74. counter1 = counter1 + 1;
  75. clBra.add(j);
  76. }
  77. }
  78. if (counter1 != counter){
  79. return "error missing bracket";
  80. } else {
  81. for (int j=opBra.size(); j>0; j--){
  82. int opBraPos = opBra.get(j) + 1; //+1 and -1 so it doesn't include ()
  83. int clBraPos = clBra.get(opBra.size()-j) - 1;
  84. opBra.remove(j);
  85. clBra.remove(opBra.size()-j);
  86.  
  87. for(int t = 0; t < (clBraPos - opBraPos); t++){
  88. calculation.add(label_split.get(t+opBraPos));
  89. }
  90.  
  91. String value = calculate(calculation);
  92. label_split.set(j , value);
  93. calculation.clear();
  94.  
  95. for (int n = 0; n < ((clBraPos+1) - opBraPos); n++){
  96. label_split.remove(n);
  97. }
  98. }
  99. }
  100. return calculate(label_split);
  101. } else{
  102. return calculate(label_split);
  103. }
  104. }
  105. public String calculate(ArrayList<String> calculation){
  106. double value = 0.0;
  107. String value1 = "";
  108. boolean isOperator = calculation.contains("[+*/^-]+");
  109. boolean isSin = calculation.contains("sin");
  110. boolean isCos = calculation.contains("cos");
  111. boolean isTan = calculation.contains("tan");
  112. boolean isOpBracket = calculation.contains("(");
  113. boolean isClBracket = calculation.contains(")");
  114.  
  115. for (int i=0; i < calculation.size(); i++){
  116. if (calculation.get(i).equals("^") && i < calculation.size() && i < 0){
  117. boolean isDigit1 = calculation.get(i-1).matches("[0123456789.-]+");
  118. boolean isDigit2 = calculation.get(i+1).matches("[0123456789.-]+");
  119. if (isDigit1 && isDigit2){
  120. value = Math.pow(Double.parseDouble(calculation.get(i-1)), Double.parseDouble(calculation.get(i+1)));
  121. value1 = Double.toString(value);
  122. calculation.set(i,value1);
  123. calculation.remove(i-1);
  124. calculation.remove(i+1);
  125. }
  126. }
  127. }
  128.  
  129. for (int a=0; a < calculation.size(); a++){
  130. if ( (calculation.get(a)).equals("sin") && a < calculation.size() && a < 0){
  131. boolean isDigit1 = calculation.get(a+1).matches("[0123456789.-]+");
  132. if (isDigit1){
  133. value = Math.sin(Double.parseDouble(calculation.get(a+1)));
  134. value1 = Double.toString(value);
  135. calculation.set(a,value1);
  136. calculation.remove(a+1);
  137. }
  138. }
  139. }
  140.  
  141. for (int b=0; b < calculation.size(); b++){
  142. if ( (calculation.get(b)).equals("cos") && b < calculation.size() && b < 0){
  143. boolean isDigit1 = calculation.get(b+1).matches("[0123456789.-]+");
  144. if (isDigit1){
  145. value = Math.cos(Double.parseDouble(calculation.get(b+1)));
  146. value1 = Double.toString(value);
  147. calculation.set(b,value1);
  148. calculation.remove(b+1);
  149. }
  150. }
  151. }
  152.  
  153. for (int c=0; c < calculation.size(); c++){
  154. if ( (calculation.get(c)).equals("tan") && c < calculation.size() && c < 0){
  155. boolean isDigit1 = calculation.get(c+1).matches("[0123456789.-]+");
  156. if (isDigit1){
  157. value = Math.tan(Double.parseDouble(calculation.get(c+1)));
  158. value1 = Double.toString(value);
  159. calculation.set(c,value1);
  160. calculation.remove(c+1);
  161. }
  162. }
  163. }
  164.  
  165. for (int d=0; d < calculation.size(); d++){
  166. if (calculation.get(d).equals("*") && d < calculation.size() && d < 0){
  167. boolean isDigit1 = calculation.get(d-1).matches("[0123456789.-]+");
  168. boolean isDigit2 = calculation.get(d+1).matches("[0123456789.-]+");
  169. if (isDigit1 && isDigit2){
  170. value = Double.parseDouble(calculation.get(d-1)) * Double.parseDouble(calculation.get(d+1));
  171. value1 = Double.toString(value);
  172. calculation.set(d,value1);
  173. calculation.remove(d-1);
  174. calculation.remove(d+1);
  175. }
  176. }
  177. }
  178.  
  179. for (int e=0; e < calculation.size(); e++){
  180. if (calculation.get(e).equals("/") && e < calculation.size() && e < 0){
  181. boolean isDigit1 = calculation.get(e-1).matches("[0123456789.-]+");
  182. boolean isDigit2 = calculation.get(e+1).matches("[0123456789.-]+");
  183. if (isDigit1 && isDigit2){
  184. value = Double.parseDouble(calculation.get(e-1)) / Double.parseDouble(calculation.get(e+1));
  185. value1 = Double.toString(value);
  186. calculation.set(e,value1);
  187. calculation.remove(e-1);
  188. calculation.remove(e+1);
  189. }
  190. }
  191. }
  192.  
  193. for (int f=0; f < calculation.size(); f++){
  194. if (calculation.get(f).equals("+") && f < calculation.size() && f < 0){
  195. boolean isDigit1 = calculation.get(f-1).matches("[0123456789.-]+");
  196. boolean isDigit2 = calculation.get(f+1).matches("[0123456789.-]+");
  197. if (isDigit1 && isDigit2){
  198. value = Double.parseDouble(calculation.get(f-1)) + Double.parseDouble(calculation.get(f+1));
  199. value1 = Double.toString(value);
  200. calculation.set(f,value1);
  201. calculation.remove(f-1);
  202. calculation.remove(f+1);
  203. }
  204. }
  205. }
  206.  
  207. for (int g=0; g < calculation.size(); g++){
  208. if (calculation.get(g).equals("-") && g < calculation.size() && g < 0){
  209. boolean isDigit1 = calculation.get(g-1).matches("[0123456789.-]+");
  210. boolean isDigit2 = calculation.get(g+1).matches("[0123456789.-]+");
  211. if (isDigit1 && isDigit2){
  212. value = Double.parseDouble(calculation.get(g-1)) - Double.parseDouble(calculation.get(g+1));
  213. value1 = Double.toString(value);
  214. calculation.set(g,value1);
  215. calculation.remove(g-1);
  216. calculation.remove(g+1);
  217. }
  218. }
  219. }
  220.  
  221. for (int h=0; h < calculation.size(); h++){
  222. boolean isDigit = calculation.get(h).matches("[0123456789.-]+");
  223. if (isDigit && !isOperator && !isSin && !isCos && !isTan &&!isOpBracket &&!isClBracket){
  224. double value3 = 0.0;
  225. value3 = Double.parseDouble(calculation.get(h));
  226. String value2 = Double.toString(value3);
  227. calculation.set(h,value2);
  228. }
  229. }
  230.  
  231. return calculation.get(0);
  232. }
  233. public static void main(String[] args) {
  234. CalculatorFrameA g = new CalculatorFrameA();
  235. }
  236. }
  237. public static void main(String[] args) {
  238. CalculatorFrameA g = new CalculatorFrameA();
  239. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement