C#

public class AbstractBase<T, U> where T : AbstractBase<T, U> {
    public static implicit operator T(U other) {
        T rval = new T(); // I realize I will need to do this through reflection, since
                          // the compiler doesn't know if this exists, but you get the idea
        foreach (PropertyInfo Upi in typeof(U).GetProperties()) {
            PropertyInfo Tpi = typeof(T).GetProperty(Upi.Name, Upi.PropertyType);
            if (Tpi != null && Tpi.CanWrite && Upi.CanRead
                && Upi.GetIndexParameters().Length == 0)
                Tpi.SetValue(rval, Upi.GetValue(other, null), null);
        }
        return rval;
    }
    public static implicit operator U(T other) {
        U rval = new U(); // I realize I will need to do this through reflection, since
                          // the compiler doesn't know if this exists, but you get the idea
        foreach (PropertyInfo Tpi in typeof(T).GetProperties()) {
            PropertyInfo Upi = typeof(U).GetProperty(Tpi.Name, Tpi.PropertyType);
            if (Upi != null && Upi.CanWrite && Tpi.CanRead
                && Tpi.GetIndexParameters().Length == 0)
                Upi.SetValue(rval, Tpi.GetValue(other, null), null);
        }
        return rval;
    }
}

public class myClass : AbstractBase<myClass, otherClass> { ... }

private bool IsPowerOfTwo(int numeric, int min, int max)
{
    bool valid = false;
    if (numeric >= min && numeric <= max && numeric % 2 == 0)
    {
        int pow2 = min;
        while (pow2 <= max && !valid)
        {
            valid = ((pow2 *= 2) == numeric);
        }
    }
    return valid;
}