Physics Calculator

[Derek Smiths]

Alright, hopefully I will have some luck on this forum and someone can help me get past this issue: There are a lot of variables in physics and it is easy to manipulate equations to find the unknown variable. Well, in my program I have the problem of determining which equation to solve for an unknown. You can see I have a timeF, timeI, time, distanceI, distanceF, distance...etc...variables. The way that I have written the code, it will scan for an empty() JTF and assign it as the unknown variable (not sure I can do it this way anymore). At that point, the value is passed into the correct calculation method to process the equation based on a series of case statements in each method. Can someone please help me figure this part out. I think once I get past this issue...the rest will fall into place.

I know the button arrays I have set up will process correctly in the checkJTF method...and I will need to account for that...but right now my focus is on getting the program to properly calculate the kinematics equations and display the result in the JPanel.

NOTE: If you see any other problems, please let me know so that I don't venture too far off the beaten path.

public class PhysicsFrame extends JFrame {
    //Kinematic variables
     private static float distanceI, distanceF, velocityI, velocityF,
    velocityAverage, acceleration, time, timeF, timeI, result;
     //Power variables
     private static float power, energyKin, energyGrav, energyTot, work, timeOne, timeTwo, distanceOne,
    distanceTwo, velocityOne, velocityTwo, mass, gravity, heightF, heightI;
     //Dynamics variables
     private static float netForce, weight, friction, radius, radiusOne, radiusTwo,
    massOne, massTwo, frictionConstant, gravForce, gravConstant, frictionNormal;
     private static int unknownVar = 0;
         
