#include <iostream>
#include <math.h>
using namespace std;

int main() {
   int val, tolerance;
   cout << "Input the values of the number whose square root need be found, and the tolerance limit in the number of digits, of integer variable: tolerance, giving tolerance limit as: 10^{-tolerance}" << endl;
   cout<< "Enter the number, followed by the # tolerance digits."<< endl;
   cin >>val>> tolerance;
   if(val< 0)
      exit(0); 
   else 
   {
      long double low = 0, high = val;
      long double  mid = (low + high)/2;
      int c = 0; 
      long double diff = 0;

      while (!c) 
      {
         if((mid*mid-val)<0)
             diff = val - mid*mid;
         if (diff <= pow(10, -1*tolerance))
         {
            c = 1;
            cout << "Square root of 2= "<< mid<<endl;
         }
         else if(mid * mid > val) 
         {
               high = mid;
               mid = (low + high)/2;      
          } 
          else 
          {
               low = mid;
               mid = (low + high)/2;
          }
      }
    }
   return 0;
}

#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;

int main() {
   int val, tolerance;
   cout << "Input the values of the number whose square root need be found, and the tolerance limit in the number of digits, of integer variable: tolerance, giving tolerance limit as: 10^{-tolerance}" << endl;
   cout<< "Enter the number, followed by the # tolerance digits."<< endl;
   cin >>val>> tolerance;
   if(val< 0)
      exit(0); 
   else 
   {
      long double limit = powl(10,-tolerance);  // use powl, not pow for better precision
      long double low = 0, high = val;
      long double  mid = (low + high)/2;
      int c = 0; 
      long double diff = 0;

      while (!c) 
      {
         if((mid*mid-val)<0)
             diff = val - mid*mid;
         if (diff <= limit)
         {
            c = 1;
            cout << "Square root of 2= "<< setprecision(tolerance) << mid<<endl;
         }
         else if(mid * mid > val) 
         {
               high = mid;
               mid = (low + high)/2;      
          } 
          else 
          {
               low = mid;
               mid = (low + high)/2;
          }
      }
    }
   return 0;
}

#include <iostream>
#include <iomanip>
#include <fstream>
#include <math.h>
using namespace std;

int main() {
   int val, prec;
   ofstream out_file;
   out_file.open("output_bisect.txt");
   cout << "Enter the number, and precision"<<endl;
   out_file << "Enter the number, and precision"<<endl;
   cin >>val>> prec;
   
   if(val< 0) 
       exit(0);
   else 
   {
      long double low = 0, high = val;
      long double  mid = (low + high)/2;
      int c = 0; long double magn=0;

      while (!c) 
      {
         if((mid*mid-val)<0)
             magn = val - mid*mid;
         
         if (magn <= pow(10, -1*prec))
         {
            cout << "Square root is: " << mid <<endl;
            out_file << "Square root is: " << mid <<endl;
            c = 1;
         }
         else if(mid * mid > val) 
         {
               high = mid;
               mid = (low + high)/2;
          } 
          else 
          {
               low = mid;
               mid = (low + high)/2;  
          }
       }
    }
   return 0;
}

#include <iostream>
#include <iomanip>
#include <numbers>
#include <limits>
#include <format>

int main( )
{
   std::cout << "float: " << sizeof(float) << '\n';
   std::cout << std::numeric_limits<float>::digits10 << "\n\n";

   std::cout << "double: " << sizeof(double) << '\n';
   std::cout << std::numeric_limits<double>::digits10 << "\n\n";

   std::cout << "long double: " << sizeof(long double) << '\n';
   std::cout << std::numeric_limits<long double>::digits10 << "\n\n";

   // default precision, outputs 3.14159
   std::cout << std::numbers::pi << '\n';

   // maximum precision, outputs 3.141592653589793
   constexpr auto max_precision { std::numeric_limits<long double>::digits10 + 1 };
   std::cout << std::setprecision(max_precision) << std::numbers::pi << "\n\n";

   // default precision, outputs 3.141592653589793
   std::cout << std::format("{}\n", std::numbers::pi);

   // https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification
   // outputs 3.141592653589793115997963468544185161590576171875
   // is this really a valid number, though?
   std::cout << std::format("{:2.48f}\n", std::numbers::pi);
}

#include <iostream>
#include <vector>
using namespace std;


void fix( vector<int> &V )             // sort out any "carry" operations
{
   for ( int i = 0, carry = 0; i < V.size() || carry > 0; i++ )
   {
      if ( i < V.size() ) carry += V[i];
      int digit = carry % 10;
      carry /= 10;
      if ( i < V.size() ) V[i] = digit;
      else                V.push_back( digit );
   }
}

ostream &operator << ( ostream &out, const vector<int> &V )
{
   out << V.back() << ".";
   for ( int i = V.size() - 2; i >= 0; i-- ) out << V[i];
   return out;
}


int main()
{
   int N = 2;                                               // SINGLE digit number (for the moment)
   int DP = 60;                                             // Decimal places for square root
   int first = 0;
   for ( int digit = 1; digit * digit <= N; digit++ ) first++;  // Find whole-number part of square root
   vector<int> S = { first }, SS = { first * first };       // These hold the prospective square root and its square in REVERSE order

   for ( int decimals = 1; decimals <= DP; decimals++ )     // Add one decimal place at a time
   {
      SS.insert( SS.begin(), { 0, 0 } );                    // The square must add two decimal places
      int nextDigit = 0;
      auto SSnext = SS;
      for ( int digit = 1; digit < 10; digit++ )            // Find the largest final digit such that the square doesn't exceed N
      {
         vector<int> TEST = SS;
         TEST[0] += digit * digit;                                              // These two lines obviate having to multiply 
         for ( int i = 0; i < S.size(); i++ ) TEST[i+1] += 2 * digit * S[i];    //      whole big numbers, which is expensive
         fix( TEST );                                                           // Make sure that all digits are less then 10
         if ( TEST.size() > 2 * decimals + 1 || TEST[2*decimals] >= N ) break;  // Too large
         SSnext = TEST;                                                         // Update the candidate square
         nextDigit = digit;                                                     //      and last digit of the square root
      }
      SS = SSnext;
      S.insert( S.begin(), nextDigit );
      cout << S << '\n';
   }
}