an.tsouchlos/b2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add files

Browse Source
This commit is contained in:
Andreas Tsouchlos
2025-01-14 01:15:48 +01:00
commit 2f9fcec55b
406 changed files with 87154 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
core/include/bertini2/blackbox/algorithm_builder.hpp Normal file
View File

@@ -0,0 +1,74 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/algorithm_builder.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/algorithm_builder.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/algorithm_builder.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2017-2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// individual authors of this file include
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file include/bertini2/blackbox/algorithm_builder.hpp
\brief A type which determines which algorithms etc, to run, and sets them up.
*/
#pragma once
#include "bertini2/io/file_utilities.hpp"
namespace bertini {
namespace blackbox {
/**
\brief A de-serializer, whose responsibility it is to construct runnable objects based on input files.
This class is inspired by the SimBuilder class from Hythem Sidky's SAPHRON package for molecular dynamics.
*/
class AlgoBuilder
{
public:
AlgoBuilder() = default;
/**
\brief Method for constructing an algorithm from a bertini classic input file
*/
int ClassicBuild(boost::filesystem::path const& input_file);
/**
\brief Returns a non-owning pointer to the built algorithm
*/
AnyAlgorithm* GetAlg()
{
return alg_.get();
}
private:
std::unique_ptr<AnyAlgorithm> alg_;
};
} // blackbox
} //namespace bertini

41
core/include/bertini2/blackbox/argc_argv.hpp Normal file
View File

@@ -0,0 +1,41 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/argc_argv.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/argc_argv.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/argc_argv.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2015 - 2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
/**
\file bertini2/blackbox/argc_argv.hpp
\brief Provides the methods for parsing the command-line arguments.
*/
#pragma once
namespace bertini{
/**
Main initial function for doing stuff to interpret the command-line arguments for invokation of the program.
\param argc The number of arguments to the program. Must be at least one.
\param argv array of character arrays, the arguments to the program when called.
*/
void ParseArgcArgv(int argc, char** argv);
} //namespace bertini

73
core/include/bertini2/blackbox/config.hpp Normal file
View File

@@ -0,0 +1,73 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/config.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/config.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/config.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2017-2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file bertini2/blackbox/config.hpp
\brief Configs for the blackbox whatnot
*/
#pragma once
namespace bertini{
namespace blackbox{
namespace type{
enum class Start{ TotalDegree, MHom, User};
enum class Tracker{ FixedDouble, FixedMultiple, Adaptive};
enum class Endgame{ PowerSeries, Cauchy};
}
template<typename T>
struct StorageSelector{};
template<>
struct StorageSelector<start_system::User>
{
using ShouldClone = typename std::false_type;
// typename algorithm::StorageSelector<StartType>::Storage
// using Storage = typename policy::RefToGiven<System, start_system::User>;
};
template<>
struct StorageSelector<start_system::TotalDegree>
{
// using Storage = typename policy::CloneGiven<System, start_system::TotalDegree>;
// typedef policy::CloneGiven Storage;
using ShouldClone = typename std::true_type;
// using Storage = typename policy::CloneGiven;
};
template<>
struct StorageSelector<start_system::MHomogeneous>
{
using ShouldClone = typename std::true_type;
// template < typename T, typename S>
// using Storage = typename policy::CloneGiven<T,S>;
};
}
}

83
core/include/bertini2/blackbox/global_configs.hpp Normal file
View File

@@ -0,0 +1,83 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/global_configs.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/global_configs.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/global_configs.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2017-2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file bertini2/blackbox/global_configs.hpp
\brief Provides types and utilities for dealing with global defaults for the blackbox routines
*/
#pragma once
#include "bertini2/detail/typelist.hpp"
#include "bertini2/detail/configured.hpp"
#include "bertini2/trackers/config.hpp"
#include "bertini2/endgames/config.hpp"
#include "bertini2/nag_algorithms/common/config.hpp"
namespace bertini{
namespace blackbox{
namespace config {
namespace {
using namespace tracking;
using namespace endgame;
using namespace algorithm;
}
struct Configs
{
using Tracking = detail::TypeList<SteppingConfig, NewtonConfig, FixedPrecisionConfig, AdaptiveMultiplePrecisionConfig, tracking::PrecisionType, Predictor>;
using Endgame = detail::TypeList<SecurityConfig, EndgameConfig, PowerSeriesConfig, CauchyConfig, TrackBackConfig>;
template<typename T>
using Algorithm = detail::TypeList<TolerancesConfig, MidPathConfig, AutoRetrackConfig, SharpeningConfig, RegenerationConfig, PostProcessingConfig, ZeroDimConfig<T>, classic::AlgoChoice>;
template<typename T>
using All = detail::ListCat<Tracking, Endgame, Algorithm<T>>;
};
struct Defaults :
detail::Configured<Configs::All<bertini::dbl>, Configs::All<bertini::mpfr_complex>>
{
};
}
} // namespace blackbox
} // namespace bertini

40
core/include/bertini2/blackbox/main_mode_switch.hpp Normal file
View File

@@ -0,0 +1,40 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/main_mode_switch.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/main_mode_switch.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/main_mode_switch.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2015 - 2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file bertini2/blackbox/main_mode_switch.hpp
\brief Provides the main mode switch for the Bertini2 executable program.
*/
#pragma once
namespace bertini{
void MainModeSwitch();
}

