Thread: Newton's Method

That didn't change anything that I can see. The answer still comes out to -1.#INF. Even when I try sqroot(16) I get the same answer (-1.#INF not 4). Why would I change TOLERANCE to 100? Since the program has to have a tolerance of .000001, would I have to use #include<iomanip> and setprecision(6)? I forgot how to define a tolerance..

Awesome. It's working now Thanks! The only thing is how do I set it to where it always shows the answer with 6 decimal places? I tried setpresicion(7) but that displays 7 digits instead of 6 decimal places.

Oh yeah!! Thanks. I haven't used that since the begining of last semester so I forgot it. Thank you so much for the help

Originally Posted by nimitzhunter

Use fixed along with setpricision.

Code:

cout<< fixed << setprecison(6).

I believe you will also need the library,

Code:

#include <iomanip>

to use setprecision.

This is what i came up with, not the most efficient but it works

Code:

double Sqrt(double num)
{
    return Guess(num/2, num, 0, 256);
}
double Guess(double x, double y, int depth, int maxDepth)
{
    if (++depth < maxDepth)
        return Guess(x - (((x * x) - y) / (2 * x)), y, depth, maxDepth);
    return x;
}

Originally Posted by Elysia

What? You invented your own sqrt or something?

Using Newton's Method, yes i did.

For a bit of fun, I thought I'd write my version of this program. Criticisms encouraged :-).

Code:

#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iostream>

#include "boost/bind.hpp"
#include "boost/cstdint.hpp"

template <typename Function1, typename Function2>
double NewtonsMethod(
    Function1 f,
    Function2 fPrime,
    double x,
    double tolerance,
    boost::uint32_t maxIterations)
{
    assert(tolerance > 0);
    assert(maxIterations != 0);

    double last;
    boost::uint32_t iterations = 0;

    do
    {
        last = x;
        x -= f(x) / fPrime(x);
        ++iterations;
    }
    while (std::abs(x - last) > tolerance && iterations != maxIterations);

    return x;
}

double XPowNMinusC(double x, boost::uint32_t n, double c) { return std::pow(x, n) - c; }
double XPowNMinusCPrime(double x, boost::uint32_t n, double c) { return n * std::pow(x, n - 1); }

int main(int argc, char** argv)
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << " n x" << std::endl;
        std::cerr << "(Prints the nth root of x)" << std::endl;
        return 1;
    }

    boost::uint32_t n;
    double x;

    n = atoi(argv[1]);
    x = atof(argv[2]);

    double nthRootOfX = NewtonsMethod(
        boost::bind(XPowNMinusC, _1, n, x), // f
        boost::bind(XPowNMinusCPrime, _1, n, x), // f'
        x / 2, // x[0]
        10E-6, // tolerance
        100); // max iterations

    std::cout << nthRootOfX << std::endl;

    return 0;
}

Originally Posted by Elysia

The only thing I can say is avoid atoi (use boost::lexical_cast instead) and I would prefer lambdas over boost::bind (error messages are horrible as usual).
Otherwise it looks like a very nice C++-like solution.

Ah yes boost::lexical_cast would be better. I'm not very familiar with C++0x's lambda functions, can they be used in that program without changing NewtonsMethod() ?