void TheoryArith::printRational(ExprStream& os, const Rational& r,
bool printAsReal)
{
// Print rational
if (r.isInteger()) {
if (r < 0) {
if (os.lang() == SPASS_LANG) {
os << "-" << (-r).toString();
if (printAsReal) os << ".0";
} else {
os << "(" << push;
if (os.lang() == SMTLIB_LANG) {
os << "~";
}
else {
os << "-";
}
os << space << (-r).toString();
if (printAsReal) os << ".0";
os << push << ")";
}
}
else {
os << r.toString();
if (printAsReal) os << ".0";
}
}
else {
os << "(" << push << "/ ";
Rational tmp = r.getNumerator();
if (tmp < 0) {
if (os.lang() == SPASS_LANG) {
os << "-" << (-tmp).toString();
if (printAsReal) os << ".0";
} else {
os << "(" << push;
if (os.lang() == SMTLIB_LANG) {
os << "~";
}
else {
os << "-";
}
os << space << (-tmp).toString();
if (printAsReal) os << ".0";
os << push << ")";
}
}
else {
os << tmp.toString();
if (printAsReal) os << ".0";
}
os << space;
tmp = r.getDenominator();
DebugAssert(tmp > 0 && tmp.isInteger(), "Unexpected rational denominator");
os << tmp.toString();
if (printAsReal) os << ".0";
os << push << ")";
}
}
static void checkInt(const Rational& n, const string& funName) {
DebugAssert(n.isInteger(),
("CVC3::Rational::" + funName
+ ": argument is not an integer: " + n.toString()).c_str());
}
int main( int argc, char** argv )
{
// Command line options
bool help_mode_enabled{ false };
scalar end_time_override{ -1.0 };
unsigned output_frequency{ 0 };
std::string serialized_file_name;
// Attempt to load command line options
if( !parseCommandLineOptions( &argc, &argv, help_mode_enabled, end_time_override, output_frequency, serialized_file_name ) )
{
return EXIT_FAILURE;
}
// If the user requested help, print help and exit
if( help_mode_enabled )
{
printUsage( argv[0] );
return EXIT_SUCCESS;
}
// Check for impossible combinations of options
#ifdef USE_HDF5
if( g_output_forces && g_output_dir_name.empty() )
{
std::cerr << "Impulse output requires an output directory." << std::endl;
return EXIT_FAILURE;
}
#endif
#ifdef USE_PYTHON
// Initialize the Python interpreter
Py_SetProgramName( argv[0] );
Py_Initialize();
// Initialize a callback that will close down the interpreter
atexit( exitCleanup );
// Allow subsequent Python commands to use the sys module
PythonTools::pythonCommand( "import sys" );
// Prevent Python from intercepting the interrupt signal
PythonTools::pythonCommand( "import signal" );
PythonTools::pythonCommand( "signal.signal( signal.SIGINT, signal.SIG_DFL )" );
// Initialize the callbacks
PythonScripting::initializeCallbacks();
#endif
if( !serialized_file_name.empty() )
{
if( deserializeSystem( serialized_file_name ) == EXIT_FAILURE )
{
return EXIT_FAILURE;
}
return executeSimLoop();
}
// The user must provide the path to an xml scene file
if( argc != optind + 1 )
{
std::cerr << "Invalid arguments. Must provide a single xml scene file name." << std::endl;
return EXIT_FAILURE;
}
// Attempt to load the user-provided scene
if( !loadXMLScene( std::string{ argv[optind] } ) )
{
return EXIT_FAILURE;
}
// Override the default end time with the requested one, if provided
if( end_time_override > 0.0 )
{
g_end_time = end_time_override;
}
// Compute the data output rate
assert( g_dt.positive() );
// If the user provided an output frequency
if( output_frequency != 0 )
{
const Rational<std::intmax_t> potential_steps_per_frame{ std::intmax_t( 1 ) / ( g_dt * std::intmax_t( output_frequency ) ) };
if( !potential_steps_per_frame.isInteger() )
{
std::cerr << "Timestep and output frequency do not yield an integer number of timesteps for data output. Exiting." << std::endl;
return EXIT_FAILURE;
}
g_steps_per_save = unsigned( potential_steps_per_frame.numerator() );
}
// Otherwise default to dumping every frame
else
{
g_steps_per_save = 1;
}
assert( g_end_time > 0.0 );
g_save_number_width = MathUtilities::computeNumDigits( 1 + unsigned( ceil( g_end_time / scalar( g_dt ) ) ) / g_steps_per_save );
printCompileInfo( std::cout );
std::cout << "Geometry count: " << g_sim.state().ngeo() << std::endl;
std::cout << "Body count: " << g_sim.state().nbodies() << std::endl;
// If there are any intitial collisions, warn the user
{
std::map<std::string,unsigned> collision_counts;
std::map<std::string,scalar> collision_depths;
std::map<std::string,scalar> overlap_volumes;
g_sim.computeNumberOfCollisions( collision_counts, collision_depths, overlap_volumes );
assert( collision_counts.size() == collision_depths.size() ); assert( collision_counts.size() == overlap_volumes.size() );
if( !collision_counts.empty() )
{
std::cout << "Warning, initial collisions detected (name : count : total_depth : total_volume):" << std::endl;
}
for( const auto& count_pair : collision_counts )
{
const std::string& constraint_name{ count_pair.first };
const unsigned& constraint_count{ count_pair.second };
assert( collision_depths.find( constraint_name ) != collision_depths.cend() );
const scalar& constraint_depth{ collision_depths[constraint_name] };
const scalar& constraint_volume{ overlap_volumes[constraint_name] };
std::string depth_string;
if( !std::isnan( constraint_depth ) )
{
depth_string = StringUtilities::convertToString( constraint_depth );
}
else
{
depth_string = "depth_computation_not_supported";
}
std::string volume_string;
if( !std::isnan( constraint_volume ) )
{
volume_string = StringUtilities::convertToString( constraint_volume );
}
else
{
volume_string = "volume_computation_not_supported";
}
std::cout << " " << constraint_name << " : " << constraint_count << " : " << depth_string << " : " << volume_string << std::endl;
}
}
if( g_end_time == SCALAR_INFINITY )
{
std::cout << "No end time specified. Simulation will run indefinitely." << std::endl;
}
//scalar total_volume = 0.0;
//for( int bdy_idx = 0; bdy_idx < g_sim.state().nbodies(); ++bdy_idx )
//{
// total_volume += g_sim.state().getGeometryOfBody( bdy_idx ).volume();
//}
//std::cout << "Total volume: " << total_volume << std::endl;
return executeSimLoop();
}
