diff --git a/ACKNOWLEDGEMENTS.html b/ACKNOWLEDGEMENTS.html
index 354bd46d..51b3db25 100644
--- a/ACKNOWLEDGEMENTS.html
+++ b/ACKNOWLEDGEMENTS.html
@@ -1224,4 +1224,10 @@ https://www.reddit.com/r/gamedev/comments/5iuf3h/i_am_writting_a_3d_monster_mode
A Fast Parallel Algorithm for Thinning Digital Patterns
https://dl.acm.org/citation.cfm?id=358023
+
+
+Huang, Jingwei and Zhou, Yichao and Niessner, Matthias and Shewchuk, Jonathan Richard and Guibas, Leonidas J.
+
+ QuadriFlow: A Scalable and Robust Method for Quadrangulation
+ http://stanford.edu/~jingweih/papers/quadriflow/
\ No newline at end of file
diff --git a/dust3d.pro b/dust3d.pro
index 47baa91a..3664a929 100644
--- a/dust3d.pro
+++ b/dust3d.pro
@@ -483,10 +483,64 @@ HEADERS += src/imageskeletonextractor.h
SOURCES += src/contourtopartconverter.cpp
HEADERS += src/contourtopartconverter.h
+SOURCES += src/remesher.cpp
+HEADERS += src/remesher.h
+
SOURCES += src/main.cpp
HEADERS += src/version.h
+INCLUDEPATH += thirdparty/QuadriFlow
+INCLUDEPATH += thirdparty/QuadriFlow/3rd/pcg32
+INCLUDEPATH += thirdparty/QuadriFlow/3rd/pss
+INCLUDEPATH += thirdparty/QuadriFlow/3rd/lemon-1.3.1
+
+SOURCES += thirdparty/QuadriFlow/src/adjacent-matrix.cpp
+HEADERS += thirdparty/QuadriFlow/src/adjacent-matrix.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/compare-key.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/config.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/dedge.cpp
+HEADERS += thirdparty/QuadriFlow/src/dedge.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/disajoint-tree.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/dset.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/field-math.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/flow.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/hierarchy.cpp
+HEADERS += thirdparty/QuadriFlow/src/hierarchy.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/loader.cpp
+HEADERS += thirdparty/QuadriFlow/src/loader.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/localsat.cpp
+HEADERS += thirdparty/QuadriFlow/src/localsat.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/merge-vertex.cpp
+HEADERS += thirdparty/QuadriFlow/src/merge-vertex.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/optimizer.cpp
+HEADERS += thirdparty/QuadriFlow/src/optimizer.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/parametrizer.cpp
+SOURCES += thirdparty/QuadriFlow/src/parametrizer-flip.cpp
+SOURCES += thirdparty/QuadriFlow/src/parametrizer-int.cpp
+SOURCES += thirdparty/QuadriFlow/src/parametrizer-mesh.cpp
+SOURCES += thirdparty/QuadriFlow/src/parametrizer-scale.cpp
+SOURCES += thirdparty/QuadriFlow/src/parametrizer-sing.cpp
+HEADERS += thirdparty/QuadriFlow/src/parametrizer.hpp
+
+HEADERS += thirdparty/QuadriFlow/src/serialize.hpp
+
+SOURCES += thirdparty/QuadriFlow/src/subdivide.cpp
+HEADERS += thirdparty/QuadriFlow/src/subdivide.hpp
+
INCLUDEPATH += thirdparty/bullet3/src
SOURCES += thirdparty/bullet3/src/LinearMath/btAlignedAllocator.cpp
diff --git a/src/meshgenerator.cpp b/src/meshgenerator.cpp
index e5119289..a926d74c 100644
--- a/src/meshgenerator.cpp
+++ b/src/meshgenerator.cpp
@@ -16,6 +16,7 @@
#include "imageforever.h"
#include "gridmeshbuilder.h"
#include "triangulatefaces.h"
+#include "remesher.h"
MeshGenerator::MeshGenerator(Snapshot *snapshot) :
m_snapshot(snapshot)
@@ -1310,6 +1311,25 @@ void MeshGenerator::generate()
m_outcome->vertices = combinedVertices;
m_outcome->triangles = combinedFaces;
m_outcome->paintMaps = componentCache.outcomePaintMaps;
+
+ /*
+ Remesher remesher;
+ remesher.setMesh(combinedVertices, combinedFaces);
+ remesher.remesh();
+ m_outcome->vertices = remesher.getRemeshedVertices();
+ const auto &remeshedFaces = remesher.getRemeshedFaces();
+ m_outcome->triangleAndQuads = remeshedFaces;
+ m_outcome->triangles.clear();
+ m_outcome->triangles.reserve(remeshedFaces.size() * 2);
+ for (const auto &it: remeshedFaces) {
+ m_outcome->triangles.push_back(std::vector {
+ it[0], it[1], it[2]
+ });
+ m_outcome->triangles.push_back(std::vector {
+ it[2], it[3], it[0]
+ });
+ }
+ */
}
// Recursively check uncombined components
diff --git a/src/remesher.cpp b/src/remesher.cpp
new file mode 100644
index 00000000..a71aba4a
--- /dev/null
+++ b/src/remesher.cpp
@@ -0,0 +1,109 @@
+#include
+#include
+#include
+#include
+#ifdef WITH_CUDA
+#include
+#endif
+#include "remesher.h"
+
+using namespace qflow;
+
+Remesher::~Remesher()
+{
+}
+
+void Remesher::setMesh(const std::vector &vertices,
+ const std::vector> &triangles)
+{
+ m_vertices = vertices;
+ m_triangles = triangles;
+}
+
+const std::vector &Remesher::getRemeshedVertices()
+{
+ return m_remeshedVertices;
+}
+const std::vector> &Remesher::getRemeshedFaces()
+{
+ return m_remeshedFaces;
+}
+
+void Remesher::remesh()
+{
+ Parametrizer field;
+
+#ifdef WITH_CUDA
+ cudaFree(0);
+#endif
+
+ field.V.resize(3, m_vertices.size());
+ field.F.resize(3, m_triangles.size());
+ for (decltype(m_vertices.size()) i = 0; i < m_vertices.size(); i++) {
+ const auto &vertex = m_vertices[i];
+ field.V.col(i) << (double)vertex.x(), (double)vertex.y(), (double)vertex.z();
+ }
+ for (decltype(m_triangles.size()) i = 0; i < m_triangles.size(); i++) {
+ const auto &face = m_triangles[i];
+ field.F.col(i) << (uint32_t)face[0], (uint32_t)face[1], (uint32_t)face[2];
+ }
+ field.NormalizeMesh();
+
+ int faces = -1;
+ field.Initialize(faces);
+
+ if (field.flag_preserve_boundary) {
+ Hierarchy& hierarchy = field.hierarchy;
+ hierarchy.clearConstraints();
+ for (uint32_t i = 0; i < 3 * hierarchy.mF.cols(); ++i) {
+ if (hierarchy.mE2E[i] == -1) {
+ uint32_t i0 = hierarchy.mF(i % 3, i / 3);
+ uint32_t i1 = hierarchy.mF((i + 1) % 3, i / 3);
+ Vector3d p0 = hierarchy.mV[0].col(i0), p1 = hierarchy.mV[0].col(i1);
+ Vector3d edge = p1 - p0;
+ if (edge.squaredNorm() > 0) {
+ edge.normalize();
+ hierarchy.mCO[0].col(i0) = p0;
+ hierarchy.mCO[0].col(i1) = p1;
+ hierarchy.mCQ[0].col(i0) = hierarchy.mCQ[0].col(i1) = edge;
+ hierarchy.mCQw[0][i0] = hierarchy.mCQw[0][i1] = hierarchy.mCOw[0][i0] = hierarchy.mCOw[0][i1] =
+ 1.0;
+ }
+ }
+ }
+ hierarchy.propagateConstraints();
+ }
+
+ Optimizer::optimize_orientations(field.hierarchy);
+ field.ComputeOrientationSingularities();
+
+ if (field.flag_adaptive_scale == 1) {
+ field.EstimateSlope();
+ }
+
+ Optimizer::optimize_scale(field.hierarchy, field.rho, field.flag_adaptive_scale);
+ field.flag_adaptive_scale = 1;
+
+ Optimizer::optimize_positions(field.hierarchy, field.flag_adaptive_scale);
+ field.ComputePositionSingularities();
+
+ field.ComputeIndexMap();
+
+ m_remeshedVertices.reserve(field.O_compact.size());
+ for (size_t i = 0; i < field.O_compact.size(); ++i) {
+ auto t = field.O_compact[i] * field.normalize_scale + field.normalize_offset;
+ m_remeshedVertices.push_back(QVector3D(t[0], t[1], t[2]));
+ }
+ m_remeshedFaces.reserve(field.F_compact.size());
+ for (size_t i = 0; i < field.F_compact.size(); ++i) {
+ m_remeshedFaces.push_back(std::vector {
+ (size_t)field.F_compact[i][0],
+ (size_t)field.F_compact[i][1],
+ (size_t)field.F_compact[i][2],
+ (size_t)field.F_compact[i][3]
+ });
+ }
+
+ printf("m_remeshedVertices.size:%lu\r\n", m_remeshedVertices.size());
+ printf("m_remeshedFaces.size:%lu\r\n", m_remeshedFaces.size());
+}
diff --git a/src/remesher.h b/src/remesher.h
new file mode 100644
index 00000000..1a35515f
--- /dev/null
+++ b/src/remesher.h
@@ -0,0 +1,24 @@
+#ifndef DUST3D_REMESHER_H
+#define DUST3D_REMESHER_H
+#include
+#include
+#include
+
+class Remesher : public QObject
+{
+ Q_OBJECT
+public:
+ ~Remesher();
+ void setMesh(const std::vector &vertices,
+ const std::vector> &triangles);
+ void remesh();
+ const std::vector &getRemeshedVertices();
+ const std::vector> &getRemeshedFaces();
+private:
+ std::vector m_vertices;
+ std::vector> m_triangles;
+ std::vector m_remeshedVertices;
+ std::vector> m_remeshedFaces;
+};
+
+#endif
diff --git a/thirdparty/QuadriFlow/.clang-format b/thirdparty/QuadriFlow/.clang-format
new file mode 100755
index 00000000..3f406687
--- /dev/null
+++ b/thirdparty/QuadriFlow/.clang-format
@@ -0,0 +1,5 @@
+Language: Cpp
+BasedOnStyle: Google
+IndentWidth: 4
+Standard: Cpp11
+ColumnLimit: 99
diff --git a/thirdparty/QuadriFlow/.gitignore b/thirdparty/QuadriFlow/.gitignore
new file mode 100755
index 00000000..c92aebc8
--- /dev/null
+++ b/thirdparty/QuadriFlow/.gitignore
@@ -0,0 +1,293 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.o
+*.or
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+data/
+[Bb]uild/
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+**/Properties/launchSettings.json
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+open-wbo
+open-wbo_*
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Typescript v1 declaration files
+typings/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/CMakeLists.txt b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/CMakeLists.txt
new file mode 100755
index 00000000..113701d1
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.1)
+project(MapleCOMSPS_LRB)
+
+find_package(ZLIB)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+include_directories(${ZLIB_INCLUDE_DIRS})
+
+set(
+ minisat_SRC
+ core/Solver.cc
+ simp/Main.cc
+ simp/SimpSolver.cc
+ utils/Options.cc
+ utils/System.cc
+)
+
+add_executable(
+ minisat
+ ${minisat_SRC}
+)
+
+target_link_libraries(
+ minisat
+ ${ZLIB_LIBRARIES}
+)
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/LICENSE b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/LICENSE
new file mode 100755
index 00000000..9ecdbc93
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/LICENSE
@@ -0,0 +1,23 @@
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010 Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/README b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/README
new file mode 100755
index 00000000..e5e5617d
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/README
@@ -0,0 +1,24 @@
+================================================================================
+DIRECTORY OVERVIEW:
+
+mtl/ Mini Template Library
+utils/ Generic helper code (I/O, Parsing, CPU-time, etc)
+core/ A core version of the solver
+simp/ An extended solver with simplification capabilities
+README
+LICENSE
+
+================================================================================
+BUILDING: (release version: without assertions, statically linked, etc)
+
+export MROOT= (or setenv in cshell)
+cd { core | simp }
+gmake rs
+cp minisat_static /minisat
+
+================================================================================
+EXAMPLES:
+
+Run minisat with same heuristics as version 2.0:
+
+> minisat -no-luby -rinc=1.5 -phase-saving=0 -rnd-freq=0.02
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Dimacs.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Dimacs.h
new file mode 100755
index 00000000..a05e900c
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Dimacs.h
@@ -0,0 +1,89 @@
+/****************************************************************************************[Dimacs.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Dimacs_h
+#define Minisat_Dimacs_h
+
+#include
+
+#include "utils/ParseUtils.h"
+#include "core/SolverTypes.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// DIMACS Parser:
+
+template
+static void readClause(B& in, Solver& S, vec& lits) {
+ int parsed_lit, var;
+ lits.clear();
+ for (;;){
+ parsed_lit = parseInt(in);
+ if (parsed_lit == 0) break;
+ var = abs(parsed_lit)-1;
+ while (var >= S.nVars()) S.newVar();
+ lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
+ }
+}
+
+template
+static void parse_DIMACS_main(B& in, Solver& S) {
+ vec lits;
+ int vars = 0;
+ int clauses = 0;
+ int cnt = 0;
+ for (;;){
+ skipWhitespace(in);
+ if (*in == EOF) break;
+ else if (*in == 'p'){
+ if (eagerMatch(in, "p cnf")){
+ vars = parseInt(in);
+ clauses = parseInt(in);
+ // SATRACE'06 hack
+ // if (clauses > 4000000)
+ // S.eliminate(true);
+ }else{
+ printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+ }
+ } else if (*in == 'c' || *in == 'p')
+ skipLine(in);
+ else{
+ cnt++;
+ readClause(in, S, lits);
+ S.addClause_(lits); }
+ }
+ if (vars != S.nVars())
+ fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n");
+ if (cnt != clauses)
+ fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n");
+}
+
+// Inserts problem into solver.
+//
+template
+static void parse_DIMACS(gzFile input_stream, Solver& S) {
+ StreamBuffer in(input_stream);
+ parse_DIMACS_main(in, S); }
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Main.cc b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Main.cc
new file mode 100755
index 00000000..7c93befc
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Main.cc
@@ -0,0 +1,202 @@
+/*****************************************************************************************[Main.cc]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include
+
+#include
+#include
+
+#include "utils/System.h"
+#include "utils/ParseUtils.h"
+#include "utils/Options.h"
+#include "core/Dimacs.h"
+#include "core/Solver.h"
+
+using namespace Minisat;
+
+//=================================================================================================
+
+
+void printStats(Solver& solver)
+{
+ double cpu_time = cpuTime();
+// double mem_used = memUsedPeak();
+// printf("c restarts : %"PRIu64"\n", solver.starts);
+// printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time);
+// printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time);
+// printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
+// printf("c conflict literals : %-12"PRIu64" (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals);
+// if (mem_used != 0) printf("c Memory used : %.2f MB\n", mem_used);
+ printf("c CPU time : %g s\n", cpu_time);
+}
+
+
+static Solver* solver;
+// Terminate by notifying the solver and back out gracefully. This is mainly to have a test-case
+// for this feature of the Solver as it may take longer than an immediate call to '_exit()'.
+static void SIGINT_interrupt(int signum) { solver->interrupt(); }
+
+// Note that '_exit()' rather than 'exit()' has to be used. The reason is that 'exit()' calls
+// destructors and may cause deadlocks if a malloc/free function happens to be running (these
+// functions are guarded by locks for multithreaded use).
+static void SIGINT_exit(int signum) {
+ printf("\n"); printf("c *** INTERRUPTED ***\n");
+ if (solver->verbosity > 0){
+ printStats(*solver);
+ printf("\n"); printf("c *** INTERRUPTED ***\n"); }
+ _exit(1); }
+
+
+//=================================================================================================
+// Main:
+
+
+int main(int argc, char** argv)
+{
+ try {
+ setUsageHelp("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n");
+ printf("c This is COMiniSatPS.\n");
+
+#if defined(__linux__)
+ fpu_control_t oldcw, newcw;
+ _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw);
+ printf("c WARNING: for repeatability, setting FPU to use double precision\n");
+#endif
+ // Extra options:
+ //
+ IntOption verb ("MAIN", "verb", "Verbosity level (0=silent, 1=some, 2=more).", 1, IntRange(0, 2));
+ IntOption cpu_lim("MAIN", "cpu-lim","Limit on CPU time allowed in seconds.\n", INT32_MAX, IntRange(0, INT32_MAX));
+ IntOption mem_lim("MAIN", "mem-lim","Limit on memory usage in megabytes.\n", INT32_MAX, IntRange(0, INT32_MAX));
+
+ parseOptions(argc, argv, true);
+
+ Solver S;
+ double initial_time = cpuTime();
+
+ S.verbosity = verb;
+
+ solver = &S;
+ // Use signal handlers that forcibly quit until the solver will be able to respond to
+ // interrupts:
+ signal(SIGINT, SIGINT_exit);
+ signal(SIGXCPU,SIGINT_exit);
+
+ // Set limit on CPU-time:
+ if (cpu_lim != INT32_MAX){
+ rlimit rl;
+ getrlimit(RLIMIT_CPU, &rl);
+ if (rl.rlim_max == RLIM_INFINITY || (rlim_t)cpu_lim < rl.rlim_max){
+ rl.rlim_cur = cpu_lim;
+ if (setrlimit(RLIMIT_CPU, &rl) == -1)
+ printf("c WARNING! Could not set resource limit: CPU-time.\n");
+ } }
+
+ // Set limit on virtual memory:
+ if (mem_lim != INT32_MAX){
+ rlim_t new_mem_lim = (rlim_t)mem_lim * 1024*1024;
+ rlimit rl;
+ getrlimit(RLIMIT_AS, &rl);
+ if (rl.rlim_max == RLIM_INFINITY || new_mem_lim < rl.rlim_max){
+ rl.rlim_cur = new_mem_lim;
+ if (setrlimit(RLIMIT_AS, &rl) == -1)
+ printf("c WARNING! Could not set resource limit: Virtual memory.\n");
+ } }
+
+ if (argc == 1)
+ printf("c Reading from standard input... Use '--help' for help.\n");
+
+ gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
+ if (in == NULL)
+ printf("c ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1);
+
+ if (S.verbosity > 0){
+ printf("c ============================[ Problem Statistics ]=============================\n");
+ printf("c | |\n"); }
+
+ parse_DIMACS(in, S);
+ gzclose(in);
+ FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
+
+ if (S.verbosity > 0){
+ printf("c | Number of variables: %12d |\n", S.nVars());
+ printf("c | Number of clauses: %12d |\n", S.nClauses()); }
+
+ double parsed_time = cpuTime();
+ if (S.verbosity > 0){
+ printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time);
+ printf("c | |\n"); }
+
+ // Change to signal-handlers that will only notify the solver and allow it to terminate
+ // voluntarily:
+ signal(SIGINT, SIGINT_interrupt);
+ signal(SIGXCPU,SIGINT_interrupt);
+
+ if (!S.simplify()){
+ if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res);
+ if (S.verbosity > 0){
+ printf("c ===============================================================================\n");
+ printf("c Solved by unit propagation\n");
+ printStats(S);
+ printf("\n"); }
+ printf("s UNSATISFIABLE\n");
+ exit(20);
+ }
+
+ vec dummy;
+ lbool ret = S.solveLimited(dummy);
+ if (S.verbosity > 0){
+ printStats(S);
+ printf("\n"); }
+ printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n");
+ if (ret == l_True){
+ printf("v ");
+ for (int i = 0; i < S.nVars(); i++)
+ if (S.model[i] != l_Undef)
+ printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+ printf(" 0\n");
+ }
+
+ if (res != NULL){
+ if (ret == l_True){
+ fprintf(res, "SAT\n");
+ for (int i = 0; i < S.nVars(); i++)
+ if (S.model[i] != l_Undef)
+ fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+ fprintf(res, " 0\n");
+ }else if (ret == l_False)
+ fprintf(res, "UNSAT\n");
+ else
+ fprintf(res, "INDET\n");
+ fclose(res);
+ }
+
+#ifdef NDEBUG
+ exit(ret == l_True ? 10 : ret == l_False ? 20 : 0); // (faster than "return", which will invoke the destructor for 'Solver')
+#else
+ return (ret == l_True ? 10 : ret == l_False ? 20 : 0);
+#endif
+ } catch (OutOfMemoryException&){
+ printf("c ===============================================================================\n");
+ printf("s UNKNOWN\n");
+ exit(0);
+ }
+}
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Makefile b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Makefile
new file mode 100755
index 00000000..5de1f729
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Makefile
@@ -0,0 +1,4 @@
+EXEC = minisat
+DEPDIR = mtl utils
+
+include $(MROOT)/mtl/template.mk
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.cc b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.cc
new file mode 100755
index 00000000..39b1ddd8
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.cc
@@ -0,0 +1,1547 @@
+/***************************************************************************************[Solver.cc]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include
+
+#include "mtl/Sort.h"
+#include "core/Solver.h"
+
+using namespace Minisat;
+
+#ifdef BIN_DRUP
+int Solver::buf_len = 0;
+unsigned char Solver::drup_buf[2 * 1024 * 1024];
+unsigned char* Solver::buf_ptr = drup_buf;
+#endif
+
+//=================================================================================================
+// Options:
+
+
+static const char* _cat = "CORE";
+
+static DoubleOption opt_step_size (_cat, "step-size", "Initial step size", 0.40, DoubleRange(0, false, 1, false));
+static DoubleOption opt_step_size_dec (_cat, "step-size-dec","Step size decrement", 0.000001, DoubleRange(0, false, 1, false));
+static DoubleOption opt_min_step_size (_cat, "min-step-size","Minimal step size", 0.06, DoubleRange(0, false, 1, false));
+static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.80, DoubleRange(0, false, 1, false));
+static DoubleOption opt_clause_decay (_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false));
+static DoubleOption opt_random_var_freq (_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true));
+static DoubleOption opt_random_seed (_cat, "rnd-seed", "Used by the random variable selection", 91648253, DoubleRange(0, false, HUGE_VAL, false));
+static IntOption opt_ccmin_mode (_cat, "ccmin-mode", "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2));
+static IntOption opt_phase_saving (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
+static BoolOption opt_rnd_init_act (_cat, "rnd-init", "Randomize the initial activity", false);
+static IntOption opt_restart_first (_cat, "rfirst", "The base restart interval", 100, IntRange(1, INT32_MAX));
+static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 2, DoubleRange(1, false, HUGE_VAL, false));
+static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+Solver::Solver() :
+
+ // Parameters (user settable):
+ //
+ drup_file (NULL)
+ , verbosity (0)
+ , step_size (opt_step_size)
+ , step_size_dec (opt_step_size_dec)
+ , min_step_size (opt_min_step_size)
+ , timer (5000)
+ , var_decay (opt_var_decay)
+ , clause_decay (opt_clause_decay)
+ , random_var_freq (opt_random_var_freq)
+ , random_seed (opt_random_seed)
+ , VSIDS (false)
+ , ccmin_mode (opt_ccmin_mode)
+ , phase_saving (opt_phase_saving)
+ , rnd_pol (false)
+ , rnd_init_act (opt_rnd_init_act)
+ , garbage_frac (opt_garbage_frac)
+ , restart_first (opt_restart_first)
+ , restart_inc (opt_restart_inc)
+
+ // Parameters (the rest):
+ //
+ , learntsize_factor((double)1/(double)3), learntsize_inc(1.1)
+
+ // Parameters (experimental):
+ //
+ , learntsize_adjust_start_confl (100)
+ , learntsize_adjust_inc (1.5)
+
+ // Statistics: (formerly in 'SolverStats')
+ //
+ , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0), conflicts_VSIDS(0)
+ , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
+
+ , ok (true)
+ , cla_inc (1)
+ , var_inc (1)
+ , watches_bin (WatcherDeleted(ca))
+ , watches (WatcherDeleted(ca))
+ , qhead (0)
+ , simpDB_assigns (-1)
+ , simpDB_props (0)
+ , order_heap_CHB (VarOrderLt(activity_CHB))
+ , order_heap_VSIDS (VarOrderLt(activity_VSIDS))
+ , progress_estimate (0)
+ , remove_satisfied (true)
+
+ , core_lbd_cut (3)
+ , global_lbd_sum (0)
+ , lbd_queue (50)
+ , next_T2_reduce (10000)
+ , next_L_reduce (15000)
+
+ , counter (0)
+
+ // Resource constraints:
+ //
+ , conflict_budget (-1)
+ , propagation_budget (-1)
+ , asynch_interrupt (false)
+{}
+
+
+Solver::~Solver()
+{
+}
+
+
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+Var Solver::newVar(bool sign, bool dvar)
+{
+ int v = nVars();
+ watches_bin.init(mkLit(v, false));
+ watches_bin.init(mkLit(v, true ));
+ watches .init(mkLit(v, false));
+ watches .init(mkLit(v, true ));
+ assigns .push(l_Undef);
+ vardata .push(mkVarData(CRef_Undef, 0));
+ activity_CHB .push(0);
+ activity_VSIDS.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+
+ picked.push(0);
+ conflicted.push(0);
+ almost_conflicted.push(0);
+
+ seen .push(0);
+ seen2 .push(0);
+ polarity .push(sign);
+ decision .push();
+ trail .capacity(v+1);
+ setDecisionVar(v, dvar);
+
+ // Additional space needed for stamping.
+ // TODO: allocate exact memory.
+ seen .push(0);
+ discovered.push(0); discovered.push(0);
+ finished .push(0); finished .push(0);
+ observed .push(0); observed .push(0);
+ flag .push(0); flag .push(0);
+ root .push(lit_Undef); root .push(lit_Undef);
+ parent .push(lit_Undef); parent .push(lit_Undef);
+ return v;
+}
+
+
+bool Solver::addClause_(vec& ps)
+{
+ assert(decisionLevel() == 0);
+ if (!ok) return false;
+
+ // Check if clause is satisfied and remove false/duplicate literals:
+ sort(ps);
+ Lit p; int i, j;
+
+ if (drup_file){
+ add_oc.clear();
+ for (int i = 0; i < ps.size(); i++) add_oc.push(ps[i]); }
+
+ for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+ if (value(ps[i]) == l_True || ps[i] == ~p)
+ return true;
+ else if (value(ps[i]) != l_False && ps[i] != p)
+ ps[j++] = p = ps[i];
+ ps.shrink(i - j);
+
+ if (drup_file && i != j){
+#ifdef BIN_DRUP
+ binDRUP('a', ps, drup_file);
+ binDRUP('d', add_oc, drup_file);
+#else
+ for (int i = 0; i < ps.size(); i++)
+ fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+ fprintf(drup_file, "0\n");
+
+ fprintf(drup_file, "d ");
+ for (int i = 0; i < add_oc.size(); i++)
+ fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ if (ps.size() == 0)
+ return ok = false;
+ else if (ps.size() == 1){
+ uncheckedEnqueue(ps[0]);
+ return ok = (propagate() == CRef_Undef);
+ }else{
+ CRef cr = ca.alloc(ps, false);
+ clauses.push(cr);
+ attachClause(cr);
+ }
+
+ return true;
+}
+
+
+void Solver::attachClause(CRef cr) {
+ const Clause& c = ca[cr];
+ assert(c.size() > 1);
+ OccLists, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches;
+ ws[~c[0]].push(Watcher(cr, c[1]));
+ ws[~c[1]].push(Watcher(cr, c[0]));
+ if (c.learnt()) learnts_literals += c.size();
+ else clauses_literals += c.size(); }
+
+
+void Solver::detachClause(CRef cr, bool strict) {
+ const Clause& c = ca[cr];
+ assert(c.size() > 1);
+ OccLists, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches;
+
+ if (strict){
+ remove(ws[~c[0]], Watcher(cr, c[1]));
+ remove(ws[~c[1]], Watcher(cr, c[0]));
+ }else{
+ // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+ ws.smudge(~c[0]);
+ ws.smudge(~c[1]);
+ }
+
+ if (c.learnt()) learnts_literals -= c.size();
+ else clauses_literals -= c.size(); }
+
+
+void Solver::removeClause(CRef cr) {
+ Clause& c = ca[cr];
+
+ if (drup_file){
+ if (c.mark() != 1){
+#ifdef BIN_DRUP
+ binDRUP('d', c, drup_file);
+#else
+ fprintf(drup_file, "d ");
+ for (int i = 0; i < c.size(); i++)
+ fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }else
+ printf("c Bug: removeClause(). I don't expect this to happen.\n");
+ }
+
+ detachClause(cr);
+ // Don't leave pointers to free'd memory!
+ if (locked(c)){
+ Lit implied = c.size() != 2 ? c[0] : (value(c[0]) == l_True ? c[0] : c[1]);
+ vardata[var(implied)].reason = CRef_Undef; }
+ c.mark(1);
+ ca.free(cr);
+}
+
+
+bool Solver::satisfied(const Clause& c) const {
+ for (int i = 0; i < c.size(); i++)
+ if (value(c[i]) == l_True)
+ return true;
+ return false; }
+
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+void Solver::cancelUntil(int level) {
+ if (decisionLevel() > level){
+ for (int c = trail.size()-1; c >= trail_lim[level]; c--){
+ Var x = var(trail[c]);
+
+ if (!VSIDS){
+ uint32_t age = conflicts - picked[x];
+ if (age > 0){
+ double adjusted_reward = ((double) (conflicted[x] + almost_conflicted[x])) / ((double) age);
+ double old_activity = activity_CHB[x];
+ activity_CHB[x] = step_size * adjusted_reward + ((1 - step_size) * old_activity);
+ if (order_heap_CHB.inHeap(x)){
+ if (activity_CHB[x] > old_activity)
+ order_heap_CHB.decrease(x);
+ else
+ order_heap_CHB.increase(x);
+ }
+ }
+ }
+
+ assigns [x] = l_Undef;
+ if (phase_saving > 1 || (phase_saving == 1) && c > trail_lim.last())
+ polarity[x] = sign(trail[c]);
+ insertVarOrder(x); }
+ qhead = trail_lim[level];
+ trail.shrink(trail.size() - trail_lim[level]);
+ trail_lim.shrink(trail_lim.size() - level);
+ } }
+
+
+//=================================================================================================
+// Major methods:
+
+
+Lit Solver::pickBranchLit()
+{
+ Var next = var_Undef;
+ Heap& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB;
+
+ // Random decision:
+ /*if (drand(random_seed) < random_var_freq && !order_heap.empty()){
+ next = order_heap[irand(random_seed,order_heap.size())];
+ if (value(next) == l_Undef && decision[next])
+ rnd_decisions++; }*/
+
+ // Activity based decision:
+ while (next == var_Undef || value(next) != l_Undef || !decision[next])
+ if (order_heap.empty())
+ return lit_Undef;
+ else
+ next = order_heap.removeMin();
+
+ return mkLit(next, polarity[next]);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+| analyze : (confl : Clause*) (out_learnt : vec&) (out_btlevel : int&) -> [void]
+|
+| Description:
+| Analyze conflict and produce a reason clause.
+|
+| Pre-conditions:
+| * 'out_learnt' is assumed to be cleared.
+| * Current decision level must be greater than root level.
+|
+| Post-conditions:
+| * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+| * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the
+| rest of literals. There may be others from the same level though.
+|
+|________________________________________________________________________________________________@*/
+void Solver::analyze(CRef confl, vec& out_learnt, int& out_btlevel, int& out_lbd)
+{
+ int pathC = 0;
+ Lit p = lit_Undef;
+
+ // Generate conflict clause:
+ //
+ out_learnt.push(); // (leave room for the asserting literal)
+ int index = trail.size() - 1;
+
+ do{
+ assert(confl != CRef_Undef); // (otherwise should be UIP)
+ Clause& c = ca[confl];
+
+ // For binary clauses, we don't rearrange literals in propagate(), so check and make sure the first is an implied lit.
+ if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False){
+ assert(value(c[1]) == l_True);
+ Lit tmp = c[0];
+ c[0] = c[1], c[1] = tmp; }
+
+ // Update LBD if improved.
+ if (c.learnt() && c.mark() != CORE){
+ int lbd = computeLBD(c);
+ if (lbd < c.lbd()){
+ if (c.lbd() <= 30) c.removable(false); // Protect once from reduction.
+ c.set_lbd(lbd);
+ if (lbd <= core_lbd_cut){
+ learnts_core.push(confl);
+ c.mark(CORE);
+ }else if (lbd <= 6 && c.mark() == LOCAL){
+ // Bug: 'cr' may already be in 'learnts_tier2', e.g., if 'cr' was demoted from TIER2
+ // to LOCAL previously and if that 'cr' is not cleaned from 'learnts_tier2' yet.
+ learnts_tier2.push(confl);
+ c.mark(TIER2); }
+ }
+
+ if (c.mark() == TIER2)
+ c.touched() = conflicts;
+ else if (c.mark() == LOCAL)
+ claBumpActivity(c);
+ }
+
+ for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+ Lit q = c[j];
+
+ if (!seen[var(q)] && level(var(q)) > 0){
+ if (VSIDS){
+ varBumpActivity(var(q), .5);
+ add_tmp.push(q);
+ }else
+ conflicted[var(q)]++;
+ seen[var(q)] = 1;
+ if (level(var(q)) >= decisionLevel()){
+ pathC++;
+ }else
+ out_learnt.push(q);
+ }
+ }
+
+ // Select next clause to look at:
+ while (!seen[var(trail[index--])]);
+ p = trail[index+1];
+ confl = reason(var(p));
+ seen[var(p)] = 0;
+ pathC--;
+
+ }while (pathC > 0);
+ out_learnt[0] = ~p;
+
+ // Simplify conflict clause:
+ //
+ int i, j;
+ out_learnt.copyTo(analyze_toclear);
+ if (ccmin_mode == 2){
+ uint32_t abstract_level = 0;
+ for (i = 1; i < out_learnt.size(); i++)
+ abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+ for (i = j = 1; i < out_learnt.size(); i++)
+ if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+ out_learnt[j++] = out_learnt[i];
+
+ }else if (ccmin_mode == 1){
+ for (i = j = 1; i < out_learnt.size(); i++){
+ Var x = var(out_learnt[i]);
+
+ if (reason(x) == CRef_Undef)
+ out_learnt[j++] = out_learnt[i];
+ else{
+ Clause& c = ca[reason(var(out_learnt[i]))];
+ for (int k = c.size() == 2 ? 0 : 1; k < c.size(); k++)
+ if (!seen[var(c[k])] && level(var(c[k])) > 0){
+ out_learnt[j++] = out_learnt[i];
+ break; }
+ }
+ }
+ }else
+ i = j = out_learnt.size();
+
+ max_literals += out_learnt.size();
+ out_learnt.shrink(i - j);
+ tot_literals += out_learnt.size();
+
+ out_lbd = computeLBD(out_learnt);
+ if (out_lbd <= 6 && out_learnt.size() <= 30) // Try further minimization?
+ if (binResMinimize(out_learnt))
+ out_lbd = computeLBD(out_learnt); // Recompute LBD if minimized.
+
+ // Find correct backtrack level:
+ //
+ if (out_learnt.size() == 1)
+ out_btlevel = 0;
+ else{
+ int max_i = 1;
+ // Find the first literal assigned at the next-highest level:
+ for (int i = 2; i < out_learnt.size(); i++)
+ if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+ max_i = i;
+ // Swap-in this literal at index 1:
+ Lit p = out_learnt[max_i];
+ out_learnt[max_i] = out_learnt[1];
+ out_learnt[1] = p;
+ out_btlevel = level(var(p));
+ }
+
+ if (VSIDS){
+ for (int i = 0; i < add_tmp.size(); i++){
+ Var v = var(add_tmp[i]);
+ if (level(v) >= out_btlevel - 1)
+ varBumpActivity(v, 1);
+ }
+ add_tmp.clear();
+ }else{
+ seen[var(p)] = true;
+ for(int i = out_learnt.size() - 1; i >= 0; i--){
+ Var v = var(out_learnt[i]);
+ CRef rea = reason(v);
+ if (rea != CRef_Undef){
+ const Clause& reaC = ca[rea];
+ for (int i = 0; i < reaC.size(); i++){
+ Lit l = reaC[i];
+ if (!seen[var(l)]){
+ seen[var(l)] = true;
+ almost_conflicted[var(l)]++;
+ analyze_toclear.push(l); } } } } }
+
+ for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared)
+}
+
+
+// Try further learnt clause minimization by means of binary clause resolution.
+bool Solver::binResMinimize(vec& out_learnt)
+{
+ // Preparation: remember which false variables we have in 'out_learnt'.
+ counter++;
+ for (int i = 1; i < out_learnt.size(); i++)
+ seen2[var(out_learnt[i])] = counter;
+
+ // Get the list of binary clauses containing 'out_learnt[0]'.
+ const vec& ws = watches_bin[~out_learnt[0]];
+
+ int to_remove = 0;
+ for (int i = 0; i < ws.size(); i++){
+ Lit the_other = ws[i].blocker;
+ // Does 'the_other' appear negatively in 'out_learnt'?
+ if (seen2[var(the_other)] == counter && value(the_other) == l_True){
+ to_remove++;
+ seen2[var(the_other)] = counter - 1; // Remember to remove this variable.
+ }
+ }
+
+ // Shrink.
+ if (to_remove > 0){
+ int last = out_learnt.size() - 1;
+ for (int i = 1; i < out_learnt.size() - to_remove; i++)
+ if (seen2[var(out_learnt[i])] != counter)
+ out_learnt[i--] = out_learnt[last--];
+ out_learnt.shrink(to_remove);
+ }
+ return to_remove != 0;
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+ analyze_stack.clear(); analyze_stack.push(p);
+ int top = analyze_toclear.size();
+ while (analyze_stack.size() > 0){
+ assert(reason(var(analyze_stack.last())) != CRef_Undef);
+ Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop();
+
+ // Special handling for binary clauses like in 'analyze()'.
+ if (c.size() == 2 && value(c[0]) == l_False){
+ assert(value(c[1]) == l_True);
+ Lit tmp = c[0];
+ c[0] = c[1], c[1] = tmp; }
+
+ for (int i = 1; i < c.size(); i++){
+ Lit p = c[i];
+ if (!seen[var(p)] && level(var(p)) > 0){
+ if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){
+ seen[var(p)] = 1;
+ analyze_stack.push(p);
+ analyze_toclear.push(p);
+ }else{
+ for (int j = top; j < analyze_toclear.size(); j++)
+ seen[var(analyze_toclear[j])] = 0;
+ analyze_toclear.shrink(analyze_toclear.size() - top);
+ return false;
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+| analyzeFinal : (p : Lit) -> [void]
+|
+| Description:
+| Specialized analysis procedure to express the final conflict in terms of assumptions.
+| Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+| stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+void Solver::analyzeFinal(Lit p, vec& out_conflict)
+{
+ out_conflict.clear();
+ out_conflict.push(p);
+
+ if (decisionLevel() == 0)
+ return;
+
+ seen[var(p)] = 1;
+
+ for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+ Var x = var(trail[i]);
+ if (seen[x]){
+ if (reason(x) == CRef_Undef){
+ assert(level(x) > 0);
+ out_conflict.push(~trail[i]);
+ }else{
+ Clause& c = ca[reason(x)];
+ for (int j = c.size() == 2 ? 0 : 1; j < c.size(); j++)
+ if (level(var(c[j])) > 0)
+ seen[var(c[j])] = 1;
+ }
+ seen[x] = 0;
+ }
+ }
+
+ seen[var(p)] = 0;
+}
+
+
+void Solver::uncheckedEnqueue(Lit p, CRef from)
+{
+ assert(value(p) == l_Undef);
+ Var x = var(p);
+ if (!VSIDS){
+ picked[x] = conflicts;
+ conflicted[x] = 0;
+ almost_conflicted[x] = 0;
+ }
+
+ assigns[x] = lbool(!sign(p));
+ vardata[x] = mkVarData(from, decisionLevel());
+ trail.push_(p);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+| propagate : [void] -> [Clause*]
+|
+| Description:
+| Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+| otherwise CRef_Undef.
+|
+| Post-conditions:
+| * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+CRef Solver::propagate()
+{
+ CRef confl = CRef_Undef;
+ int num_props = 0;
+ watches.cleanAll();
+ watches_bin.cleanAll();
+
+ while (qhead < trail.size()){
+ Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
+ vec& ws = watches[p];
+ Watcher *i, *j, *end;
+ num_props++;
+
+ vec& ws_bin = watches_bin[p]; // Propagate binary clauses first.
+ for (int k = 0; k < ws_bin.size(); k++){
+ Lit the_other = ws_bin[k].blocker;
+ if (value(the_other) == l_False){
+ confl = ws_bin[k].cref;
+#ifdef LOOSE_PROP_STAT
+ return confl;
+#else
+ goto ExitProp;
+#endif
+ }else if(value(the_other) == l_Undef)
+ uncheckedEnqueue(the_other, ws_bin[k].cref);
+ }
+
+ for (i = j = (Watcher*)ws, end = i + ws.size(); i != end;){
+ // Try to avoid inspecting the clause:
+ Lit blocker = i->blocker;
+ if (value(blocker) == l_True){
+ *j++ = *i++; continue; }
+
+ // Make sure the false literal is data[1]:
+ CRef cr = i->cref;
+ Clause& c = ca[cr];
+ Lit false_lit = ~p;
+ if (c[0] == false_lit)
+ c[0] = c[1], c[1] = false_lit;
+ assert(c[1] == false_lit);
+ i++;
+
+ // If 0th watch is true, then clause is already satisfied.
+ Lit first = c[0];
+ Watcher w = Watcher(cr, first);
+ if (first != blocker && value(first) == l_True){
+ *j++ = w; continue; }
+
+ // Look for new watch:
+ for (int k = 2; k < c.size(); k++)
+ if (value(c[k]) != l_False){
+ c[1] = c[k]; c[k] = false_lit;
+ watches[~c[1]].push(w);
+ goto NextClause; }
+
+ // Did not find watch -- clause is unit under assignment:
+ *j++ = w;
+ if (value(first) == l_False){
+ confl = cr;
+ qhead = trail.size();
+ // Copy the remaining watches:
+ while (i < end)
+ *j++ = *i++;
+ }else
+ uncheckedEnqueue(first, cr);
+
+ NextClause:;
+ }
+ ws.shrink(i - j);
+ }
+
+ExitProp:;
+ propagations += num_props;
+ simpDB_props -= num_props;
+
+ return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+| reduceDB : () -> [void]
+|
+| Description:
+| Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+| clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt {
+ ClauseAllocator& ca;
+ reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {}
+ bool operator () (CRef x, CRef y) const { return ca[x].activity() < ca[y].activity(); }
+};
+void Solver::reduceDB()
+{
+ int i, j;
+ //if (local_learnts_dirty) cleanLearnts(learnts_local, LOCAL);
+ //local_learnts_dirty = false;
+
+ sort(learnts_local, reduceDB_lt(ca));
+
+ int limit = learnts_local.size() / 2;
+ for (i = j = 0; i < learnts_local.size(); i++){
+ Clause& c = ca[learnts_local[i]];
+ if (c.mark() == LOCAL)
+ if (c.removable() && !locked(c) && i < limit)
+ removeClause(learnts_local[i]);
+ else{
+ if (!c.removable()) limit++;
+ c.removable(true);
+ learnts_local[j++] = learnts_local[i]; }
+ }
+ learnts_local.shrink(i - j);
+
+ checkGarbage();
+}
+void Solver::reduceDB_Tier2()
+{
+ int i, j;
+ for (i = j = 0; i < learnts_tier2.size(); i++){
+ Clause& c = ca[learnts_tier2[i]];
+ if (c.mark() == TIER2)
+ if (!locked(c) && c.touched() + 30000 < conflicts){
+ learnts_local.push(learnts_tier2[i]);
+ c.mark(LOCAL);
+ //c.removable(true);
+ c.activity() = 0;
+ claBumpActivity(c);
+ }else
+ learnts_tier2[j++] = learnts_tier2[i];
+ }
+ learnts_tier2.shrink(i - j);
+}
+
+
+void Solver::removeSatisfied(vec& cs)
+{
+ int i, j;
+ for (i = j = 0; i < cs.size(); i++){
+ Clause& c = ca[cs[i]];
+ if (satisfied(c))
+ removeClause(cs[i]);
+ else
+ cs[j++] = cs[i];
+ }
+ cs.shrink(i - j);
+}
+
+void Solver::rebuildOrderHeap()
+{
+ vec vs;
+ for (Var v = 0; v < nVars(); v++)
+ if (decision[v] && value(v) == l_Undef)
+ vs.push(v);
+
+ order_heap_CHB .build(vs);
+ order_heap_VSIDS.build(vs);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+| simplify : [void] -> [bool]
+|
+| Description:
+| Simplify the clause database according to the current top-level assigment. Currently, the only
+| thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+bool Solver::simplify(bool do_stamping)
+{
+ assert(decisionLevel() == 0);
+
+ if (!ok || propagate() != CRef_Undef)
+ return ok = false;
+
+ if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+ return true;
+
+ // Remove satisfied clauses:
+ safeRemoveSatisfiedCompact(learnts_core, CORE);
+ safeRemoveSatisfiedCompact(learnts_tier2, TIER2);
+ safeRemoveSatisfiedCompact(learnts_local, LOCAL);
+ if (remove_satisfied) // Can be turned off.
+ removeSatisfied(clauses);
+
+ if (do_stamping)
+ ok = stampAll(true);
+
+ checkGarbage();
+ rebuildOrderHeap();
+
+ simpDB_assigns = nAssigns();
+ simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now)
+
+ return ok;
+}
+
+
+// TODO: very dirty and hackish.
+void Solver::removeClauseHack(CRef cr, Lit watched0, Lit watched1)
+{
+ assert(ca[cr].size() >= 2);
+
+ Clause& c = ca[cr];
+ if (drup_file) // Hackish.
+ if (c.mark() != 1){
+#ifdef BIN_DRUP
+ binDRUP('d', add_oc, drup_file); // 'add_oc' not 'c'.
+#else
+ for (int i = 0; i < add_oc.size(); i++)
+ fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }else
+ printf("c Bug: removeClauseHack(). I don't expect this to happen.\n");
+
+ // TODO: dirty hack to exploit 'detachClause'. 'c' hasn't shrunk yet, so this will work fine.
+ c[0] = watched0, c[1] = watched1;
+ detachClause(cr);
+ // Don't leave pointers to free'd memory!
+ if (locked(c)){
+ Lit implied = c.size() != 2 ? c[0] : (value(c[0]) == l_True ? c[0] : c[1]);
+ vardata[var(implied)].reason = CRef_Undef; }
+ c.mark(1);
+ ca.free(cr);
+}
+
+// TODO: needs clean up.
+void Solver::safeRemoveSatisfiedCompact(vec& cs, unsigned valid_mark)
+{
+ int i, j, k, l;
+ for (i = j = 0; i < cs.size(); i++){
+ Clause& c = ca[cs[i]];
+ if (c.mark() != valid_mark) continue;
+
+ Lit c0 = c[0], c1 = c[1];
+ if (drup_file){ // Remember the original clause before attempting to modify it.
+ add_oc.clear();
+ for (int i = 0; i < c.size(); i++) add_oc.push(c[i]); }
+
+ // Remove false literals at the same time.
+ for (k = l = 0; k < c.size(); k++)
+ if (value(c[k]) == l_True){
+ removeClauseHack(cs[i], c0, c1);
+ goto NextClause; // Clause already satisfied; forget about it.
+ }else if (value(c[k]) == l_Undef)
+ c[l++] = c[k];
+ assert(1 < l && l <= k);
+
+ // If became binary, we also need to migrate watchers. The easiest way is to allocate a new binary.
+ if (l == 2 && k != 2){
+ assert(add_tmp.size() == 0);
+ add_tmp.push(c[0]); add_tmp.push(c[1]);
+ bool learnt = c.learnt(); // Need a copy; see right below.
+ int lbd = c.lbd();
+ int m = c.mark();
+ CRef cr = ca.alloc(add_tmp, learnt); // Caution! 'alloc' may invalidate the 'c' reference.
+ if (learnt){
+ if (m != CORE) learnts_core.push(cr);
+ ca[cr].mark(CORE);
+ ca[cr].set_lbd(lbd > 2 ? 2 : lbd); }
+ attachClause(cr);
+
+ if (drup_file){
+#ifdef BIN_DRUP
+ binDRUP('a', add_tmp, drup_file);
+#else
+ for (int i = 0; i < add_tmp.size(); i++)
+ fprintf(drup_file, "%i ", (var(add_tmp[i]) + 1) * (-2 * sign(add_tmp[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+ add_tmp.clear();
+
+ removeClauseHack(cs[i], c0, c1);
+ cs[j++] = cr; // Should be after 'removeClauseHack' because 'i' may be equal to 'j'.
+ goto NextClause;
+ }
+
+ c.shrink(k - l); // FIXME: fix (statistical) memory leak.
+ if (c.learnt()) learnts_literals -= (k - l);
+ else clauses_literals -= (k - l);
+
+ if (drup_file && k != l){
+#ifdef BIN_DRUP
+ binDRUP('a', c, drup_file);
+ binDRUP('d', add_oc, drup_file);
+#else
+ for (int i = 0; i < c.size(); i++)
+ fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+ fprintf(drup_file, "0\n");
+
+ fprintf(drup_file, "d ");
+ for (int i = 0; i < add_oc.size(); i++)
+ fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ cs[j++] = cs[i];
+NextClause:;
+ }
+ cs.shrink(i - j);
+}
+
+/*_________________________________________________________________________________________________
+|
+| search : (nof_conflicts : int) (params : const SearchParams&) -> [lbool]
+|
+| Description:
+| Search for a model the specified number of conflicts.
+|
+| Output:
+| 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+| all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+| if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+lbool Solver::search(int& nof_conflicts)
+{
+ assert(ok);
+ int backtrack_level;
+ int lbd;
+ vec learnt_clause;
+ bool cached = false;
+ starts++;
+
+ for (;;){
+ CRef confl = propagate();
+
+ if (confl != CRef_Undef){
+ // CONFLICT
+ if (VSIDS){
+ if (--timer == 0 && var_decay < 0.95) timer = 5000, var_decay += 0.01;
+ }else
+ if (step_size > min_step_size) step_size -= step_size_dec;
+
+ conflicts++; nof_conflicts--;
+ if (conflicts == 100000 && learnts_core.size() < 100) core_lbd_cut = 5;
+ if (decisionLevel() == 0) return l_False;
+
+ learnt_clause.clear();
+ analyze(confl, learnt_clause, backtrack_level, lbd);
+ cancelUntil(backtrack_level);
+
+ lbd--;
+ if (VSIDS){
+ cached = false;
+ conflicts_VSIDS++;
+ lbd_queue.push(lbd);
+ global_lbd_sum += (lbd > 50 ? 50 : lbd); }
+
+ if (learnt_clause.size() == 1){
+ uncheckedEnqueue(learnt_clause[0]);
+ }else{
+ CRef cr = ca.alloc(learnt_clause, true);
+ ca[cr].set_lbd(lbd);
+ if (lbd <= core_lbd_cut){
+ learnts_core.push(cr);
+ ca[cr].mark(CORE);
+ }else if (lbd <= 6){
+ learnts_tier2.push(cr);
+ ca[cr].mark(TIER2);
+ ca[cr].touched() = conflicts;
+ }else{
+ learnts_local.push(cr);
+ claBumpActivity(ca[cr]); }
+ attachClause(cr);
+ uncheckedEnqueue(learnt_clause[0], cr);
+ }
+ if (drup_file){
+#ifdef BIN_DRUP
+ binDRUP('a', learnt_clause, drup_file);
+#else
+ for (int i = 0; i < learnt_clause.size(); i++)
+ fprintf(drup_file, "%i ", (var(learnt_clause[i]) + 1) * (-2 * sign(learnt_clause[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ if (VSIDS) varDecayActivity();
+ claDecayActivity();
+
+ /*if (--learntsize_adjust_cnt == 0){
+ learntsize_adjust_confl *= learntsize_adjust_inc;
+ learntsize_adjust_cnt = (int)learntsize_adjust_confl;
+ max_learnts *= learntsize_inc;
+
+ if (verbosity >= 1)
+ printf("c | %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n",
+ (int)conflicts,
+ (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals,
+ (int)max_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progressEstimate()*100);
+ }*/
+
+ }else{
+ // NO CONFLICT
+ bool restart = false;
+ if (!VSIDS)
+ restart = nof_conflicts <= 0;
+ else if (!cached){
+ restart = lbd_queue.full() && (lbd_queue.avg() * 0.8 > global_lbd_sum / conflicts_VSIDS);
+ cached = true;
+ }
+ if (restart /*|| !withinBudget()*/){
+ lbd_queue.clear();
+ cached = false;
+ // Reached bound on number of conflicts:
+ progress_estimate = progressEstimate();
+ cancelUntil(0);
+ return l_Undef; }
+
+ // Simplify the set of problem clauses:
+ if (decisionLevel() == 0 && !simplify(true))
+ return l_False;
+
+ if (conflicts >= next_T2_reduce){
+ next_T2_reduce = conflicts + 10000;
+ reduceDB_Tier2(); }
+ if (conflicts >= next_L_reduce){
+ next_L_reduce = conflicts + 15000;
+ reduceDB(); }
+
+ Lit next = lit_Undef;
+ /*while (decisionLevel() < assumptions.size()){
+ // Perform user provided assumption:
+ Lit p = assumptions[decisionLevel()];
+ if (value(p) == l_True){
+ // Dummy decision level:
+ newDecisionLevel();
+ }else if (value(p) == l_False){
+ analyzeFinal(~p, conflict);
+ return l_False;
+ }else{
+ next = p;
+ break;
+ }
+ }
+
+ if (next == lit_Undef)*/{
+ // New variable decision:
+ decisions++;
+ next = pickBranchLit();
+
+ if (next == lit_Undef)
+ // Model found:
+ return l_True;
+ }
+
+ // Increase decision level and enqueue 'next'
+ newDecisionLevel();
+ uncheckedEnqueue(next);
+ }
+ }
+}
+
+
+double Solver::progressEstimate() const
+{
+ double progress = 0;
+ double F = 1.0 / nVars();
+
+ for (int i = 0; i <= decisionLevel(); i++){
+ int beg = i == 0 ? 0 : trail_lim[i - 1];
+ int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+ progress += pow(F, i) * (end - beg);
+ }
+
+ return progress / nVars();
+}
+
+/*
+ Finite subsequences of the Luby-sequence:
+
+ 0: 1
+ 1: 1 1 2
+ 2: 1 1 2 1 1 2 4
+ 3: 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8
+ ...
+
+
+ */
+
+static double luby(double y, int x){
+
+ // Find the finite subsequence that contains index 'x', and the
+ // size of that subsequence:
+ int size, seq;
+ for (size = 1, seq = 0; size < x+1; seq++, size = 2*size+1);
+
+ while (size-1 != x){
+ size = (size-1)>>1;
+ seq--;
+ x = x % size;
+ }
+
+ return pow(y, seq);
+}
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+lbool Solver::solve_()
+{
+ model.clear();
+ conflict.clear();
+ if (!ok) return l_False;
+
+ solves++;
+
+ max_learnts = nClauses() * learntsize_factor;
+ learntsize_adjust_confl = learntsize_adjust_start_confl;
+ learntsize_adjust_cnt = (int)learntsize_adjust_confl;
+ lbool status = l_Undef;
+
+ if (verbosity >= 1){
+ printf("c ============================[ Search Statistics ]==============================\n");
+ printf("c | Conflicts | ORIGINAL | LEARNT | Progress |\n");
+ printf("c | | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
+ printf("c ===============================================================================\n");
+ }
+
+ add_tmp.clear();
+
+ VSIDS = true;
+ int init = 10000;
+ while (status == l_Undef && init > 0 /*&& withinBudget()*/)
+ status = search(init);
+ VSIDS = false;
+
+ // Search:
+ int phase_allotment = 100;
+ int curr_restarts = 0;
+ for (;;){
+ int weighted = phase_allotment;
+ fflush(stdout);
+
+ while (status == l_Undef && weighted > 0 /*&& withinBudget()*/)
+ if (VSIDS)
+ status = search(weighted);
+ else{
+ int nof_conflicts = luby(restart_inc, curr_restarts) * restart_first;
+ curr_restarts++;
+ weighted -= nof_conflicts;
+ status = search(nof_conflicts);
+ }
+
+ if (status != l_Undef /*|| !withinBudget()*/)
+ break; // Should break here for correctness in incremental SAT solving.
+
+ VSIDS = !VSIDS;
+ if (!VSIDS)
+ phase_allotment += phase_allotment / 10;
+ }
+
+ if (verbosity >= 1)
+ printf("c ===============================================================================\n");
+
+#ifdef BIN_DRUP
+ if (drup_file && status == l_False) binDRUP_flush(drup_file);
+#endif
+
+ if (status == l_True){
+ // Extend & copy model:
+ model.growTo(nVars());
+ for (int i = 0; i < nVars(); i++) model[i] = value(i);
+ }else if (status == l_False && conflict.size() == 0)
+ ok = false;
+
+ cancelUntil(0);
+ return status;
+}
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+//
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec& map, Var& max)
+{
+ if (map.size() <= x || map[x] == -1){
+ map.growTo(x+1, -1);
+ map[x] = max++;
+ }
+ return map[x];
+}
+
+
+void Solver::toDimacs(FILE* f, Clause& c, vec& map, Var& max)
+{
+ if (satisfied(c)) return;
+
+ for (int i = 0; i < c.size(); i++)
+ if (value(c[i]) != l_False)
+ fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1);
+ fprintf(f, "0\n");
+}
+
+
+void Solver::toDimacs(const char *file, const vec& assumps)
+{
+ FILE* f = fopen(file, "wr");
+ if (f == NULL)
+ fprintf(stderr, "could not open file %s\n", file), exit(1);
+ toDimacs(f, assumps);
+ fclose(f);
+}
+
+
+void Solver::toDimacs(FILE* f, const vec& assumps)
+{
+ // Handle case when solver is in contradictory state:
+ if (!ok){
+ fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+ return; }
+
+ vec map; Var max = 0;
+
+ // Cannot use removeClauses here because it is not safe
+ // to deallocate them at this point. Could be improved.
+ int cnt = 0;
+ for (int i = 0; i < clauses.size(); i++)
+ if (!satisfied(ca[clauses[i]]))
+ cnt++;
+
+ for (int i = 0; i < clauses.size(); i++)
+ if (!satisfied(ca[clauses[i]])){
+ Clause& c = ca[clauses[i]];
+ for (int j = 0; j < c.size(); j++)
+ if (value(c[j]) != l_False)
+ mapVar(var(c[j]), map, max);
+ }
+
+ // Assumptions are added as unit clauses:
+ cnt += assumptions.size();
+
+ fprintf(f, "p cnf %d %d\n", max, cnt);
+
+ for (int i = 0; i < assumptions.size(); i++){
+ assert(value(assumptions[i]) != l_False);
+ fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "", mapVar(var(assumptions[i]), map, max)+1);
+ }
+
+ for (int i = 0; i < clauses.size(); i++)
+ toDimacs(f, ca[clauses[i]], map, max);
+
+ if (verbosity > 0)
+ printf("c Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+void Solver::relocAll(ClauseAllocator& to)
+{
+ // All watchers:
+ //
+ // for (int i = 0; i < watches.size(); i++)
+ watches.cleanAll();
+ watches_bin.cleanAll();
+ for (int v = 0; v < nVars(); v++)
+ for (int s = 0; s < 2; s++){
+ Lit p = mkLit(v, s);
+ // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+ vec& ws = watches[p];
+ for (int j = 0; j < ws.size(); j++)
+ ca.reloc(ws[j].cref, to);
+ vec& ws_bin = watches_bin[p];
+ for (int j = 0; j < ws_bin.size(); j++)
+ ca.reloc(ws_bin[j].cref, to);
+ }
+
+ // All reasons:
+ //
+ for (int i = 0; i < trail.size(); i++){
+ Var v = var(trail[i]);
+
+ if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+ ca.reloc(vardata[v].reason, to);
+ }
+
+ // All learnt:
+ //
+ for (int i = 0; i < learnts_core.size(); i++)
+ ca.reloc(learnts_core[i], to);
+ for (int i = 0; i < learnts_tier2.size(); i++)
+ ca.reloc(learnts_tier2[i], to);
+ for (int i = 0; i < learnts_local.size(); i++)
+ ca.reloc(learnts_local[i], to);
+
+ // All original:
+ //
+ int i, j;
+ for (i = j = 0; i < clauses.size(); i++)
+ if (ca[clauses[i]].mark() != 1){
+ ca.reloc(clauses[i], to);
+ clauses[j++] = clauses[i]; }
+ clauses.shrink(i - j);
+}
+
+
+void Solver::garbageCollect()
+{
+ // Initialize the next region to a size corresponding to the estimated utilization degree. This
+ // is not precise but should avoid some unnecessary reallocations for the new region:
+ ClauseAllocator to(ca.size() - ca.wasted());
+
+ relocAll(to);
+ if (verbosity >= 2)
+ printf("c | Garbage collection: %12d bytes => %12d bytes |\n",
+ ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+ to.moveTo(ca);
+}
+
+
+inline int gcd(int a, int b) {
+ int tmp;
+ if (a < b) tmp = a, a = b, b = tmp;
+ while (b) tmp = b, b = a % b, a = tmp;
+ return a;
+}
+
+bool Solver::stampAll(bool use_bin_learnts)
+{
+ // Initialization.
+ int stamp_time = 0;
+ int nLits = 2*nVars();
+ for (int i = 0; i < nVars(); i++){
+ int m = i*2, n = i*2 + 1;
+ discovered[m] = discovered[n] = finished[m] = finished[n] = observed[m] = observed[n] = 0;
+ root[m] = root[n] = parent[m] = parent[n] = lit_Undef;
+ flag[m] = flag[n] = 0; }
+
+ for (int roots_only = 1; roots_only >= 0; roots_only--){
+ int l = irand(random_seed, nLits);
+ int l_inc = irand(random_seed, nLits-1) + 1; // Avoid 0 but ensure less than 'nLits'.
+ while (gcd(nLits, l_inc) > 1)
+ if (++l_inc == nLits) l_inc = 1;
+
+ int first = l;
+ do{
+ Lit p = toLit(l);
+ if (value(p) == l_Undef && !discovered[toInt(p)] &&
+ (!roots_only || isRoot(p, use_bin_learnts)) &&
+ implExistsByBin(p, use_bin_learnts)){
+ stamp_time = stamp(p, stamp_time, use_bin_learnts);
+
+ if (!ok || propagate() != CRef_Undef)
+ return ok = false;
+ }
+
+ // Compute next literal to look at.
+ l += l_inc;
+ if (l >= nLits) l -= nLits;
+
+ }while(l != first);
+ }
+
+ return true;
+}
+
+int Solver::stamp(Lit p, int stamp_time, bool use_bin_learnts)
+{
+ assert(value(p) == l_Undef && !discovered[toInt(p)] && !finished[toInt(p)]);
+ assert(rec_stack.size() == 0 && scc.size() == 0);
+
+ int start_stamp = 0;
+ rec_stack.push(Frame(Frame::START, p, lit_Undef, 0));
+
+ while (rec_stack.size()){
+ const Frame f = rec_stack.last(); rec_stack.pop();
+ int i_curr = toInt(f.curr);
+ int i_next = toInt(f.next);
+
+ if (f.type == Frame::START){
+ if (discovered[i_curr]){
+ observed[i_curr] = stamp_time;
+ continue; }
+
+ assert(!finished[i_curr]);
+ discovered[i_curr] = observed[i_curr] = ++stamp_time;
+
+ if (start_stamp == 0){
+ start_stamp = stamp_time;
+ root[i_curr] = f.curr;
+ assert(parent[i_curr] == lit_Undef); }
+ rec_stack.push(Frame(Frame::CLOSE, f.curr, lit_Undef, 0));
+
+ assert(!flag[i_curr]);
+ flag[i_curr] = 1;
+ scc.push(f.curr);
+
+ for (int undiscovered = 0; undiscovered <= 1; undiscovered++){
+ int prev_top = rec_stack.size();
+ analyze_toclear.clear();
+
+ const vec& ws = watches_bin[f.curr];
+ for (int k = 0; k < ws.size(); k++){
+ Lit the_other = ws[k].blocker;
+
+ if (value(the_other) == l_Undef
+ && !seen[toInt(the_other)]
+ && undiscovered == !discovered[toInt(the_other)])
+// && (use_bin_learnts || !ca[ws[k].cref].learnt()))
+ {
+ seen[toInt(the_other)] = 1;
+ analyze_toclear.push(the_other);
+
+ rec_stack.push(Frame(Frame::ENTER, f.curr, the_other, 0));
+ //rec_stack.push(Frame(Frame::ENTER, f.curr, the_other, ca[ws[k].cref].learnt()));
+ }
+ }
+ for (int k = 0; k < analyze_toclear.size(); k++) seen[toInt(analyze_toclear[k])] = 0;
+
+ // Now randomize child nodes to visit by shuffling pushed stack entries.
+ int stacked = rec_stack.size() - prev_top;
+ for (int i = 0; i < stacked - 1; i++){
+ int j = i + irand(random_seed, stacked - i); // i <= j < stacked
+ if (i != j){
+ Frame tmp = rec_stack[prev_top + i];
+ rec_stack[prev_top + i] = rec_stack[prev_top + j];
+ rec_stack[prev_top + j] = tmp; }
+ }
+ }
+
+ }else if (f.type == Frame::ENTER){
+ rec_stack.push(Frame(Frame::RETURN, f.curr, f.next, f.learnt));
+
+ int neg_observed = observed[toInt(~f.next)];
+ if (start_stamp <= neg_observed){ // Failed literal?
+ Lit failed;
+ for (failed = f.curr;
+ discovered[toInt(failed)] > neg_observed;
+ failed = parent[toInt(failed)])
+ assert(failed != lit_Undef);
+
+ if (drup_file && value(~failed) != l_True){
+#ifdef BIN_DRUP
+ assert(add_tmp.size() == 0);
+ add_tmp.push(~failed);
+ binDRUP('a', add_tmp, drup_file);
+ add_tmp.clear();
+#else
+ fprintf(drup_file, "%i 0\n", (var(~failed) + 1) * (-2 * sign(~failed) + 1));
+#endif
+ }
+
+ if (!(ok = enqueue(~failed)))
+ return -1; // Who cares what?
+
+ if (discovered[toInt(~f.next)] && !finished[toInt(~f.next)]){
+ rec_stack.pop(); // Skip this edge after a failed literal.
+ continue; }
+ }
+
+ if (!discovered[i_next]){
+ parent[i_next] = f.curr;
+ root[i_next] = p;
+ rec_stack.push(Frame(Frame::START, f.next, lit_Undef, 0)); }
+
+ }else if (f.type == Frame::RETURN){
+ if (!finished[i_next] && discovered[i_next] < discovered[i_curr]){
+ discovered[i_curr] = discovered[i_next];
+ flag[i_curr] = 0;
+ }
+ observed[i_next] = stamp_time;
+
+ }else if (f.type == Frame::CLOSE){
+ if (flag[i_curr]){
+ stamp_time++;
+ int curr_discovered = discovered[i_curr];
+ Lit q;
+ do{
+ q = scc.last(); scc.pop();
+ flag [toInt(q)] = 0;
+ discovered[toInt(q)] = curr_discovered;
+ finished [toInt(q)] = stamp_time;
+ }while (q != f.curr);
+ }
+
+ }else assert(false);
+ }
+
+ return stamp_time;
+}
+
+bool Solver::implExistsByBin(Lit p, bool use_bin_learnts) const {
+ assert(value(p) == l_Undef);
+
+ const vec& ws = watches_bin[p];
+ for (int i = 0; i < ws.size(); i++){
+ Lit the_other = ws[i].blocker;
+ assert(value(the_other) != l_False); // Propagate then.
+
+ if (value(the_other) != l_True && !discovered[toInt(the_other)])
+ if (use_bin_learnts || !ca[ws[i].cref].learnt())
+ return true;
+ }
+ return false;
+}
+
+bool Solver::isRoot(Lit p, bool use_bin_learnts) const { return !implExistsByBin(~p, use_bin_learnts); }
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.h
new file mode 100755
index 00000000..9efca16a
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/Solver.h
@@ -0,0 +1,524 @@
+/****************************************************************************************[Solver.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Solver_h
+#define Minisat_Solver_h
+
+#define BIN_DRUP
+
+#define GLUCOSE23
+//#define INT_QUEUE_AVG
+//#define LOOSE_PROP_STAT
+
+#ifdef GLUCOSE23
+ #define INT_QUEUE_AVG
+ #define LOOSE_PROP_STAT
+#endif
+
+#include "mtl/Vec.h"
+#include "mtl/Heap.h"
+#include "mtl/Alg.h"
+#include "utils/Options.h"
+#include "core/SolverTypes.h"
+
+
+// Don't change the actual numbers.
+#define LOCAL 0
+#define TIER2 2
+#define CORE 3
+
+namespace Minisat {
+
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver {
+private:
+ template
+ class MyQueue {
+ int max_sz, q_sz;
+ int ptr;
+ int64_t sum;
+ vec q;
+ public:
+ MyQueue(int sz) : max_sz(sz), q_sz(0), ptr(0), sum(0) { assert(sz > 0); q.growTo(sz); }
+ inline bool full () const { return q_sz == max_sz; }
+#ifdef INT_QUEUE_AVG
+ inline T avg () const { assert(full()); return sum / max_sz; }
+#else
+ inline double avg () const { assert(full()); return sum / (double) max_sz; }
+#endif
+ inline void clear() { sum = 0; q_sz = 0; ptr = 0; }
+ void push(T e) {
+ if (q_sz < max_sz) q_sz++;
+ else sum -= q[ptr];
+ sum += e;
+ q[ptr++] = e;
+ if (ptr == max_sz) ptr = 0;
+ }
+ };
+
+public:
+
+ // Constructor/Destructor:
+ //
+ Solver();
+ virtual ~Solver();
+
+ // Problem specification:
+ //
+ Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+
+ bool addClause (const vec& ps); // Add a clause to the solver.
+ bool addEmptyClause(); // Add the empty clause, making the solver contradictory.
+ bool addClause (Lit p); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+ bool addClause_( vec& ps); // Add a clause to the solver without making superflous internal copy. Will
+ // change the passed vector 'ps'.
+
+ // Solving:
+ //
+ bool simplify (bool do_stamping = false); // Removes already satisfied clauses.
+ bool solve (const vec& assumps); // Search for a model that respects a given set of assumptions.
+ lbool solveLimited (const vec& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+ bool solve (); // Search without assumptions.
+ bool solve (Lit p); // Search for a model that respects a single assumption.
+ bool solve (Lit p, Lit q); // Search for a model that respects two assumptions.
+ bool solve (Lit p, Lit q, Lit r); // Search for a model that respects three assumptions.
+ bool okay () const; // FALSE means solver is in a conflicting state
+
+ void toDimacs (FILE* f, const vec& assumps); // Write CNF to file in DIMACS-format.
+ void toDimacs (const char *file, const vec& assumps);
+ void toDimacs (FILE* f, Clause& c, vec& map, Var& max);
+
+ // Convenience versions of 'toDimacs()':
+ void toDimacs (const char* file);
+ void toDimacs (const char* file, Lit p);
+ void toDimacs (const char* file, Lit p, Lit q);
+ void toDimacs (const char* file, Lit p, Lit q, Lit r);
+
+ // Variable mode:
+ //
+ void setPolarity (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+ void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+ // Read state:
+ //
+ lbool value (Var x) const; // The current value of a variable.
+ lbool value (Lit p) const; // The current value of a literal.
+ lbool modelValue (Var x) const; // The value of a variable in the last model. The last call to solve must have been satisfiable.
+ lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable.
+ int nAssigns () const; // The current number of assigned literals.
+ int nClauses () const; // The current number of original clauses.
+ int nLearnts () const; // The current number of learnt clauses.
+ int nVars () const; // The current number of variables.
+ int nFreeVars () const;
+
+ // Resource contraints:
+ //
+ void setConfBudget(int64_t x);
+ void setPropBudget(int64_t x);
+ void budgetOff();
+ void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver.
+ void clearInterrupt(); // Clear interrupt indicator flag.
+
+ // Memory managment:
+ //
+ virtual void garbageCollect();
+ void checkGarbage(double gf);
+ void checkGarbage();
+
+ // Extra results: (read-only member variable)
+ //
+ vec model; // If problem is satisfiable, this vector contains the model (if any).
+ vec conflict; // If problem is unsatisfiable (possibly under assumptions),
+ // this vector represent the final conflict clause expressed in the assumptions.
+
+ // Mode of operation:
+ //
+ FILE* drup_file;
+ int verbosity;
+ double step_size;
+ double step_size_dec;
+ double min_step_size;
+ int timer;
+ double var_decay;
+ double clause_decay;
+ double random_var_freq;
+ double random_seed;
+ bool VSIDS;
+ int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+ int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full).
+ bool rnd_pol; // Use random polarities for branching heuristics.
+ bool rnd_init_act; // Initialize variable activities with a small random value.
+ double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+ int restart_first; // The initial restart limit. (default 100)
+ double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.5)
+ double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3)
+ double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1)
+
+ int learntsize_adjust_start_confl;
+ double learntsize_adjust_inc;
+
+ // Statistics: (read-only member variable)
+ //
+ uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, conflicts_VSIDS;
+ uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
+
+ vec picked;
+ vec conflicted;
+ vec almost_conflicted;
+
+protected:
+
+ // Helper structures:
+ //
+ struct VarData { CRef reason; int level; };
+ static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+ struct Watcher {
+ CRef cref;
+ Lit blocker;
+ Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+ bool operator==(const Watcher& w) const { return cref == w.cref; }
+ bool operator!=(const Watcher& w) const { return cref != w.cref; }
+ };
+
+ struct WatcherDeleted
+ {
+ const ClauseAllocator& ca;
+ WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+ bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+ };
+
+ struct VarOrderLt {
+ const vec& activity;
+ bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+ VarOrderLt(const vec& act) : activity(act) { }
+ };
+
+ // Solver state:
+ //
+ bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+ vec clauses; // List of problem clauses.
+ vec learnts_core, // List of learnt clauses.
+ learnts_tier2,
+ learnts_local;
+ double cla_inc; // Amount to bump next clause with.
+ vec activity_CHB, // A heuristic measurement of the activity of a variable.
+ activity_VSIDS;
+ double var_inc; // Amount to bump next variable with.
+ OccLists, WatcherDeleted>
+ watches_bin, // Watches for binary clauses only.
+ watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+ vec assigns; // The current assignments.
+ vec polarity; // The preferred polarity of each variable.
+ vec decision; // Declares if a variable is eligible for selection in the decision heuristic.
+ vec trail; // Assignment stack; stores all assigments made in the order they were made.
+ vec trail_lim; // Separator indices for different decision levels in 'trail'.
+ vec vardata; // Stores reason and level for each variable.
+ int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+ int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'.
+ int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'.
+ vec assumptions; // Current set of assumptions provided to solve by the user.
+ Heap order_heap_CHB, // A priority queue of variables ordered with respect to the variable activity.
+ order_heap_VSIDS;
+ double progress_estimate;// Set by 'search()'.
+ bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+
+ int core_lbd_cut;
+ float global_lbd_sum;
+ MyQueue lbd_queue; // For computing moving averages of recent LBD values.
+
+ uint64_t next_T2_reduce,
+ next_L_reduce;
+
+ ClauseAllocator ca;
+
+ // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+ // used, exept 'seen' wich is used in several places.
+ //
+ vec seen;
+ vec analyze_stack;
+ vec analyze_toclear;
+ vec add_tmp;
+ vec add_oc;
+
+ vec seen2; // Mostly for efficient LBD computation. 'seen2[i]' will indicate if decision level or variable 'i' has been seen.
+ uint64_t counter; // Simple counter for marking purpose with 'seen2'.
+
+ double max_learnts;
+ double learntsize_adjust_confl;
+ int learntsize_adjust_cnt;
+
+ // Resource contraints:
+ //
+ int64_t conflict_budget; // -1 means no budget.
+ int64_t propagation_budget; // -1 means no budget.
+ bool asynch_interrupt;
+
+ // Main internal methods:
+ //
+ void insertVarOrder (Var x); // Insert a variable in the decision order priority queue.
+ Lit pickBranchLit (); // Return the next decision variable.
+ void newDecisionLevel (); // Begins a new decision level.
+ void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined.
+ bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise.
+ CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause.
+ void cancelUntil (int level); // Backtrack until a certain level.
+ void analyze (CRef confl, vec& out_learnt, int& out_btlevel, int& out_lbd); // (bt = backtrack)
+ void analyzeFinal (Lit p, vec& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+ bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()')
+ lbool search (int& nof_conflicts); // Search for a given number of conflicts.
+ lbool solve_ (); // Main solve method (assumptions given in 'assumptions').
+ void reduceDB (); // Reduce the set of learnt clauses.
+ void reduceDB_Tier2 ();
+ void removeSatisfied (vec& cs); // Shrink 'cs' to contain only non-satisfied clauses.
+ void safeRemoveSatisfiedCompact(vec& cs, unsigned valid_mark);
+ void rebuildOrderHeap ();
+ bool binResMinimize (vec& out_learnt); // Further learnt clause minimization by binary resolution.
+
+ // Maintaining Variable/Clause activity:
+ //
+ void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+ void varBumpActivity (Var v, double mult); // Increase a variable with the current 'bump' value.
+ void claDecayActivity (); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+ void claBumpActivity (Clause& c); // Increase a clause with the current 'bump' value.
+
+ // Operations on clauses:
+ //
+ void attachClause (CRef cr); // Attach a clause to watcher lists.
+ void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+ void removeClause (CRef cr); // Detach and free a clause.
+ void removeClauseHack (CRef cr, Lit watched0, Lit watched1);
+ bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+ bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+ void relocAll (ClauseAllocator& to);
+
+ // Misc:
+ //
+ int decisionLevel () const; // Gives the current decisionlevel.
+ uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels.
+ CRef reason (Var x) const;
+ int level (Var x) const;
+ double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+ bool withinBudget () const;
+
+ template int computeLBD(const V& c) {
+ int lbd = 0;
+
+ counter++;
+ for (int i = 0; i < c.size(); i++){
+ int l = level(var(c[i]));
+ if (l != 0 && seen2[l] != counter){
+ seen2[l] = counter;
+ lbd++; } }
+
+ return lbd;
+ }
+
+#ifdef BIN_DRUP
+ static int buf_len;
+ static unsigned char drup_buf[];
+ static unsigned char* buf_ptr;
+
+ static inline void byteDRUP(Lit l){
+ unsigned int u = 2 * (var(l) + 1) + sign(l);
+ do{
+ *buf_ptr++ = u & 0x7f | 0x80; buf_len++;
+ u = u >> 7;
+ }while (u);
+ *(buf_ptr - 1) &= 0x7f; // End marker of this unsigned number.
+ }
+
+ template
+ static inline void binDRUP(unsigned char op, const V& c, FILE* drup_file){
+ assert(op == 'a' || op == 'd');
+ *buf_ptr++ = op; buf_len++;
+ for (int i = 0; i < c.size(); i++) byteDRUP(c[i]);
+ *buf_ptr++ = 0; buf_len++;
+ if (buf_len > 1048576) binDRUP_flush(drup_file);
+ }
+
+ static inline void binDRUP_strengthen(const Clause& c, Lit l, FILE* drup_file){
+ *buf_ptr++ = 'a'; buf_len++;
+ for (int i = 0; i < c.size(); i++)
+ if (c[i] != l) byteDRUP(c[i]);
+ *buf_ptr++ = 0; buf_len++;
+ if (buf_len > 1048576) binDRUP_flush(drup_file);
+ }
+
+ static inline void binDRUP_flush(FILE* drup_file){
+ fwrite(drup_buf, sizeof(unsigned char), buf_len, drup_file);
+ buf_ptr = drup_buf; buf_len = 0;
+ }
+#endif
+
+ // Static helpers:
+ //
+
+ // Returns a random float 0 <= x < 1. Seed must never be 0.
+ static inline double drand(double& seed) {
+ seed *= 1389796;
+ int q = (int)(seed / 2147483647);
+ seed -= (double)q * 2147483647;
+ return seed / 2147483647; }
+
+ // Returns a random integer 0 <= x < size. Seed must never be 0.
+ static inline int irand(double& seed, int size) {
+ return (int)(drand(seed) * size); }
+
+ // For (advanced) stamping.
+ struct Frame {
+ enum TYPE { START = 0, ENTER = 1, RETURN = 2, CLOSE = 3 };
+ Lit curr, next;
+ unsigned type : 3;
+ unsigned learnt : 1;
+ Frame(TYPE t, Lit p, Lit q, unsigned l) : curr(p), next(q), type(t), learnt(l) {}
+ };
+
+ vec discovered;
+ vec finished;
+ vec observed;
+ vec flag;
+ vec root;
+ vec parent;
+
+ vec rec_stack;
+ vec scc; // Strongly connected component.
+
+ bool stampAll(bool use_bin_learnts);
+ int stamp(Lit p, int stamp_time, bool use_bin_learnts);
+ inline bool implExistsByBin(Lit p, bool use_bin_learnts) const;
+ inline bool isRoot(Lit p, bool use_bin_learnts) const;
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+ Heap& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB;
+ if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() {
+ var_inc *= (1 / var_decay); }
+
+inline void Solver::varBumpActivity(Var v, double mult) {
+ if ( (activity_VSIDS[v] += var_inc * mult) > 1e100 ) {
+ // Rescale:
+ for (int i = 0; i < nVars(); i++)
+ activity_VSIDS[i] *= 1e-100;
+ var_inc *= 1e-100; }
+
+ // Update order_heap with respect to new activity:
+ if (order_heap_VSIDS.inHeap(v)) order_heap_VSIDS.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+ if ( (c.activity() += cla_inc) > 1e20 ) {
+ // Rescale:
+ for (int i = 0; i < learnts_local.size(); i++)
+ ca[learnts_local[i]].activity() *= 1e-20;
+ cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+ if (ca.wasted() > ca.size() * gf)
+ garbageCollect(); }
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool Solver::addClause (const vec& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool Solver::addEmptyClause () { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool Solver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool Solver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool Solver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool Solver::locked (const Clause& c) const {
+ int i = c.size() != 2 ? 0 : (value(c[0]) == l_True ? 0 : 1);
+ return value(c[i]) == l_True && reason(var(c[i])) != CRef_Undef && ca.lea(reason(var(c[i]))) == &c;
+}
+inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); }
+
+inline int Solver::decisionLevel () const { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const { return 1 << (level(x) & 31); }
+inline lbool Solver::value (Var x) const { return assigns[x]; }
+inline lbool Solver::value (Lit p) const { return assigns[var(p)] ^ sign(p); }
+inline lbool Solver::modelValue (Var x) const { return model[x]; }
+inline lbool Solver::modelValue (Lit p) const { return model[var(p)] ^ sign(p); }
+inline int Solver::nAssigns () const { return trail.size(); }
+inline int Solver::nClauses () const { return clauses.size(); }
+inline int Solver::nLearnts () const { return learnts_core.size() + learnts_tier2.size() + learnts_local.size(); }
+inline int Solver::nVars () const { return vardata.size(); }
+inline int Solver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void Solver::setPolarity (Var v, bool b) { polarity[v] = b; }
+inline void Solver::setDecisionVar(Var v, bool b)
+{
+ if ( b && !decision[v]) dec_vars++;
+ else if (!b && decision[v]) dec_vars--;
+
+ decision[v] = b;
+ if (b && !order_heap_CHB.inHeap(v)){
+ order_heap_CHB.insert(v);
+ order_heap_VSIDS.insert(v); }
+}
+inline void Solver::setConfBudget(int64_t x){ conflict_budget = conflicts + x; }
+inline void Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void Solver::interrupt(){ asynch_interrupt = true; }
+inline void Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool Solver::withinBudget() const {
+ return !asynch_interrupt &&
+ (conflict_budget < 0 || conflicts < (uint64_t)conflict_budget) &&
+ (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool Solver::solve () { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool Solver::solve (Lit p) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool Solver::solve (Lit p, Lit q) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool Solver::solve (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool Solver::solve (const vec& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool Solver::solveLimited (const vec& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool Solver::okay () const { return ok; }
+
+inline void Solver::toDimacs (const char* file){ vec as; toDimacs(file, as); }
+inline void Solver::toDimacs (const char* file, Lit p){ vec as; as.push(p); toDimacs(file, as); }
+inline void Solver::toDimacs (const char* file, Lit p, Lit q){ vec as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ vec as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+
+//=================================================================================================
+// Debug etc:
+
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/SolverTypes.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/SolverTypes.h
new file mode 100755
index 00000000..5b7bda7e
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/core/SolverTypes.h
@@ -0,0 +1,426 @@
+/***********************************************************************************[SolverTypes.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_SolverTypes_h
+#define Minisat_SolverTypes_h
+
+#include
+
+#include "mtl/IntTypes.h"
+#include "mtl/Alg.h"
+#include "mtl/Vec.h"
+#include "mtl/Map.h"
+#include "mtl/Alloc.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+ int x;
+
+ // Use this as a constructor:
+ friend Lit mkLit(Var var, bool sign);
+
+ bool operator == (Lit p) const { return x == p.x; }
+ bool operator != (Lit p) const { return x != p.x; }
+ bool operator < (Lit p) const { return x < p.x; } // '<' makes p, ~p adjacent in the ordering.
+};
+
+
+inline Lit mkLit (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline Lit operator ~(Lit p) { Lit q; q.x = p.x ^ 1; return q; }
+inline Lit operator ^(Lit p, bool b) { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline bool sign (Lit p) { return p.x & 1; }
+inline int var (Lit p) { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline int toInt (Var v) { return v; }
+inline int toInt (Lit p) { return p.x; }
+inline Lit toLit (int i) { Lit p; p.x = i; return p; }
+
+//const Lit lit_Undef = mkLit(var_Undef, false); // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true ); // }
+
+const Lit lit_Undef = { -2 }; // }- Useful special constants.
+const Lit lit_Error = { -1 }; // }
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+// between one variable and one constant. Some care had to be taken to make sure that gcc
+// does enough constant propagation to produce sensible code, and this appears to be somewhat
+// fragile unfortunately.
+
+#define l_True (lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants.
+#define l_False (lbool((uint8_t)1))
+#define l_Undef (lbool((uint8_t)2))
+
+class lbool {
+ uint8_t value;
+
+public:
+ explicit lbool(uint8_t v) : value(v) { }
+
+ lbool() : value(0) { }
+ explicit lbool(bool x) : value(!x) { }
+
+ bool operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
+ bool operator != (lbool b) const { return !(*this == b); }
+ lbool operator ^ (bool b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+ lbool operator && (lbool b) const {
+ uint8_t sel = (this->value << 1) | (b.value << 3);
+ uint8_t v = (0xF7F755F4 >> sel) & 3;
+ return lbool(v); }
+
+ lbool operator || (lbool b) const {
+ uint8_t sel = (this->value << 1) | (b.value << 3);
+ uint8_t v = (0xFCFCF400 >> sel) & 3;
+ return lbool(v); }
+
+ friend int toInt (lbool l);
+ friend lbool toLbool(int v);
+};
+inline int toInt (lbool l) { return l.value; }
+inline lbool toLbool(int v) { return lbool((uint8_t)v); }
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+class Clause;
+typedef RegionAllocator::Ref CRef;
+
+class Clause {
+ struct {
+ unsigned mark : 2;
+ unsigned learnt : 1;
+ unsigned has_extra : 1;
+ unsigned reloced : 1;
+ unsigned lbd : 26;
+ unsigned removable : 1;
+ unsigned size : 32; } header;
+ union { Lit lit; float act; uint32_t abs; uint32_t touched; CRef rel; } data[0];
+
+ friend class ClauseAllocator;
+
+ // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+ template
+ Clause(const V& ps, bool use_extra, bool learnt) {
+ header.mark = 0;
+ header.learnt = learnt;
+ header.has_extra = learnt | use_extra;
+ header.reloced = 0;
+ header.size = ps.size();
+ header.lbd = 0;
+ header.removable = 1;
+
+ for (int i = 0; i < ps.size(); i++)
+ data[i].lit = ps[i];
+
+ if (header.has_extra){
+ if (header.learnt){
+ data[header.size].act = 0;
+ data[header.size+1].touched = 0;
+ }else
+ calcAbstraction(); }
+ }
+
+public:
+ void calcAbstraction() {
+ assert(header.has_extra);
+ uint32_t abstraction = 0;
+ for (int i = 0; i < size(); i++)
+ abstraction |= 1 << (var(data[i].lit) & 31);
+ data[header.size].abs = abstraction; }
+
+
+ int size () const { return header.size; }
+ void shrink (int i) { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
+ void pop () { shrink(1); }
+ bool learnt () const { return header.learnt; }
+ bool has_extra () const { return header.has_extra; }
+ uint32_t mark () const { return header.mark; }
+ void mark (uint32_t m) { header.mark = m; }
+ const Lit& last () const { return data[header.size-1].lit; }
+
+ bool reloced () const { return header.reloced; }
+ CRef relocation () const { return data[0].rel; }
+ void relocate (CRef c) { header.reloced = 1; data[0].rel = c; }
+
+ int lbd () const { return header.lbd; }
+ void set_lbd (int lbd) { header.lbd = lbd; }
+ bool removable () const { return header.removable; }
+ void removable (bool b) { header.removable = b; }
+
+ // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+ // subsumption operations to behave correctly.
+ Lit& operator [] (int i) { return data[i].lit; }
+ Lit operator [] (int i) const { return data[i].lit; }
+ operator const Lit* (void) const { return (Lit*)data; }
+
+ uint32_t& touched () { assert(header.has_extra && header.learnt); return data[header.size+1].touched; }
+ float& activity () { assert(header.has_extra); return data[header.size].act; }
+ uint32_t abstraction () const { assert(header.has_extra); return data[header.size].abs; }
+
+ Lit subsumes (const Clause& other) const;
+ void strengthen (Lit p);
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+const CRef CRef_Undef = RegionAllocator::Ref_Undef;
+class ClauseAllocator : public RegionAllocator
+{
+ static int clauseWord32Size(int size, int extras){
+ return (sizeof(Clause) + (sizeof(Lit) * (size + extras))) / sizeof(uint32_t); }
+ public:
+ bool extra_clause_field;
+
+ ClauseAllocator(uint32_t start_cap) : RegionAllocator(start_cap), extra_clause_field(false){}
+ ClauseAllocator() : extra_clause_field(false){}
+
+ void moveTo(ClauseAllocator& to){
+ to.extra_clause_field = extra_clause_field;
+ RegionAllocator::moveTo(to); }
+
+ template
+ CRef alloc(const Lits& ps, bool learnt = false)
+ {
+ assert(sizeof(Lit) == sizeof(uint32_t));
+ assert(sizeof(float) == sizeof(uint32_t));
+ int extras = learnt ? 2 : (int)extra_clause_field;
+
+ CRef cid = RegionAllocator::alloc(clauseWord32Size(ps.size(), extras));
+ new (lea(cid)) Clause(ps, extra_clause_field, learnt);
+
+ return cid;
+ }
+
+ // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+ Clause& operator[](Ref r) { return (Clause&)RegionAllocator::operator[](r); }
+ const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator::operator[](r); }
+ Clause* lea (Ref r) { return (Clause*)RegionAllocator::lea(r); }
+ const Clause* lea (Ref r) const { return (Clause*)RegionAllocator::lea(r); }
+ Ref ael (const Clause* t){ return RegionAllocator::ael((uint32_t*)t); }
+
+ void free(CRef cid)
+ {
+ Clause& c = operator[](cid);
+ int extras = c.learnt() ? 2 : (int)c.has_extra();
+ RegionAllocator::free(clauseWord32Size(c.size(), extras));
+ }
+
+ void reloc(CRef& cr, ClauseAllocator& to)
+ {
+ Clause& c = operator[](cr);
+
+ if (c.reloced()) { cr = c.relocation(); return; }
+
+ cr = to.alloc(c, c.learnt());
+ c.relocate(cr);
+
+ // Copy extra data-fields:
+ // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+ to[cr].mark(c.mark());
+ if (to[cr].learnt()){
+ to[cr].touched() = c.touched();
+ to[cr].activity() = c.activity();
+ to[cr].set_lbd(c.lbd());
+ to[cr].removable(c.removable());
+ }
+ else if (to[cr].has_extra()) to[cr].calcAbstraction();
+ }
+};
+
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template
+class OccLists
+{
+ vec occs;
+ vec dirty;
+ vec dirties;
+ Deleted deleted;
+
+ public:
+ OccLists(const Deleted& d) : deleted(d) {}
+
+ void init (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+ const Vec& operator[](const Idx& idx) const { return occs[toInt(idx)]; }
+ Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; }
+ Vec& lookup (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+ void cleanAll ();
+ void clean (const Idx& idx);
+ void smudge (const Idx& idx){
+ if (dirty[toInt(idx)] == 0){
+ dirty[toInt(idx)] = 1;
+ dirties.push(idx);
+ }
+ }
+
+ void clear(bool free = true){
+ occs .clear(free);
+ dirty .clear(free);
+ dirties.clear(free);
+ }
+};
+
+
+template
+void OccLists::cleanAll()
+{
+ for (int i = 0; i < dirties.size(); i++)
+ // Dirties may contain duplicates so check here if a variable is already cleaned:
+ if (dirty[toInt(dirties[i])])
+ clean(dirties[i]);
+ dirties.clear();
+}
+
+
+template
+void OccLists::clean(const Idx& idx)
+{
+ Vec& vec = occs[toInt(idx)];
+ int i, j;
+ for (i = j = 0; i < vec.size(); i++)
+ if (!deleted(vec[i]))
+ vec[j++] = vec[i];
+ vec.shrink(i - j);
+ dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template
+class CMap
+{
+ struct CRefHash {
+ uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+ typedef Map HashTable;
+ HashTable map;
+
+ public:
+ // Size-operations:
+ void clear () { map.clear(); }
+ int size () const { return map.elems(); }
+
+
+ // Insert/Remove/Test mapping:
+ void insert (CRef cr, const T& t){ map.insert(cr, t); }
+ void growTo (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+ void remove (CRef cr) { map.remove(cr); }
+ bool has (CRef cr, T& t) { return map.peek(cr, t); }
+
+ // Vector interface (the clause 'c' must already exist):
+ const T& operator [] (CRef cr) const { return map[cr]; }
+ T& operator [] (CRef cr) { return map[cr]; }
+
+ // Iteration (not transparent at all at the moment):
+ int bucket_count() const { return map.bucket_count(); }
+ const vec& bucket(int i) const { return map.bucket(i); }
+
+ // Move contents to other map:
+ void moveTo(CMap& other){ map.moveTo(other.map); }
+
+ // TMP debug:
+ void debug(){
+ printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+| subsumes : (other : const Clause&) -> Lit
+|
+| Description:
+| Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+| by subsumption resolution.
+|
+| Result:
+| lit_Error - No subsumption or simplification
+| lit_Undef - Clause subsumes 'other'
+| p - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+ //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+ //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+ assert(!header.learnt); assert(!other.header.learnt);
+ assert(header.has_extra); assert(other.header.has_extra);
+ if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+ return lit_Error;
+
+ Lit ret = lit_Undef;
+ const Lit* c = (const Lit*)(*this);
+ const Lit* d = (const Lit*)other;
+
+ for (unsigned i = 0; i < header.size; i++) {
+ // search for c[i] or ~c[i]
+ for (unsigned j = 0; j < other.header.size; j++)
+ if (c[i] == d[j])
+ goto ok;
+ else if (ret == lit_Undef && c[i] == ~d[j]){
+ ret = c[i];
+ goto ok;
+ }
+
+ // did not find it
+ return lit_Error;
+ ok:;
+ }
+
+ return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+ remove(*this, p);
+ calcAbstraction();
+}
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/doc/ReleaseNotes-2.2.0.txt b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/doc/ReleaseNotes-2.2.0.txt
new file mode 100755
index 00000000..7f084de2
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/doc/ReleaseNotes-2.2.0.txt
@@ -0,0 +1,79 @@
+Release Notes for MiniSat 2.2.0
+===============================
+
+Changes since version 2.0:
+
+ * Started using a more standard release numbering.
+
+ * Includes some now well-known heuristics: phase-saving and luby
+ restarts. The old heuristics are still present and can be activated
+ if needed.
+
+ * Detection/Handling of out-of-memory and vector capacity
+ overflow. This is fairly new and relatively untested.
+
+ * Simple resource controls: CPU-time, memory, number of
+ conflicts/decisions.
+
+ * CPU-time limiting is implemented by a more general, but simple,
+ asynchronous interruption feature. This means that the solving
+ procedure can be interrupted from another thread or in a signal
+ handler.
+
+ * Improved portability with respect to building on Solaris and with
+ Visual Studio. This is not regularly tested and chances are that
+ this have been broken since, but should be fairly easy to fix if
+ so.
+
+ * Changed C++ file-extention to the less problematic ".cc".
+
+ * Source code is now namespace-protected
+
+ * Introducing a new Clause Memory Allocator that brings reduced
+ memory consumption on 64-bit architechtures and improved
+ performance (to some extent). The allocator uses a region-based
+ approach were all references to clauses are represented as a 32-bit
+ index into a global memory region that contains all clauses. To
+ free up and compact memory it uses a simple copying garbage
+ collector.
+
+ * Improved unit-propagation by Blocking Literals. For each entry in
+ the watcher lists, pair the pointer to a clause with some
+ (arbitrary) literal from the clause. The idea is that if the
+ literal is currently true (i.e. the clause is satisfied) the
+ watchers of the clause does not need to be altered. This can thus
+ be detected without touching the clause's memory at all. As often
+ as can be done cheaply, the blocking literal for entries to the
+ watcher list of a literal 'p' is set to the other literal watched
+ in the corresponding clause.
+
+ * Basic command-line/option handling system. Makes it easy to specify
+ options in the class that they affect, and whenever that class is
+ used in an executable, parsing of options and help messages are
+ brought in automatically.
+
+ * General clean-up and various minor bug-fixes.
+
+ * Changed implementation of variable-elimination/model-extension:
+
+ - The interface is changed so that arbitrary remembering is no longer
+ possible. If you need to mention some variable again in the future,
+ this variable has to be frozen.
+
+ - When eliminating a variable, only clauses that contain the variable
+ with one sign is necessary to store. Thereby making the other sign
+ a "default" value when extending models.
+
+ - The memory consumption for eliminated clauses is further improved
+ by storing all eliminated clauses in a single contiguous vector.
+
+ * Some common utility code (I/O, Parsing, CPU-time, etc) is ripped
+ out and placed in a separate "utils" directory.
+
+ * The DIMACS parse is refactored so that it can be reused in other
+ applications (not very elegant, but at least possible).
+
+ * Some simple improvements to scalability of preprocessing, using
+ more lazy clause removal from data-structures and a couple of
+ ad-hoc limits (the longest clause that can be produced in variable
+ elimination, and the longest clause used in backward subsumption).
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alg.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alg.h
new file mode 100755
index 00000000..bb1ee5ad
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alg.h
@@ -0,0 +1,84 @@
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Alg_h
+#define Minisat_Alg_h
+
+#include "mtl/Vec.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template
+static inline void remove(V& ts, const T& t)
+{
+ int j = 0;
+ for (; j < ts.size() && ts[j] != t; j++);
+ assert(j < ts.size());
+ for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+ ts.pop();
+}
+
+
+template
+static inline bool find(V& ts, const T& t)
+{
+ int j = 0;
+ for (; j < ts.size() && ts[j] != t; j++);
+ return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template
+static inline void copy(const T& from, T& to)
+{
+ to = from;
+}
+
+// Recursive case:
+template
+static inline void copy(const vec& from, vec& to, bool append = false)
+{
+ if (!append)
+ to.clear();
+ for (int i = 0; i < from.size(); i++){
+ to.push();
+ copy(from[i], to.last());
+ }
+}
+
+template
+static inline void append(const vec& from, vec& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alloc.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alloc.h
new file mode 100755
index 00000000..76322b8b
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Alloc.h
@@ -0,0 +1,131 @@
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_Alloc_h
+#define Minisat_Alloc_h
+
+#include "mtl/XAlloc.h"
+#include "mtl/Vec.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template
+class RegionAllocator
+{
+ T* memory;
+ uint32_t sz;
+ uint32_t cap;
+ uint32_t wasted_;
+
+ void capacity(uint32_t min_cap);
+
+ public:
+ // TODO: make this a class for better type-checking?
+ typedef uint32_t Ref;
+ enum { Ref_Undef = UINT32_MAX };
+ enum { Unit_Size = sizeof(uint32_t) };
+
+ explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+ ~RegionAllocator()
+ {
+ if (memory != NULL)
+ ::free(memory);
+ }
+
+
+ uint32_t size () const { return sz; }
+ uint32_t wasted () const { return wasted_; }
+
+ Ref alloc (int size);
+ void free (int size) { wasted_ += size; }
+
+ // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+ T& operator[](Ref r) { assert(r >= 0 && r < sz); return memory[r]; }
+ const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+ T* lea (Ref r) { assert(r >= 0 && r < sz); return &memory[r]; }
+ const T* lea (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+ Ref ael (const T* t) { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+ return (Ref)(t - &memory[0]); }
+
+ void moveTo(RegionAllocator& to) {
+ if (to.memory != NULL) ::free(to.memory);
+ to.memory = memory;
+ to.sz = sz;
+ to.cap = cap;
+ to.wasted_ = wasted_;
+
+ memory = NULL;
+ sz = cap = wasted_ = 0;
+ }
+
+
+};
+
+template
+void RegionAllocator::capacity(uint32_t min_cap)
+{
+ if (cap >= min_cap) return;
+
+ uint32_t prev_cap = cap;
+ while (cap < min_cap){
+ // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+ // result even by clearing the least significant bit. The resulting sequence of capacities
+ // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+ // using 'uint32_t' as indices so that as much as possible of this space can be used.
+ uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+ cap += delta;
+
+ if (cap <= prev_cap)
+ throw OutOfMemoryException();
+ }
+ // printf(" .. (%p) cap = %u\n", this, cap);
+
+ assert(cap > 0);
+ memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template
+typename RegionAllocator::Ref
+RegionAllocator::alloc(int size)
+{
+ // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+ assert(size > 0);
+ capacity(sz + size);
+
+ uint32_t prev_sz = sz;
+ sz += size;
+
+ // Handle overflow:
+ if (sz < prev_sz)
+ throw OutOfMemoryException();
+
+ return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Heap.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Heap.h
new file mode 100755
index 00000000..b73f9e21
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Heap.h
@@ -0,0 +1,148 @@
+/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Heap_h
+#define Minisat_Heap_h
+
+#include "mtl/Vec.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template
+class Heap {
+ Comp lt; // The heap is a minimum-heap with respect to this comparator
+ vec heap; // Heap of integers
+ vec indices; // Each integers position (index) in the Heap
+
+ // Index "traversal" functions
+ static inline int left (int i) { return i*2+1; }
+ static inline int right (int i) { return (i+1)*2; }
+ static inline int parent(int i) { return (i-1) >> 1; }
+
+
+ void percolateUp(int i)
+ {
+ int x = heap[i];
+ int p = parent(i);
+
+ while (i != 0 && lt(x, heap[p])){
+ heap[i] = heap[p];
+ indices[heap[p]] = i;
+ i = p;
+ p = parent(p);
+ }
+ heap [i] = x;
+ indices[x] = i;
+ }
+
+
+ void percolateDown(int i)
+ {
+ int x = heap[i];
+ while (left(i) < heap.size()){
+ int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+ if (!lt(heap[child], x)) break;
+ heap[i] = heap[child];
+ indices[heap[i]] = i;
+ i = child;
+ }
+ heap [i] = x;
+ indices[x] = i;
+ }
+
+
+ public:
+ Heap(const Comp& c) : lt(c) { }
+
+ int size () const { return heap.size(); }
+ bool empty () const { return heap.size() == 0; }
+ bool inHeap (int n) const { return n < indices.size() && indices[n] >= 0; }
+ int operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+ void decrease (int n) { assert(inHeap(n)); percolateUp (indices[n]); }
+ void increase (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+ // Safe variant of insert/decrease/increase:
+ void update(int n)
+ {
+ if (!inHeap(n))
+ insert(n);
+ else {
+ percolateUp(indices[n]);
+ percolateDown(indices[n]); }
+ }
+
+
+ void insert(int n)
+ {
+ indices.growTo(n+1, -1);
+ assert(!inHeap(n));
+
+ indices[n] = heap.size();
+ heap.push(n);
+ percolateUp(indices[n]);
+ }
+
+
+ int removeMin()
+ {
+ int x = heap[0];
+ heap[0] = heap.last();
+ indices[heap[0]] = 0;
+ indices[x] = -1;
+ heap.pop();
+ if (heap.size() > 1) percolateDown(0);
+ return x;
+ }
+
+
+ // Rebuild the heap from scratch, using the elements in 'ns':
+ void build(const vec& ns) {
+ for (int i = 0; i < heap.size(); i++)
+ indices[heap[i]] = -1;
+ heap.clear();
+
+ for (int i = 0; i < ns.size(); i++){
+ indices[ns[i]] = i;
+ heap.push(ns[i]); }
+
+ for (int i = heap.size() / 2 - 1; i >= 0; i--)
+ percolateDown(i);
+ }
+
+ void clear(bool dealloc = false)
+ {
+ for (int i = 0; i < heap.size(); i++)
+ indices[heap[i]] = -1;
+ heap.clear(dealloc);
+ }
+};
+
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/IntTypes.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/IntTypes.h
new file mode 100755
index 00000000..c4881628
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/IntTypes.h
@@ -0,0 +1,42 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_IntTypes_h
+#define Minisat_IntTypes_h
+
+#ifdef __sun
+ // Not sure if there are newer versions that support C99 headers. The
+ // needed features are implemented in the headers below though:
+
+# include
+# include
+# include
+
+#else
+
+# include
+# include
+
+#endif
+
+#include
+
+//=================================================================================================
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Map.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Map.h
new file mode 100755
index 00000000..8a82d0e2
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Map.h
@@ -0,0 +1,193 @@
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Map_h
+#define Minisat_Map_h
+
+#include "mtl/IntTypes.h"
+#include "mtl/Vec.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template struct Hash { uint32_t operator()(const K& k) const { return hash(k); } };
+template struct Equal { bool operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template struct DeepHash { uint32_t operator()(const K* k) const { return hash(*k); } };
+template struct DeepEqual { bool operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template, class E = Equal >
+class Map {
+ public:
+ struct Pair { K key; D data; };
+
+ private:
+ H hash;
+ E equals;
+
+ vec* table;
+ int cap;
+ int size;
+
+ // Don't allow copying (error prone):
+ Map& operator = (Map& other) { assert(0); }
+ Map (Map& other) { assert(0); }
+
+ bool checkCap(int new_size) const { return new_size > cap; }
+
+ int32_t index (const K& k) const { return hash(k) % cap; }
+ void _insert (const K& k, const D& d) {
+ vec& ps = table[index(k)];
+ ps.push(); ps.last().key = k; ps.last().data = d; }
+
+ void rehash () {
+ const vec* old = table;
+
+ int old_cap = cap;
+ int newsize = primes[0];
+ for (int i = 1; newsize <= cap && i < nprimes; i++)
+ newsize = primes[i];
+
+ table = new vec[newsize];
+ cap = newsize;
+
+ for (int i = 0; i < old_cap; i++){
+ for (int j = 0; j < old[i].size(); j++){
+ _insert(old[i][j].key, old[i][j].data); }}
+
+ delete [] old;
+
+ // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+ }
+
+
+ public:
+
+ Map () : table(NULL), cap(0), size(0) {}
+ Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+ ~Map () { delete [] table; }
+
+ // PRECONDITION: the key must already exist in the map.
+ const D& operator [] (const K& k) const
+ {
+ assert(size != 0);
+ const D* res = NULL;
+ const vec& ps = table[index(k)];
+ for (int i = 0; i < ps.size(); i++)
+ if (equals(ps[i].key, k))
+ res = &ps[i].data;
+ assert(res != NULL);
+ return *res;
+ }
+
+ // PRECONDITION: the key must already exist in the map.
+ D& operator [] (const K& k)
+ {
+ assert(size != 0);
+ D* res = NULL;
+ vec& ps = table[index(k)];
+ for (int i = 0; i < ps.size(); i++)
+ if (equals(ps[i].key, k))
+ res = &ps[i].data;
+ assert(res != NULL);
+ return *res;
+ }
+
+ // PRECONDITION: the key must *NOT* exist in the map.
+ void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+ bool peek (const K& k, D& d) const {
+ if (size == 0) return false;
+ const vec& ps = table[index(k)];
+ for (int i = 0; i < ps.size(); i++)
+ if (equals(ps[i].key, k)){
+ d = ps[i].data;
+ return true; }
+ return false;
+ }
+
+ bool has (const K& k) const {
+ if (size == 0) return false;
+ const vec& ps = table[index(k)];
+ for (int i = 0; i < ps.size(); i++)
+ if (equals(ps[i].key, k))
+ return true;
+ return false;
+ }
+
+ // PRECONDITION: the key must exist in the map.
+ void remove(const K& k) {
+ assert(table != NULL);
+ vec& ps = table[index(k)];
+ int j = 0;
+ for (; j < ps.size() && !equals(ps[j].key, k); j++);
+ assert(j < ps.size());
+ ps[j] = ps.last();
+ ps.pop();
+ size--;
+ }
+
+ void clear () {
+ cap = size = 0;
+ delete [] table;
+ table = NULL;
+ }
+
+ int elems() const { return size; }
+ int bucket_count() const { return cap; }
+
+ // NOTE: the hash and equality objects are not moved by this method:
+ void moveTo(Map& other){
+ delete [] other.table;
+
+ other.table = table;
+ other.cap = cap;
+ other.size = size;
+
+ table = NULL;
+ size = cap = 0;
+ }
+
+ // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+ const vec& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Queue.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Queue.h
new file mode 100755
index 00000000..17567d69
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Queue.h
@@ -0,0 +1,69 @@
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Queue_h
+#define Minisat_Queue_h
+
+#include "mtl/Vec.h"
+
+namespace Minisat {
+
+//=================================================================================================
+
+template
+class Queue {
+ vec buf;
+ int first;
+ int end;
+
+public:
+ typedef T Key;
+
+ Queue() : buf(1), first(0), end(0) {}
+
+ void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+ int size () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+ const T& operator [] (int index) const { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+ T& operator [] (int index) { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+ T peek () const { assert(first != end); return buf[first]; }
+ void pop () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+ void insert(T elem) { // INVARIANT: buf[end] is always unused
+ buf[end++] = elem;
+ if (end == buf.size()) end = 0;
+ if (first == end){ // Resize:
+ vec tmp((buf.size()*3 + 1) >> 1);
+ //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+ int i = 0;
+ for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+ for (int j = 0 ; j < end ; j++) tmp[i++] = buf[j];
+ first = 0;
+ end = buf.size();
+ tmp.moveTo(buf);
+ }
+ }
+};
+
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Sort.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Sort.h
new file mode 100755
index 00000000..e9313ef8
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Sort.h
@@ -0,0 +1,98 @@
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Sort_h
+#define Minisat_Sort_h
+
+#include "mtl/Vec.h"
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+namespace Minisat {
+
+template
+struct LessThan_default {
+ bool operator () (T x, T y) { return x < y; }
+};
+
+
+template
+void selectionSort(T* array, int size, LessThan lt)
+{
+ int i, j, best_i;
+ T tmp;
+
+ for (i = 0; i < size-1; i++){
+ best_i = i;
+ for (j = i+1; j < size; j++){
+ if (lt(array[j], array[best_i]))
+ best_i = j;
+ }
+ tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+ }
+}
+template static inline void selectionSort(T* array, int size) {
+ selectionSort(array, size, LessThan_default()); }
+
+template
+void sort(T* array, int size, LessThan lt)
+{
+ if (size <= 15)
+ selectionSort(array, size, lt);
+
+ else{
+ T pivot = array[size / 2];
+ T tmp;
+ int i = -1;
+ int j = size;
+
+ for(;;){
+ do i++; while(lt(array[i], pivot));
+ do j--; while(lt(pivot, array[j]));
+
+ if (i >= j) break;
+
+ tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+ }
+
+ sort(array , i , lt);
+ sort(&array[i], size-i, lt);
+ }
+}
+template static inline void sort(T* array, int size) {
+ sort(array, size, LessThan_default()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template void sort(vec& v, LessThan lt) {
+ sort((T*)v, v.size(), lt); }
+template void sort(vec& v) {
+ sort(v, LessThan_default()); }
+
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Vec.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Vec.h
new file mode 100755
index 00000000..9e220852
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/Vec.h
@@ -0,0 +1,130 @@
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Vec_h
+#define Minisat_Vec_h
+
+#include
+#include
+
+#include "mtl/IntTypes.h"
+#include "mtl/XAlloc.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template
+class vec {
+ T* data;
+ int sz;
+ int cap;
+
+ // Don't allow copying (error prone):
+ vec& operator = (vec& other) { assert(0); return *this; }
+ vec (vec& other) { assert(0); }
+
+ // Helpers for calculating next capacity:
+ static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+ //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+ static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+ // Constructors:
+ vec() : data(NULL) , sz(0) , cap(0) { }
+ explicit vec(int size) : data(NULL) , sz(0) , cap(0) { growTo(size); }
+ vec(int size, const T& pad) : data(NULL) , sz(0) , cap(0) { growTo(size, pad); }
+ ~vec() { clear(true); }
+
+ // Pointer to first element:
+ operator T* (void) { return data; }
+
+ // Size operations:
+ int size (void) const { return sz; }
+ void shrink (int nelems) { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+ void shrink_ (int nelems) { assert(nelems <= sz); sz -= nelems; }
+ int capacity (void) const { return cap; }
+ void capacity (int min_cap);
+ void growTo (int size);
+ void growTo (int size, const T& pad);
+ void clear (bool dealloc = false);
+
+ // Stack interface:
+ void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+ void push (const T& elem) { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+ void push_ (const T& elem) { assert(sz < cap); data[sz++] = elem; }
+ void pop (void) { assert(sz > 0); sz--, data[sz].~T(); }
+ // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+ // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+ // happen given the way capacities are calculated (below). Essentially, all capacities are
+ // even, but INT_MAX is odd.
+
+ const T& last (void) const { return data[sz-1]; }
+ T& last (void) { return data[sz-1]; }
+
+ // Vector interface:
+ const T& operator [] (int index) const { return data[index]; }
+ T& operator [] (int index) { return data[index]; }
+
+ // Duplicatation (preferred instead):
+ void copyTo(vec& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+ void moveTo(vec& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+
+template
+void vec::capacity(int min_cap) {
+ if (cap >= min_cap) return;
+ int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2
+ if (add > INT_MAX - cap || ((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM)
+ throw OutOfMemoryException();
+ }
+
+
+template
+void vec::growTo(int size, const T& pad) {
+ if (sz >= size) return;
+ capacity(size);
+ for (int i = sz; i < size; i++) data[i] = pad;
+ sz = size; }
+
+
+template
+void vec::growTo(int size) {
+ if (sz >= size) return;
+ capacity(size);
+ for (int i = sz; i < size; i++) new (&data[i]) T();
+ sz = size; }
+
+
+template
+void vec::clear(bool dealloc) {
+ if (data != NULL){
+ for (int i = 0; i < sz; i++) data[i].~T();
+ sz = 0;
+ if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/XAlloc.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/XAlloc.h
new file mode 100755
index 00000000..1da17602
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/XAlloc.h
@@ -0,0 +1,45 @@
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_XAlloc_h
+#define Minisat_XAlloc_h
+
+#include
+#include
+
+namespace Minisat {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+ void* mem = realloc(ptr, size);
+ if (mem == NULL && errno == ENOMEM){
+ throw OutOfMemoryException();
+ }else
+ return mem;
+}
+
+//=================================================================================================
+}
+
+#endif
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/config.mk b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/config.mk
new file mode 100755
index 00000000..b5c36fc6
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/config.mk
@@ -0,0 +1,6 @@
+##
+## This file is for system specific configurations. For instance, on
+## some systems the path to zlib needs to be added. Example:
+##
+## CFLAGS += -I/usr/local/include
+## LFLAGS += -L/usr/local/lib
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/template.mk b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/template.mk
new file mode 100755
index 00000000..3f443fc3
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/mtl/template.mk
@@ -0,0 +1,107 @@
+##
+## Template makefile for Standard, Profile, Debug, Release, and Release-static versions
+##
+## eg: "make rs" for a statically linked release version.
+## "make d" for a debug version (no optimizations).
+## "make" for the standard version (optimized, but with debug information and assertions active)
+
+PWD = $(shell pwd)
+EXEC ?= $(notdir $(PWD))
+
+CSRCS = $(wildcard $(PWD)/*.cc)
+DSRCS = $(foreach dir, $(DEPDIR), $(filter-out $(MROOT)/$(dir)/Main.cc, $(wildcard $(MROOT)/$(dir)/*.cc)))
+CHDRS = $(wildcard $(PWD)/*.h)
+COBJS = $(CSRCS:.cc=.o) $(DSRCS:.cc=.o)
+
+PCOBJS = $(addsuffix p, $(COBJS))
+DCOBJS = $(addsuffix d, $(COBJS))
+RCOBJS = $(addsuffix r, $(COBJS))
+
+
+CXX ?= g++
+CFLAGS ?= -Wall -Wno-parentheses
+LFLAGS ?= -Wall
+
+COPTIMIZE ?= -O3
+
+CFLAGS += -I$(MROOT) -D __STDC_LIMIT_MACROS -D __STDC_FORMAT_MACROS
+LFLAGS += -lz
+
+.PHONY : s p d r rs clean
+
+s: $(EXEC)
+p: $(EXEC)_profile
+d: $(EXEC)_debug
+r: $(EXEC)_release
+rs: $(EXEC)_static
+
+libs: lib$(LIB)_standard.a
+libp: lib$(LIB)_profile.a
+libd: lib$(LIB)_debug.a
+libr: lib$(LIB)_release.a
+
+## Compile options
+%.o: CFLAGS +=$(COPTIMIZE) -g -D DEBUG
+%.op: CFLAGS +=$(COPTIMIZE) -pg -g -D NDEBUG
+%.od: CFLAGS +=-O0 -g -D DEBUG
+%.or: CFLAGS +=$(COPTIMIZE) -g -D NDEBUG
+
+## Link options
+$(EXEC): LFLAGS += -g
+$(EXEC)_profile: LFLAGS += -g -pg
+$(EXEC)_debug: LFLAGS += -g
+#$(EXEC)_release: LFLAGS += ...
+$(EXEC)_static: LFLAGS += --static
+
+## Dependencies
+$(EXEC): $(COBJS)
+$(EXEC)_profile: $(PCOBJS)
+$(EXEC)_debug: $(DCOBJS)
+$(EXEC)_release: $(RCOBJS)
+$(EXEC)_static: $(RCOBJS)
+
+lib$(LIB)_standard.a: $(filter-out */Main.o, $(COBJS))
+lib$(LIB)_profile.a: $(filter-out */Main.op, $(PCOBJS))
+lib$(LIB)_debug.a: $(filter-out */Main.od, $(DCOBJS))
+lib$(LIB)_release.a: $(filter-out */Main.or, $(RCOBJS))
+
+
+## Build rule
+%.o %.op %.od %.or: %.cc
+ @echo Compiling: $(subst $(MROOT)/,,$@)
+ @$(CXX) $(CFLAGS) -c -o $@ $<
+
+## Linking rules (standard/profile/debug/release)
+$(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static:
+ @echo Linking: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )"
+ @$(CXX) $^ $(LFLAGS) -o $@
+
+## Library rules (standard/profile/debug/release)
+lib$(LIB)_standard.a lib$(LIB)_profile.a lib$(LIB)_release.a lib$(LIB)_debug.a:
+ @echo Making library: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )"
+ @$(AR) -rcsv $@ $^
+
+## Library Soft Link rule:
+libs libp libd libr:
+ @echo "Making Soft Link: $^ -> lib$(LIB).a"
+ @ln -sf $^ lib$(LIB).a
+
+## Clean rule
+clean:
+ @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
+ $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mk
+
+## Make dependencies
+depend.mk: $(CSRCS) $(CHDRS)
+ @echo Making dependencies
+ @$(CXX) $(CFLAGS) -I$(MROOT) \
+ $(CSRCS) -MM | sed 's|\(.*\):|$(PWD)/\1 $(PWD)/\1r $(PWD)/\1d $(PWD)/\1p:|' > depend.mk
+ @for dir in $(DEPDIR); do \
+ if [ -r $(MROOT)/$${dir}/depend.mk ]; then \
+ echo Depends on: $${dir}; \
+ cat $(MROOT)/$${dir}/depend.mk >> depend.mk; \
+ fi; \
+ done
+
+-include $(MROOT)/mtl/config.mk
+-include depend.mk
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Main.cc b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Main.cc
new file mode 100755
index 00000000..d4ca8873
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Main.cc
@@ -0,0 +1,251 @@
+/*****************************************************************************************[Main.cc]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include
+
+#include
+#include
+#include
+
+#include "utils/System.h"
+#include "utils/ParseUtils.h"
+#include "utils/Options.h"
+#include "core/Dimacs.h"
+#include "simp/SimpSolver.h"
+
+using namespace Minisat;
+
+//=================================================================================================
+
+
+void printStats(Solver& solver)
+{
+ double cpu_time = cpuTime();
+// double mem_used = memUsedPeak();
+// printf("c restarts : %"PRIu64"\n", solver.starts);
+// printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time);
+// printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time);
+// printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
+// printf("c conflict literals : %-12"PRIu64" (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals);
+// if (mem_used != 0) printf("c Memory used : %.2f MB\n", mem_used);
+ printf("c CPU time : %g s\n", cpu_time);
+}
+
+
+static Solver* solver;
+// Terminate by notifying the solver and back out gracefully. This is mainly to have a test-case
+// for this feature of the Solver as it may take longer than an immediate call to '_exit()'.
+static void SIGINT_interrupt(int signum) { solver->interrupt(); }
+
+// Note that '_exit()' rather than 'exit()' has to be used. The reason is that 'exit()' calls
+// destructors and may cause deadlocks if a malloc/free function happens to be running (these
+// functions are guarded by locks for multithreaded use).
+static void SIGINT_exit(int signum) {
+ printf("\n"); printf("c *** INTERRUPTED ***\n");
+ if (solver->verbosity > 0){
+ printStats(*solver);
+ printf("\n"); printf("c *** INTERRUPTED ***\n"); }
+ _exit(1); }
+
+
+//=================================================================================================
+// Main:
+
+int main(int argc, char** argv)
+{
+ try {
+ setUsageHelp("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n");
+ printf("c This is COMiniSatPS.\n");
+
+#if defined(__linux__)
+ fpu_control_t oldcw, newcw;
+ _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw);
+ printf("c WARNING: for repeatability, setting FPU to use double precision\n");
+#endif
+ // Extra options:
+ //
+ IntOption verb ("MAIN", "verb", "Verbosity level (0=silent, 1=some, 2=more).", 1, IntRange(0, 2));
+ BoolOption pre ("MAIN", "pre", "Completely turn on/off any preprocessing.", true);
+ StringOption dimacs ("MAIN", "dimacs", "If given, stop after preprocessing and write the result to this file.");
+ IntOption cpu_lim("MAIN", "cpu-lim","Limit on CPU time allowed in seconds.\n", INT32_MAX, IntRange(0, INT32_MAX));
+ IntOption mem_lim("MAIN", "mem-lim","Limit on memory usage in megabytes.\n", INT32_MAX, IntRange(0, INT32_MAX));
+ BoolOption drup ("MAIN", "drup", "Generate DRUP UNSAT proof.", false);
+ StringOption drup_file("MAIN", "drup-file", "DRUP UNSAT proof ouput file.", "");
+
+ parseOptions(argc, argv, true);
+
+ SimpSolver S;
+ double initial_time = cpuTime();
+
+ if (!pre) S.eliminate(true);
+
+ S.parsing = true;
+ S.verbosity = verb;
+ if (drup || strlen(drup_file)){
+ S.drup_file = strlen(drup_file) ? fopen(drup_file, "wb") : stdout;
+ if (S.drup_file == NULL){
+ S.drup_file = stdout;
+ printf("c Error opening %s for write.\n", (const char*) drup_file); }
+ printf("c DRUP proof generation: %s\n", S.drup_file == stdout ? "stdout" : drup_file);
+ }
+
+ solver = &S;
+ // Use signal handlers that forcibly quit until the solver will be able to respond to
+ // interrupts:
+ signal(SIGINT, SIGINT_exit);
+ signal(SIGXCPU,SIGINT_exit);
+
+ // Set limit on CPU-time:
+ if (cpu_lim != INT32_MAX){
+ rlimit rl;
+ getrlimit(RLIMIT_CPU, &rl);
+ if (rl.rlim_max == RLIM_INFINITY || (rlim_t)cpu_lim < rl.rlim_max){
+ rl.rlim_cur = cpu_lim;
+ if (setrlimit(RLIMIT_CPU, &rl) == -1)
+ printf("c WARNING! Could not set resource limit: CPU-time.\n");
+ } }
+
+ // Set limit on virtual memory:
+ if (mem_lim != INT32_MAX){
+ rlim_t new_mem_lim = (rlim_t)mem_lim * 1024*1024;
+ rlimit rl;
+ getrlimit(RLIMIT_AS, &rl);
+ if (rl.rlim_max == RLIM_INFINITY || new_mem_lim < rl.rlim_max){
+ rl.rlim_cur = new_mem_lim;
+ if (setrlimit(RLIMIT_AS, &rl) == -1)
+ printf("c WARNING! Could not set resource limit: Virtual memory.\n");
+ } }
+
+ if (argc == 1)
+ printf("c Reading from standard input... Use '--help' for help.\n");
+
+ gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
+ if (in == NULL)
+ printf("c ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1);
+
+ if (S.verbosity > 0){
+ printf("c ============================[ Problem Statistics ]=============================\n");
+ printf("c | |\n"); }
+
+ parse_DIMACS(in, S);
+ gzclose(in);
+ FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
+
+ if (S.verbosity > 0){
+ printf("c | Number of variables: %12d |\n", S.nVars());
+ printf("c | Number of clauses: %12d |\n", S.nClauses()); }
+
+ double parsed_time = cpuTime();
+ if (S.verbosity > 0)
+ printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time);
+
+ // Change to signal-handlers that will only notify the solver and allow it to terminate
+ // voluntarily:
+ // signal(SIGINT, SIGINT_interrupt);
+ // signal(SIGXCPU,SIGINT_interrupt);
+
+ S.parsing = false;
+ S.eliminate(true);
+ double simplified_time = cpuTime();
+ if (S.verbosity > 0){
+ printf("c | Simplification time: %12.2f s |\n", simplified_time - parsed_time);
+ printf("c | |\n"); }
+
+ if (!S.okay()){
+ if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res);
+ if (S.verbosity > 0){
+ printf("c ===============================================================================\n");
+ printf("c Solved by simplification\n");
+ printStats(S);
+ printf("\n"); }
+ printf("s UNSATISFIABLE\n");
+ if (S.drup_file){
+#ifdef BIN_DRUP
+ fputc('a', S.drup_file); fputc(0, S.drup_file);
+#else
+ fprintf(S.drup_file, "0\n");
+#endif
+ }
+ if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file);
+ exit(20);
+ }
+
+ if (dimacs){
+ if (S.verbosity > 0)
+ printf("c ==============================[ Writing DIMACS ]===============================\n");
+ S.toDimacs((const char*)dimacs);
+ if (S.verbosity > 0)
+ printStats(S);
+ exit(0);
+ }
+
+ vec dummy;
+ lbool ret = S.solveLimited(dummy);
+
+ if (S.verbosity > 0){
+ printStats(S);
+ printf("\n"); }
+ printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n");
+ // Do not flush stdout
+ // if (ret == l_True){
+ // printf("v ");
+ // for (int i = 0; i < S.nVars(); i++)
+ // if (S.model[i] != l_Undef)
+ // printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+ // printf(" 0\n");
+ // }
+
+ if (S.drup_file && ret == l_False){
+#ifdef BIN_DRUP
+ fputc('a', S.drup_file); fputc(0, S.drup_file);
+#else
+ fprintf(S.drup_file, "0\n");
+#endif
+ }
+ if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file);
+
+ if (res != NULL){
+ if (ret == l_True){
+ fprintf(res, "SAT\n");
+ for (int i = 0; i < S.nVars(); i++)
+ if (S.model[i] != l_Undef)
+ fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+ fprintf(res, " 0\n");
+ }else if (ret == l_False)
+ fprintf(res, "UNSAT\n");
+ else
+ fprintf(res, "INDET\n");
+ fclose(res);
+ }
+
+#ifdef NDEBUG
+ exit(ret == l_True ? 10 : ret == l_False ? 20 : 0); // (faster than "return", which will invoke the destructor for 'Solver')
+#else
+ return (ret == l_True ? 10 : ret == l_False ? 20 : 0);
+#endif
+ } catch (OutOfMemoryException&){
+ printf("c ===============================================================================\n");
+ printf("c Out of memory\n");
+ printf("s UNKNOWN\n");
+ exit(0);
+ }
+}
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Makefile b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Makefile
new file mode 100755
index 00000000..27b45f49
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/Makefile
@@ -0,0 +1,4 @@
+EXEC = minisat
+DEPDIR = mtl utils core
+
+include $(MROOT)/mtl/template.mk
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.cc b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.cc
new file mode 100755
index 00000000..ebf9e33b
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.cc
@@ -0,0 +1,825 @@
+/***********************************************************************************[SimpSolver.cc]
+MiniSat -- Copyright (c) 2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include "mtl/Sort.h"
+#include "simp/SimpSolver.h"
+#include "utils/System.h"
+
+using namespace Minisat;
+
+//=================================================================================================
+// Options:
+
+
+static const char* _cat = "SIMP";
+
+static BoolOption opt_use_asymm (_cat, "asymm", "Shrink clauses by asymmetric branching.", false);
+static BoolOption opt_use_rcheck (_cat, "rcheck", "Check if a clause is already implied. (costly)", false);
+static BoolOption opt_use_elim (_cat, "elim", "Perform variable elimination.", true);
+static IntOption opt_grow (_cat, "grow", "Allow a variable elimination step to grow by a number of clauses.", 0);
+static IntOption opt_clause_lim (_cat, "cl-lim", "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20, IntRange(-1, INT32_MAX));
+static IntOption opt_subsumption_lim (_cat, "sub-lim", "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
+static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.", 0.5, DoubleRange(0, false, HUGE_VAL, false));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+SimpSolver::SimpSolver() :
+ parsing (false)
+ , grow (opt_grow)
+ , clause_lim (opt_clause_lim)
+ , subsumption_lim (opt_subsumption_lim)
+ , simp_garbage_frac (opt_simp_garbage_frac)
+ , use_asymm (opt_use_asymm)
+ , use_rcheck (opt_use_rcheck)
+ , use_elim (opt_use_elim)
+ , merges (0)
+ , asymm_lits (0)
+ , eliminated_vars (0)
+ , elimorder (1)
+ , use_simplification (true)
+ , occurs (ClauseDeleted(ca))
+ , elim_heap (ElimLt(n_occ))
+ , bwdsub_assigns (0)
+ , n_touched (0)
+{
+ vec dummy(1,lit_Undef);
+ ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+ bwdsub_tmpunit = ca.alloc(dummy);
+ remove_satisfied = false;
+}
+
+
+SimpSolver::~SimpSolver()
+{
+}
+
+
+Var SimpSolver::newVar(bool sign, bool dvar) {
+ Var v = Solver::newVar(sign, dvar);
+
+ frozen .push((char)false);
+ eliminated.push((char)false);
+
+ if (use_simplification){
+ n_occ .push(0);
+ n_occ .push(0);
+ occurs .init(v);
+ touched .push(0);
+ elim_heap .insert(v);
+ }
+ return v; }
+
+
+
+lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+ vec extra_frozen;
+ lbool result = l_True;
+
+ do_simp &= use_simplification;
+
+ if (do_simp){
+ // Assumptions must be temporarily frozen to run variable elimination:
+ for (int i = 0; i < assumptions.size(); i++){
+ Var v = var(assumptions[i]);
+
+ // If an assumption has been eliminated, remember it.
+ assert(!isEliminated(v));
+
+ if (!frozen[v]){
+ // Freeze and store.
+ setFrozen(v, true);
+ extra_frozen.push(v);
+ } }
+
+ result = lbool(eliminate(turn_off_simp));
+ }
+
+ if (result == l_True)
+ result = Solver::solve_();
+ else if (verbosity >= 1)
+ printf("c ===============================================================================\n");
+
+ if (result == l_True)
+ extendModel();
+
+ if (do_simp)
+ // Unfreeze the assumptions that were frozen:
+ for (int i = 0; i < extra_frozen.size(); i++)
+ setFrozen(extra_frozen[i], false);
+
+ return result;
+}
+
+
+
+bool SimpSolver::addClause_(vec& ps)
+{
+#ifndef NDEBUG
+ for (int i = 0; i < ps.size(); i++)
+ assert(!isEliminated(var(ps[i])));
+#endif
+
+ int nclauses = clauses.size();
+
+ if (use_rcheck && implied(ps))
+ return true;
+
+ if (!Solver::addClause_(ps))
+ return false;
+
+ if (!parsing && drup_file) {
+#ifdef BIN_DRUP
+ binDRUP('a', ps, drup_file);
+#else
+ for (int i = 0; i < ps.size(); i++)
+ fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ if (use_simplification && clauses.size() == nclauses + 1){
+ CRef cr = clauses.last();
+ const Clause& c = ca[cr];
+
+ // NOTE: the clause is added to the queue immediately and then
+ // again during 'gatherTouchedClauses()'. If nothing happens
+ // in between, it will only be checked once. Otherwise, it may
+ // be checked twice unnecessarily. This is an unfortunate
+ // consequence of how backward subsumption is used to mimic
+ // forward subsumption.
+ subsumption_queue.insert(cr);
+ for (int i = 0; i < c.size(); i++){
+ occurs[var(c[i])].push(cr);
+ n_occ[toInt(c[i])]++;
+ touched[var(c[i])] = 1;
+ n_touched++;
+ if (elim_heap.inHeap(var(c[i])))
+ elim_heap.increase(var(c[i]));
+ }
+ }
+
+ return true;
+}
+
+
+void SimpSolver::removeClause(CRef cr)
+{
+ const Clause& c = ca[cr];
+
+ if (use_simplification)
+ for (int i = 0; i < c.size(); i++){
+ n_occ[toInt(c[i])]--;
+ updateElimHeap(var(c[i]));
+ occurs.smudge(var(c[i]));
+ }
+
+ Solver::removeClause(cr);
+}
+
+
+bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+ Clause& c = ca[cr];
+ assert(decisionLevel() == 0);
+ assert(use_simplification);
+
+ // FIX: this is too inefficient but would be nice to have (properly implemented)
+ // if (!find(subsumption_queue, &c))
+ subsumption_queue.insert(cr);
+
+ if (drup_file){
+#ifdef BIN_DRUP
+ binDRUP_strengthen(c, l, drup_file);
+#else
+ for (int i = 0; i < c.size(); i++)
+ if (c[i] != l) fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ if (c.size() == 2){
+ removeClause(cr);
+ c.strengthen(l);
+ }else{
+ if (drup_file){
+#ifdef BIN_DRUP
+ binDRUP('d', c, drup_file);
+#else
+ fprintf(drup_file, "d ");
+ for (int i = 0; i < c.size(); i++)
+ fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+ fprintf(drup_file, "0\n");
+#endif
+ }
+
+ detachClause(cr, true);
+ c.strengthen(l);
+ attachClause(cr);
+ remove(occurs[var(l)], cr);
+ n_occ[toInt(l)]--;
+ updateElimHeap(var(l));
+ }
+
+ return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& out_clause)
+{
+ merges++;
+ out_clause.clear();
+
+ bool ps_smallest = _ps.size() < _qs.size();
+ const Clause& ps = ps_smallest ? _qs : _ps;
+ const Clause& qs = ps_smallest ? _ps : _qs;
+
+ for (int i = 0; i < qs.size(); i++){
+ if (var(qs[i]) != v){
+ for (int j = 0; j < ps.size(); j++)
+ if (var(ps[j]) == var(qs[i]))
+ if (ps[j] == ~qs[i])
+ return false;
+ else
+ goto next;
+ out_clause.push(qs[i]);
+ }
+ next:;
+ }
+
+ for (int i = 0; i < ps.size(); i++)
+ if (var(ps[i]) != v)
+ out_clause.push(ps[i]);
+
+ return true;
+}
+
+
+// Returns FALSE if clause is always satisfied.
+bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+ merges++;
+
+ bool ps_smallest = _ps.size() < _qs.size();
+ const Clause& ps = ps_smallest ? _qs : _ps;
+ const Clause& qs = ps_smallest ? _ps : _qs;
+ const Lit* __ps = (const Lit*)ps;
+ const Lit* __qs = (const Lit*)qs;
+
+ size = ps.size()-1;
+
+ for (int i = 0; i < qs.size(); i++){
+ if (var(__qs[i]) != v){
+ for (int j = 0; j < ps.size(); j++)
+ if (var(__ps[j]) == var(__qs[i]))
+ if (__ps[j] == ~__qs[i])
+ return false;
+ else
+ goto next;
+ size++;
+ }
+ next:;
+ }
+
+ return true;
+}
+
+
+void SimpSolver::gatherTouchedClauses()
+{
+ if (n_touched == 0) return;
+
+ int i,j;
+ for (i = j = 0; i < subsumption_queue.size(); i++)
+ if (ca[subsumption_queue[i]].mark() == 0)
+ ca[subsumption_queue[i]].mark(2);
+
+ for (i = 0; i < touched.size(); i++)
+ if (touched[i]){
+ const vec& cs = occurs.lookup(i);
+ for (j = 0; j < cs.size(); j++)
+ if (ca[cs[j]].mark() == 0){
+ subsumption_queue.insert(cs[j]);
+ ca[cs[j]].mark(2);
+ }
+ touched[i] = 0;
+ }
+
+ for (i = 0; i < subsumption_queue.size(); i++)
+ if (ca[subsumption_queue[i]].mark() == 2)
+ ca[subsumption_queue[i]].mark(0);
+
+ n_touched = 0;
+}
+
+
+bool SimpSolver::implied(const vec& c)
+{
+ assert(decisionLevel() == 0);
+
+ trail_lim.push(trail.size());
+ for (int i = 0; i < c.size(); i++)
+ if (value(c[i]) == l_True){
+ cancelUntil(0);
+ return true;
+ }else if (value(c[i]) != l_False){
+ assert(value(c[i]) == l_Undef);
+ uncheckedEnqueue(~c[i]);
+ }
+
+ bool result = propagate() != CRef_Undef;
+ cancelUntil(0);
+ return result;
+}
+
+
+// Backward subsumption + backward subsumption resolution
+bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+ int cnt = 0;
+ int subsumed = 0;
+ int deleted_literals = 0;
+ assert(decisionLevel() == 0);
+
+ while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
+
+ // Empty subsumption queue and return immediately on user-interrupt:
+ if (asynch_interrupt){
+ subsumption_queue.clear();
+ bwdsub_assigns = trail.size();
+ break; }
+
+ // Check top-level assignments by creating a dummy clause and placing it in the queue:
+ if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
+ Lit l = trail[bwdsub_assigns++];
+ ca[bwdsub_tmpunit][0] = l;
+ ca[bwdsub_tmpunit].calcAbstraction();
+ subsumption_queue.insert(bwdsub_tmpunit); }
+
+ CRef cr = subsumption_queue.peek(); subsumption_queue.pop();
+ Clause& c = ca[cr];
+
+ if (c.mark()) continue;
+
+ if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+ printf("c subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
+
+ assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point.
+
+ // Find best variable to scan:
+ Var best = var(c[0]);
+ for (int i = 1; i < c.size(); i++)
+ if (occurs[var(c[i])].size() < occurs[best].size())
+ best = var(c[i]);
+
+ // Search all candidates:
+ vec& _cs = occurs.lookup(best);
+ CRef* cs = (CRef*)_cs;
+
+ for (int j = 0; j < _cs.size(); j++)
+ if (c.mark())
+ break;
+ else if (!ca[cs[j]].mark() && cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
+ Lit l = c.subsumes(ca[cs[j]]);
+
+ if (l == lit_Undef)
+ subsumed++, removeClause(cs[j]);
+ else if (l != lit_Error){
+ deleted_literals++;
+
+ if (!strengthenClause(cs[j], ~l))
+ return false;
+
+ // Did current candidate get deleted from cs? Then check candidate at index j again:
+ if (var(l) == best)
+ j--;
+ }
+ }
+ }
+
+ return true;
+}
+
+
+bool SimpSolver::asymm(Var v, CRef cr)
+{
+ Clause& c = ca[cr];
+ assert(decisionLevel() == 0);
+
+ if (c.mark() || satisfied(c)) return true;
+
+ trail_lim.push(trail.size());
+ Lit l = lit_Undef;
+ for (int i = 0; i < c.size(); i++)
+ if (var(c[i]) != v){
+ if (value(c[i]) != l_False)
+ uncheckedEnqueue(~c[i]);
+ }else
+ l = c[i];
+
+ if (propagate() != CRef_Undef){
+ cancelUntil(0);
+ asymm_lits++;
+ if (!strengthenClause(cr, l))
+ return false;
+ }else
+ cancelUntil(0);
+
+ return true;
+}
+
+
+bool SimpSolver::asymmVar(Var v)
+{
+ assert(use_simplification);
+
+ const vec& cls = occurs.lookup(v);
+
+ if (value(v) != l_Undef || cls.size() == 0)
+ return true;
+
+ for (int i = 0; i < cls.size(); i++)
+ if (!asymm(v, cls[i]))
+ return false;
+
+ return backwardSubsumptionCheck();
+}
+
+
+static void mkElimClause(vec& elimclauses, Lit x)
+{
+ elimclauses.push(toInt(x));
+ elimclauses.push(1);
+}
+
+
+static void mkElimClause(vec& elimclauses, Var v, Clause& c)
+{
+ int first = elimclauses.size();
+ int v_pos = -1;
+
+ // Copy clause to elimclauses-vector. Remember position where the
+ // variable 'v' occurs:
+ for (int i = 0; i < c.size(); i++){
+ elimclauses.push(toInt(c[i]));
+ if (var(c[i]) == v)
+ v_pos = i + first;
+ }
+ assert(v_pos != -1);
+
+ // Swap the first literal with the 'v' literal, so that the literal
+ // containing 'v' will occur first in the clause:
+ uint32_t tmp = elimclauses[v_pos];
+ elimclauses[v_pos] = elimclauses[first];
+ elimclauses[first] = tmp;
+
+ // Store the length of the clause last:
+ elimclauses.push(c.size());
+}
+
+
+
+bool SimpSolver::eliminateVar(Var v)
+{
+ assert(!frozen[v]);
+ assert(!isEliminated(v));
+ assert(value(v) == l_Undef);
+
+ // Split the occurrences into positive and negative:
+ //
+ const vec& cls = occurs.lookup(v);
+ vec pos, neg;
+ for (int i = 0; i < cls.size(); i++)
+ (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+ // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
+ // clause must exceed the limit on the maximal clause size (if it is set):
+ //
+ int cnt = 0;
+ int clause_size = 0;
+
+ for (int i = 0; i < pos.size(); i++)
+ for (int j = 0; j < neg.size(); j++)
+ if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) &&
+ (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
+ return true;
+
+ // Delete and store old clauses:
+ eliminated[v] = true;
+ setDecisionVar(v, false);
+ eliminated_vars++;
+
+ if (pos.size() > neg.size()){
+ for (int i = 0; i < neg.size(); i++)
+ mkElimClause(elimclauses, v, ca[neg[i]]);
+ mkElimClause(elimclauses, mkLit(v));
+ }else{
+ for (int i = 0; i < pos.size(); i++)
+ mkElimClause(elimclauses, v, ca[pos[i]]);
+ mkElimClause(elimclauses, ~mkLit(v));
+ }
+
+ // Produce clauses in cross product:
+ vec& resolvent = add_tmp;
+ for (int i = 0; i < pos.size(); i++)
+ for (int j = 0; j < neg.size(); j++)
+ if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+ return false;
+
+ for (int i = 0; i < cls.size(); i++)
+ removeClause(cls[i]);
+
+ // Free occurs list for this variable:
+ occurs[v].clear(true);
+
+ // Free watchers lists for this variable, if possible:
+ watches_bin[ mkLit(v)].clear(true);
+ watches_bin[~mkLit(v)].clear(true);
+ watches[ mkLit(v)].clear(true);
+ watches[~mkLit(v)].clear(true);
+
+ return backwardSubsumptionCheck();
+}
+
+
+bool SimpSolver::substitute(Var v, Lit x)
+{
+ assert(!frozen[v]);
+ assert(!isEliminated(v));
+ assert(value(v) == l_Undef);
+
+ if (!ok) return false;
+
+ eliminated[v] = true;
+ setDecisionVar(v, false);
+ const vec& cls = occurs.lookup(v);
+
+ vec& subst_clause = add_tmp;
+ for (int i = 0; i < cls.size(); i++){
+ Clause& c = ca[cls[i]];
+
+ subst_clause.clear();
+ for (int j = 0; j < c.size(); j++){
+ Lit p = c[j];
+ subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+ }
+
+ if (!addClause_(subst_clause))
+ return ok = false;
+
+ removeClause(cls[i]);
+ }
+
+ return true;
+}
+
+
+void SimpSolver::extendModel()
+{
+ int i, j;
+ Lit x;
+
+ for (i = elimclauses.size()-1; i > 0; i -= j){
+ for (j = elimclauses[i--]; j > 1; j--, i--)
+ if (modelValue(toLit(elimclauses[i])) != l_False)
+ goto next;
+
+ x = toLit(elimclauses[i]);
+ model[var(x)] = lbool(!sign(x));
+ next:;
+ }
+}
+
+// Almost duplicate of Solver::removeSatisfied. Didn't want to make the base method 'virtual'.
+void SimpSolver::removeSatisfied()
+{
+ int i, j;
+ for (i = j = 0; i < clauses.size(); i++){
+ const Clause& c = ca[clauses[i]];
+ if (c.mark() == 0)
+ if (satisfied(c))
+ removeClause(clauses[i]);
+ else
+ clauses[j++] = clauses[i];
+ }
+ clauses.shrink(i - j);
+}
+
+// The technique and code are by the courtesy of the GlueMiniSat team. Thank you!
+// It helps solving certain types of huge problems tremendously.
+bool SimpSolver::eliminate(bool turn_off_elim)
+{
+ bool res = true;
+ int iter = 0;
+ int n_cls, n_cls_init, n_vars;
+
+ if (nVars() == 0) goto cleanup; // User disabling preprocessing.
+
+ // Get an initial number of clauses (more accurately).
+ if (trail.size() != 0) removeSatisfied();
+ n_cls_init = nClauses();
+
+ res = eliminate_(); // The first, usual variable elimination of MiniSat.
+ if (!res) goto cleanup;
+
+ n_cls = nClauses();
+ n_vars = nFreeVars();
+
+ printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars, n_cls, grow);
+
+ if ((double)n_cls / n_vars >= 5 || n_vars < 10000){
+ printf("c No iterative elimination performed. (vars=%d, c/v ratio=%.1f)\n", n_vars, (double)n_cls / n_vars);
+ goto cleanup; }
+
+ grow = grow ? grow * 2 : 8;
+ for (; grow < 10000; grow *= 2){
+ // Rebuild elimination variable heap.
+ for (int i = 0; i < clauses.size(); i++){
+ const Clause& c = ca[clauses[i]];
+ for (int j = 0; j < c.size(); j++)
+ if (!elim_heap.inHeap(var(c[j])))
+ elim_heap.insert(var(c[j]));
+ else
+ elim_heap.update(var(c[j])); }
+
+ int n_cls_last = nClauses();
+ int n_vars_last = nFreeVars();
+
+ res = eliminate_();
+ if (!res || n_vars_last == nFreeVars()) break;
+ iter++;
+
+ int n_cls_now = nClauses();
+ int n_vars_now = nFreeVars();
+
+ double cl_inc_rate = (double)n_cls_now / n_cls_last;
+ double var_dec_rate = (double)n_vars_last / n_vars_now;
+
+ printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars_now, n_cls_now, grow);
+ printf("c cl_inc_rate=%.3f, var_dec_rate=%.3f\n", cl_inc_rate, var_dec_rate);
+
+ if (n_cls_now > n_cls_init || cl_inc_rate > var_dec_rate) break;
+ }
+ printf("c No. effective iterative eliminations: %d\n", iter);
+
+cleanup:
+ touched .clear(true);
+ occurs .clear(true);
+ n_occ .clear(true);
+ elim_heap.clear(true);
+ subsumption_queue.clear(true);
+
+ use_simplification = false;
+ remove_satisfied = true;
+ ca.extra_clause_field = false;
+
+ // Force full cleanup (this is safe and desirable since it only happens once):
+ rebuildOrderHeap();
+ garbageCollect();
+
+ return res;
+}
+
+
+bool SimpSolver::eliminate_()
+{
+ if (!simplify())
+ return false;
+ else if (!use_simplification)
+ return true;
+
+ int trail_size_last = trail.size();
+
+ // Main simplification loop:
+ //
+ while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0){
+
+ gatherTouchedClauses();
+ // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+ if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) &&
+ !backwardSubsumptionCheck(true)){
+ ok = false; goto cleanup; }
+
+ // Empty elim_heap and return immediately on user-interrupt:
+ if (asynch_interrupt){
+ assert(bwdsub_assigns == trail.size());
+ assert(subsumption_queue.size() == 0);
+ assert(n_touched == 0);
+ elim_heap.clear();
+ goto cleanup; }
+
+ // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+ for (int cnt = 0; !elim_heap.empty(); cnt++){
+ Var elim = elim_heap.removeMin();
+
+ if (asynch_interrupt) break;
+
+ if (isEliminated(elim) || value(elim) != l_Undef) continue;
+
+ if (verbosity >= 2 && cnt % 100 == 0)
+ printf("c elimination left: %10d\r", elim_heap.size());
+
+ if (use_asymm){
+ // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+ bool was_frozen = frozen[elim];
+ frozen[elim] = true;
+ if (!asymmVar(elim)){
+ ok = false; goto cleanup; }
+ frozen[elim] = was_frozen; }
+
+ // At this point, the variable may have been set by assymetric branching, so check it
+ // again. Also, don't eliminate frozen variables:
+ if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
+ ok = false; goto cleanup; }
+
+ checkGarbage(simp_garbage_frac);
+ }
+
+ assert(subsumption_queue.size() == 0);
+ }
+ cleanup:
+ // To get an accurate number of clauses.
+ if (trail_size_last != trail.size())
+ removeSatisfied();
+ else{
+ int i,j;
+ for (i = j = 0; i < clauses.size(); i++)
+ if (ca[clauses[i]].mark() == 0)
+ clauses[j++] = clauses[i];
+ clauses.shrink(i - j);
+ }
+ checkGarbage();
+
+ if (verbosity >= 1 && elimclauses.size() > 0)
+ printf("c | Eliminated clauses: %10.2f Mb |\n",
+ double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
+
+ return ok;
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+
+void SimpSolver::relocAll(ClauseAllocator& to)
+{
+ if (!use_simplification) return;
+
+ // All occurs lists:
+ //
+ occurs.cleanAll();
+ for (int i = 0; i < nVars(); i++){
+ vec& cs = occurs[i];
+ for (int j = 0; j < cs.size(); j++)
+ ca.reloc(cs[j], to);
+ }
+
+ // Subsumption queue:
+ //
+ for (int i = 0; i < subsumption_queue.size(); i++)
+ ca.reloc(subsumption_queue[i], to);
+
+ // Temporary clause:
+ //
+ ca.reloc(bwdsub_tmpunit, to);
+}
+
+
+void SimpSolver::garbageCollect()
+{
+ // Initialize the next region to a size corresponding to the estimated utilization degree. This
+ // is not precise but should avoid some unnecessary reallocations for the new region:
+ ClauseAllocator to(ca.size() - ca.wasted());
+
+ to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+ relocAll(to);
+ Solver::relocAll(to);
+ if (verbosity >= 2)
+ printf("c | Garbage collection: %12d bytes => %12d bytes |\n",
+ ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+ to.moveTo(ca);
+}
diff --git a/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.h b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.h
new file mode 100755
index 00000000..b4c6b803
--- /dev/null
+++ b/thirdparty/QuadriFlow/3rd/MapleCOMSPS_LRB/simp/SimpSolver.h
@@ -0,0 +1,201 @@
+/************************************************************************************[SimpSolver.h]
+MiniSat -- Copyright (c) 2006, Niklas Een, Niklas Sorensson
+ Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_SimpSolver_h
+#define Minisat_SimpSolver_h
+
+#include "mtl/Queue.h"
+#include "core/Solver.h"
+
+
+namespace Minisat {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+ // Constructor/Destructor:
+ //
+ SimpSolver();
+ ~SimpSolver();
+
+ // Problem specification:
+ //
+ Var newVar (bool polarity = true, bool dvar = true);
+ bool addClause (const vec& ps);
+ bool addEmptyClause(); // Add the empty clause to the solver.
+ bool addClause (Lit p); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+ bool addClause_( vec& ps);
+ bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction).
+
+ // Variable mode:
+ //
+ void setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+ bool isEliminated(Var v) const;
+
+ // Solving:
+ //
+ bool solve (const vec& assumps, bool do_simp = true, bool turn_off_simp = false);
+ lbool solveLimited(const vec& assumps, bool do_simp = true, bool turn_off_simp = false);
+ bool solve ( bool do_simp = true, bool turn_off_simp = false);
+ bool solve (Lit p , bool do_simp = true, bool turn_off_simp = false);
+ bool solve (Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false);
+ bool solve (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+ bool eliminate (bool turn_off_elim = false); // Perform variable elimination based simplification.
+ bool eliminate_ ();
+ void removeSatisfied();
+
+ // Memory managment:
+ //
+ virtual void garbageCollect();
+
+
+ // Generate a (possibly simplified) DIMACS file:
+ //
+#if 0
+ void toDimacs (const char* file, const vec