135
core/include/bertini2/blackbox/switches_zerodim.hpp Normal file
View File

@@ -0,0 +1,135 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/switches_zerodim.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/switches_zerodim.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/switches_zerodim.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2017-2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file bertini2/blackbox/switches_zerodim.hpp
\brief A sequence of switches for getting a particular instantiation of a ZeroDim algorithm, based on runtime options.
*/
#pragma once
#include "bertini2/system.hpp"
#include "bertini2/nag_algorithms/zero_dim_solve.hpp"
#include "bertini2/endgames.hpp"
#include "bertini2/blackbox/config.hpp"
namespace bertini{
namespace blackbox{
struct ZeroDimRT
{
type::Start start = type::Start::TotalDegree;
type::Tracker tracker = type::Tracker::Adaptive;
type::Endgame endgame = type::Endgame::Cauchy;
};
template <typename StartType, typename TrackerType, typename EndgameType, template<typename,typename> class SystemManagementPol, typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyComplete(ConstTs const& ...ts)
{
return std::make_unique<
algorithm::ZeroDim<
TrackerType,
EndgameType,
System,
StartType,
SystemManagementPol>
>(ts...);
}
template <typename StartType, typename TrackerType, typename EndgameType, typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyShouldClone(std::true_type, ConstTs const& ...ts)
{
return ZeroDimSpecifyComplete<StartType, TrackerType,
typename endgame::EndgameSelector<TrackerType>::Cauchy, policy::CloneGiven>(ts...);
}
template <typename StartType, typename TrackerType, typename EndgameType, typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyShouldClone(std::false_type, ConstTs const& ...ts)
{
return ZeroDimSpecifyComplete<StartType, TrackerType,
typename endgame::EndgameSelector<TrackerType>::Cauchy, policy::RefToGiven>(ts...);
}
template <typename StartType, typename TrackerType, typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyEndgame(ZeroDimRT const& rt, ConstTs const& ...ts)
{
switch (rt.endgame)
{
case type::Endgame::PowerSeries:
return ZeroDimSpecifyShouldClone<StartType, TrackerType,
typename endgame::EndgameSelector<TrackerType>::PSEG>(typename StorageSelector<StartType>::ShouldClone(), ts...);
case type::Endgame::Cauchy:
return ZeroDimSpecifyShouldClone<StartType, TrackerType,
typename endgame::EndgameSelector<TrackerType>::Cauchy>(typename StorageSelector<StartType>::ShouldClone(), ts...);
}
}
template <typename StartType, typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyTracker(ZeroDimRT const& rt, ConstTs const& ...ts)
{
switch (rt.tracker)
{
case type::Tracker::FixedDouble:
return ZeroDimSpecifyEndgame<StartType, tracking::DoublePrecisionTracker>(rt, ts...);
case type::Tracker::FixedMultiple:
return ZeroDimSpecifyEndgame<StartType, tracking::MultiplePrecisionTracker>(rt, ts...);
case type::Tracker::Adaptive:
return ZeroDimSpecifyEndgame<StartType, tracking::AMPTracker>(rt, ts...);
}
}
template <typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> ZeroDimSpecifyStart(ZeroDimRT const& rt, ConstTs const& ...ts)
{
switch (rt.start)
{
case type::Start::TotalDegree:
return ZeroDimSpecifyTracker<start_system::TotalDegree>(rt, ts...);
case type::Start::MHom:
return ZeroDimSpecifyTracker<start_system::MHomogeneous>(rt, ts...);
case type::Start::User:
throw std::runtime_error("trying to use generic zero dim with user homotopy. use the specific UserBlaBla instead");
}
}
template <typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> MakeZeroDim(ZeroDimRT const& rt, ConstTs const& ...ts)
{
return ZeroDimSpecifyStart(rt, ts...);
}
} //ns blackbox
} //ns bertini

63
core/include/bertini2/blackbox/user_homotopy.hpp Normal file
View File

@@ -0,0 +1,63 @@
//This file is part of Bertini 2.
//
//bertini2/blackbox/switches_zerodim.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/blackbox/switches_zerodim.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/blackbox/switches_zerodim.hpp. If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2017-2021 by Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING. Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
//
// silviana amethyst, university of wisconsin-eau claire
/**
\file bertini2/blackbox/switches_zerodim.hpp
\brief A sequence of switches for getting a particular instantiation of a ZeroDim algorithm, based on runtime options.
*/
#pragma once
#include "bertini2/system.hpp"
#include "bertini2/nag_algorithms/zero_dim_solve.hpp"
#include "bertini2/endgames.hpp"
#include "bertini2/blackbox/config.hpp"
namespace bertini{
namespace blackbox{
template <typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> UserHomSpecifyStart(ZeroDimRT const& rt, ConstTs const& ...ts)
{
return ZeroDimSpecifyTracker<start_system::User>(rt, ts...);
}
template <typename ... ConstTs>
std::unique_ptr<algorithm::AnyZeroDim> MakeUserHom(ZeroDimRT const& rt, ConstTs const& ...ts)
{
return UserHomSpecifyStart(rt, ts...);
}
} //ns blackbox
} //ns bertini