def joueur_suivant(self):
j=self.get_joueur_actif()
i=imod(j.get_idj() + 1,self.nb_joueur)
for j in self.joueurs:
if i==j.get_idj():
if j.is_vendu() or not j.is_inGame():
# Le joueur suivant est vendu ou a fini! On donne la main au joueur d'après
j.activer(False)
i=imod(i+1,self.nb_joueur)
else:
j.activer(True)
else:
j.activer(False)
#Deuxieme tour pour la forme
for j in self.joueurs:
if i==j.get_idj():
if j.is_vendu() or not j.is_inGame():
# Le joueur suivant est vendu ! On donne la main au joueur d'après
j.activer(False)
i=imod(i+1,self.nb_joueur)
else:
j.activer(True)
else:
j.activer(False)
def operator_imod(size):
a = Array(size, 'int32')
b = Array(size, 'int32')
for i in range(size):
a[i] = nb_types.int32(i * 123)
b[i] = nb_types.int32(7)
operator.imod(a, b)
return a
def main():
x,y = 5,6
a,b = 7,8
# Incremental Add : x += y
iAdd = operator.iadd(5, 6)
print("iAdd: ", iAdd)
# Incremental Concatenate
iConCat = operator.iconcat("Hello", "World")
print("iConCat:", iConCat)
# Incremental Subtraction
iSub = operator.isub(5, 6)
print("iSub: ", iSub)
# Incremental Multiplication
iMul = operator.imul(5,6)
print("iMul:", iMul)
# Incremental Division
iDiv = operator.itruediv(10, 5)
print("iDiv: ", iDiv)
# Incremental Modulus
iMod = operator.imod(10, 6)
print("iMod: ", iMod)
# Incremental Exponential
iPow = operator.ipow(2, 4)
print("iPow: ", iPow)
def legal_actions(self):
"""The list of all legal actions.
The first two actions must be using a number as all the operators are
binary and require two numbers.
"""
# By checking against evaluated_expression instead of expression this
# checks that there are enough numbers for an operator to be a legal
# action.
if not self.evaluated_expression:
return self.numbers
if len(self.evaluated_expression) == 1:
# This assumes that step() removed the number from the expression.
return self.numbers
# Check if the divide operator is valid.
if len(self.evaluated_expression) >= 2:
if self.evaluated_expression[-1] == 0:
# The expression would be A / 0 which is not legal.
legal_operators = self.operators[:]
legal_operators.remove(operator.floordiv)
return self.numbers + legal_operators
if operator.imod(*self.evaluated_expression[-2:]) != 0:
# The expression A / B would result in a non-integer result.
# This makes the floordiv operator illegal here.
legal_operators = self.operators[:]
legal_operators.remove(operator.floordiv)
return self.numbers + legal_operators
return self.numbers + self.operators
def test_inplace(self):
#operator = self.module
class C(object):
def __iadd__ (self, other): return "iadd"
def __iand__ (self, other): return "iand"
def __ifloordiv__(self, other): return "ifloordiv"
def __ilshift__ (self, other): return "ilshift"
def __imod__ (self, other): return "imod"
def __imul__ (self, other): return "imul"
def __ior__ (self, other): return "ior"
def __ipow__ (self, other): return "ipow"
def __irshift__ (self, other): return "irshift"
def __isub__ (self, other): return "isub"
def __itruediv__ (self, other): return "itruediv"
def __ixor__ (self, other): return "ixor"
def __getitem__(self, other): return 5 # so that C is a sequence
c = C()
self.assertEqual(operator.iadd (c, 5), "iadd")
self.assertEqual(operator.iand (c, 5), "iand")
self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
self.assertEqual(operator.ilshift (c, 5), "ilshift")
self.assertEqual(operator.imod (c, 5), "imod")
self.assertEqual(operator.imul (c, 5), "imul")
self.assertEqual(operator.ior (c, 5), "ior")
self.assertEqual(operator.ipow (c, 5), "ipow")
self.assertEqual(operator.irshift (c, 5), "irshift")
self.assertEqual(operator.isub (c, 5), "isub")
self.assertEqual(operator.itruediv (c, 5), "itruediv")
self.assertEqual(operator.ixor (c, 5), "ixor")
self.assertEqual(operator.iconcat (c, c), "iadd")
def test_inplace(self):
#operator = self.module
class C(object):
def __iadd__(self, other):
return "iadd"
def __iand__(self, other):
return "iand"
def __ifloordiv__(self, other):
return "ifloordiv"
def __ilshift__(self, other):
return "ilshift"
def __imod__(self, other):
return "imod"
def __imul__(self, other):
return "imul"
def __ior__(self, other):
return "ior"
def __ipow__(self, other):
return "ipow"
def __irshift__(self, other):
return "irshift"
def __isub__(self, other):
return "isub"
def __itruediv__(self, other):
return "itruediv"
def __ixor__(self, other):
return "ixor"
def __getitem__(self, other):
return 5 # so that C is a sequence
c = C()
self.assertEqual(operator.iadd(c, 5), "iadd")
self.assertEqual(operator.iand(c, 5), "iand")
self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
self.assertEqual(operator.ilshift(c, 5), "ilshift")
self.assertEqual(operator.imod(c, 5), "imod")
self.assertEqual(operator.imul(c, 5), "imul")
self.assertEqual(operator.ior(c, 5), "ior")
self.assertEqual(operator.ipow(c, 5), "ipow")
self.assertEqual(operator.irshift(c, 5), "irshift")
self.assertEqual(operator.isub(c, 5), "isub")
self.assertEqual(operator.itruediv(c, 5), "itruediv")
self.assertEqual(operator.ixor(c, 5), "ixor")
self.assertEqual(operator.iconcat(c, c), "iadd")
def test_imod(self):
x = 10 * pq.m
x %= 3 * pq.m
self.assertQuantityEqual(x, 1 * pq.m)
x = 10 * pq.m
x %= (3 * pq.m).rescale('ft')
self.assertQuantityEqual(x, 10 * pq.m % (3 * pq.m))
self.assertRaises(ValueError, lambda: op.imod(10 * pq.J, 3 * pq.m))
def test_imod(self):
x = 10*pq.m
x %= 3*pq.m
self.assertQuantityEqual(x, 1*pq.m)
x = 10*pq.m
x %= (3*pq.m).rescale('ft')
self.assertQuantityEqual(x, 10*pq.m % (3*pq.m))
self.assertRaises(ValueError, lambda: op.imod(10*pq.J, 3*pq.m))
def test_class_binary_inplace_operators(self):
class WithLotsOfOperators(Class):
def __iadd__(self, other):
return (self, "iadd", other)
def __isub__(self, other):
return (self, "isub", other)
def __imul__(self, other):
return (self, "imul", other)
def __imod__(self, other):
return (self, "imod", other)
def __itruediv__(self, other):
return (self, "itruediv", other)
def __ifloordiv__(self, other):
return (self, "ifloordiv", other)
def __ilshift__(self, other):
return (self, "ilshift", other)
def __irshift__(self, other):
return (self, "irshift", other)
def __ior__(self, other):
return (self, "ior", other)
def __iand__(self, other):
return (self, "iand", other)
def __ixor__(self, other):
return (self, "ixor", other)
def __imatmul__(self, other):
return (self, "imatmul", other)
c = WithLotsOfOperators()
self.assertEqual(operator.iadd(c, 0), (c, "iadd", 0))
self.assertEqual(operator.isub(c, 0), (c, "isub", 0))
self.assertEqual(operator.imul(c, 0), (c, "imul", 0))
self.assertEqual(operator.imod(c, 0), (c, "imod", 0))
self.assertEqual(operator.itruediv(c, 0), (c, "itruediv", 0))
self.assertEqual(operator.ifloordiv(c, 0), (c, "ifloordiv", 0))
self.assertEqual(operator.ilshift(c, 0), (c, "ilshift", 0))
self.assertEqual(operator.irshift(c, 0), (c, "irshift", 0))
self.assertEqual(operator.ior(c, 0), (c, "ior", 0))
self.assertEqual(operator.iand(c, 0), (c, "iand", 0))
self.assertEqual(operator.ixor(c, 0), (c, "ixor", 0))
self.assertEqual(operator.imatmul(c, 0), (c, "imatmul", 0))
def distribuer(self, nbjoueurs=5):
#par défaut on jouera à 5
mains = []
i = 0
while i < nbjoueurs:
mains.append(Main(i))
i += 1
i = 0
for c in self.pioche:
mains[i].ajouter_carte(c)
i = imod(i + 1, nbjoueurs)
self.pioche = []
return mains
def __init__(self, players=None):
"""
:type self: object
"""
self.board = Board()
self.number_stones = 11
self.number_foxes = 1
self.number_blockers = 1
self.players = players
self.nplayer = 1
self.current_player = Color.blue
self.other_player = Color.red
self.board = Board()
self.size = 10
self.available_simple_stones = {}
self.available_foxes = {}
self.available_blockers = {}
self.removed_stones = {}
for c in Color:
self.available_simple_stones[
c] = self.number_stones #[SimpleStone(c) for i in range(0, self.size)]
self.available_foxes[c] = self.number_foxes
self.available_blockers[c] = self.number_blockers
self.removed_stones[c] = []
self.player = [Color.red, Color.blue]
self.mod_size = lambda x: operator.imod(x, self.size)
self.ml = lambda s, x, y, z: [
"%s_%s" % (s, i) for i in map(self.mod_size, [x, y, z])
]
self.same_col = lambda a, b: a.color == b.color
self.occupied = lambda x: x != Board.empty
self.stones_of_same_player = lambda a, b: self.occupied(
a) and self.occupied(b) and self.same_col(a, b)
def __init__(self, players=None):
"""
:type self: object
"""
self.board = Board()
self.number_stones = 11
self.number_foxes = 1
self.number_blockers = 1
self.players = players
self.nplayer = 1
self.current_player = Color.blue
self.other_player = Color.red
self.board = Board()
self.size = 10
self.available_simple_stones = {}
self.available_foxes = {}
self.available_blockers = {}
self.removed_stones = {}
for c in Color:
self.available_simple_stones[c] = self.number_stones #[SimpleStone(c) for i in range(0, self.size)]
self.available_foxes[c] = self.number_foxes
self.available_blockers[c] = self.number_blockers
self.removed_stones[c] = []
self.player = [Color.red, Color.blue]
self.mod_size = lambda x: operator.imod(x, self.size)
self.ml = lambda s, x, y, z: ["%s_%s" % (s, i) for i in map(self.mod_size, [x, y, z])]
self.same_col = lambda a, b: a.color == b.color
self.occupied = lambda x: x != Board.empty
self.stones_of_same_player = lambda a, b: self.occupied(a) and self.occupied(b) and self.same_col(a, b)
def _test_quantity_mod(self, unit, func):
a = self.Q_("10*meter")
b = self.Q_("3*second")
with pytest.raises(DimensionalityError):
op.mod(a, b)
with pytest.raises(DimensionalityError):
op.mod(3, b)
with pytest.raises(DimensionalityError):
op.mod(a, 3)
with pytest.raises(DimensionalityError):
op.imod(a, b)
with pytest.raises(DimensionalityError):
op.imod(3, b)
with pytest.raises(DimensionalityError):
op.imod(a, 3)
func(
op.mod,
unit * self.NON_INT_TYPE("10"),
"4.2*meter/meter",
self.NON_INT_TYPE("1.6"),
unit,
)
such as strings, numbers and tuples.'''
import operator
# using iadd() to add and assign value
x = 2;y = 3
x = operator.iadd(x,y)
print("Addition",x)
x = 2;y = 3
x = operator.isub(x,y)
print("Subtraction", x)
x = 2;y = 3
x = operator.imul(x,y)
print("Multiply",x)
x = 10;y = 5
x = operator.itruediv(x,y)
print("Divide",x)
x = 10; y = 6
x = operator.imod(x,y)
print("Mod",x)
# initializing another values
y = 'geeks'
z = 'forgeeks'
# using iconcat() to concat the sequences
y = operator.iconcat(y,z)
print(y)
def imod_usecase(x, y):
return operator.imod(x, y)
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE."""
import platform
import operator
import os
# version x.y.z
# This version will have same meaning as Linux
# x -- Production version with big different feature
# y -- Odd number means formal version, Even number means development version
# z -- Count of fixing bugs
__version__ = '0.1.1'
__os_platform__ = platform.system().upper() if platform.system() else 'LINUX'
__running_mode__ = (0 == operator.imod(int(__version__.split('.')[1]), 2))
DATABASE_CONFIG = {
'authentication': {
'user': os.getenv('DB_USER'),
'password': os.getenv('DB_PASSWORD'),
},
'type': os.getenv('DB_TYPE', 'mongodb'),
'channel': os.getenv('DB_CHANNEL', 'Channel') if __running_mode__ else os.getenv('DB_CHANNEL', 'beta-channel'),
'trans': os.getenv('DB_TRANS','Transaction') if __running_mode__ else os.getenv('DB_TRANS','beta-trans'),
'history': os.getenv('DB_HISTORY','History') if __running_mode__ else os.getenv('DB_HISTORY','beta-history'),
'host': os.getenv('DB_HOST', '127.0.0.1'),
'port': int(os.getenv('DB_PORT', 27017))
}
b = 6 print(operator.imul(a, b)) """5.itruediv() :- This function is used to assign and divide the current value. This operation does “a/=b” operation. Assigning is not performed in case of immutable containers, such as strings, numbers and tuples.""" a = 64 b = 8 print(operator.itruediv(a, b)) """6.imod()- This function is used to assign and return remainder. This operation does “a%=b” operation. Assigning is not performed in case of immutable containers, such as strings, numbers and tuples.""" a = 3 b = 2 print(operator.imod(a, b)) """7. ixor() :- This function is used to assign and xor the current value. This operation does “a^ = b” operation. Assigning is not performed in case of immutable containers, such as strings, numbers and tuples.""" a = 1 b = 0 print(operator.ixor(a, b)) """8.ipow() :- This function is used to assign and exponentiate the current value. This operation does “a ** = b” operation. Assigning is not performed in case of immutable containers, such as strings, numbers and tuples.""" a = 3 b = 2 print(operator.ipow(a, b))
def __imod__(self, other):
return operator.imod(self._wrapped(), other)
# using isub() to subtract and assign value
x = operator.isub(2, 3);
# printing the modified value
print ("The value after subtracting and assigning : ", end="")
print (x)
# using imul() to multiply and assign value
x = operator.imul(2, 3);
# printing the modified value
print ("The value after multiplying and assigning : ", end="")
print (x)
# using itruediv() to divide and assign value
x = operator.itruediv(10, 5);
# printing the modified value
print ("The value after dividing and assigning : ", end="")
print (x)
# using imod() to modulus and assign value
x = operator.imod(10, 6);
# printing the modified value
print ("The value after modulus and assigning : ", end="")
print (x)
def imod_usecase(x, y):
return operator.imod(x, y)
if math.isnan(math.nan):
print("True : Not a number")
else:
print("its a number")
if math.isinf(math.inf):
print("True: infinite number")
else:
print("not infinite number")
#------- Random related functions
mylist = ['purushotham', 'chandra', 'ravi']
print(random.randint(1, 5))
print(random.random())
print(random.choice(mylist))
random.shuffle(mylist)
#--- Number of seconds from EPOCH time i.e from Jan1st 1970
print(time.time())
print(date.fromtimestamp(1565335861.4913108))
#------------- operator(Inplace) related functions --------------------
print(operator.iadd(2, 3))
print(operator.isub(3, 2))
print(operator.imul(3, 2))
print(operator.itruediv(5, 3))
print(operator.imod(5, 3))
print(operator.iconcat('Purushotham', 'Reddy'))
print(li)
operator.delitem(li, slice(1, 4))
print(li)
print(operator.getitem(li, slice(0, 2)))
s1 = "testing "
s2 = "operator"
print(operator.concat(s1, s2))
if (operator.contains(s1, s2)):
print("Contains")
else:
print("It doesn't")
a = 1
b = 0
print(operator.and_(a, b))
print(operator.or_(a, b))
print(operator.invert(a))
x = 10
y = 5
print(operator.iadd(x, y))
print(operator.isub(x, y))
print(operator.iconcat(s1, s2))
print(operator.imul(x, y))
print(operator.itruediv(x, y))
print(operator.imod(x, y))
print(operator.ixor(x, y))
print(operator.ipow(x, y))
print(operator.iand(x, y))
print(operator.ior(x, y))
print(operator.ilshift(x, y))
print(operator.irshift(x, y))
def update_event(self, inp=-1):
self.set_output_val(0, operator.imod(self.input(0), self.input(1)))
# using isub() to subtract and assign value
x = operator.isub(2, 3)
# printing the modified value
print("The value after subtracting and assigning : ", end="")
print(x)
# using imul() to multiply and assign value
x = operator.imul(2, 3)
# printing the modified value
print("The value after multiplying and assigning : ", end="")
print(x)
# Python code to demonstrate the working of
# itruediv() and imod()
# using itruediv() to divide and assign value
x = operator.itruediv(10, 5)
# printing the modified value
print("The value after dividing and assigning : ", end="")
print(x)
# using imod() to modulus and assign value
x = operator.imod(10.0, 6)
# printing the modified value
print("The value after modulus and assigning : ", end="")
print(x)
