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);
