0

I am writing a program that will implement an ADT for polynomials of the form: c0+c1x+c2x2+c3x3+… Each Polynomial object will save the appropriate coefficients for a single polynomial. I think that I have the code doing the right things, however I am getting the following undefined reference errors:
undefined reference to Polynomial::Polynomial(int, double*)
undefined reference to Polynomial::Polynomial(int, double*)
undefined reference to Polynomial::operator==(Polynomial const&) const
undefined reference to Polynomial::operator*(double) const
undefined reference to Polynomial::operator+(Polynomial const&) const' undefined reference toPolynomial::operator+(Polynomial const&) const'
undefined reference to Polynomial::getDegree() const' undefined reference toPolynomial::getDegree() const'
undefined reference to Polynomial::getCoeff(int) const' undefined reference toPolynomial::getDegree() const'
undefined reference to Polynomial::operator*(double) const' undefined reference toWinMain@16'
I have included my code and header file. I am confused as to the output of these errors as they are coming formt he output filr and the compiler does not give me any hints as to where I can look. Any help or pointers as to why/how this is happening will be greatly appreciated. Thank you!

Here is my code.

 #include "polynomial.h"
    #include <algorithm>
    #include <iostream>
    #include <iomanip>
    #include <sstream>
    #include <cassert>
    using namespace std;
    Polynomial::Polynomial ()
    {
        cout << "Enter a polynomial.\nHow many coefficients will be in the first polynomial? " << flush;
        int nCoeff1;
        cin >> nCoeff1;
        double coeff1 [nCoeff1];
        coefficients.push_back(nCoeff1);
        for (int i = 0; i < nCoeff1; ++i)
            cin >> coeff1[i];
        cout << "\nEnter the coefficients, in order of increasing power of x:\n  " << flush;

        Polynomial p1 (nCoeff1, coeff1);

        double x;
        cout << "\nEnter a value at which to evaluate the polynomial: " << flush;
        cin >> x;

        cout << p1 << "\n  at x=" << x << " evaluates to " << setprecision(3) << p1.evaluate(x)
        << endl;

        cout << "\nEnter a second polynomial, in the same format\n(# of coefficients, then each coefficient in order of increasing power of x).\n  " << flush;
        Polynomial p2 (nCoeff1, coeff1);
        coefficients.push_back(x);
        cin >> p2;

        if (p1 == p2)
        {
            cout << "Those polynomials are equal." << endl;
        }
        else
        {
            cout << "Those polynomials are not equal." << endl;
        }

        double scale;
        cout << "\nEnter a scaling factor (a floating point number): " << flush;
        cin >> scale;

        {
            Polynomial p3 = p1 * scale;
            cout << "\n\n(" << p1 << ") * "
                 << scale
                 << "  = " << p3 << endl;
        }

        {
            Polynomial p4 = p1 + p2;
            cout << "\n\n" << p1 << "\n   +\n"
                 << " (" << p2 << ")\n"
                 << "  = " << p4 << endl;
        }

        {
            Polynomial p5 = p1 + scale * p2;
            cout << "\n\n" << p1 << "\n   +\n"
                 << scale << " * (" << p2 << ")\n"
                 << "  = " << p5 << endl;
            cout << "\nThis polynomial has degree " << p5.getDegree()
                 << " and, at x=" << x << ", evaluates to " << setprecision(3) << p5.evaluate(x)
                 << endl;
        }

    }
    Polynomial::Polynomial (const vector<double>& coeff)
        : coefficients(coeff)
    {
        normalize();
    }
    void Polynomial::normalize ()
    {
        while (coefficients.size() > 0 && coefficients.back() == 0.0)
            coefficients.pop_back();
    }
    double Polynomial::evaluate (double x) const
    {
        double sum = 0.0;
        int k = coefficients.size();
        for (vector<double>::size_type i = 0; i < coefficients.size(); ++i)
        {
            --k;
            sum = x * sum + coefficients[k];
        }
        return sum;
    }
    std::istream& operator>> (std::istream& in, Polynomial& p)
    {
        int r;
        in >> r;
        Polynomial result;
        result.coefficients.resize(r);
        for (int i = 0; i < r; ++i)
            in >> result.coefficients[i];
        result.normalize();
        p = result;
        return in;
    }
    std::ostream& operator<< (std::ostream& out, const Polynomial& p)
    {
        if (p.getDegree() < 0)
        {
            out << "0";
        }
        else
        {
            bool first_printed = true;
            for (int i = 0; i <= p.getDegree(); ++i)
            {
                double c = p.getCoeff(i);
                if (c != 0.0)
                {
                    if (!first_printed)
                    {
                        out << " + ";
                    }
                    first_printed = false;
                    out << c;
                    if (i > 0)
                    {
                        out << " x";
                        if (i > 1)
                        {
                            out << "^" << i;
                        }
                    }
                }
            }
        }
        return out;
    }

Here is my header file:

