Estimate the roots of a number ...

/**************************************************************************************************************************
* SQR CLASS by: 'Mathias Van Malderen'
* Copyright (c) 2009 Mathias Van Malderen
*
* Disclaimer:
* ~~~~~~~~~~~
*
* Free to use for everyone!
* It is not allowed to sell this source code !
*
* Description:
* ~~~~~~~~~~~~
*
* 1) You create an object from the class 'sqr';
* 2) You put the value of which you want to calculate the n-root in the object using the method 'setsqr(<double>)';
* 3) (Optional) You set the 'precision' and 'n-root' (If you don't do this, the program will automatically estimate the square root with 'precision' = 1000 if you call the 'estimate()' method);
* 4) You call the method 'estimate()' to estimate the desired n-root ...
* 5) Enjoy !!
*
*
* Remarks:
* ~~~~~~~~
*
* !!: This class only returns valid results for values higher than zero ...
*
* TODO:
* ~~~~~
*
* <nothing>
*
***************************************************************************************************************************/

#include <iostream>
using namespace std;

class sqr
{
public:
    sqr(double asqr_in);
	void init(double asqr_in);
	void setsqr(double asqr_in);
	double estimate();
	void setprecision(long aprecision);
	void setnsqr(int ansqr);
	long getprecision();
	int getnsqr();
	double getsqr();
	int getcalctime();
private:
    long t_begin, t_end;
    double sqr_in, s, l, h, tmp;
    long precision;
    int nsqr;
    double apow(float x, int y);
};

sqr::sqr(double asqr_in)
{
	/* Constructor */
    init(asqr_in);
}
void sqr::setprecision(long aprecision){precision = aprecision;} /* Set the precision, the higher, the more precise the estimation is */
long sqr::getprecision(){return precision;} /* Returns the set precision */
int sqr::getnsqr(){return nsqr;} /* Returns the root which you are estimating */
double sqr::getsqr(){return sqr_in;} /* Returns the number of which you want to estimate the root */
int sqr::getcalctime(){return (t_end - t_begin);} /* Returns the total calculation time (in whole seconds) */
void sqr::init(double asqr_in)
{
	/* Public method to make it possible for the user to 'reinitialize' the object */
    sqr_in = asqr_in;
    precision = 1000;
    nsqr = 2;
    s = 0;
    l = 0;
    h = 0;
    tmp = 0;
}
void sqr::setnsqr(int ansqr)
{
	/* Set the root you want to estimate */
	if(ansqr >= 2)
	{
		nsqr = ansqr;
	}
}
void sqr::setsqr(double asqr_in)
{
	/* Set the number where you want to estimate the n-root of */
	if(!(asqr_in < 0))
	{
		sqr_in = asqr_in;
	}
}
double sqr::apow(float x, int y)
{
	/* This is a private method of the class, it's only a dependency */
	long double result = 1;
	if (y == 0)
		return result;
			
	if (y < 0)
	{
		y = -y;
		for (int i = 0; i < y; i++)
			result = result * x;
		return 1/result;
	}

	for (int i = 0; i < y; i++)
		result = result * x;
			
	return result;
}
double sqr::estimate()
{
	/* Estimate the root of a given number */
	t_begin = time(0);
	/****** BEGIN ALGORITHM ******/
	tmp = sqr_in;

	if(sqr_in < 1 && sqr_in > 0)
	{
		/* The root must be in between 0 (= zero) and 1 (= one) */
		l = 0;
		h = 1;
		s = 0.5;
	} else {
		/* Calculate two numbers 'l' (= lowest) and 'h' (= highest) where the root must be in between */
		do
		{
			tmp = tmp / 2;
		}
		while (apow(tmp, nsqr) > sqr_in);
		l = tmp;
		h = tmp*2;
	}

	/* Start estimating the desired root */
	for (int i = 0; i < precision; i++)
	{
		/* Calculate the average of 'l' and 'h' and store the result in variable 's' */
		s = (l+h)/2;
		tmp = apow(s, nsqr);
		if (tmp > sqr_in)
		{
			/* The estimated root is too high */
			h = s;
		}
		else if (tmp < sqr_in)
		{
			/* The estimated root is too low */
			l = s;
		}
		else
		{
			/* We have found the 'exact' root */
			/* Speedbooster */
			break;
		}
	}
	/****** END ALGORITHM ******/
	t_end = time(0);
	return s;
}