Merge branch 'master' of https://git.zipcode.rocks/jonathan-hinds/ZCW-MacroLabs-OOP-ScientificCalculator

Calculations.java

@@ -7,6 +7,7 @@ public class Calculations
     public static Console console = new Console();
     public static ArrayList<String> library = new ArrayList<String>();
     public static String invalidArgumentsAmountError = "You have entered an invalid amount of arguments. Please only use two arguments, or switch to PEMDAS";
+    public static Pemdas pemdas = new Pemdas();
     
     public Calculations(){
    
@@ -100,7 +101,7 @@ public class Calculations
         while(matcher.find()){
             String number = matcher.group().trim();
             Double deci = Double.valueOf(number);
-            
+
             results.add(deci);
         }
         

Pemdas.java

@@ -0,0 +1,275 @@
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.util.ArrayList;
+
+public class Pemdas
+{
+    //empty constructor function
+    public Pemdas()
+    {
+
+    }
+    
+    //function to perform main calculations using pemdas
+    public static String calculate(String s)
+    {
+        
+        System.out.println("Original " + s);
+        //String p = null;
+        //if(getBetweenBraces(s) != null)
+        //{
+        //    p = getBetweenBraces(s);
+        //}
+        //System.out.println(p);
+
+        String e = null;
+        System.out.println("expo");
+        //create a duplicate of the method below, this one should have no print statemnts - testing purposes only.
+        //instead of the above, remove everyting except for assignment and initiailization
+        //this will work because getUpdateString2 cannot return null.
+        if(getUpdateString2(s,"^") != null)
+        {
+            //assign e to this string, after this operator has been calculated, and the original value of the sting has been modified to replace the occurnece with the calculations
+            e = getUpdateString2(s,"^");
+        }
+        
+        String m = null;
+        System.out.println("mult");
+        if(getUpdateString2(e,"*") != null)
+        {
+            m = getUpdateString2(e,"*");
+        }
+        
+        String d = null;
+        System.out.println("div");
+        if(getUpdateString2(m,"/") != null)
+        {
+            d = getUpdateString2(m,"/");
+        }
+         
+        String a = null;
+        System.out.println("add");
+        if(getUpdateString2(d,"+") != null)
+        {
+            a = getUpdateString2(d,"+");
+        }
+            
+        String ss = null;
+        System.out.println("sub");
+       if(getUpdateString2(a,"-") != null)
+       {
+           ss = getUpdateString2(a,"-");
+       }
+       
+       System.out.println("calculate 1.) Answer: " + ss);
+       return ss;
+ 
+    }
+    
+    /**
+    //search a string (s) and return all occurences of r (regex pattern)
+    public static ArrayList<String> searchReturnAll(String s, String r){
+            //create a regex pattern
+        Pattern pattern = Pattern.compile(r);
+        
+        //create an arraylist to store all occurences of exponentation
+        ArrayList<String> occurences = new ArrayList<String>();
+        //create a matcher to match the pattern to the string
+        Matcher matcher = pattern.matcher(s);
+        //while the last search exists
+        while(matcher.find())
+        {
+            //add the occurences to the list
+            occurences.add(matcher.group());
+        } 
+        
+        //if(occurences.size() > 0)
+        //{
+            return occurences;
+        //}
+        
+    }*/
+    
+    //search a string ( s ) for the pattern ( r ) and return a string resemblence of the first occurrence 
+    public static String searchReturnFirstString(String s, String r){
+        
+        Pattern pattern = Pattern.compile(r);
+        Matcher matcher = pattern.matcher(s);
+
+        if(matcher.find())
+        { 
+            System.out.println("searchReturnFirstString 1.) perform on " + s + ": " + matcher.group());
+            return matcher.group();
+        }
+        
+        return null;   
+    }
+    
+        
+    //search the string (target) and replace the first occrence of (pattern) with replacement.
+    public static String searchReplaceFirst(String target, String replacement, String pattern)
+    {
+        //if nothing is replaced, return null
+        if(target.equals(target.replaceFirst(pattern, replacement))){
+            return null;
+        //if anything is replaced, return an updated string with the appropriate replacements
+        } else {
+            String result = target.replaceFirst(pattern, replacement);
+            System.out.println("searchReplaceFirst 1.) target | pattern | replacement | result");
+            System.out.println("searchReplaceFirst 2.) " + target + " | " + pattern + " | " + replacement + " | " + result);
+            return result; 
+        }
+    }
+    
+    /** 
+        - Method Name: PEMDAS
+        - The method takes in two strings, one string ( s ) - the string being modified and the operator ( r )
+        - Search the string ( s ) for the first occurrence of the operator being performed.
+        - If no occurrence is found
+            - return the original string
+        - If an occurrence of - this operation being performed - exists.
+            - store the occurrence as a string ( occ ) 
+            - store the digit left of the operator ( left ) as a double
+            - store the digit right of the operator ( right ) as a double
+            - perform switch case based on the operator ( r ) 
+                - case statement for each operator allowed
+                    - calculate the product of left and right ( result )
+            - replace ( occ ) in ( s ) with ( result ), store this in ( f )
+            - if ( f ) and ( s ) do not have the same value
+                - run PEMDAS on ( f ) and assign it to ( f )
+            - if the original ( s ) has the same value as ( f ) 
+                - return ( f )    
+                
+                
+      NOTES
+        - The logic is there, and the method behaves properly, the regex is inaccurate and will have to resolved.
+        - regex needs to pick up two numbers on either side of a given operation - no matter what the operation is.
+        - values need to be matched for both integers and floaring point.
+    */
+
+    public static String getUpdateString2(String s, String operator)
+    {
+        String f = s;
+        System.out.println("getUpdateString2 1.) Input is: " + f);
+        String pattern = "\\s?\\.?\\d+\\.?(\\d+)?\\s?\\" + operator + "\\s?\\.?\\d+\\.?(\\d+)?\\s?";
+        System.out.println("getUpdateString2 2.) Pattern is " + pattern);
+
+        String occ = searchReturnFirstString(s, pattern);
+        System.out.println("getUpdateString2 3.) the occurance is " + occ);
+        //if we recieve a result
+        if(occ != null)
+        {   
+            //store the first and last digits as left and right (based on relationship to operator)
+            String leftString = searchReturnFirstString(occ, "\\s?\\.?\\d+\\.?(\\d+)?\\s?");
+            String rightStringOpp = searchReturnFirstString(occ, "\\" + operator + "\\s?\\.?\\d+\\.?(\\d+)?\\s?");
+            String rightString = searchReturnFirstString(rightStringOpp, "\\s?\\.?\\d+\\.?(\\d+)?\\s?");
+            //create a double to store the digit on the left and right, double to store the product of right and left
+            Double left = 0.0;
+            Double right = 0.0;
+            Double doubleResult = 0.0;
+            //if the left digit is found as a string, convert to double
+            //if the right digit is found as a string, convert to double
+            if(leftString != null){left = Double.parseDouble(leftString);}
+            if(rightString != null){right = Double.parseDouble(rightString);}
+            //switch statement for the operator to conduct proper arithmetics
+            switch(operator)
+            {
+                   case "^":
+                   doubleResult = Math.pow(left, right);
+                   System.out.println("getUpdateString2 .4) " + left + operator + right + "=" + doubleResult);
+                   break;
+                   
+                   case "+":
+                   doubleResult = left + right;
+                   System.out.println("getUpdateString2 .4) " + left + operator + right + "=" + doubleResult);
+                   break;
+                   
+                   case "-":
+                   doubleResult = left - right;
+                   System.out.println("getUpdateString2 .4) " + left + operator + right + "=" + doubleResult);
+                   break;
+                   
+                   case "*":
+                   doubleResult = left * right;
+                   System.out.println("getUpdateString2 .4) " + left + operator + right + "=" + doubleResult);
+                   break;
+                   
+                   case "/":
+                   doubleResult = left / right;
+                   System.out.println("getUpdateString2 .4) " + left + operator + right + "=" + doubleResult);
+                   break;
+                   
+                   default:
+                   doubleResult = 0.0;
+                   break;                
+            }
+            //convert the double result to a string result
+            String result = String.valueOf(doubleResult);
+            //String result = String.format("%.9f", doubleResult);
+            //replace the occurence of occ in s with result
+            f = searchReplaceFirst(s, result, pattern);
+            System.out.println("getUpdateString2 5.) iteration completed, f: " + f + "\n");
+            if(!f.equals(s))
+            {
+                f = getUpdateString2(f, operator);
+            } else {
+                return f;
+            }
+        } else {
+            return f;
+        }
+        return f;
+    }
+    
+    public static String getBetweenBraces(String s){
+        //int to hold the opening braces index in the string
+        //int to hold the closing brace index in the string
+        //set a position counter = 0 to determine if the brace is closed.
+        //boolean to determine if the first opening brace has been captured = false
+        //convert string to str array
+        //for each letter in char array
+            //if the char is an opening brace
+                //if the boolean varriable to determine of the first opening brace != true
+                    //store i from the for loop in the variable to hold the opening index
+                //pos --
+            //if the char is not an opening brace 
+                //pos ++
+            
+            //if the counter = 0                
+                //store i in the varriable to hold the closing brace
+                
+        int openBrace = 0;
+        int closeBrace = 0;
+        int position = 0;
+        boolean firstBrace = false;
+        String[] strArr = s.split("(?!^)");
+        
+        for(int i = 0; i < strArr.length; i ++)
+        {
+            String letter = strArr[i];
+            if(letter.equals("("))
+            {
+                if(firstBrace == false)
+                {
+                    firstBrace = true;
+                    openBrace = i + 1;
+                }
+                position --;
+            } else if(letter.equals(")"))
+            {
+                position ++;
+            }
+            
+            if(position == 0)
+            {
+                closeBrace = i;
+                break;
+            } else {
+              return null;
+            }
+        }
+        
+        String result = s.substring(openBrace, closeBrace);
+        return result;
+    }
+}

package.bluej

@@ -8,10 +8,10 @@ dependency2.type=UsesDependency
 dependency3.from=Calculations
 dependency3.to=Console
 dependency3.type=UsesDependency
-editor.fx.0.height=709
-editor.fx.0.width=800
-editor.fx.0.x=240
-editor.fx.0.y=23
+editor.fx.0.height=1080
+editor.fx.0.width=1920
+editor.fx.0.x=-345
+editor.fx.0.y=-1080
 objectbench.height=198
 objectbench.width=595
 package.divider.horizontal=0.6