#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H
#include <iostream>
#include <vector>
/**
   This class implements a polynomial of the form
    c0 + c1 x + c2 x^2 + c3 x^3 + ...

   (The order of a polynomial is the largest
   power of x having a non-zero coefficient, or zero if the polynomial
   has all zero coefficients.) Note that adding polynomials
   together or scaling polynomials (multiplying by a constant) could
   reduce the order of the result.

*/
class Polynomial {
public:
  /**
   * Create a zero polynomial.
   */
  Polynomial ();
  /**
   * Create a polynomial with the given coefficients.
   * E.g.,
   *   double c[3] = {1.0, 2.0, 3.0};
   *   Polynomial p (3, c);
   * creates a polynomial p representing: 1.0 + 2.0*x + 3.0*x^2
   *
   * @param nCoeff number of coefficients in the input array
   * @param coeff  the coefficients of the new polynomial, starting
   *               with power 0.
   */
  Polynomial (int nCoeff, double coeff[]);
  /**
   * Create a polynomial with the given coefficients. If
   * the coeff vector is empty, create a zero polynomial.
   *
   * @param coeff  the coefficients of the new polynomial, with
   *               coeff[0] denoting the term of power 0.
   */
  Polynomial (const std::vector<double>& coeff);
  // Don't need our own Big 3 because none of the data members are pointers
  // Polynomial (const Polynomial&);
  // ~Polynomial();
  // Polynomial& operator= (const Polynomial&);
  /**
   * Compute the value of this polynomial at a given value of x.
   * E.g.,
   *   double c[3] = {1.0, 2.0, 3.0};
   *   Polynomial p (3, c);
   *   cout << p.evaluate(2.0);
   * will print 17.0
   *
   * @param x the value on which this polynomial should be evaluated.
   * @return the value of this polynomial at x
   */
  double evaluate (double x) const;
  /**
   * Get the coefficient of the term with the indicated power.
   * @param power the power of a term
   * @return the corresponding coefficient, or zero if power < 0 or if
   *          power > getDegree()
   */
  double getCoeff(int power) const;
  /**
   *  The degree of a polynomial is the largest exponent of x with a
   *  non-zero coefficient. E.g.,
   *     x^3 + 2x + 1  has degree 3
   *     42            has degree 0   (42 == 42 * x^0)
   *     0             is a special case and is regarded as degree -1
   *
   * @return the degree of this polynomial
   */
  int getDegree() const;
  /**
   * Add a polynomial to this one, returning their sum.
   *
   * @param p another polynomial
   * @return the sum of the two polynomials
   */
  Polynomial operator+ (const Polynomial& p) const;
  /**
   * Multiply this polynomial by a scalar.
   * @param scale the value by which to multiply each term in this polynomial
   * @return the polynomial resulting from this multiplication
   */
  Polynomial operator* (double scale) const;
  /**
   * Compare this polynomial for equality against another.
   *
   * @param p another polynomial
   * @return true iff the polynomials have the same degree and their corresponding
   *           coefficients are equal.
   */
  bool operator== (const Polynomial& p) const;

private:
  std::vector<double> coefficients;

  friend std::istream& operator>> (std::istream&, Polynomial&);
  //friend std::ostream& operator<< (std::ostream&, const Polynomial&);
  /**
   * A utility function to scan the current polynomial, putting it into
   * "normal form". In this case, the normalized form should not have a
   * zero coefficient for its highest power term.  For example, the
   * normal form of 0 x^3 + 3 x^2 + 0 x + 12 would be 3 x^2 + 0 x + 12.
   *
   * Polynomials should be kept in normal form at all times outside of the
   * actual member function bodies of this class.
   */
  void normalize();
};
/**
 * Read a polynomial from an istream.
 *   Polynomials are input in the format:
 *    #coefficients c0 c1 ...
 *   where the ci are floating point coefficients of x^i
 *
 *   @param in the stream from which to read the polynomial
 *   @param p the polynomial in which to store the result.
 *   @return the stream in
 */
std::istream& operator>> (std::istream& in, Polynomial& p);
/**
 *  Write a polynomial to an ostream
 *
 *   @param out the stream to which to write the polynomial
 *   @param p the polynomial to write
 *   @return the stream out
 */
std::ostream& operator<< (std::ostream&, const Polynomial&);
/**
 * Note: a member function of the Polynomial class must have a polynomial
 * as the first argument (e.g., poly.operator*(x) <===> poly * x). This
 * function simply allows for the multiplication to be written with the
 * polynomial on the right.
 *
 * @param scale the value to multiply the polynomial by
 * @param p a polynomial
 * @return the product of scale and p
 */
inline
Polynomial operator* (double scale, const Polynomial& p)
{ return p * scale; }
#endif
2
Contributors
1
Reply
13
Views
1 Year
Discussion Span
Last Post by Moschops
2

Undefined reference means that the linker is looking for a function, but it can't find it. This usally happens for one of two reasons:

1) You haven't linked to the right library. Not relevant here.

2) You haven't written it. That's the case here.

In your header file, you promised you would write the constructor function Polynomial (int nCoeff, double coeff[]); - where is it?

You promised you would write the operator function for Polynomial::operator==(Polynomial const&) const - where is it?

Likewise with the others.

Edited by Moschops

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.