Java Geometric Sequence Programming

amontellano 0 Newbie Poster

2 Years Ago

Hi everyone, I need ideas on how to initialize a new program in which a class GeometricSequence will extend Sequence. It has to implement public void generate ( ), which generates the sequence via
𝑎𝑖 = 𝑎0∙generator𝑖 (𝑖 = 0, 1, …, numTerms−1) and puts it into a double []. In java, 𝑎𝑏 is
programmed via Math.pow ( a, b ). So once the sequence is generated, public void generate ( ) should call public void setTermArray ( double [] dA ).

For example, when SequenceTest is run using 𝑎0 = 3, generator = 4 and numTerms = 9, the output of
the program will look like what is shown below.

a0 = ? 3.0
generator = ? 4.0
number of terms = ? 9
------+------------
i | a_i
------+------------
0 | 3.0000
1 | 12.0000
2 | 48.0000
3 | 192.0000
4 | 768.0000
5 | 3072.0000
6 | 12288.0000
7 | 49152.0000
8 | 196608.0000
------+------------
sum = 262143.0000

I need suggestions on how to implement and call methods. I included some of my work in a file.

java

ConsoleInput.txt (2.32 KB)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
/**
 *  This is a convenience class for reading <code>int</code>s, <code>double</code>s and <code>String</code>s from the console.
 *  No exceptions are thrown.
 */
public class ConsoleInput {
  /**/
  private BufferedReader br;
  /**
   *  Open the input connection.
   */
  public ConsoleInput ( ) {
    /**/
    br=new BufferedReader( new InputStreamReader( System.in ) );
  }
  /**
   *  Close the input connection.
   */
  public void close () {
    /**/
    try { br.close(); }
    catch( IOException ioe ) { }
    /**/
    return;    
  }
  /**
   *  Read a <code>String</code>. The user will be prompted until a non-empty <code>String</code> is enterred.
   *
   *  @param  prompt The user prompt.
   *  @return A non-empty String.
   */
  public String readString ( String prompt ) {
    /**/
    String rv;
    /**/
    while ( true ) {
      System.out.print(prompt);
      rv=readLine();
      if ( rv != null ) break;
    }
    /**/
    return rv;
  }
  /**
   *  Read an <code>int</code>. The user will be prompted until a valid <code>int</code> is enterred.
   *
   *  @param  prompt The user prompt.
   *  @return A valid int.
   */
  public int readInt ( String prompt ) {
    /**/
    int rv;
    String s;
    /**/
    while ( true ) {
      s=readString(prompt);
      rv=0;
      try {
        rv=Integer.parseInt(s);
        break;
      }
      catch ( NumberFormatException nfe ) { }
    }
    /**/
    return rv;
  }
  /**
   *  Read a <code>double</code>. The user will be prompted until a valid <code>double</code> is enterred.
   *
   *  @param  prompt The user prompt.
   *  @return A valid double.
   */
  public double readDouble ( String prompt ) {
    /**/
    double rv;
    String s;
    /**/
    while ( true ) {
      s=readString(prompt);
      rv=0.0;
      try {
        rv=Double.parseDouble(s);
        break;
      }
      catch ( NumberFormatException nfe ) { }
    }
    /**/
    return rv;
  }
  /**/
  private String readLine () {
    /**/
    String rv;
    /**/
    rv=null;
    try { rv=br.readLine(); }
    catch( IOException ioe ) { }
    /**/
    if ( rv.equals("") ) return null;
    else                 return rv.trim();
  }
}

GeometricSequence.txt (0.05 KB)

public class GeometricSequence extends Sequence {
	//

Sequence.txt (1.3 KB)

public abstract class Sequence {
  /**/
  private double a0, generator;
  private int numTerms;
  private double [] terms;
  /**/
  public Sequence ( double a0, double generator, int numTerms ) {
    /**/
    this.a0 = a0;
    this.generator = generator;
    this.numTerms = numTerms;
  }
  /**/
  public abstract void generate ();
  /**/
  public void setTermArray ( double [] da ) {
    terms = da;
    return;
  }
  /**/
  public double getA0 ()        { return a0;        }
  public double getGenerator () { return generator; }
  public int    getNumTerms ()  { return numTerms;  }
  /**/
  public String toString () {
    /**/
    String lf, head1, head2, outLine, rv;
    /**/
    lf=System.lineSeparator();
    head1="------+------------";
    head2="  i   |     a_i    ";
    /**/
    rv = head1 + lf
       + head2 + lf
       + head1 + lf;
    for ( int i=0; i<numTerms; ++i ) {
      outLine = String.format("%5d",i) + " | " + String.format("%11.4f",terms[i]) + lf;
      rv += outLine;
    }
    rv += ( head1 +lf );
    rv += ( "  sum = " + String.format("%11.4f",sum()) );
    /**/
    return rv;
  }
  /**/
  private double sum () {
    /**/
    double rv;
    /**/
    rv = 0.0;
    for ( int i=0; i<numTerms; ++i ) rv += terms[i];
    /**/
    return rv;
  }
}

SequenceTest.txt (0.58 KB)

public class SequenceTest {
  /**/
  public static void main ( String [] arg ) {
    /**/
    int numTerms;
    double a0, generator;
    ConsoleInput ci;
    /**/
    System.out.println();
    ci = new ConsoleInput();
    a0        = ci.readDouble("             a0 = ? ");
    generator = ci.readDouble("      generator = ? ");
    numTerms  =    ci.readInt("number of terms = ? ");
    ci.close();
    /**/
    System.out.println();
    Sequence s = new GeometricSequence(a0,generator,numTerms);
    s.generate();
    System.out.println(s);
    /**/
    return;
  }
}

1 Contributor
0 Replies
61 Views

Be the first to reply

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.