    public PhysicsFrame() throws IOException {
        super("PhysAssist");
 
        // Buttons
        JButton kinematic = new JButton("Kinematic");
        kinematic.setMnemonic(KeyEvent.VK_K);
        JButton dynamics = new JButton("Dynamics");
        dynamics.setMnemonic(KeyEvent.VK_D);
        JButton power = new JButton("Power and Energy");
        power.setMnemonic(KeyEvent.VK_E);
        JButton wave = new JButton("Wave");
        wave.setMnemonic(KeyEvent.VK_W);
        JButton sound = new JButton("Sound");
        sound.setMnemonic(KeyEvent.VK_S);
        JButton circuit = new JButton("Circuit");
        circuit.setMnemonic(KeyEvent.VK_C);
 
        // Execute Buttons
        JButton calculate = new JButton("Calculate");
        calculate.setMnemonic(KeyEvent.VK_ENTER);
        calculate.setFont(new java.awt.Font("Georgia", Font.BOLD, 16));
        calculate.setForeground(Color.BLUE);
        JButton back = new JButton("Back");
        back.setMnemonic(KeyEvent.VK_ESCAPE);
        back.setFont(new java.awt.Font("Georgia", Font.ITALIC, 16));
        back.setForeground(Color.RED);
 
        // Button Array Characteristics
        final JButton[] buttonArray = { kinematic, dynamics, power, wave,
                sound, circuit };
        for (int i = 0; i < buttonArray.length; i++) {
            buttonArray[i].setFont(new java.awt.Font("Georgia", Font.BOLD, 16));
            buttonArray[i].setForeground(Color.darkGray);
            buttonArray[i].setBackground(Color.GRAY);
        }
 
        // Panels
        final JPanel mainPanel = new JPanel();
        mainPanel.setLayout(new BorderLayout());
 
        final JPanel executePanel = new JPanel();
        executePanel.setLayout(new FlowLayout());
        executePanel.add(back);
        executePanel.add(calculate);
 
        final JPanel sidePanel = new JPanel();
        sidePanel.setLayout(new BorderLayout());
 
        final JPanel combinationPanel = new JPanel();
        combinationPanel.setLayout(new GridLayout(2, 1));
 
        final JPanel resultPanel = new JPanel();
        Border border = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED);
        TitledBorder titled = BorderFactory.createTitledBorder(border,
                "Results", TitledBorder.DEFAULT_JUSTIFICATION,
                TitledBorder.DEFAULT_POSITION, new Font("Synchro LET",
                        Font.BOLD, 14), Color.WHITE);
        resultPanel.setBorder(titled);
        resultPanel.setLayout(new GridLayout(4, 2));               
        resultPanel.setBackground(Color.DARK_GRAY);
             /////////////////////////////////////////////////
        final JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new GridLayout(6, 1));
        buttonPanel.setBackground(Color.DARK_GRAY);
 
    /////////// Kinematic Pane and Contents////////////////
        final JPanel kinematicPanel = new JPanel(new GridLayout(8, 2));
        kinematicPanel.add(new JLabel("Initial Distance"));
        final JTextField dI = new JTextField();
        kinematicPanel.add(dI);
        kinematicPanel.add(new JLabel("Final Distance"));
        final JTextField d0 = new JTextField();
        kinematicPanel.add(d0);
        kinematicPanel.add(new JLabel("Initial Velocity"));
        final JTextField velocityI = new JTextField();
        kinematicPanel.add(velocityI);
        kinematicPanel.add(new JLabel("Final Velocity"));
        final JTextField velocityF = new JTextField();
        kinematicPanel.add(velocityF);
        kinematicPanel.add(new JLabel("Average Velocity"));
        final JTextField velocityAverage = new JTextField();
        kinematicPanel.add(velocityAverage);
        kinematicPanel.add(new JLabel("Acceleration"));
        final JTextField accelerationAverage = new JTextField();
        kinematicPanel.add(accelerationAverage);
        kinematicPanel.add(new JLabel("Time"));
        final JTextField initialTime = new JTextField();
        kinematicPanel.add(initialTime);
        /*kinematicPane.add(new JLabel("Final Time"));
        final JTextField finalTime = new JTextField();
        kinematicPane.add(finalTime);*/
 
        final JTextField[] kinematicsJT = { dI, d0, velocityI, velocityF,
                velocityAverage, accelerationAverage, initialTime};
 
         
         
         
         
    ////////// Dynamics Panel//////////////
        final JPanel dynamicsPanel = new JPanel(new GridLayout(6, 2));
        dynamicsPanel.add(new JLabel("Force"));
        final JTextField force = new JTextField();
        dynamicsPanel.add(force);
        dynamicsPanel.add(new JLabel("Mass One"));
        final JTextField massOne = new JTextField();
        dynamicsPanel.add(massOne);
        dynamicsPanel.add(new JLabel("Mass One"));
        final JTextField massTwo = new JTextField();
        dynamicsPanel.add(massTwo);
        dynamicsPanel.add(new JLabel("Radius One"));
        final JTextField radiusOne = new JTextField();
        dynamicsPanel.add(radiusOne);
        dynamicsPanel.add(new JLabel("Radius Two"));
        final JTextField radiusTwo = new JTextField();
        dynamicsPanel.add(radiusTwo);
        dynamicsPanel.add(new JLabel("Normal Friction"));
            final JTextField frictionNormal = new JTextField();
        dynamicsPanel.add(frictionNormal);
                 
                final JTextField[] dynamicsJT = {force, massOne,massTwo, radiusOne,
                                      radiusTwo, frictionNormal};
 
    /////////Power, Work, Energy Pane/////////////
        final JPanel powerPanel = new JPanel(new GridLayout(7, 2));
        powerPanel.add(new JLabel("Work"));
        final JTextField work = new JTextField();
        powerPanel.add(work);
        powerPanel.add(new JLabel("Energy"));
        final JTextField energy = new JTextField();
        powerPanel.add(energy);
        powerPanel.add(new JLabel("Power"));
        final JTextField powerTF = new JTextField();
        powerPanel.add(powerTF);
        powerPanel.add(new JLabel("Mass"));
        final JTextField mass = new JTextField();
        powerPanel.add(mass);
        powerPanel.add(new JLabel("Initial Time"));
        final JTextField timeOne = new JTextField();
        powerPanel.add(timeOne);
        powerPanel.add(new JLabel("Final Time"));
        final JTextField timeTwo = new JTextField();
        powerPanel.add(timeTwo);
        powerPanel.add(new JLabel("Velocity"));
        final JTextField velocity = new JTextField();
        powerPanel.add(velocity);
        powerPanel.add(new JLabel("Force"));
        final JTextField powerForce = new JTextField();
        powerPanel.add(powerForce);
             
                final JTextField[] powerJT = {work, energy, powerTF, mass, timeOne,
                timeTwo, velocity, powerForce};
           ////////////WAVE PANE//////////////
        final JPanel wavePanel = new JPanel();
        wavePanel.add(new JLabel());
          ////////////SOUND PANE//////////////
        final JPanel soundPane = new JPanel();
          //////////////CIRCUIT PANE//////////
        final JPanel circuitPanel = new JPanel(new GridLayout(3, 2));
        circuitPanel.add(new JLabel("Voltage"));
        final JTextField voltage = new JTextField();
        circuitPanel.add(voltage);
        circuitPanel.add(new JLabel("Current"));
        final JTextField current = new JTextField();
        circuitPanel.add(current);
        circuitPanel.add(new JLabel("Resistance"));
        final JTextField resistance = new JTextField();
        circuitPanel.add(resistance);
 
            /////////// Add Header to JFrame////////////
        final JPanel imagePanel = new JPanel();
        //imagePanel.setBackground(Color.DARK_GRAY);
        //BufferedImage bfimage = ImageIO.read(getClass().getResource(
                //"physicsImg.jpg"));
        //ImageLabel image = new ImageLabel(bfimage);
        //JLabel headerLabel = new JLabel(new ImageIcon(bfimage));
        //headerLabel.add(image);
        //imagePanel.add(headerLabel);
 
            ///////////// ADD BUTTON PANEL COMPONENTS////////////////
        buttonPanel.add(kinematic);
        buttonPanel.add(dynamics);
        buttonPanel.add(power);
        buttonPanel.add(wave);
        buttonPanel.add(sound);
        buttonPanel.add(circuit);
 
        add(mainPanel);
        mainPanel.add(imagePanel, BorderLayout.CENTER);
        mainPanel.add(buttonPanel, BorderLayout.SOUTH);
 
        validate();
            ///////////////ACTION LISTENERS///////////////
        back.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                for (int i = 0; i < buttonArray.length; i++) {
                    mainPanel.remove(buttonArray[i]);
                }
                mainPanel.remove(sidePanel);
                mainPanel.remove(combinationPanel);
                mainPanel.add(buttonPanel, BorderLayout.SOUTH);
                mainPanel.add(imagePanel, BorderLayout.CENTER);
                mainPanel.revalidate();
                mainPanel.repaint();
            }
        });
 
        calculate.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                PhysicsFrame.checkJTF(kinematicsJT);
                if(unknownVar >= 0 && unknownVar <= 6){
                                try {
                    float distanceI = Float.parseFloat(dI.getText());
                    PhysicsFrame.setDistanceI(distanceI);
                    float distanceF = Float.parseFloat(d0.getText());
                    PhysicsFrame.setDistanceF(distanceF);
                    float v0 = Float.parseFloat(velocityI.getText());
                    PhysicsFrame.setVelocityI(v0);
                    float v1 = Float.parseFloat(velocityF.getText());
                    PhysicsFrame.setVelocityF(v1);
                    float vA = Float.parseFloat(velocityAverage.getText());
                    PhysicsFrame.setVelocityAverage(vA);
                    float aA = Float.parseFloat(accelerationAverage.getText());
                    PhysicsFrame.setAcceleration(aA);
                                        float time = Float.parseFloat(initialTime.getText());
                                        PhysicsFrame.setTime(time);
                                        calcKinematic(getUnknown());
 
                } catch (NumberFormatException e) {
                    JOptionPane.showMessageDialog(null, "Numbers Only");
                }
                            }
                                PhysicsFrame.checkJTF(dynamicsJT);
                                if(unknownVar >=7 && unknownVar <= 13){
                                    try{
                                        float f = Float.parseFloat(force.getText());
                float m1 = Float.parseFloat(massOne.getText());
                                PhysicsFrame.setMassOne(m1);
                float m2 = Float.parseFloat(massTwo.getText());
                                PhysicsFrame.setMassTwo(m2);
                float r1 = Float.parseFloat(radiusOne.getText());
                                PhysicsFrame.setRadiusOne(r1);
                float r2 = Float.parseFloat(radiusTwo.getText());
                                PhysicsFrame.setRadiusTwo(r2);
                float fN = Float.parseFloat(frictionNormal.getText());
                                PhysicsFrame.setFrictionNormal(fN);
                                    }catch(NumberFormatException e){
                                        JOptionPane.showMessageDialog(null, "Numbers Only");
                                    }
                                     
                                }
                                PhysicsFrame.checkJTF(powerJT);
                                if(unknownVar >=14 && unknownVar <= 22){
                                     
                                }
                               // final JLabel unknownLabel = new JLabel("Unknown" + );
                               // resultPanel.add(unknownLabel);
                                //resultPanel.revalidate();
                //resultPanel.repaint();
                       }
        });
 
        kinematic.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(kinematicPanel, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                combinationPanel.add(buttonPanel);
                combinationPanel.add(resultPanel);
                mainPanel.add(combinationPanel, BorderLayout.WEST);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
            }
        });
 
        dynamics.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(dynamicsPanel, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.add(buttonPanel, BorderLayout.WEST);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
            }
        });
 
        power.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(powerPanel, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.add(buttonPanel, BorderLayout.WEST);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
 
                float w = Float.parseFloat(work.getText());
                float e = Float.parseFloat(energy.getText());
                float p = Float.parseFloat(powerTF.getText());
                float m = Float.parseFloat(mass.getText());
                float t1 = Float.parseFloat(timeOne.getText());
                float t2 = Float.parseFloat(timeTwo.getText());
                float v = Float.parseFloat(velocity.getText());
                float pF = Float.parseFloat(powerForce.getText());
            }
        });
 
        wave.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(wavePanel, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.add(buttonPanel, BorderLayout.WEST);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
            }
        });
 
        sound.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(soundPane, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.add(buttonPanel, BorderLayout.WEST);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
            }
        });
 
        circuit.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                sidePanel.add(circuitPanel, BorderLayout.CENTER);
                sidePanel.add(executePanel, BorderLayout.SOUTH);
                mainPanel.add(sidePanel, BorderLayout.CENTER);
                mainPanel.add(buttonPanel, BorderLayout.WEST);
                mainPanel.remove(imagePanel);
                mainPanel.revalidate();
                mainPanel.repaint();
 
                float volt = Float.parseFloat(voltage.getText());
                float cI = Float.parseFloat(current.getText());
                float rR = Float.parseFloat(resistance.getText());
            }
        });
        // System.out.println(kinematics.getDistanceI());
    }
   ///////////FIND UNKNOWN VARIABLE METHOD////////////    
    static void checkJTF(JTextField[] a) {
        for (int i = 0; i < a.length; i++) {
            if (a[i].getText().isEmpty()) {
                                int unknownVar = i;
                PhysicsFrame.setUnknown(unknownVar);
                System.out.println("checkJTF: " + unknownVar);
                                a[i].setText("0");
            }
        }
    }
    /////////////SET/GET VARIABLES//////////////
    public static void setDistanceI(float dI){
        distanceI = dI;
    }
    public static void setDistanceF(float dF){
        distanceF = dF;
    }
    public static void setVelocityI(float vI){
        velocityI = vI;
    }
    public static void setVelocityF(float F){
        velocityF = F;
    }
    public static void setVelocityAverage(float vAverage){
        velocityAverage = vAverage;
    }
    public static void setAcceleration(float accel){
        acceleration = accel;
    }
        public static void setTime(float timeTF){
            time = timeTF;
        }
        public static void setMassOne(float m1){
            massOne = m1;
        }
        public static void setMassTwo(float m2){
            massTwo = m2;
        }
        public static void setRadiusOne(float r1){
            radiusOne = r1;
        }
         public static void setRadiusTwo(float r2){
            radiusTwo = r2;
        }
          public static void setFrictionNormal(float fn){
            frictionNormal = fn;
        }
    public static void setUnknown(int unknown) {
                unknownVar = unknown;
    }
        public static void setResult(float results){
            result = results;
        }
         
 
    public int getUnknown() {
        return unknownVar;
    }
    public static int getResult() {
        return unknownVar;
    }
    //////////////CALCULATION METHODS////////////////
        public static void calcKinematic(int unknown){
         
            if (unknown >= 0 && unknown <= 7) {
            switch (unknown) {
                case 0://velocifyI
                    result = velocityF - acceleration * (timeF - timeI);
                    System.out.println("Case 0");
                    System.out.println("VerifyAcceleraion : " + acceleration);
                    System.out.println("VerifyVelocityI : " + velocityI);
                    System.out.println("Restult" + result);
                     
                    break;
                case 1: //distanceF
                    result = distanceI + ((velocityI + velocityF) / 2);
                    System.out.println("Case 1");
                    System.out.println("VerifyDistance: " + distanceI);
                    System.out.println("VerifyVelocityI : " + velocityI);
                    System.out.println("VerifyVelocityF :" + velocityF);
                    System.out.println("Result: " + result);
                    break;
                case 2: //distanceF
                    result = (float) (velocityF * (timeF - timeI) + 0.5 * (acceleration * ((time) * (time))));
                    System.out.println("Case 2");
                    System.out.println("Restult" + result);
                    break;
                case 3://velocityF
                    result = (float) Math.sqrt((velocityI * velocityI) + 2 * acceleration * (distanceF - distanceI));
                            System.out.println("Case 3");
                            System.out.println("VerifyRestult" + result);
                            System.out.println("VerifyVelocity : " + velocityI);                           
                    break;      
                case 4: //velocityAverage
                    result = (distanceF - distanceI) / (time);
                    System.out.println("Case4");
                    System.out.println("Restult " + result);
                    break;
                case 5: //acceleration
                    result = (velocityF - velocityI)/time;
                    System.out.println("Case 5");
                    System.out.println("Restult " + result);
                }
            PhysicsFrame.setResult((result));
             
            }
        }
         
        public static void calcDynamics(int unknown){
            if(unknown >= 7 && unknown <= 13){
                switch(unknown){
                    case 6: //
                    case 7:
                    case 8:
                    case 9:
                    case 10:
                    case 11:
                    case 12:
                }
            }
        }
        public static void calcPower(int unknown){
            if(unknown >= 14 && unknown <= 22){
                switch(unknown){
                    case 14: //
                    case 15:
                    case 16:
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                     
                }
            }
        }                
}

