```
#include <iostream>
#include <deque>
#include <string>
#include <limits>
#include <sstream>
#include <iomanip>
/* Obtaining square root using the decimimal method */
class square_root {
double result,tmp,rmndr;
long input;
double decim; //Will contain the number of trailing decimimals.
std::deque<double> tokens; //Will contain the tokenized 'input' value.
square_root ();
/* Aproximates the biggest number 'n' given as input 'a' and 'x' such that ( y=(a*20)+n | x - (y*n) < y ) */
double aprox (double a,double x) {
double ret=1;
a*=20;
while ((a+ret)*ret <= x) {
ret++;
}
ret--;
return ret;
}
void sqt (double num,bool point=0) { // 3 45 34. 00 | 185.8
rmndr*=100; // 3- |________________________________________
rmndr+=num; // 1= | 1*1=1 < 3 => 1
tmp=aprox (result,rmndr); // 245- | (((1*2)*10)+8)*8=224 < 245 => 8
rmndr-=((result*20)+tmp)*tmp; // 224 |
result*=10; // 2134- | (((18*2)*10)+5)*5=1825 < 2134 => 5
result+=tmp; // 1825 |
if (point==1) { // 33900 | (((185*2)*10)+8)*8=29664 < 33900 => 0.8
decim*=10;
}
}
/* Tokenizes a number by grouping it's digits in pairs of two from back to front
* and stores them in 'tokens'.
* ex: input=3453545;
* Now 'tokens' will contain four objects (45,35,45,3)
*/
void tokenize (long inp) {
const long step=100;
for (long x=step,y=1;x <= inp*step;x*=step,y*=step) {
double tok=((inp%x - inp%y) / y);
tokens.push_front (tok);
}
}
public:
explicit square_root (long input_) : input(input_), result(0), rmndr(0), tmp(0), decim(1) {
if (input <= std::numeric_limits<long>().max()) {
tokenize (input);
for (std::deque<double>::iterator i=tokens.begin();i!=tokens.end();++i) {
sqt (*i);
}
//calling sqt with 'point' set starts counting trailing decimals
for (int x=0;x<square_root::precision;x++) sqt(0,1);
/* Dividing to the apropriate value */
result/=decim;
}
}
~square_root () {}
static const int precision=25;
operator double () const {
return result;
}
};
int main (int argc,char* argv[]) {
long n;
std::stringstream (argv[1]) >> n;
std::cout << "\n\n\n" << std::fixed << std::setprecision(square_root::precision) << square_root (n) << "\n\n\n\n";
}
```

**Are you able to help answer this sponsored question?**

Questions asked by members who have earned a lot of community kudos are featured in order to give back and encourage quality replies.

Recommended Topics