unsigned long staticity( method const& m ) { unsigned long s = 0ul; //1ul; for ( int i=0, b=m.bells(); i!=b-1; ++i) { int j=0, l=m.size(); while ( j!=l && ( m[j].findswap(i) || m[j].findplace(i) && m[j].findplace(i+1) ) ) ++j; if (j==l) return static_cast<unsigned long>(-1); for ( int k=j; k<j+l; ++k ) { int k0=k; while ( k!=j+l && ( m[k%l].findswap(i) || m[k%l].findplace(i) && m[k%l].findplace(i+1) ) ) ++k; if (k!=k0) { // s *= ipower( 2, k-k0-1 ); s += k-k0-1; } } } return s; }
bool division_bad_parity_hack( const method &m, const change &c, size_t div_start, size_t cur_div_len ) { // It should be possible to do this easily without calculating rows. row r( c.bells() ); vector< row > rows( 1, r ); rows.reserve( cur_div_len ); for ( int i = div_start; i < m.length(); ++i ) { r *= m[i]; rows.push_back( r ); } rows.push_back( r * c ); assert( rows.size() == cur_div_len ); size_t even[2] = { 0u, 0u }, odd[2] = { 0u, 0u }; for ( unsigned int i = 0; i < rows.size(); ++i ) { if ( rows[i].sign() == +1 ) ++even[i%2]; else ++odd[i%2]; } if ( even[0] != odd[0] || even[1] != odd[1] ) return true; // Bad return false; // OK }
string tenors_together_coursing_order( const method& m ) { const row lh( m.lh() ); int i(0); bell b( m.bells() - 1 ); do { b *= lh, ++i; assert( i <= m.bells() ); } while ( b < m.bells() - 2 ); if ( b == m.bells() - 1 ) // 7 and 8 are in different orbits throw runtime_error( "Unable to get a tenors together coursing order" ); assert( b == m.bells() - 2 ); row cg(lh); for ( int j=1; j<i; ++j ) cg *= lh; make_string ms; ms << b; do { ms << (b *= cg); } while ( b != m.bells() - 1 ); return ms; }
bool has_mirror_symmetry( const method& m ) { const int n( m.size() ); for ( int i=0; i<n; ++i ) if ( m[i] != m[i].reverse() ) return false; return true; }
bool is_too_many_places( const method &m, const change &c, size_t max, size_t stopoff ) { for ( int i=0; i<c.bells(); ++i ) if ( c.findplace(i) ) { size_t count(2u); for ( ; count <= size_t(m.length())+1; ++count ) { size_t o = m.length() - count + 1; if ( o == stopoff || !m[o].findplace(i) ) break; } if ( count > max ) return true; } return false; }
bool has_glide_symmetry( const method& m ) { const int n( m.size() ); if ( n % 2 == 1 ) return false; for ( int i=0; i<n/2; ++i ) if ( m[i] != m[(i + n/2) % n].reverse() ) return false; return true; }
bool has_conventional_symmetry( const method& m ) { const int n( m.size() ); for ( int i=0; i < (n%2==0 ? n/2 : n); ++i ) { // try m[i] as the sym point bool ok(true); for ( int j=1; ok && j<(n%2==0 ? n/2 : n/2+1); ++j ) if ( m[(i+j) % n] != m[(i-j+n) % n] ) ok = false; if (ok) return true; } return false; }
bool is_division_false( const method &m, const change &c, size_t div_start, size_t cur_div_len ) { size_t const len = m.length(); if ( len - div_start < 3 || len - div_start == cur_div_len-1 ) return false; row r( c.bells() ); vector< row > rows( 1, r ); rows.reserve( cur_div_len ); for ( int i = div_start; i < len; ++i ) { r *= m[i]; rows.push_back( r ); } if ( find( rows.begin(), rows.end(), r * c ) != rows.end() ) return true; return false; }
bool has_rotational_symmetry( const method &m ) { const int n( m.size() ); { // Rotational symmetry about a change for ( int i=0; i<n/2+1; ++i ) { // Try m[i] as the rotational symmetry point bool ok = true; for ( int j=0; j<n/2+1 && ok; ++j ) if ( m[ (i+j)%n ] != m[ (n+i-j)%n ].reverse() ) ok = false; if (ok) return true; } } { // Rotational symmetry about a row for ( int i=0; i<n/2+1; ++i ) { // Try m[i] / m[(i+1)%n] as the rotational symmetry point bool ok = true; for ( int j=0; j<n/2 && ok; ++j ) if ( m[ (i+j+1)%n ] != m[ (n+i-j)%n ].reverse() ) ok = false; if (ok) return true; } } return false; }
.method("static_func", &method_misc_test::static_func) .method("default_func", &method_misc_test::default_func) ( default_arguments(std::string("text")), metadata(E_MetaData::SCRIPTABLE, true), metadata("Text", "Some funky description") ) ; } ///////////////////////////////////////////////////////////////////////////////////////// TEST_CASE("method - get_name()", "[method]") { method meth = type::get_by_name("method_misc_test").get_method("func"); CHECK(meth.get_name() == "func"); meth = type::get_by_name("method_misc_test").get_method("default_func"); CHECK(meth.get_name() == "default_func"); // negative test meth = type::get_by_name("method_misc_test").get_method(""); CHECK(meth.get_name() == ""); } ///////////////////////////////////////////////////////////////////////////////////////// TEST_CASE("method - is_static()", "[method]") { method meth = type::get_by_name("method_misc_test").get_method("static_func");
{ type t_meth = type::get("method_test"); REQUIRE(t_meth.is_valid() == true); variant inst = t_meth.create({}); method_test& obj = *inst.get_value<method_test*>(); //////////////////////////////////////////////////////////// // invoke tests variant ret = t_meth.get_method("method_1").invoke(inst); REQUIRE(obj.method_1_called == true); REQUIRE(ret.is_valid() == true); REQUIRE(ret.is_type<void>() == true); //////////////////////////////////////// obj.method_1_called = false; // reset method meth = t_meth.get_method("method_1"); meth.invoke_variadic(inst, {}); REQUIRE(obj.method_1_called == true); REQUIRE(meth.get_name() == "method_1"); REQUIRE(meth.get_parameter_types().empty() == true); //////////////////////////////////////// t_meth.get_method("method_2").invoke(inst); REQUIRE(obj.method_2_called == true); obj.method_2_called = false; meth = t_meth.get_method("method_2"); meth.invoke_variadic(inst, {}); REQUIRE(obj.method_2_called == true); //////////////////////////////////////// t_meth.get_method("method_3").invoke(inst, 35);