Add files

core/example/performance_numbers/.gitignore

@@ -0,0 +1 @@
+build/

core/example/performance_numbers/CMakeLists.txt

@@ -0,0 +1,68 @@
+cmake_minimum_required (VERSION 3.4)
+
+project (performance_numbers)
+
+
+IF( NOT CMAKE_BUILD_TYPE )
+   SET( CMAKE_BUILD_TYPE release)
+ENDIF()
+
+message("CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}")
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -g -O0")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g")
+
+
+
+include_directories (include)
+
+set(MY_HEADERS
+	include/construct_system.hpp
+	)
+
+set(MY_SOURCES
+	src/main.cpp
+	)
+
+include(GenerateExportHeader)
+
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
+
+find_library(B2_LIBRARIES 
+	NAMES "bertini2"
+)
+
+find_library(GMP_LIBRARIES 
+	NAMES "gmp"
+)
+
+find_library(MPFR_LIBRARIES 
+	NAMES "mpfr"
+)
+
+#Prep for compiling against boost
+find_package(Boost REQUIRED
+			COMPONENTS system log)
+
+INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
+LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
+
+
+
+find_package (Eigen3 3.3 REQUIRED NO_MODULE)
+
+include_directories(${B2_INCLUDE_DIRS})
+
+
+
+add_executable(performance_numbers ${MY_SOURCES})
+
+
+target_link_libraries (performance_numbers ${B2_LIBRARIES} ${MPFR_LIBRARIES} ${GMP_LIBRARIES} Eigen3::Eigen ${Boost_LIBRARIES})
+
+
+#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -ltcmalloc")
+#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lprofiler")

core/example/performance_numbers/README.md

@@ -0,0 +1,14 @@
+This example illustrates a way to use Bertini2 as an engine to run parameter homotopies.
+
+--
+
+### Compiling
+
+Uses CMake.  
+
+1. `cd b2/core/example/parameter_homotopy`
+2. `mkdir build && cd build`
+3. `cmake ..`
+4. `make`
+
+Resulting product `parameter_homotopy` is in `build/bin/`

core/example/performance_numbers/include/construct_system.hpp

