Member Avatar for amontellano

Hi everyone, I need ideas on how to initialize a new program in which a class GeometricSequence will extends 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

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;
  }
}
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;
  }
}
  • 2 Contributors
  • 2 Replies
  • 36 Views
  • 20 Hours Discussion Span
  • Latest Post Latest Post by amontellano
Member Avatar for JamesCherrill

The instructions are pretty clear and detailed, so what exactly is stopping you from making progress?

Ps: what is the ConsoleInput class? It’s not part of the Java SE API.

Edited by JamesCherrill
Member Avatar for amontellano

So, the ConsoleInput file is here. What is stopping is that I am having a difficult time thinking on how to make this program run properly. Here is what I have written so far.

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();
  }
}
public class GeometricSequence extends Sequence {
	//
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.