Merge pull request #1 from BoostGSoC20/feature/log_agm

AGM implementation of log(x) and Karatsuba and Newton-Raphson implementation of sqrt(x)

Author: Dim131

.gitignore

@@ -1 +1,14 @@
-# /boost/libs/multiprecision/.gitignore# Use of manifest is unclear, so add to .gitignore./doc/html/standalone_HTML.manifest
+# /boost/libs/multiprecision/.gitignore
+# Use of manifest is unclear, so add to .gitignore.
+/doc/html/standalone_HTML.manifest
+example/mpfr-4.1.0/mpfr-4.1.0.vcxproj.user
+example/mpfr-4.1.0/.vs/mpfr-4.1.0/v16/.suo
+example/mpfr-4.1.0/x64/Release/abort_prec_max.obj
+example/mpfr-4.1.0/x64/
+example/mpir-3.0.0/build.vc16/.vs/
+example/mpir-3.0.0/build.vc16/lib_mpir_core2/lib_mpir_core2.vcxproj.user
+example/mpir-3.0.0/build.vc16/lib_mpir_core2/x64/
+example/mpir-3.0.0/lib/
+example/pi_millions_with_boost_multiprecision/pi_millions_with_boost_multiprecision.vcxproj.user
+example/pi_millions_with_boost_multiprecision/.vs/
+example/pi_millions_with_boost_multiprecision/x64/

example/boost_gsoc_benchmark_utils.h

@@ -0,0 +1,89 @@
+#include <chrono>
+#include <limits>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace boost_gsoc2020 {
+
+/* Utility class to measure the execution time. */
+template <class clock_type>
+struct stopwatch
+{
+ public:
+   typedef typename clock_type::duration duration_type;
+
+   stopwatch() : m_start(clock_type::now()) {}
+
+   stopwatch(const stopwatch& other) : m_start(other.m_start) {}
+
+   stopwatch& operator=(const stopwatch& other)
+   {
+      m_start = other.m_start;
+      return *this;
+   }
+
+   ~stopwatch() {}
+
+   /* Returns the elapsed time since the timer was last reset. */
+   duration_type elapsed() const
+   {
+      return (clock_type::now() - m_start);
+   }
+
+   /* Resets the timer. */
+   void reset()
+   {
+      m_start = clock_type::now();
+   }
+
+ private:
+   typename clock_type::time_point m_start;
+};
+
+using stopwatch_type = stopwatch<std::chrono::high_resolution_clock>;
+
+/* Utility class to compute the mean and variance over independent
+   and identically distributed samples. */
+template <typename T>
+struct Aggregator
+{
+
+   Aggregator() : mean(0), variance(0), n(0) {}
+
+   void addMeasurement(T measurement)
+   {
+      T prev_mean = mean;
+      if (n == 0)
+      {
+         mean = measurement;
+      }
+      else
+      {
+         mean += (measurement - mean) / T(n+1);
+         variance += (measurement - prev_mean) * (measurement - mean);
+      }
+      ++n;
+   }
+
+   /* Returns the estimated mean. */
+   T getMean() const
+   {
+      return mean;
+   }
+
+   /* Returns the estimated variance. */
+   T getVariance() const
+   {
+      return variance / (n - 1);
+   }
+
+   T      mean;
+   T      variance;
+   size_t n;
+};
+
+using aggregator_type = Aggregator<long long>;
+
+} // namespace boost_gsoc2020

example/complex_exponential_snips.cpp