[Paul Clapham]

Hi Derek, welcome to the Ranch!

The main problem I see there, I'm sorry to say, is that you have posted 500 lines of code. And you haven't told us what part of the code you're asking about. It would be much more practical if you posted a much smaller piece of code to demonstrate the problem. For example I don't think you need a whole lot of buttons to do that.

[Derek Smiths]

Thank you! Yeah, I know you guys are busy and its probably a pain to read through so much code and I just wanted you to be able to see it in its entirety. I will post the snippets of code that are the problem areas.

In code 1: This will calculate the input from the user that was entered into the JTextField. I have a checkJTF method that will scan the array for an empty JTF and assign it the variable unknownVar. As you can see in the calculate ActionListener you can see it will pass the unknownVar through some if/else arguments to determine which calculate method to call. The problem I have is what to do when more than one JTF in the array is left empty -- meaning more than one unknownVar. The physics equations have different variables depending on which equation, in addition to them being manipulated any number of different ways, and I'm really not sure how to account for this in code.
Hopefully this is a little easier to see specifically what is the problem.

  calculate.addActionListener(new ActionListener() {  
            public void actionPerformed(ActionEvent ae) {  
                PhysicsFrame.checkJTF(kinematicsJT);  
                if(unknownVar >= 0 && unknownVar <= 6){  
                                try {  
                    float distanceI = Float.parseFloat(dI.getText());  
                    PhysicsFrame.setDistanceI(distanceI);  
                    float distanceF = Float.parseFloat(d0.getText());  
                    PhysicsFrame.setDistanceF(distanceF);  
                    float v0 = Float.parseFloat(velocityI.getText());  
                    PhysicsFrame.setVelocityI(v0);  
                    float v1 = Float.parseFloat(velocityF.getText());  
                    PhysicsFrame.setVelocityF(v1);  
                    float vA = Float.parseFloat(velocityAverage.getText());  
                    PhysicsFrame.setVelocityAverage(vA);  
                    float aA = Float.parseFloat(accelerationAverage.getText());  
                    PhysicsFrame.setAcceleration(aA);  
                                        float time = Float.parseFloat(initialTime.getText());  
                                        PhysicsFrame.setTime(time);  
                                        calcKinematic(getUnknown());  
   
                } catch (NumberFormatException e) {  
                    JOptionPane.showMessageDialog(null, "Numbers Only");  
                }  
                            }  
                                PhysicsFrame.checkJTF(dynamicsJT);  
                                if(unknownVar >=7 && unknownVar <= 13){  
                                    try{  
                                        float f = Float.parseFloat(force.getText());  
                float m1 = Float.parseFloat(massOne.getText());  
                                PhysicsFrame.setMassOne(m1);  
                float m2 = Float.parseFloat(massTwo.getText());  
                                PhysicsFrame.setMassTwo(m2);  
                float r1 = Float.parseFloat(radiusOne.getText());  
                                PhysicsFrame.setRadiusOne(r1);  
                float r2 = Float.parseFloat(radiusTwo.getText());  
                                PhysicsFrame.setRadiusTwo(r2);  
                float fN = Float.parseFloat(frictionNormal.getText());  
                                PhysicsFrame.setFrictionNormal(fN);  
                                    }catch(NumberFormatException e){  
                                        JOptionPane.showMessageDialog(null, "Numbers Only");  
                                    }  
                                       
                                }  
                                PhysicsFrame.checkJTF(powerJT);  
                                if(unknownVar >=14 && unknownVar <= 22){  
                                       
                                }  
                               // final JLabel unknownLabel = new JLabel("Unknown" + );  
                               // resultPanel.add(unknownLabel);  
                                //resultPanel.revalidate();  
                //resultPanel.repaint();  
                       }  
        });  

 ///////////FIND UNKNOWN VARIABLE METHOD////////////      
    static void checkJTF(JTextField[] a) {  
        for (int i = 0; i < a.length; i++) {  
            if (a[i].getText().isEmpty()) {  
                                int unknownVar = i;  
                PhysicsFrame.setUnknown(unknownVar);  
                System.out.println("checkJTF: " + unknownVar);  
                                a[i].setText("0");  
            }  
        }  
    }  

