Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 6 of 6

Thread: Big Calculator , import* problem.

  1. #1
    Junior Member
    Join Date
    Oct 2018
    Posts
    3
    Thanks
    0
    Thanked 0 Times in 0 Posts

    Default Big Calculator , import* problem.

    Good morning ,

    This program is a big number calculator , but it does not work , it's a import* problem .

    Thank you






    Big Calculator.pdfbig calculator img.png

  2. #2
    Member
    Join Date
    Sep 2018
    Location
    Virginia
    Posts
    284
    My Mood
    Cool
    Thanks
    0
    Thanked 38 Times in 36 Posts

    Default Re: Big Calculator , import* problem.

    Please don't post items like this. Include them in the text of your post. And use code tags (See BBCODE) to properly format code. And ask a specific question as to how you need some help.

    Regards,
    Jim

  3. #3
    Junior Member
    Join Date
    Oct 2018
    Posts
    3
    Thanks
    0
    Thanked 0 Times in 0 Posts

    Default Re: Big Calculator , import* problem.

    Hello Jim ,

    why does not it work?

    import java.applet.*;
    import java.awt.*;
    import java.math.*;
    import java.net.URL;
     
    public class BigCalculator extends Applet implements Runnable {
    public static final BigInteger UNITY = new BigInteger("1");
    public static final BigDecimal ZERO = new BigDecimal(0.0d);
    public static final BigDecimal QUARTER = new BigDecimal(0.25d);
    public static final BigDecimal HALF = new BigDecimal(0.5d);
    public static final BigDecimal ONE = new BigDecimal(1.0d);
    public static final BigDecimal TWO = new BigDecimal(2.0d);
    public static final BigDecimal TEN = new BigDecimal(10.0d);
    public static final BigDecimal ONE_EIGHTY = new BigDecimal(180.0d);
    public static final BigDecimal PI = set_PI();
    public static final BigDecimal LN10 = set_LN10();
    public static final int RHU = BigDecimal.ROUND_HALF_UP;
    Thread crunch = new Thread(this);
    boolean breakSignal = false;
    String commandString = "none" ; // serves as the "parameter" for run().
    TextField display,digits_field,DRG_field;
    boolean firstDigit = true;
    BigDecimal operand1 = ZERO;
    String operator = "="; //Initial operator
    BigDecimal memory[];
    Canvas busy;
    int digits;
    int default_digits = 80;
    boolean degrees = false;
    boolean inDigitsField = false;
    boolean clearButtonFlag = false;
    Button feedback_button;
    URL feedback_URL;
    //--------------------------------------------------------------------
    public void init() {
    /* Initialize everybody */
    digits = default_digits;
    memory = new BigDecimal[3];
    memory[0] = ZERO;
    memory[1] = ZERO;
    memory[2] = ZERO;
    display = new TextField("0");
    display.setEditable(false);
    display.setBackground(Color.black);
    display.setForeground(Color.green);
    digits_field = new TextField(Integer.toString(digits));
    digits_field.setBackground(Color.gray);
    digits_field.setFont(new Font("Helvetica", Font.BOLD, 12));
    DRG_field = new TextField("RAD");
    DRG_field.setEditable(false);
    DRG_field.setBackground(Color.black);
    DRG_field.setForeground(Color.yellow);
    DRG_field.setFont(new Font("Helvetica", Font.PLAIN, 12));
    busy = new Canvas();
    GridBagLayout gb = new GridBagLayout();
    this.setLayout(gb);
    this.setFont(new Font("Helvetica", Font.BOLD, 16));
    this.setBackground(Color.darkGray);
    Label title_label = new Label("BIG CALCULATOR",Label.CENTER);
    title_label.setFont(new Font("Helvetica", Font.BOLD, 16));
    title_label.setForeground(Color.white);
    Label subt_label = new Label("An arbitrary precision calculator",
    Label.CENTER);
    subt_label.setForeground(Color.white);
    Label digits_label = new Label("digits:",Label.RIGHT);
    digits_label.setForeground(Color.white);
    feedback_button = new Button("by Jason Tiscione");
    feedback_button.setForeground(Color.white);
    feedback_button.setBackground(Color.darkGray);
    feedback_button.setFont(new Font("Helvetica", Font.ITALIC, 12));
    try { feedback_URL = new URL("mailto:j_tiscione@geocities.com"); }
    catch (java.net.MalformedURLException exc) {}
    /* Lay everything out */
    int NONE=GridBagConstraints.NONE;
    int BOTH=GridBagConstraints.BOTH;
    int CENTER=GridBagConstraints.CENTER;
    int HORIZONTAL=GridBagConstraints.HORIZONTAL;
    Color syscol = Color.lightGray;
    Color stdcalc = Color.gray;
    Color breakcol = Color.getHSBColor(0.01f,0.5f,0.6f);
    Color scicalc = Color.getHSBColor(0.9f,0.2f,0.5f);
    Color memcol = Color.getHSBColor(0.6f,0.2f,0.5f);
    Color trigcol = Color.getHSBColor(0.1f,0.2f,0.5f);
    try {
    addComponent(this,title_label,0,0,10,1,HORIZONTAL,CENTER,0,0,0);
    addComponent(this,subt_label,3,1,4,1,HORIZONTAL,CENTER,0,0,0);
    addComponent(this,display,0,2,10,1,HORIZONTAL,CENTER,0,0,0);
    addComponent(this,feedback_button,8,1,2,1,HORIZONTAL,CENTER,0,0,5);
    addComponent(this,digits_label,0,3,1,1,HORIZONTAL,CENTER,0,0,0);
    addComponent(this,digits_field,1,3,1,1,HORIZONTAL,CENTER,0,0,0);
    addButton(new Button ("roundoff"),2,3,2,1,syscol);
    addButton(new Button ("backspace"),4,3,2,1,syscol);
    addComponent(this,DRG_field,6,3,1,1,HORIZONTAL,CENTER,0,0,8);
    addButton(new Button ("break"),7,3,2,1,breakcol);
    addComponent(this,busy,9,3,1,1,HORIZONTAL,CENTER,15,15,0);
    addButton(new Button ("CE/C"),0,4,1,1,syscol);
    addButton(new Button ("\u00f7"),1,4,1,1,stdcalc); //division symbol
    addButton(new Button ("\u00d7"),2,4,1,1,stdcalc); //mult. symbol
    addButton(new Button ("-"),3,4,1,1,stdcalc);
    addButton(new Button ("e^x"),4,4,1,1,scicalc);
    addButton(new Button ("10^x"),5,4,1,1,scicalc);
    addButton(new Button ("M3+"),6,4,1,1,memcol);
    addButton(new Button ("M3-"),7,4,1,1,memcol);
    addButton(new Button ("M3R"),8,4,1,1,memcol);
    addButton(new Button ("M3C"),9,4,1,1,memcol);
    addButton(new Button ("7"),0,5,1,1,stdcalc);
    addButton(new Button ("8"),1,5,1,1,stdcalc);
    addButton(new Button ("9"),2,5,1,1,stdcalc);
    addButton(new Button ("+"),3,5,1,2,stdcalc);
    addButton(new Button ("ln"),4,5,1,1,scicalc);
    addButton(new Button ("log"),5,5,1,1,scicalc);
    addButton(new Button ("M2+"),6,5,1,1,memcol);
    addButton(new Button ("M2-"),7,5,1,1,memcol);
    addButton(new Button ("M2R"),8,5,1,1,memcol);
    addButton(new Button ("M2C"),9,5,1,1,memcol);
    addButton(new Button ("4"),0,6,1,1,stdcalc);
    addButton(new Button ("5"),1,6,1,1,stdcalc);
    addButton(new Button ("6"),2,6,1,1,stdcalc);
    addButton(new Button ("sqrt"),4,6,1,1,scicalc);
    addButton(new Button ("rootn"),5,6,1,1,scicalc);
    addButton(new Button ("M1+"),6,6,1,1,memcol);
    addButton(new Button ("M1-"),7,6,1,1,memcol);
    addButton(new Button ("M1R"),8,6,1,1,memcol);
    addButton(new Button ("M1C"),9,6,1,1,memcol);
    addButton(new Button ("1"),0,7,1,1,stdcalc);
    addButton(new Button ("2"),1,7,1,1,stdcalc);
    addButton(new Button ("3"),2,7,1,1,stdcalc);
    addButton(new Button ("="),3,7,1,2,stdcalc);
    addButton(new Button ("1/x"),4,7,1,1,scicalc);
    addButton(new Button ("x^y"),5,7,1,1,scicalc);
    addButton(new Button ("pi"),6,7,1,1,trigcol);
    addButton(new Button ("arcsin"),7,7,1,1,trigcol);
    addButton(new Button ("arccos"),8,7,1,1,trigcol);
    addButton(new Button ("arctan"),9,7,1,1,trigcol);
    addButton(new Button ("0"),0,8,2,1,stdcalc);
    addButton(new Button ("."),2,8,1,1,stdcalc);
    addButton(new Button ("+/-"),4,8,1,1,scicalc);
    addButton(new Button ("x!"),5,8,1,1,scicalc);
    addButton(new Button ("R-D"),6,8,1,1,trigcol);
    addButton(new Button ("sin"),7,8,1,1,trigcol);
    addButton(new Button ("cos"),8,8,1,1,trigcol);
    addButton(new Button ("tan"),9,8,1,1,trigcol);
    } catch (AWTException e) {
    System.out.println("AWTException");
    e.printStackTrace();
    }
    crunch.start();
    }
    //--------------------------------------------------------------------
    public void destroy() {
    crunch.stop();
    }
    //--------------------------------------------------------------------
    public void start() {
    crunch.resume();
    }
    //--------------------------------------------------------------------
    public void stop() {
    crunch.suspend();
    }
    //--------------------------------------------------------------------
    public boolean mouseMove(Event e, int x, int y) {
    if (feedback_button.bounds().inside(x,y)) {
    this.showStatus("Email me questions, comments, bug reports, job offers...");
    return true;
    }
    return false;
    }
    //--------------------------------------------------------------------
    public boolean gotFocus(Event e, Object arg) {
    if (e.target == digits_field) {
    inDigitsField=true;
    } else {
    inDigitsField=false;
    return false;
    }
    return true;
    }
    //--------------------------------------------------------------------
    public boolean lostFocus(Event e, Object arg) {
    if (e.target == digits_field) {
    int numberEntered;
    try {
    numberEntered = Integer.parseInt(digits_field.getText());
    }
    catch (NumberFormatException exc) { // invalid entry
    numberEntered=default_digits;
    digits_field.setText(Integer.toString(numberEntered));
    }
    if (numberEntered < 1) { // also an invalid entry
    numberEntered=default_digits;
    digits_field.setText(Integer.toString(numberEntered));
    }
    digits = numberEntered;
    inDigitsField=false;
    } else {
    inDigitsField=true;
    return false;
    }
    return true;
    }
    //--------------------------------------------------------------------
    public boolean action (Event e, Object arg) {
    if (e.target instanceof Button) {
    if (e.target==feedback_button) {
    try {
    this.getAppletContext().showDocument (feedback_URL, "_blank");
    return true;
    } catch (Exception exc) { return true; }
    }
    String argstr = (String)arg;
    if (argstr.equalsIgnoreCase("break")) {
    breakSignal = true;
    } else {
    synchronized (commandString) {
    commandString = argstr;
    }
    }
    return true;
    }
    return false; // only if event was not a button press
    }
    //--------------------------------------------------------------------
    public boolean keyDown(Event e, int key) {
    if((e.id==Event.KEY_PRESS) && (inDigitsField != true)) {
    synchronized (commandString) {
    switch (key) {
    case 10: // User pressed ENTER
    commandString = "=";
    break;
    case 8: // User pressed backspace key
    commandString = "backspace";
    break;
    case 127: // User pressed delete key
    commandString = "backspace";
    break;
    case 27: // User pressed escape key
    breakSignal = true;
    break;
    default:
    char dummyarg[] = { (char)key };
    commandString = new String(dummyarg);
    }
    }
    return true;
    }
    return false; // only if event was not a keypress
    }
    //--------------------------------------------------------------------
    public void run() {
    // crunch thread runs in an endless loop. If commandString is
    // set to a value by the main thread, crunch will grab it.
    // Therefore a synchronization lock is placed on all code in this
    // applet that reads or sets commandString.
    String s;
    while (true) {
    synchronized (commandString) {
    s=commandString;
    commandString = "none";
    }
    if (!(s.equalsIgnoreCase("none"))) {
    light(true);
    discriminate(s);
    light(false);
    if (breakSignal) { // break key was hit- so do cleanup
    display.setText("0");
    operator = "=";
    operand1 = ZERO;
    clearButtonFlag = false;
    firstDigit = true;
    breakSignal = false;
    }
    }
    }
    }
    //--------------------------------------------------------------------
    private void discriminate(String s) {
    // if any key other than CE/C is pressed, clear clearButtonFlag
    if (!(s.equalsIgnoreCase("CE/C")||s.equalsIgnoreCase("c"))) {
    clearButtonFlag = false;
    }
    if (s.equalsIgnoreCase("backspace")&&!firstDigit){
    String disp = display.getText();
    disp = disp.substring(0,disp.length()-1);
    if (disp.length()==0) {
    disp="0";
    firstDigit=true;
    }
    display.setText(disp);
    }
    if ("0123456789.".indexOf(s) != -1) {
    // s contains either a digit or a decimal point
    if (firstDigit) {
    firstDigit=false;
    display.setText(s);
    } else {
    display.setText(display.getText() + s);
    }
    }
    else {
    String coplist = "= + - x * / \u00d7 \u00f7 x^y rootn";
    if (coplist.indexOf(s) != -1) { //a conjunctive operator
    conjunctive (display.getText());
    firstDigit = true;
    operator = s;
    }
    else {
    String uoplist = "C CE/C c M1+ M1- M1R M1C M2+ M2- M2R M2C"
    + " M3+ M3- M3R M3C +/- 1/x sqrt ln e^x log 10^x pi x!"
    + " sin cos tan arcsin arccos arctan R-D roundoff ";
    if (uoplist.indexOf(s) != -1) {
    //s is a unary operator
    unary (display.getText(),s);
    firstDigit = true;
    }
    }
    }
    }
    //--------------------------------------------------------------------
    private void conjunctive (String disp) {
    BigDecimal operand2;
    try { operand2 = new BigDecimal(disp); }
    catch (NumberFormatException exc) {
    operand1 = ZERO;
    operand2 = ZERO;
    operator = "=";
    }
    char c=operator.charAt(0);
    if (c == '\u00d7') operator="x";
    if (c == '*') operator = "x";
    if (c == '\u00f7') operator="/";
    if (operator.equalsIgnoreCase("=")) {
    operand1 = operand2;
    }
    if (operator.equalsIgnoreCase("+")) {
    operand1 = operand1.add(operand2);
    }
    if (operator.equalsIgnoreCase("-")) {
    operand1 = operand1.subtract(operand2);
    }
    if (operator.equalsIgnoreCase("x")) {
    operand1 = operand1.multiply(operand2);
    }
    if (operator.equalsIgnoreCase("/")) {
    if (operand2.signum()!=0) {
    operand1 = operand1.divide(operand2,digits,RHU);
    }
    }
    if (operator.equalsIgnoreCase("x^y")) {
    operand1 = pow(operand1,operand2);
    }
    if (operator.equalsIgnoreCase("rootn")) {
    operand1 = rootn(operand1,operand2);
    }
    display.setText (operand1.toString());
    }
    //--------------------------------------------------------------------
    private void unary (String disp, String op) {
    BigDecimal operand = new BigDecimal(disp);
    if (op.equalsIgnoreCase("CE/C")||op.equalsIgnoreCase("c")) {
    operand = ZERO;
    if (clearButtonFlag) { // second press of CE/C key
    operand1 = ZERO;
    operator = "=";
    }
    clearButtonFlag = true;
    }
    if (op.equalsIgnoreCase("1/x")) {
    if (operand.signum()!=0) {
    BigDecimal temp = ONE;
    operand = temp.divide(operand,digits,RHU);
    }
    }
    if (op.equalsIgnoreCase("+/-")) {
    operand = operand.negate();
    }
    if (op.equalsIgnoreCase("sqrt")) {
    if (operand.signum() == 1) {
    operand = sqrt(operand);
    }
    }
    if (op.equalsIgnoreCase("e^x")) {
    operand = exp(operand);
    }
    if (op.equalsIgnoreCase("ln")) {
    if (operand.signum() == 1) {
    operand = ln(operand);
    }
    }
    if (op.equalsIgnoreCase("10^x")) {
    operand = alog(operand);
    }
    if (op.equalsIgnoreCase("log")) {
    if (operand.signum() == 1) {
    operand = log(operand);
    }
    }
    if (op.equalsIgnoreCase("x!")) {
    if (operand.compareTo(ONE.negate()) != -1) {
    operand = fact(operand);
    }
    }
    if (op.equalsIgnoreCase("R-D")) {
    degrees = !degrees;
    if (degrees) {
    DRG_field.setText("DEG");
    } else {
    DRG_field.setText("RAD");
    }
    }
    if (op.equalsIgnoreCase("pi")) {
    operand = pi();
    }
    if (op.equalsIgnoreCase("sin")) {
    operand = sin(operand);
    }
    if (op.equalsIgnoreCase("cos")) {
    operand = cos(operand);
    }
    if (op.equalsIgnoreCase("tan")) {
    operand = tan(operand);
    }
    if (op.equalsIgnoreCase("arcsin")) {
    operand = arcsin(operand);
    }
    if (op.equalsIgnoreCase("arccos")) {
    operand = arccos(operand);
    }
    if (op.equalsIgnoreCase("arctan")) {
    operand = arctan(operand);
    }
    if (op.equalsIgnoreCase("roundoff")) {
    operand = operand.setScale(digits,RHU);
    }
    if (op.startsWith("M")) {
    int memindx=0;
    char c = op.charAt(1); // specifies which memory
    switch (c) {
    case '1':
    memindx = 0;
    break;
    case '2':
    memindx = 1;
    break;
    case '3':
    memindx = 2;
    break;
    }
    c = op.charAt(2); // specifies which memory operation
    switch (c) {
    case '+':
    memory[memindx] = memory[memindx].add(operand);
    break;
    case '-':
    memory[memindx] = memory[memindx].subtract(operand);
    break;
    case 'R':
    operand = memory[memindx];
    break;
    case 'C':
    memory[memindx] = ZERO;
    break;
    }
    }
    display.setText (operand.toString());
    }
    //--------------------------------------------------------------------
    private void light (boolean status) {
    Graphics g=busy.getGraphics();
    Rectangle r=busy.bounds();
    int cx = r.width/2;
    int cy = r.height/2;
    if (status==true) {
    g.setColor(Color.red);
    g.fill3DRect(cx-5,cy-5,10,10,true);
    } else {
    g.setColor(Color.darkGray);
    g.fillRect(cx-5,cy-5,10,10);
    }
    }
    //--------------------------------------------------------------------
    private void addButton(Button button, int gridx, int gridy,
    int gridwidth, int gridheight, Color c) {
    button.setBackground(c);
    button.setForeground(Color.black);
    Graphics g = this.getGraphics();
    FontMetrics fm = g.getFontMetrics();
    int textwidth = fm.stringWidth(button.getLabel());
    int ipadx = (40-textwidth);
    int ipady = 0;
    int ext = 5;
    try {
    addComponent(this,button,gridx,gridy,gridwidth,gridheight,
    GridBagConstraints.BOTH,GridBagConstraints.CENTER,ipadx,0,ext);
    } catch (AWTException e) {
    System.out.println("AWTException");
    e.printStackTrace();
    }
    }
    //--------------------------------------------------------------------
    private static void addComponent(Container container, Component component,
    int gridx, int gridy, int gridwidth, int gridheight, int fill,
    int anchor, int ipadx, int ipady, int extpad) throws AWTException {
    LayoutManager lm = container.getLayout();
    if(!(lm instanceof GridBagLayout)) {
    throw new AWTException ("Invalid layout" + lm);
    } else {
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.gridx = gridx;
    gbc.gridy = gridy;
    gbc.weightx = gridx;
    gbc.weighty = gridy;
    gbc.gridwidth = gridwidth;
    gbc.gridheight = gridheight;
    gbc.fill = fill;
    gbc.anchor = anchor;
    gbc.ipadx = ipadx;
    gbc.ipady = ipady;
    gbc.insets = new Insets(extpad,extpad,extpad,extpad);
    ((GridBagLayout)lm).setConstraints(component, gbc);
    container.add(component);
    }
    }
    //--------------------------------------------------------------------
    //--------------------------------------------------------------------
    //--------------------- Numerical methods follow ---------------------
    //--------------------------------------------------------------------
    //--------------------------------------------------------------------
    private BigDecimal exp (BigDecimal x) {
    if (breakSignal) return ONE;
    if (x.signum()==-1) {
    return ONE.divide(exp(x.negate()),digits,RHU);
    }
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal n = ZERO;
    BigDecimal term = ONE;
    BigDecimal acc_new = ONE;
    BigDecimal acc_old = ZERO;
    BigDecimal diff = acc_new.subtract(acc_old);
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    acc_old = acc_new;
    n = n.add(ONE);
    term = term.multiply(x);
    term = term.divide(n,digits,RHU);
    acc_new = acc_new.add(term);
    diff = term;
    }
    return acc_new.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal ln (BigDecimal x){
    if (breakSignal) return ONE;
    if ((x.compareTo(TEN)==0) && (digits<=1000)) {
    return LN10.setScale(digits,RHU);
    }
    if (x.compareTo(ONE)==1) {
    BigDecimal temp = ONE.divide(x,digits,RHU);
    temp = ln(temp);
    return (temp.negate());
    }
    BigDecimal pointnine = new BigDecimal(0.9d);
    if (x.compareTo(pointnine) == -1) {
    digits++;
    BigDecimal temp = sqrt(x);
    if (breakSignal) return ONE;
    temp = ln(temp);
    digits--;
    temp = temp.add(temp);
    return (temp.setScale(digits,RHU));
    }
    x = x.subtract(ONE);
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal n = ZERO;
    BigDecimal term = ONE;
    BigDecimal powr = ONE;
    BigDecimal acc_new = ZERO;
    BigDecimal acc_old = ONE.negate();
    BigDecimal diff = term.abs();
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    acc_old=acc_new;
    n = n.add(ONE);
    powr = powr.multiply(x);
    powr = powr.setScale(digits,RHU);
    term = powr.divide(n,digits,RHU);
    acc_new = acc_new.add(term);
    powr = powr.negate();
    diff = term.abs();
    }
    return acc_new;
    }
    //--------------------------------------------------------------------
    private BigDecimal alog (BigDecimal x){
    if (x.scale()==0) { // x is an integer, so we can "cheat"
    return ONE.movePointRight(x.intValue());
    }
    else {
    BigDecimal temp = x.multiply(LN10);
    temp = temp.setScale(digits,RHU);
    return exp(temp);
    }
    }
    //--------------------------------------------------------------------
    private BigDecimal log (BigDecimal x){
    if (x.compareTo(TEN)==0) {
    return ONE;
    }
    else {
    return (ln(x)).divide(ln(TEN),digits,RHU);
    }
    }
    //--------------------------------------------------------------------
    private BigDecimal pow (BigDecimal x, BigDecimal y){
    if (breakSignal) return ONE;
    if (x.signum() == 0) {return ZERO;} //get x=0 case out of the way
    if (y.scale()==0) { // if y is an integer, we can "cheat".
    int yint = y.intValue();
    if (yint==0) {return x;} // get y=0 case out of the way
    BigDecimal product = ONE;
    BigDecimal multiplier = x;
    if (yint<0) {
    multiplier = ONE.divide(multiplier,digits,RHU);
    yint = -yint;
    }
    for (int i=0;i<yint;i++){
    if (breakSignal) return ONE;
    product = product.multiply(multiplier);
    }
    return product;
    }
    else {
    if (x.signum()==1) { // require x>0
    BigDecimal temp = y.multiply(ln(x));
    temp = temp.setScale(digits,RHU);
    return exp(temp);
    }
    }
    return ZERO; // if thread reaches this point, args were no good.
    }
    //--------------------------------------------------------------------
    private BigDecimal rootn (BigDecimal x, BigDecimal y){
    if (y.signum()==0) return ZERO; // get rid of y=0 case
    if (y.scale()>0) { // y is not an integer. Send problem to pow().
    return pow(x,ONE.divide(y,digits,RHU));
    }
    return rootn(x,y.intValue()); //calls other version of rootn()
    }
    //--------------------------------------------------------------------
    private BigDecimal rootn (BigDecimal a, int n){
    if (breakSignal) return ONE;
    double double_n = (double)n;
    BigDecimal bigdec_n = new BigDecimal(double_n);
    BigDecimal c1 = new BigDecimal(double_n-1);
    c1 = c1.divide(bigdec_n,digits,RHU);
    BigDecimal c2 = a.divide(bigdec_n,digits,RHU);
    // algorithm is: let x = c1*x + c2/(x^powr)
    // where c1=(n-1)/n, c2=a/n, powr=n-1
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal xold = ZERO; //xxx just to initialize it
    BigDecimal xnew = ONE; //xxx 1 is as good a guess as any
    BigDecimal diff = xnew.subtract(xold);
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    xold = xnew;
    BigDecimal powerofx = ONE;
    for (int j=0;j<n-1;j++) {
    if (breakSignal) return ONE;
    powerofx=powerofx.divide(xold,digits+3,RHU);
    }
    xnew = c1.multiply(xold); //first term.
    xnew = xnew.add(c2.multiply(powerofx)); // second term.
    diff = xnew.subtract(xold);
    diff = diff.abs();
    }
    if (breakSignal) return ONE;
    return xnew.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal sqrt (BigDecimal a){
    if (breakSignal) return ONE;
    // algorithm is: let x = half * ( x + (a/x) )
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal xold = ZERO; // just to initialize it
    BigDecimal xnew = ONE; // 1 is as good a guess as any
    BigDecimal diff = xnew.subtract(xold);
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    xold = xnew;
    xnew = xold.add(a.divide(xold,digits+3,RHU)); // second term.
    xnew = xnew.divide(TWO,digits+3,RHU);
    diff = xnew.subtract(xold);
    diff = diff.abs();
    }
    return xnew.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal fact(BigDecimal n) {
    // Returns the factorial of a positive real argument n.
    // If n is not an integer it returns gamma(1+n), which is defined to be
    // an extension to the factorial from N to R, since for positive integers
    // n!=gamma(1+n).
    // The gamma function is not analytic for n=0,-1,-2,-3... and is not
    // "well-behaved" in the negative real domain, so this method will only
    // compute the function of arguments greater than -1.
    if (n.compareTo(ONE.negate())== -1) return ZERO;
    BigDecimal result = ONE; //xxx
    while (n.compareTo(ONE)!=-1) { // if not n<1
    if (breakSignal) return ONE;
    result=result.multiply(n);
    n=n.subtract(ONE);
    }
    // at this point we have n less than 1, and result. The argument to
    // return will be gamma(1+n)*result. If n=0 then gamma(1)=1, so:
    if (n.signum()==0) return result;
    // Therefore, now we must find out what gamma(1+n) is. This will not
    // be ultraprecise no matter what we do, so we might as well use doubles.
    // The code below computes the natural log of the gamma function using the
    // Lanczos approximation formula. The gamma function is defined by
    // ( z - 1 ) -t
    // gamma( z ) = Integral[ t e dt ]
    // integrated over the positive real domain.
    // The gamma function satisfies gamma( n + 1 ) = n!
    // This algorithm has been adapted from "Numerical Recipes", p. 157.
    double x = n.doubleValue();
    x=x+1; // because it's gamma(x+1) we're getting now
    double coeff0 = 76.1800917300d;
    double coeff1 = -86.5053203300d;
    double coeff2 = 24.0140982200d;
    double coeff3 = -1.23173951600d;
    double coeff4 = 1.20858003000E-3d;
    double coeff5 = -5.36382000000E-6d;
    double stp = 2.50662827465d;
    double r = (coeff0/x)+(coeff1/(x+1.0d))+(coeff2/(x+2.0d))
    +(coeff3/(x+3.0d))+(coeff4/(x+4.0d))+(coeff5/(x+5.0d));
    double s = x+4.5d;
    double t = (x-0.5d)*Math.log(s) - s;
    t = Math.exp(t);
    t *= (stp*(r+1.0d));
    double res=1.0d;
    try {
    res=result.doubleValue();
    res *= t;
    result = new BigDecimal(res);
    }
    catch (NumberFormatException exc)
    { result = result.multiply(new BigDecimal(t));
    return result.setScale(0,RHU); }
    return result.setScale(10,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal pi() {
    if (digits<=1000) {
    return (PI.setScale(digits,RHU));
    } else {
    int extradigits = 3;
    digits += extradigits;
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal a = ONE;
    BigDecimal x = ONE;
    BigDecimal b = ONE;
    b = b.divide(sqrt(TWO),digits,RHU);
    BigDecimal c = QUARTER;
    BigDecimal y = ZERO;
    BigDecimal pi_old = ZERO;
    BigDecimal pi_new = ONE;
    BigDecimal diff = pi_new.subtract(pi_old);
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    pi_old = pi_new;
    y = a;
    a = a.add(b);
    a = a.divide(TWO,digits,RHU); // a=(a+b)/2
    b = sqrt(b.multiply(y)); // b=sqrt(b*y)
    pi_new = a.subtract(y); //pi_new is temporarily holding a value
    c = c.subtract(x.multiply(pi_new.multiply(pi_new))); //c=c-x*(a-y)^2
    x = x.add(x); // i.e. x=2*x
    pi_new = a.add(b); //pi_new is temporarily holding again
    pi_new = pi_new.multiply(pi_new);
    y = c.multiply(new BigDecimal(4.0d)); //y is temporarily holding
    pi_new = pi_new.divide(y,digits,RHU);
    // pi = (a+b)^2 / (4*c)
    diff = pi_new.subtract(pi_old);
    c=c.setScale(digits,RHU);
    x=x.setScale(digits,RHU);
    y=y.setScale(digits,RHU);
    }
    digits -= extradigits;
    pi_new = pi_new.setScale(digits,RHU);
    return pi_new;
    }
    }
    //--------------------------------------------------------------------
    private BigDecimal sin (BigDecimal x){
    // ensure we're using radians
    if (degrees) {
    x = x.multiply(pi());
    x = x.divide(ONE_EIGHTY,digits,RHU);
    }
    // renormalize to the interval from -pi/2 to pi/2
    BigDecimal twopi = pi().multiply(TWO);
    x = x.divide(twopi,digits,RHU);
    x = x.subtract(x.setScale(0,BigDecimal.ROUND_DOWN));
    //This is the only way to get a fractional part!
    // interval (-1,1).
    if (x.compareTo(QUARTER.negate())==-1) {
    x = x.add(ONE);
    }
    // interval [-0.25,1).
    if (x.compareTo(new BigDecimal(0.75d))!=-1) {
    x = x.subtract(ONE);
    }
    // interval [-0.25,0.75).
    if (x.compareTo(QUARTER)==1) {
    x = HALF.subtract(x);
    }
    // interval [-0.25,0.25].
    x = x.multiply(twopi);
    // interval [-pi/2,pi/2]. What a pain in the ass...
    BigDecimal x2 = x.multiply(x);
    x2 = x2.setScale(digits,RHU);
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal n = ONE;
    BigDecimal term = x;
    BigDecimal acc_new = x;
    BigDecimal acc_old = ZERO;
    BigDecimal diff = acc_new.subtract(acc_old);
    diff = diff.abs();
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    acc_old = acc_new;
    term = term.multiply(x2);
    n = n.add(ONE);
    term = term.divide(n,digits,RHU);
    n = n.add(ONE);
    term = term.divide(n,digits,RHU);
    term = term.negate();
    acc_new = acc_new.add(term);
    diff = term.abs();
    }
    return acc_new.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal cos (BigDecimal x){
    // could have called sin(pi/2 - x) or something but decided to
    // compute cosine directly- it's just too easy to cut and paste
    // and make minor changes.
    // ensure we're using radians
    if (degrees) {
    x = x.multiply(pi());
    x = x.divide(ONE_EIGHTY,digits,RHU);
    }
    // renormalize to the interval from 0 to pi
    BigDecimal twopi = pi().multiply(TWO);
    x = x.divide(twopi,digits,RHU);
    x = x.subtract(x.setScale(0,BigDecimal.ROUND_DOWN));
    // interval (-1,1).
    if (x.signum()==-1) {
    x = x.negate();
    }
    // interval [0,1).
    if (x.compareTo(HALF)!=-1) {
    x = ONE.subtract(x);
    }
    // interval [0,0.5).
    x = x.multiply(twopi);
    // interval [0,pi].
    BigDecimal x2 = x.multiply(x);
    x2 = x2.setScale(digits,RHU);
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal n = ZERO;
    boolean signIsPositive = false;
    BigDecimal term = ONE;
    BigDecimal acc_new = ONE;
    BigDecimal acc_old = ZERO;
    BigDecimal diff = term.abs();
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    acc_old = acc_new;
    term = term.multiply(x2);
    n = n.add(ONE);
    term = term.divide(n,digits,RHU);
    n = n.add(ONE);
    term = term.divide(n,digits,RHU);
    term = term.negate();
    acc_new = acc_new.add(term);
    diff = term.abs();
    }
    return acc_new.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal tan (BigDecimal x){
    BigDecimal s=sin(x);
    BigDecimal c=sqrt(ONE.subtract(s.multiply(s)));
    if (breakSignal) return ONE;
    // Must determine the SIGN of the cos.
    if (degrees) {
    x = x.multiply(pi());
    x = x.divide(ONE_EIGHTY,digits,RHU);
    }
    BigDecimal twopi = pi().multiply(TWO);
    x = x.divide(twopi,digits,RHU);
    x = x.subtract(x.setScale(0,BigDecimal.ROUND_DOWN));
    if (x.signum()==-1) {
    x = x.negate();
    }
    if (x.compareTo(HALF)!=-1) {
    x = ONE.subtract(x);
    }
    if (x.compareTo(QUARTER)==1) {
    c=c.negate();
    }
    if (c.signum()==0) return ZERO;
    return s.divide(c,digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal arcsin (BigDecimal x){
    if (breakSignal) return ONE;
    BigDecimal x2 = x.multiply(x);
    x2 = x2.setScale(digits,RHU);
    if(x2.compareTo(ONE)==1) return ZERO; //arcsin domain is [-1,1]
    if(x2.compareTo(HALF)==1) {
    // Angle is greater than 45 degrees. Smaller angles work better.
    // Use identity arcsin(x)=pi/2 - arcsin(sqrt(1-x^2))
    BigDecimal temp;
    if (degrees)
    { temp = new BigDecimal(90.0d); }
    else
    { temp = pi().divide(TWO,digits,RHU); }
    temp = temp.subtract(arcsin(sqrt(ONE.subtract(x2))));
    if (x.signum()==-1)
    {return temp.negate();}
    else
    {return temp;}
    }
    BigDecimal smallest = new BigDecimal(UNITY,digits); // 0.000...001
    BigDecimal n = ONE;
    BigDecimal term;
    BigDecimal powr = x;
    BigDecimal acc_new = x;
    BigDecimal acc_old = ZERO;
    BigDecimal diff = acc_new.subtract(acc_old);
    BigDecimal oddsOverEvens= ONE;
    diff = diff.abs();
     
    while (diff.compareTo(smallest)==1) {
    if (breakSignal) return ONE;
    acc_old = acc_new;
    powr = powr.multiply(x2);
    powr = powr.setScale(digits,RHU);
    oddsOverEvens=oddsOverEvens.multiply(n);
    n = n.add(ONE);
    oddsOverEvens=oddsOverEvens.divide(n,digits,RHU);
    n = n.add(ONE);
    term = powr.multiply(oddsOverEvens);
    term = term.divide(n,digits,RHU);
    acc_new = acc_new.add(term);
    diff = term.abs();
    }
    if (degrees) {
    acc_new = acc_new.multiply(ONE_EIGHTY);
    acc_new = acc_new.divide(pi(),digits,RHU);
    }
    return acc_new.setScale(digits,RHU);
    }
    //--------------------------------------------------------------------
    private BigDecimal arccos (BigDecimal x){
    BigDecimal x2 = x.multiply(x);
    x2 = x2.setScale(digits,RHU);
    if(x2.compareTo(ONE)==1) return ZERO; //arccos domain is [-1,1]
    if (x.signum()==-1)
    {
    BigDecimal temp;
    if (degrees) {temp=ONE_EIGHTY;}
    else {temp=pi();}
    return temp.subtract(arcsin(sqrt(ONE.subtract(x2))));
    }
    return arcsin(sqrt(ONE.subtract(x2)));
    }
    //--------------------------------------------------------------------
    private BigDecimal arctan (BigDecimal x){
    BigDecimal x2 = x.multiply(x);
    x2 = x2.setScale(digits,RHU);
    return arcsin(x.divide(sqrt(x2.add(ONE)),digits,RHU));
    }
    //--------------------------------------------------------------------
    private static BigDecimal set_PI() {
    // Defines the PI constant to be the 1000 digit approximation of pi.
    // If precision requires 1000 digits or fewer, the applet can use PI.
    String piS="3."
    + "14159265358979323846264338327950288419716939937510"
    + "58209749445923078164062862089986280348253421170679"
    + "82148086513282306647093844609550582231725359408128"
    + "48111745028410270193852110555964462294895493038196"
    + "44288109756659334461284756482337867831652712019091"
    + "45648566923460348610454326648213393607260249141273"
    + "72458700660631558817488152092096282925409171536436"
    + "78925903600113305305488204665213841469519415116094"
    + "33057270365759591953092186117381932611793105118548"
    + "07446237996274956735188575272489122793818301194912"
    + "98336733624406566430860213949463952247371907021798"
    + "60943702770539217176293176752384674818467669405132"
    + "00056812714526356082778577134275778960917363717872"
    + "14684409012249534301465495853710507922796892589235"
    + "42019956112129021960864034418159813629774771309960"
    + "51870721134999999837297804995105973173281609631859"
    + "50244594553469083026425223082533446850352619311881"
    + "71010003137838752886587533208381420617177669147303"
    + "59825349042875546873115956286388235378759375195778"
    + "18577805321712268066130019278766111959092164201989";
    return new BigDecimal(piS);
    }
    //--------------------------------------------------------------------
    private static BigDecimal set_LN10() {
    // Defines the LN10 constant to be the 1000 digit approximation of
    // the natural log of ten. If precision requires 1000 digits or
    // fewer, the applet can use LN10 when computing common logarithms.
    String ln10S="2."
    + "30258509299404568401799145468436420760110148862877"
    + "29760333279009675726096773524802359972050895982983"
    + "41967784042286248633409525465082806756666287369098"
    + "78168948290720832555468084379989482623319852839350"
    + "53089653777326288461633662222876982198867465436674"
    + "74404243274365155048934314939391479619404400222105"
    + "10171417480036880840126470806855677432162283552201"
    + "14804663715659121373450747856947683463616792101806"
    + "44507064800027750268491674655058685693567342067058"
    + "11364292245544057589257242082413146956890167589402"
    + "56776311356919292033376587141660230105703089634572"
    + "07544037084746994016826928280848118428931484852494"
    + "86448719278096762712757753970276686059524967166741"
    + "83485704422507197965004714951050492214776567636938"
    + "66297697952211071826454973477266242570942932258279"
    + "85025855097852653832076067263171643095059950878075"
    + "23710333101197857547331541421808427543863591778117"
    + "05430982748238504564801909561029929182431823752535"
    + "77097505395651876975103749708886921802051893395072"
    + "38539205144634197265287286965110862571492198849979";
    return new BigDecimal(ln10S);
    }
    }

  4. #4
    Member
    Join Date
    Sep 2018
    Location
    Virginia
    Posts
    284
    My Mood
    Cool
    Thanks
    0
    Thanked 38 Times in 36 Posts

    Default Re: Big Calculator , import* problem.

    I tried a few calculations and it appears to work. What specifically didn't work?

    Note: Applets are deprecated and should not be used. They are no longer supported by any reputable web browser.

    Regards,
    Jim

  5. #5
    Junior Member
    Join Date
    Oct 2018
    Posts
    3
    Thanks
    0
    Thanked 0 Times in 0 Posts

    Default Re: Big Calculator , import* problem.

    how can I do? I'm not a programmer.

    I tried with www . compilejava . net and output is :


    /tmp/java_T8nQMd/BigCalculator.java:159: warning: [deprecation] stop() in Thread has been deprecated
    crunch.stop();
    ^
    /tmp/java_T8nQMd/BigCalculator.java:163: warning: [deprecation] resume() in Thread has been deprecated
    crunch.resume();
    ^
    /tmp/java_T8nQMd/BigCalculator.java:167: warning: [deprecation] suspend() in Thread has been deprecated
    crunch.suspend();
    ^
    /tmp/java_T8nQMd/BigCalculator.java:170: warning: [deprecation] mouseMove(Event,int,int) in Component has been deprecated
    public boolean mouseMove(Event e, int x, int y) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:171: warning: [deprecation] bounds() in Component has been deprecated
    if (feedback_button.bounds().inside(x,y)) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:171: warning: [deprecation] inside(int,int) in Rectangle has been deprecated
    if (feedback_button.bounds().inside(x,y)) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:178: warning: [deprecation] gotFocus(Event,Object) in Component has been deprecated
    public boolean gotFocus(Event e, Object arg) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:188: warning: [deprecation] lostFocus(Event,Object) in Component has been deprecated
    public boolean lostFocus(Event e, Object arg) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:211: warning: [deprecation] action(Event,Object) in Component has been deprecated
    public boolean action (Event e, Object arg) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:232: warning: [deprecation] keyDown(Event,int) in Component has been deprecated
    public boolean keyDown(Event e, int key) {
    ^
    /tmp/java_T8nQMd/BigCalculator.java:478: warning: [deprecation] bounds() in Component has been deprecated
    Rectangle r=busy.bounds();
    ^
    11 warnings


    Unable to execute program; could not compile!

  6. #6
    Super Moderator Norm's Avatar
    Join Date
    May 2010
    Location
    Eastern Florida
    Posts
    22,325
    Thanks
    53
    Thanked 2,393 Times in 2,347 Posts

    Default Re: Big Calculator , import* problem.

    has been deprecated
    Too many of those error messages often means the code is very old and is using features that have been replaced by better options.
    If you are not a programmer, I suggest that you find a better, more modern version of the program to work with
    Or find a programmer to convert the code for you.

    11 warnings
    Note: those messages are only warnings and the generated code can still work.
    If you don't understand my answer, don't ignore it, ask a question.

Similar Threads

  1. problem big
    By AJAY KAMBLE in forum Android Development
    Replies: 0
    Last Post: March 27th, 2014, 11:34 AM
  2. Replies: 3
    Last Post: January 25th, 2013, 05:53 AM
  3. Small problem in big code, not sure why
    By diesal11 in forum What's Wrong With My Code?
    Replies: 0
    Last Post: October 16th, 2011, 10:25 AM
  4. Simple import problem
    By Mekster in forum Java IDEs
    Replies: 3
    Last Post: November 13th, 2009, 08:17 PM
  5. Problem in import com. in eclipse
    By java_cs in forum What's Wrong With My Code?
    Replies: 6
    Last Post: September 11th, 2009, 07:26 AM