//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
double a, b, c, d, e(0.0000000001), count(0);
a = atof(Edit1->Text.c_str());
if(a < 0)
{
   Label1->Caption = "Domain error!";
   return;
}
b = (1.0 + a)/2;
c = (b - a/b)/2;
d = fabs(c);
while(d > e && count < 1000)
{
   b -= c;
   c = (b - a/b)/2;
   d = fabs(c);
   ++count;
}
Label1->Caption = AnsiString(b) + " by algorithm";
Label2->Caption = AnsiString(sqrt(a)) + " by sqrt() function";
Label3->Caption = AnsiString(count) + " itterations";
}
//---------------------------------------------------------------------------

float SquareRootOf(int num)
{
	int i = 0;
	//Check for perfect square root
	for(i = 0; ; i++)
	{
		if(i * i > num) break;
		else if(i * i == num) return float(i);
	}
 
	i-=2;
	float j = i;
	float precision = 0.00001f;
	while(j * j < num - precision )
		j+=precision;
 
	return j;
}

float sqrt (float x)
{
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i>>1);
    x = *(float*)&i;
    return 1/(x*(1.5f - xhalf*x*x));
}

float sqrt (float x)
{
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i>>1);
    x = *(float*)&i;
    for(int k=0; k<5; k++)
        x*=(1.5f - xhalf*x*x);
    return 1.0f/x;
}

#include <iostream>
using namespace std;
 
double NthRoot(double, int);
 
double RaisedTo(double, int);
 
double NthRoot(double number, int nthRoot )
{
	bool done = false;
	unsigned short int digits = 0;
	double temp = number / 2;
	double sqrt = 0;
	double plusplus = 1;
	if (number == 1)
		return 1;
	for (;;)
	{
		if (digits > 0)
			plusplus /= 10.0;
		if (digits == 12)
			return sqrt;
		for ( double i = sqrt; i <= (temp + 1); i += plusplus)
		{
			if (RaisedTo(i, nthRoot) > number)
			{
				sqrt = i - plusplus;
				digits++;
				break;
			}
		}
	}
}
 
double RaisedTo(double base, int power)
{
       double temp;
	for (int i = 1; i < power; i++)
	{
		base *= temp;
	}
	return base;
}
 
int main()
{
	double number = 0;
	double answer;
	int root;
	cout << "Please enter a number to find the nth root: ";
	cin >> number;
	cout << "Please enter the root you wish to find: ";
	cin >> root;
	answer = NthRoot(number, root);
	cout << "The " << root << "th root is: " << answer << endl;
	cin.get();
	cin.get();
	return 0;
}

//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   double a, b, c, d, e(0.0000000001), f, count(0);
   a = atof(Edit1->Text.c_str());
   if(a < 0)
   {
      Label1->Caption = "Domain error!";
      return;
   }
   while(e > a) // For very small values the criterion for stopping needs to be smaller.
      e /= 10;
   b = (1.0 + a)/2;	// First estimate of square root of a.
   c = (b - a/b)/2;  // Correction to give a better estimate.
   while(c > e && count < 1000)
   {
      f = b;	// For very small and very large values we will see
      b -= c;	// if the correction has any effect.
      c = (b - a/b)/2;  // A revised correction.
      if(f == b)  // Applying the correction made no difference to our answer.
         break;
      ++count;		// A counter to measure the effectiveness of our algorithm.
   }
   Label1->Caption = AnsiString(b) + " by algorithm";		// Our answer.
   Label2->Caption = AnsiString(sqrt(a)) + " by sqrt() function";	// The true answer for comparison.
   Label3->Caption = AnsiString(count) + " iterations";	// Tells us how much effort it took.
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   double a, b;
   int count(0);
   a = atof(Edit1->Text.c_str());
   b = MySQRT(a, &count);
   if(a < 0)
   {
      Label1->Caption = "Domain error!";
      return;
   }
   Label1->Caption = AnsiString(b) + " by algorithm";		// Our answer.
   Label2->Caption = AnsiString(sqrt(a)) + " by sqrt() function";	// The true answer for comparison.
   Label3->Caption = AnsiString(count) + " iterations";	// Tells us how much effort it took.
}
//---------------------------------------------------------------------------
double __fastcall TForm1::MySQRT(double number, int *iterations)
{
   double b, c, e(1e-12), f;
   if(number < 0)
      return -1;
   while(e > number) // For very small values the criterion for stopping needs to be smaller.
      e /= 10;
   b = (1.0 + number)/2; // First estimate of square root of number.
   c = (b - number/b)/2; // Correction to give a better estimate.
   while(c > e && (*iterations) < 1000)
   {
      f = b;   // For very small and very large values we will see
      b -= c;  // if the correction has any effect.
      if(f == b)       // Applying the correction made no difference to our answer.
         return b;
      c = (b - number/b)/2; // A revised correction.
      ++(*iterations); // A counter to measure the effectiveness of our algorithm.
   }
   return b;
}
//---------------------------------------------------------------------------