def t_order(self, v=2):
"""
Compute order using Terr's Baby-step Giant-step algorithm.
"""
if (v < 1) or not(rational.isIntegerObject(v)):
raise TypeError("input integer v >= 1")
e = self.set.identity()
a = self.set.identity()
R = [(e, 0)]
for i in range(1, v + 1):
a = self.ope(a)
if a == e:
return i
else:
R.append((a, i))
j = 0
b = a.ope2(2)
t = 2 * v
while True:
for (c, k) in R:
if b == c:
return (t - k)
a = self.ope(a)
j += 1
R.append((a, j + v))
b = a.ope(b)
t += j + v
def t_order(self, v=2):
"""
Compute order using Terr's Baby-step Giant-step algorithm.
"""
if (v < 1) or not (rational.isIntegerObject(v)):
raise TypeError("input integer v >= 1")
e = self.set.identity()
a = self.set.identity()
R = [(e, 0)]
for i in range(1, v + 1):
a = self.ope(a)
if a == e:
return i
else:
R.append((a, i))
j = 0
b = a.ope2(2)
t = 2 * v
while True:
for (c, k) in R:
if b == c:
return (t - k)
a = self.ope(a)
j += 1
R.append((a, j + v))
b = a.ope(b)
t += j + v
def getDenominator(ele):
"""
get the denominator of ele
"""
if rational.isIntegerObject(ele):
return 1
else: # rational
return ele.denominator
def getNumerator(ele):
"""
get the numerator of ele
"""
if rational.isIntegerObject(ele):
return ele
else: # rational
return ele.numerator
def getNumerator_and_Denominator(ele):
"""
get the pair of numerator and denominator of ele
"""
if rational.isIntegerObject(ele):
return (ele, 1)
else: # rational
return (ele.numerator, ele.denominator)
def getDenominator(ele):
"""
get the denominator of ele
"""
if rational.isIntegerObject(ele):
return 1
else: # rational
return ele.denominator
def getNumerator(ele):
"""
get the numerator of ele
"""
if rational.isIntegerObject(ele):
return ele
else: # rational
return ele.numerator
def getNumerator_and_Denominator(ele):
"""
get the pair of numerator and denominator of ele
"""
if rational.isIntegerObject(ele):
return (ele, 1)
else: # rational
return (ele.numerator, ele.denominator)
def __init__(self, value, key=None, flag=False):
"""
You can initialize with various one-to-one onto mapping.
Example,
Permute([2,3,4,5,1]) -> normal type
Permute([3,4,2,1,0], 0) -> [4,5,3,2,1]-normal type(index start with 0)
Permute(['b','c','d','e','a'], 1) -> [2,3,4,5,1]-normal type(identity is ascending order)
Permute(['b','c','d','e','a'], -1) -> [4,3,2,1,5]-normal type(identity is descending order)
Permute(['b','c','d','e','a'], ['b','a', 'c','d','e']) -> [1,3,4,5,2]-normal type(identity=key)
Permute({'a':'b','b':'c','c':'d','d':'e','e':'a'}) -> [2,3,4,5,1]-normal type
"""
if isinstance(value, dict):
if key:
raise TypeError("key isn't need when dict type is used")
data = value.values()
key = value.keys()
elif isinstance(value, (list, tuple)):
data = list(value)
else:
raise TypeError("Not normal form")
if key == 0:
self.data = [i + 1 for i in data]
self.key = range(len(data))
elif key:
if isinstance(key, (list, tuple)):
self.key = list(key)
if len(value) != len(key):
raise TypeError("Length error")
elif key == 1:
p_key = list(data)
p_key.sort()
self.key = p_key
elif key == -1:
p_key = list(data)
p_key.sort()
p_key.reverse()
self.key = p_key
else:
raise TypeError("Input sequence type")
key = self.key
if flag:
self.data = data
else:
self.data = [key.index(x) + 1 for x in data]
else:
self.data = data
self.key = range(1, len(data) + 1)
data = self.data
p_data = range(len(data))
for x in data:
if not rational.isIntegerObject(x):
raise TypeError("This number should be integer list")
elif x <= 0 or x > len(data):
raise TypeError("This isn't onto")
elif p_data[x-1] == -1:
raise ValueError("This isn't one-to-one")
else:
p_data[x-1] = -1
def ope2(self, other):
"""
Group extended operation
"""
if rational.isIntegerObject(other):
if not self.operation:
return GroupElement(self.entity * other, self.operation)
else:
return GroupElement(self.entity ** other, self.operation)
else:
raise TypeError("input integer")
def ope2(self, other):
"""
Group extended operation
"""
if rational.isIntegerObject(other):
if not self.operation:
return GroupElement(self.entity * other, self.operation)
else:
return GroupElement(self.entity**other, self.operation)
else:
raise TypeError("input integer")
def __pow__(self, other):
sol = self.__class__(self.data, self.key, flag=True)
if not rational.isIntegerObject(other):
raise TypeError("cannot pow operation with %s" % other)
if other > 0:
for i in range(other - 1):
sol = self * sol
else:
inv = self.inverse()
for i in range(abs(other) + 1):
sol = inv * sol
return sol
def __pow__(self, other):
sol = ExPermute(self.dim, self.data, self.key, flag=True) # other instance
if not rational.isIntegerObject(other):
raise TypeError("This can't calculate")
if other > 0:
for i in range(other - 1):
sol = self * sol
else:
inv = self.inverse()
for i in range(abs(other) + 1):
sol = inv * sol
return sol
def __pow__(self, other):
if rational.isIntegerObject(other):
if other == 0:
return rational.Integer(1)
elif other == 1:
return +self
elif other < 0:
return (self**(-other)).inverse()
elif other == 2:
return self.__class__(self.real ** 2 - self.imag ** 2, 2 * self.real * self.imag)
else:
return rational.Integer(other).actMultiplicative(self)
return exp(other * log(self))
def __pow__(self, other):
if rational.isIntegerObject(other):
if other == 0:
return rational.Integer(1)
elif other == 1:
return +self
elif other < 0:
return (self**(-other)).inverse()
elif other == 2:
return self.__class__(self.real ** 2 - self.imag ** 2, 2 * self.real * self.imag)
else:
return rational.Integer(other).actMultiplicative(self)
return exp(other * log(self))
def __init__(self, dim, value, key=None, flag=False):
if not (rational.isIntegerObject(dim) and isinstance(value, list)):
raise TypeError(
"cannot convert ExPermute. `dim` should be an integer and `value` should be a list."
)
self.dim = dim
data = value
self.data = []
if key == 0:
self.key = range(dim)
for x in data:
ele = [y + 1 for y in x]
self.data.append(tuple(ele))
elif key:
if isinstance(key, (list, tuple)):
self.key = list(key)
if dim != len(key):
raise TypeError(
"cannot convert ExPermute. The length of `key` should be equal to dim."
)
else:
raise TypeError(
"cannot convert ExPermute. `key` should be a list or a tuple."
)
key = self.key
if flag:
self.data = data
else:
for x in data:
ele = [key.index(x[i]) + 1 for i in range(len(x))]
self.data.append(tuple(ele))
else:
self.data = data
self.key = range(1, dim + 1)
data = self.data
for x in data:
if not isinstance(x, tuple):
raise TypeError(
"cannot convert ExPermute. `flag` should be False.")
box = range(dim)
for y in x:
if (y > dim) or (y <= 0):
raise TypeError(
"cannot convert ExPermute. The map should be onto.")
elif box[y - 1] == -1:
raise ValueError(
"cannot convert ExPermute. The map should be one-to-one."
)
else:
box[y - 1] = -1
def __init__(self, dim, value, key=None, flag=False):
if not (rational.isIntegerObject(dim) and isinstance(value, list)):
raise TypeError("This isn't cyclic form")
self.dim = dim
data = value
self.data = []
if key == 0:
self.key = range(dim)
for x in data:
ele = [ y + 1 for y in x ]
self.data.append(tuple(ele))
elif key:
if isinstance(key, (list, tuple)):
self.key = list(key)
if dim != len(key):
raise TypeError("Length error")
else:
raise TypeError("Input sequence type")
key = self.key
if flag:
self.data = data
else:
for x in data:
ele = [key.index(x[i]) + 1 for i in range(len(x))]
self.data.append(tuple(ele))
else:
self.data = data
self.key = range(1, dim + 1)
data = self.data
for x in data:
if not isinstance(x, tuple):
raise TypeError("This isn't cyclic form")
box = range(dim)
for y in x:
if (y > dim) or (y <= 0):
raise TypeError("This is out of range")
elif box[y-1] == -1:
raise ValueError("This isn't one-to-one")
else:
box[y-1] = -1
def _rational_mul(self, other):
"""
return other * self, assuming other is a rational element
"""
if rational.isIntegerObject(other):
other_numerator = rational.Integer(other)
other_denominator = rational.Integer(1)
else:
other_numerator = other.numerator
other_denominator = other.denominator
denom_gcd = gcd.gcd(self.denominator, other_numerator)
if denom_gcd != 1:
new_denominator = ring.exact_division(
self.denominator, denom_gcd) * other_denominator
multiply_num = other_numerator.exact_division(denom_gcd)
else:
new_denominator = self.denominator * other_denominator
multiply_num = other_numerator
new_module = self.__class__(
[self.mat_repr * multiply_num, new_denominator], self.number_field,
self.base, self.mat_repr.ishnf)
new_module._simplify()
return new_module
def _rational_mul(self, other):
"""
return other * self, assuming other is a rational element
"""
if rational.isIntegerObject(other):
other_numerator = rational.Integer(other)
other_denominator = rational.Integer(1)
else:
other_numerator = other.numerator
other_denominator = other.denominator
denom_gcd = gcd.gcd(self.denominator, other_numerator)
if denom_gcd != 1:
new_denominator = ring.exact_division(
self.denominator, denom_gcd) * other_denominator
multiply_num = other_numerator.exact_division(denom_gcd)
else:
new_denominator = self.denominator * other_denominator
multiply_num = other_numerator
new_module = self.__class__(
[self.mat_repr * multiply_num, new_denominator],
self.number_field, self.base, self.mat_repr.ishnf)
new_module._simplify()
return new_module
def __init__(self, value, key=None, flag=False):
"""
You can initialize with various one-to-one onto mapping.
Example,
Permute([2,3,4,5,1]) -> normal type
Permute([3,4,2,1,0], 0) -> [4,5,3,2,1]-normal type(index start with 0)
Permute(['b','c','d','e','a'], 1) -> [2,3,4,5,1]-normal type(identity is ascending order)
Permute(['b','c','d','e','a'], -1) -> [4,3,2,1,5]-normal type(identity is descending order)
Permute(['b','c','d','e','a'], ['b','a', 'c','d','e']) -> [1,3,4,5,2]-normal type(identity=key)
Permute({'a':'b','b':'c','c':'d','d':'e','e':'a'}) -> [2,3,4,5,1]-normal type
"""
if isinstance(value, dict):
if key:
raise TypeError(
"cannot convert Permute. I think `key` should be None.")
data = value.values()
key = value.keys()
elif isinstance(value, (list, tuple)):
data = list(value)
else:
raise TypeError(
"cannot convert Permute. `value` should be a list or a dict.")
if key == 0:
self.data = [i + 1 for i in data]
self.key = range(len(data))
elif key:
if isinstance(key, (list, tuple)):
self.key = list(key)
if len(value) != len(key):
raise TypeError(
"cannot convert Permute. The length of `key` should be equal to that of `value`."
)
elif key == 1:
p_key = list(data)
p_key.sort()
self.key = p_key
elif key == -1:
p_key = list(data)
p_key.sort()
p_key.reverse()
self.key = p_key
else:
raise TypeError(
"cannot convert Permute. `key` should be a list.")
key = self.key
if flag:
self.data = data
else:
self.data = [key.index(x) + 1 for x in data]
else:
self.data = data
self.key = range(1, len(data) + 1)
data = self.data
p_data = range(len(data))
for x in data:
if not rational.isIntegerObject(x):
raise TypeError(
"cannot convert Permute. `flag` should be False.")
elif x <= 0 or x > len(data):
raise TypeError(
"cannot convert Permute. The map should be onto.")
elif p_data[x - 1] == -1:
raise ValueError(
"cannot convert Permute. The map should be one-to-one.")
else:
p_data[x - 1] = -1