@@ -0,0 +1,120 @@
+
+#pragma once
+
+#include <bertini2/system.hpp>
+
+template<typename NumType> using Vec = Eigen::Matrix<NumType, Eigen::Dynamic, 1>;
+template<typename NumType> using Mat = Eigen::Matrix<NumType, Eigen::Dynamic, Eigen::Dynamic>;
+using dbl = bertini::dbl;
+using mpfr = bertini::mpfr;
+
+namespace demo{
+
+
+	using Node = std::shared_ptr<bertini::node::Node>;
+	using Variable = std::shared_ptr<bertini::node::Variable>;
+
+
+
+
+	auto ConstructSystem1()
+	{
+		using bertini::Variable::Make;
+        using bertini::Integer::Make;
+        using bertini::MakeFloat;
+
+	    auto x1 = Variable::Make("x1");
+	    auto x2 = Variable::Make("x2");
+	    auto x3 = Variable::Make("x3");
+	    auto x4 = Variable::Make("x4");
+        
+        auto p1 = MakeFloat("3.2");
+        auto p2 = MakeFloat("-2.8");
+        auto p3 = bertini::MakeFloat("3.5");
+        auto p4 = MakeFloat("-3.6");
+        
+        std::vector<Node> params{p1, p2, p3, p4};
+
+	    auto f1 = pow(x1,3)*params[0] + x1*x1*x2*params[1] + x1*x2*x2*params[2] + x1*x3*x3*params[3] + x1*x4*x4*params[0]
+	     + x1*params[1]+ x2*x2*x2*params[2] + x2*pow(x3,2)*params[3] + x2*x4*x4*params[0] + x2*params[1] + 1;
+	     
+	    auto f2 = x1*x1*x1*params[2] + x1*x1*x2*params[3] + x1*x2*x2*params[0] + x1*x3*x3*params[1] + x1*x4*x4*params[2]
+	     + x1*params[3] + x2*x2*x2*params[0] + x2*x3*x3*params[1] + x2*x4*x4*params[2] + x2*params[3] - 1;
+	     
+	    auto f3 = x1*x1*x3*params[0] + x1*x2*x3*params[1] + x2*x2*x3*params[2] + x3*x3*x3*params[3] + x3*pow(x4,2)*params[0] + x3*params[1] + 2;
+
+	    auto f4 = pow(x1,2)*x4*params[2] + x1*x2*x4*params[3] + x2*x2*x4*params[0] + x3*x3*x4*params[1] + x4*x4*x4*params[2] + x4*params[3] - 3;
+
+	    // make an empty system
+	    bertini::System Sys;
+
+	    // add the functions.  we could elide the `auto` construction above and construct directly into the system if we wanted
+	    Sys.AddFunction(f1);
+	    Sys.AddFunction(f2);
+	    Sys.AddFunction(f3);
+	    Sys.AddFunction(f4);
+
+	    // make an affine variable group
+	    bertini::VariableGroup vg{x1, x2, x3, x4};
+	    Sys.AddVariableGroup(vg);
+        
+        Sys.Differentiate();
+
+	    return Sys;
+	}
+    
+    
+    template<typename CType>
+    auto GenerateSystemInput(bertini::System S, unsigned int prec=16)
+    {
+        int num_variables = S.NumVariables();
+        
+        Vec<CType> v(num_variables);
+        
+        bertini::DefaultPrecision(prec);
+        for(int ii = 0; ii < num_variables; ++ii)
+        {
+            v(ii) = CType(3)*bertini::RandomUnit<CType>();
+        }
+        
+        return v;
+    }
+    
+    
+    template<typename CType>
+    auto GenerateRHS(bertini::System S, unsigned int prec=16)
+    {
+        auto num_functions = S.NumFunctions();
+        
+        Vec<CType> b(num_functions);
+        
+        bertini::DefaultPrecision(prec);
+        for(int ii = 0; ii < num_functions; ++ii)
+        {
+            b(ii) = CType(3)*bertini::RandomUnit<CType>();
+        }
+        
+        return b;
+    }
+
+
+    template<typename CType>
+    auto GenerateMatrix(int N, unsigned int prec=16)
+    {
+        Mat<CType> A(N,N);
+        
+        bertini::DefaultPrecision(prec);
+        for(int ii = 0; ii < N; ++ii)
+        {
+            for(int jj = 0; jj < N; ++jj)
+            {
+                A(ii,jj) = CType(3)*bertini::RandomUnit<CType>();
+            }
+        }
+        
+        return A;
+    }
+
+
+} // namespace demo
+

core/example/performance_numbers/include/performance_tests.hpp

@@ -0,0 +1,34 @@
+//
+//  performance_tests.hpp
+//  Xcode_b2
+//
+//  Created by Jeb Collins University of Mary Washington. All rights reserved.
+//
+
+#ifndef performance_tests_h
+#define performance_tests_h
+#include "construct_system.hpp"
+
+template<typename CType>
+void EvalAndLUTests(const bertini::System& S, const bertini::Vec<CType>& v,
+                      const bertini::Vec<CType>& b, int num_times)
+{
+    auto J = S.Jacobian(v);
+    for(int ii = 0; ii < num_times; ++ii)
+    {
+        S.Reset();
+        J = S.Jacobian(v);
+        J.lu().solve(b);
+    }
+}
+
+template<typename CType>
+void MatrixMultTests(const Mat<CType>& A, int num_times)
+{
+    for(int ii = 0; ii < num_times; ++ii)
+    {
+        A*A;
+    }
+}
+
+#endif /* performance_tests_h */

core/example/performance_numbers/src/main.cpp