//////////////CALCULATION METHODS////////////////
        public static void calcKinematic(int unknown){
        
            if (unknown >= 0 && unknown <= 7) {
            switch (unknown) {
                case 0://distanceI
                    result = distanceF - ((velocityI + velocityF) / 2);
                    System.out.println("Case 1");
                    System.out.println("VerifyDistanceF: " + distanceF);
                    System.out.println("VerifyVelocityI : " + velocityI);
                    System.out.println("VerifyVelocityF :" + velocityF);
                    System.out.println("Result DistanceI: " + result);              
                    break;
                case 1: //distanceF
                    result = distanceI + ((velocityI + velocityF) / 2);
                    System.out.println("Case 1");
                    System.out.println("VerifyDistanceI: " + distanceI);
                    System.out.println("VerifyVelocityI : " + velocityI);
                    System.out.println("VerifyVelocityF :" + velocityF);
                    System.out.println("Result DistanceF: " + result);
                    break;
                case 2: //velocifyI
                    result = velocityF - acceleration * (time);
                    System.out.println("Case 0");
                    System.out.println("VerifyAcceleraion : " + acceleration);
                    System.out.println("VerifyVelocityI : " + velocityI);
                    System.out.println("Restult" + result);//distanceF
                    result = (float) (velocityF * (time) + 0.5 * (acceleration * ((time) * (time))));
                    System.out.println("Case 2");
                    System.out.println("Restult" + result);
                    break;
                case 3://velocityF
                    result = (float) Math.sqrt((velocityI * velocityI) + 2 * acceleration * (distanceF - distanceI));
                            System.out.println("Case 3");
                            System.out.println("VerifyRestult" + result);
                            System.out.println("VerifyVelocity : " + velocityI);                            
                    break;       
                case 4: //velocityAverage
                    result = (distanceF - distanceI) / (time);
                    System.out.println("Case4");
                    System.out.println("Restult " + result);
                    break;
                case 5: //acceleration
                    result = (velocityF - velocityI)/time;
                    System.out.println("Case 5");
                    System.out.println("VerifyVelocityF: " + velocityF);
                    System.out.println("VerifyVelocifyI: " + velocityI);
                    System.out.println("VerifyTime: " + time);
                    System.out.println("Restult Acceleration: " + result);
                    break;
                case 6: //time
                    result = (distanceF - distanceI)/(velocityF - velocityI);
                }
            PhysicsFrame.setResult((result));
            
            }

[Paul Clapham]

Derek Nickerson wrote:The problem I have is what to do when more than one JTF in the array is left empty -- meaning more than one unknownVar.

Then the question is, what do you want to happen in that case? Your design seems to assume that only one of them will be empty, since you only use a single variable to say which one is empty, but perhaps that's a design error? Think up some examples and see if you can fix your design for a start.

[Winston Gutkowski]

Derek Nickerson wrote:Yeah, I know you guys are busy and its probably a pain to read through so much code and I just wanted you to be able to see it in its entirety. I will post the snippets of code that are the problem areas.

Still quite a bit, but I'll try to give you a kick-start:

Your "calculator" seems to be very tightly coupled to your GUI code and that's almost always a bad way to go. At the very least I'd suggest a Calculator or EquationSolver class that has absolutely no GUI code in it at all. It should work only with numbers or formulae and spit back a result. And if you design it well, you may well be able to subtype it to solve different equations (eg, quadratics or integrals), because that's how Object-Orientation works.

However, in order to do that, you need to first understand exactly WHAT your "calculator" needs to do. Right now, you're worrying about frames and buttons and panels and user interaction, and they are simply not important to the task of writing an equation solver.

Get back to basics: What is this "calculator" of yours supposed to do? And forget about screens when you're trying to describe it. What information does it need, and what is it supposed to produce?

HIH

Winston

PS: Your code lines are far too long, and it makes your thread very difficult to read. I'd break them up myself, but you have tons of them, so I suggest you do it yourself. Or, at the very least, read the link before you post a new thread. Thanks.

[K. Tsang]

Further to what Winston said about the calculator, maybe you can consider using the Factory design factory to instantiate the proper calculator instance given what variables are known/unknown.

[Derek Smiths]

Hey. Thank you for replying to my post. I will try to make a better quality post next time.

When I originally started designing my code, I had setup classes for each topic (kinematics, dynamics..etc.). I created the JFrame and its components (JButton, JLabels, ActionListeners..etc) within this class. I knew it would help keep everything separated and easy to read and access. Somewhere along the lines when I tried to actually use the equations from each class, I ran into issues passing the variables and creating the object ("calculate"). Instead I resorted to keeping it all in the same class, since I was having plenty of other problems at the time it seemed like the best choice. This is one of two things I am very disappointed with in the code.

As far as calculating for different equations (the 5 kinematics equations, 4 or 5 dynamics..etc), I stuck with just one equation for each topic. Trying to account for more than one empty JTF array (or variable) in the checkJTF method was a problem I just couldn't figure out. Do you guys know how I could have fixed that issue? I completed the code last night after choosing to just solve for one variable using one equation. I plan to do more work on this code and would like to improve upon it, so I will likely go back to try and put each (topic)Calculator method into its own class to start with. But I still need to figure out how to use more equations than one and solve for more than one unknown.

Thanks a lot for the replies.

[Derek Smiths]

I have a question, when I create a class for each calculation topic, where should I create the object for that class? Should I create it in the main method or within the GUI class...? I think this may have been why I couldn't get it to work properly last time.

[K. Tsang]

Derek Nickerson wrote:As far as calculating for different equations (the 5 kinematics equations, 4 or 5 dynamics..etc), I stuck with just one equation for each topic. Trying to account for more than one empty JTF array (or variable) in the checkJTF method was a problem I just couldn't figure out. Do you guys know how I could have fixed that issue? I completed the code last night after choosing to just solve for one variable using one equation. I plan to do more work on this code and would like to improve upon it, so I will likely go back to try and put each (topic)Calculator method into its own class to start with. But I still need to figure out how to use more equations than one and solve for more than one unknown.

Imagine you can calculate multiple unknowns in your "calculateXXX" methods. Passing in the unknown variables would just be passing in an array of ints or varargs of ints. The real problem is inside the calculateXXX() method. I see your current approach is using an if statement then case inside. If the passed in parameter is array, the if statement can easily turn into a for loop.

Anyway, I'm no physics or math guy much but I'm sure there are formulae for solving such equations more easier than whole bunch of case statements.

[Derek Smiths]

K. Tsang wrote:
Imagine you can calculate multiple unknowns in your "calculateXXX" methods. Passing in the unknown variables would just be passing in an array of ints or varargs of ints. The real problem is inside the calculateXXX() method. I see your current approach is using an if statement then case inside. If the passed in parameter is array, the if statement can easily turn into a for loop.

Anyway, I'm no physics or math guy much but I'm sure there are formulae for solving such equations more easier than whole bunch of case statements.

Yes, I see what you mean by passing the array of variable integers into the calculate method, but once inside this method, the problem of choosing which variable can be solved for by a variety of equations. Each equation depends on the known data and each equation can be manipulated to solve for different variables. I mean there are at least 3 different equations that can be used to solve for distance, but if a velocity variable isn't given, then I need to first find the right equation to used to solve for velocity -- then go back and solve for distance. I'm just not seeing how I can do that in code.

[K. Tsang]

Using your distance example, not knowing velocity at first. Then your calculateDistance() method would look like:

Is velocity provided?
if Y solve distance directly
if N solve velocity then solve distance

Now I'm not suggesting you use bunch of if to find "if velocity is given". Now thinking more, maybe an array may not be the best input parameter, a map can be better. But to illustrate the logic in code using a map because with array, you would not know which element is what, assuming these calculate methods are NOT GUI dependent:

public int calculateDistance(Map<String, Integer> unknownMap) {
if(unknownMap.contains("v") ) {
// solve directly
} else {
// solve velocity
// solve directly
}
return distance;
}

Now you may noticed there will be repeated code for "solving directly" part. In OO terms, reuse is key. Maybe you can have many methods calculating distance given the known variables instead. This will then become:

public int calculateDistance(Map<String, Integer> unknownMap) {
int distance = 0;
if(unknownMap.contains("v") ) {
distance = calculateDistance(unknownMap.get("v"));
} else {
int velocity = calculateVelocity(...);
distance = calculateDistance(velocity);
}
return distance;
}

public int calculateVelocity(int a, int b....) {
int velocity = .... // using necessary parms
return velocity;
}

public int calculateDistance(int velocity) {
int distance = .... // using velocity
return distance;
}

Now this surely looks lengthy depends on how many variables you can have for solving distance. But hope this helps with your design approach.

[Derek Smiths]

I definitely see what you are saying here (thanks for including code, helped to clarify your point) and this could very well be the answer to solving my dilemma. I've never used mapping before and we never covered it this semester. I will definitely look into using mapping though. My only concern with doing it this way and it could be that I don't fully understand mapping, but the distance equations don't rely on a single variable (velocity).

I know that the program will need to verify enough data field (JTF) include data in order for any equations to work, but in addition to that, if any two of the three (distance, velocity, time) variables are not entered there is not enough data.

Kinematic Equations that include distance:

(finalDistance - initialDistance) = ((initialVelocity + finalVelocity)/2 ) * (finalTime - initialTime)
(finalDistance - initialDistance) = initialVelocity * (finalTime - initialTime) + 0.5 * acceleration * (finalTime - initialTime)(finalTime - initialTime)
(finalDistance - initialDistance) = (finalVelocity*finalVelocity - initialVelocity*initialVelocity) / (2 * acceleration)

[Winston Gutkowski]

Derek Nickerson wrote:I know that the program will need to verify enough data field (JTF) include data in order for any equations to work

No, it needs to verify that it has only one unknown out of the three; and it shouldn't care less where those values come from. Indeed, if you want to set up a test rig for this, you may well want to supply values yourself (particularly for corner cases), rather than relying on someone keying them in every time.

In fact, I'm not even sure that it does need to verify that you have only one unknown because you could actually force this via a dialogue. For example, if your user chooses to enter velocity for their first two values, then they can ONLY choose either time OR distance for their second two; after which you invoke your Calculator class for the two sets of values that they did supply.

This is why I say that you've got to separate the GUI from your "calculation" logic completely, and stop thinking in terms of JTF's and JTables and JFrames - in fact, remove ALL types that start with 'J' from your thought process and think of this in purely algibraic terms.

A further suggestion: Take ONE equation (eg, the first one on your list) and tackle that; and don't even think about writing any others until you KNOW that it works. Every time, and with any set of values - including invalid ones.

Winston

[fred rosenberger]

Derek Nickerson wrote:...I need to first find the right equation to used to solve for velocity -- then go back and solve for distance. I'm just not seeing how I can do that in code.

The first thing you need to ask yourself is "How do I do this on paper?" Before you write a single line of code, you have to have a solid understanding of the problem in your brain. Work through examples on paper. write out step by step how YOU would solve this - or even better, how a high school algebra student should solve these steps. Your directions need to be unambiguous, clear, and precise.

My advice would be to throw all your code away, and not write any new code until you have the above written out on paper.