@@ -0,0 +1,116 @@
+/*
+Contains the performance tests for the logarithm implementation.
+ */
+#include <chrono>
+#include <limits>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <boost/math/constants/constants.hpp>
+#include <boost/multiprecision/cpp_bin_float.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#include <random>
+
+#include "boost_gsoc_benchmark_utils.h"
+
+template <typename Generator>
+std::string generateRandomNumber(size_t digits, Generator& gen)
+{
+   std::uniform_int_distribution<int> uniform_digit(0, 10);
+   std::uniform_int_distribution<size_t> uniform_point(1, digits);
+   std::string                        str;
+   str += std::to_string(uniform_digit(gen) % 9 + 1);
+   size_t point = uniform_point(gen);
+   for (size_t i = 1; i < digits; ++i)
+   {
+      str += std::to_string(uniform_digit(gen));
+      if (i == point)
+         str += '.';
+   }
+   return str;
+}
+
+template <typename T>
+void run_time_experiments(size_t cur_digits)
+{
+    size_t                     reps = 20;
+    std::default_random_engine generator(42);
+    int                        total = 0;
+    boost_gsoc2020::aggregator_type aggregator;
+    for (size_t rep = 0; rep < reps; ++rep)
+    {
+        T                              val(generateRandomNumber(cur_digits, generator));
+        boost_gsoc2020::stopwatch_type stopwatch;
+        stopwatch.reset();
+        T ans = log(val);
+        total += !ans.is_zero();
+        auto time = stopwatch.elapsed().count();
+        aggregator.addMeasurement(time);
+    }
+    double mean         = aggregator.getMean() / 1000000000.0;
+    double st_deviation = sqrt(aggregator.getVariance()) / 1000000000.0;
+    std::cout << "(" << cur_digits << ", " << mean << ") +- ("
+              << st_deviation << ", " << 1.96 * st_deviation << ")" << std::endl;
+}
+
+template<size_t Digits>
+void run_time_experiment_for_cpp_bin_float() {
+   run_time_experiments<boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<Digits> > >(Digits);
+}
+
+template <size_t Digits>
+void run_time_experiment_for_cpp_dec_float()
+{
+   run_time_experiments<boost::multiprecision::number<boost::multiprecision::backends::cpp_dec_float<Digits> > >(Digits);
+}
+
+int main()
+{
+   
+   std::cout << "==== Running tests for cpp_bin_float: ====" << std::endl;
+   run_time_experiment_for_cpp_bin_float<1000>();
+   run_time_experiment_for_cpp_bin_float<1500>();
+   run_time_experiment_for_cpp_bin_float<2000>();
+   run_time_experiment_for_cpp_bin_float<2500>();
+   run_time_experiment_for_cpp_bin_float<3000>();
+   run_time_experiment_for_cpp_bin_float<3500>();
+   run_time_experiment_for_cpp_bin_float<4000>();
+   run_time_experiment_for_cpp_bin_float<4500>();
+   run_time_experiment_for_cpp_bin_float<5000>();
+   run_time_experiment_for_cpp_bin_float<5500>();
+   run_time_experiment_for_cpp_bin_float<6000>();
+   run_time_experiment_for_cpp_bin_float<6500>();
+   run_time_experiment_for_cpp_bin_float<7000>();
+   run_time_experiment_for_cpp_bin_float<7500>();
+   run_time_experiment_for_cpp_bin_float<8000>();
+   run_time_experiment_for_cpp_bin_float<8500>();
+   run_time_experiment_for_cpp_bin_float<9000>();
+   run_time_experiment_for_cpp_bin_float<9500>();
+   run_time_experiment_for_cpp_bin_float<10000>();
+
+   /* std::cout << "==== Running tests for cpp_dec_float: ====" << std::endl;
+   run_time_experiment_for_cpp_dec_float<1000>();
+   run_time_experiment_for_cpp_dec_float<1500>();
+   run_time_experiment_for_cpp_dec_float<2000>();
+   run_time_experiment_for_cpp_dec_float<2500>();
+   run_time_experiment_for_cpp_dec_float<3000>();
+   run_time_experiment_for_cpp_dec_float<3500>();
+   run_time_experiment_for_cpp_dec_float<4000>();
+   run_time_experiment_for_cpp_dec_float<4500>();
+   run_time_experiment_for_cpp_dec_float<5000>();
+   run_time_experiment_for_cpp_dec_float<5500>();
+   run_time_experiment_for_cpp_dec_float<6000>();
+   run_time_experiment_for_cpp_dec_float<6500>();
+   run_time_experiment_for_cpp_dec_float<7000>();
+   run_time_experiment_for_cpp_dec_float<7500>();
+   run_time_experiment_for_cpp_dec_float<8000>();
+   run_time_experiment_for_cpp_dec_float<8500>();
+   run_time_experiment_for_cpp_dec_float<9000>();
+   run_time_experiment_for_cpp_dec_float<9500>();
+   run_time_experiment_for_cpp_dec_float<10000>();
+   */
+   return 0;
+}