@@ -0,0 +1,110 @@
+#include "performance_tests.hpp"
+#include <ctime>
+
+
+int main()
+{
+
+    int num_evaluations = 1; ///> Number of times to evaluate the Jacobian in each run
+    int num_test_runs = 5000; ///> number of times to run the test for average
+    int num_precisions = 20  ;  ///> number of different precisions to use
+    int max_precision = 308; ///> maximum precision used for testing
+    int matrix_N = 500; ///> size of matrix for matrix multiplication
+    
+    std::vector<int> precisions(num_precisions-1);
+    for(int P = 0; P < num_precisions-1; ++P)
+    {
+        precisions[P] = std::floor(16 + ((max_precision)-16.0)/num_precisions*(P));
+    }
+    precisions.push_back(max_precision);
+    
+    
+    // Compute the time using CPU clock time, not wall clock time.
+    auto start = std::clock();
+    auto end = std::clock();
+
+    auto sys1 = demo::ConstructSystem1();
+
+    
+    
+    
+    
+    auto v_d = demo::GenerateSystemInput<dbl>(sys1);
+    auto b_d = demo::GenerateRHS<dbl>(sys1);
+    auto A_d = demo::GenerateMatrix<dbl>(matrix_N);
+    auto v_mp = demo::GenerateSystemInput<mpfr>(sys1);
+    auto b_mp = demo::GenerateRHS<mpfr>(sys1);
+    auto A_mp = demo::GenerateMatrix<mpfr>(matrix_N);
+    
+    
+    //Get base number for double precision
+    std::cout << "\n\n\nTesting Jacobian evaluation, matrix multiplication, and LU decomposition in double precision:\n\n";
+    double time_delta_d = 0;
+    for(int ii = 0; ii < num_test_runs; ++ii)
+    {
+        start = std::clock();
+        EvalAndLUTests(sys1, v_d, b_d, num_evaluations);
+        MatrixMultTests(A_d, 100*num_evaluations);
+        end = std::clock();
+        time_delta_d += (double)(end-start)/(double)(CLOCKS_PER_SEC);
+    }
+    time_delta_d = time_delta_d/num_test_runs;
+
+    
+    std::cout << "Average time taken:\n";
+    std::cout << time_delta_d << std::endl << std::endl;
+
+    
+    // Now work with various precisions for mpfr
+    std::cout << "Testing Jacobian evaluation, matrix multiplication, and LU decomposition in multiple precision:\n\n";
+    Vec<double> time_delta_mp(num_precisions);
+    for(int PP = 0; PP < num_precisions; ++PP)
+    {
+        std::cout << "Evaluating with precision " << precisions[PP] << "...\n";
+        time_delta_mp(PP) = 0;
+        v_mp = demo::GenerateSystemInput<mpfr>(sys1, precisions[PP]);
+        b_mp = demo::GenerateRHS<mpfr>(sys1, Precision(v_mp));
+        sys1.precision(Precision(v_mp));
+        for(int ii = 0; ii < num_test_runs; ++ii)
+        {
+            start = std::clock();
+            EvalAndLUTests(sys1, v_mp, b_mp, num_evaluations);
+            MatrixMultTests(A_mp, 100*num_evaluations);
+            end = std::clock();
+            time_delta_mp(PP) += (double)(end-start)/(double)(CLOCKS_PER_SEC);
+        }
+        time_delta_mp(PP) = time_delta_mp(PP)/num_test_runs;
+    }
+    
+    
+    
+//    std::cout << time_delta_mp << std::endl;
+    
+    auto time_factors = time_delta_mp/time_delta_d;
+    
+    
+    // Compute coefficient for linear fit
+    Mat<double> M(2,2);
+    Vec<double> b(2);
+    
+    M(0,0) = num_precisions;
+    M(0,1) = 0;
+    M(1,1) = 0;
+    b(0) = 0; b(1) = 0;
+    for(int ii = 0; ii < num_precisions; ++ii)
+    {
+        M(0,1) += precisions[ii];
+        M(1,1) += pow(precisions[ii],2);
+        b(0) += time_factors(ii);
+        b(1) += precisions[ii]*time_factors(ii);
+    }
+    M(1,0) = M(0,1);
+    
+    Vec<double> x = M.lu().solve(b);
+    
+//    std::cout << x(0) << std::endl;
+    std::cout << "y(P) = "<< x(1)<<"*P + "<< x(0) << std::endl;
+    
+    
+	return 0;
+}