Mapytex/mapytex/calculus/core/compute/add.py

829 lines
17 KiB
Python
Raw Normal View History

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2017 lafrite <lafrite@Poivre>
#
# Distributed under terms of the MIT license.
"""
Adding MO
"""
from multipledispatch import Dispatcher
from ..tree import Tree
from ..MO import MO, MOnumber, MOstr
from ..MO.fraction import MOFraction
from ..MO.monomial import MOstrPower, MOMonomial
from ..MO.polynomial import MOpolynomial
2018-03-12 04:34:26 +00:00
from .arithmetic import lcm
2018-03-17 08:55:32 +00:00
from .filters import special_case
add_doc = """ Adding MOs
:param left: left MO
:param right: right MO
:return: Tree or MO
"""
2018-03-17 08:55:32 +00:00
add = Dispatcher("add", doc=add_doc)
2018-03-17 08:55:32 +00:00
def add_filter(left, right):
""" Automatic add on MO
:param left: MO
:param right: MO
:returns: MO if it is a special case, nothing other wise
>>> a = MOnumber(0)
>>> b = MOFraction(1, 2)
>>> add(a, b)
<MOFraction 1 / 2>
>>> add(b, a)
<MOFraction 1 / 2>
"""
try:
if left == 0:
return right
except TypeError:
pass
try:
if right == 0:
return left
except TypeError:
pass
try:
if left.variable != right.variable:
raise NotImplementedError("Can't add 2 polynomes with not same letter")
except AttributeError:
pass
2018-03-17 08:55:32 +00:00
@add.register(MOnumber, MOnumber)
2018-03-17 08:55:32 +00:00
@special_case(add_filter)
def monumber_monumber(left, right):
""" Simply add MO value
>>> a = MOnumber(4)
>>> b = MOnumber(6)
>>> add(a, b)
<MOnumber 10>
"""
return MO.factory(left.value + right.value)
@add.register(MOnumber, MOFraction)
2018-03-17 08:55:32 +00:00
@special_case(add_filter)
def monumber_mofraction(left, right):
""" Return a tree with the MOnumber transformed into a MOFraction
>>> a = MOnumber(4)
>>> b = MOFraction(6, 5)
>>> print(add(a, b))
+
> /
| > 4
| > 1
> /
| > 6
| > 5
"""
left_fraction = MOFraction(left, MOnumber(1))
return Tree("+", left_fraction, right)
@add.register(MOFraction, MOnumber)
2018-03-17 08:55:32 +00:00
@special_case(add_filter)
def mofraction_monumber(left, right):
""" Return a tree with the MOnumber transformed into a MOFraction
>>> a = MOFraction(6, 5)
>>> b = MOnumber(4)
>>> print(add(a, b))
+
> /
| > 6
| > 5
> /
| > 4
| > 1
"""
right_fraction = MOFraction(right, MOnumber(1))
return Tree("+", left, right_fraction)
@add.register(MOFraction, MOFraction)
2018-03-17 08:55:32 +00:00
@special_case(add_filter)
2018-03-12 04:34:26 +00:00
def mofraction_mofraction(left, right):
""" 3 differents cases:
2018-03-12 04:34:26 +00:00
Fractions have same denomintor -> add numerator Tree
2018-03-12 04:34:26 +00:00
>>> a = MOFraction(1, 5)
>>> b = MOFraction(4, 5)
>>> print(add(a, b))
2018-03-12 04:34:26 +00:00
/
> +
| > 1
| > 4
> 5
>>> a = MOFraction(1, 5, True)
>>> b = MOFraction(4, 5)
>>> print(mofraction_mofraction(a, b))
/
> +
| > -
| | > None
| | > 1
| > 4
> 5
>>> a = MOFraction(1, 5)
>>> b = MOFraction(4, 5, True)
>>> print(mofraction_mofraction(a, b))
/
> +
| > 1
| > -
| | > None
| | > 4
> 5
A denominator is a multiple of the other
2018-03-12 04:34:26 +00:00
>>> a = MOFraction(1, 2)
>>> b = MOFraction(1, 4)
>>> print(mofraction_mofraction(a, b))
+
> /
| > *
| | > 1
| | > 2
| > *
| | > 2
| | > 2
> /
| > 1
| > 4
Denominators are coprime
2018-03-12 04:34:26 +00:00
>>> a = MOFraction(1, 2)
>>> b = MOFraction(1, 5)
>>> print(mofraction_mofraction(a, b))
+
> /
| > *
| | > 1
| | > 5
| > *
| | > 2
| | > 5
> /
| > *
| | > 1
| | > 2
| > *
| | > 5
| | > 2
"""
if left.denominator == right.denominator:
num = Tree("+", left.numerator, right.numerator)
return Tree("/", num, left.denominator)
denom_lcm = lcm(left.denominator.value, right.denominator.value)
2018-03-12 04:34:26 +00:00
if left.denominator.value == denom_lcm:
2018-03-12 04:34:26 +00:00
left_frac = left
else:
multiply_by = MO.factory(denom_lcm // left.denominator.value)
left_num = Tree("*", left.numerator, multiply_by)
left_denom = Tree("*", left.denominator, multiply_by)
2018-03-12 04:34:26 +00:00
left_frac = Tree("/", left_num, left_denom)
if right.denominator.value == denom_lcm:
2018-03-12 04:34:26 +00:00
right_frac = right
else:
multiply_by = MO.factory(denom_lcm // right.denominator.value)
right_num = Tree("*", right.numerator, multiply_by)
right_denom = Tree("*", right.denominator, multiply_by)
2018-03-12 04:34:26 +00:00
right_frac = Tree("/", right_num, right_denom)
return Tree("+", left_frac, right_frac)
@add.register(MOstr, MOstr)
@special_case(add_filter)
def mostr_mostr(left, right):
""" Add 2 MOstr
:example:
>>> a = MOstr("x")
>>> b = MOstr("x")
>>> add(a, b)
<MOMonomial 2x>
"""
if left != right:
raise NotImplementedError("Can't add 2 MOstr with not same letter")
return MOMonomial(2, left)
@add.register(MOstrPower, MOstrPower)
@special_case(add_filter)
def mostrpower_mostrpower(left, right):
""" Add 2 MOstrPower
:example:
>>> a = MOstrPower("x", 2)
>>> b = MOstrPower("x", 2)
>>> add(a, b)
<MOMonomial 2x^2>
"""
if left.power != right.power:
raise NotImplementedError("Can't add 2 MOstrPower with not same power")
return MOMonomial(2, left.variable, left.power)
@add.register((MOnumber, MOFraction), MOpolynomial)
@special_case(add_filter)
def moscalar_mopolynomial(left, right):
""" Add a scalar to a polynomial
:example:
>>> a = MOnumber(1)
>>> b = MOpolynomial("x", [2, 3, 4])
>>> print(add(a, b))
+
> *
| > 4
| > ^
| | > x
| | > 2
> +
| > *
| | > 3
| | > x
| > +
| | > 1
| | > 2
"""
if 0 not in right.coefficients.keys():
raise NotImplementedError("Polynomial with no constant, no calculus to do")
right_const = right.monomials[0]
right_top = [mo for deg, mo in right.monomials.items() if deg > 0][::-1]
adds = right_top + [Tree("+", left, right_const)]
return Tree.from_list('+', adds)
@add.register(MOpolynomial, (MOnumber, MOFraction))
@special_case(add_filter)
def mopolynomial_moscalar(left, right):
""" Add a scalar to a polynomial
:example:
>>> a = MOpolynomial("x", [2, 3, 4])
>>> b = MOnumber(1)
>>> print(add(a, b))
+
> *
| > 4
| > ^
| | > x
| | > 2
> +
| > *
| | > 3
| | > x
| > +
| | > 2
| | > 1
"""
if 0 not in left.coefficients.keys():
raise NotImplementedError("Polynomial with no constant, no calculus to do")
left_const = left.monomials[0]
left_top = [mo for deg, mo in left.monomials.items() if deg > 0][::-1]
adds = left_top + [Tree("+", left_const, right)]
return Tree.from_list('+', adds)
@add.register(MOstr, MOpolynomial)
@special_case(add_filter)
def mostr_mopolynomial(left, right):
""" Add a str to a polynomial
:example:
>>> a = MOstr("x")
>>> b = MOpolynomial("x", [2, 3, 4])
>>> print(add(a, b))
+
> *
| > 4
| > ^
| | > x
| | > 2
> +
| > +
| | > x
| | > *
| | | > 3
| | | > x
| > 2
"""
if 1 not in right.coefficients.keys():
raise NotImplementedError("Polynomial with no constant, no calculus to do")
right_coef = right.monomials[1]
add_coefs = Tree("+", left, right_coef)
right_top = [mo for deg, mo in right.monomials.items() if deg > 1][::-1]
right_bot = [mo for deg, mo in right.monomials.items() if deg < 1][::-1]
adds = right_top + [add_coefs] + right_bot
return Tree.from_list("+", adds)
@add.register(MOpolynomial, MOstr)
@special_case(add_filter)
def mopolynomial_mostr(left, right):
""" Add a str to a polynomial
:example:
>>> a = MOpolynomial("x", [2, 3, 4])
>>> b = MOstr("x")
>>> print(add(a, b))
+
> *
| > 4
| > ^
| | > x
| | > 2
> +
| > +
| | > *
| | | > 3
| | | > x
| | > x
| > 2
"""
if 1 not in left.coefficients.keys():
raise NotImplementedError("No degree in common")
left_coef = left.monomials[1]
add_coefs = Tree("+", left_coef, right)
left_top = [mo for deg, mo in left.monomials.items() if deg > 1][::-1]
left_bot = [mo for deg, mo in left.monomials.items() if deg < 1][::-1]
adds = left_top + [add_coefs] + left_bot
return Tree.from_list("+", adds)
@add.register(MOstrPower, MOpolynomial)
@special_case(add_filter)
def mostrpower_mopolynomial(left, right):
""" Add a strpower to a polynomial
:example:
>>> a = MOstrPower("x", 2)
>>> b = MOpolynomial("x", [2, 3, 4])
>>> print(add(a, b))
+
> +
| > ^
| | > x
| | > 2
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
> +
| > *
| | > 3
| | > x
| > 2
>>> b = MOpolynomial("x", [2, 3, 4, 5])
>>> print(add(a, b))
+
> +
| > *
| | > 5
| | > ^
| | | > x
| | | > 3
| > +
| | > ^
| | | > x
| | | > 2
| | > *
| | | > 4
| | | > ^
| | | | > x
| | | | > 2
> +
| > *
| | > 3
| | > x
| > 2
"""
if left.power not in right.coefficients.keys():
raise NotImplementedError("No degree in common")
right_mono = right.monomials[left.power]
add_coefs = Tree("+", left, right_mono)
right_top = [mo for deg, mo in right.monomials.items() if deg > left.power][::-1]
right_bot = [mo for deg, mo in right.monomials.items() if deg < left.power][::-1]
adds = right_top + [add_coefs] + right_bot
return Tree.from_list("+", adds)
@add.register(MOpolynomial, MOstrPower)
@special_case(add_filter)
def mopolynomial_mostrpower(left, right):
""" Add a strpower to a polynomial
:example:
>>> a = MOpolynomial("x", [2, 3, 4])
>>> b = MOstrPower("x", 2)
>>> print(add(a, b))
+
> +
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
| > ^
| | > x
| | > 2
> +
| > *
| | > 3
| | > x
| > 2
>>> a = MOpolynomial("x", [2, 3, 4, 5])
>>> print(add(a, b))
+
> +
| > *
| | > 5
| | > ^
| | | > x
| | | > 3
| > +
| | > *
| | | > 4
| | | > ^
| | | | > x
| | | | > 2
| | > ^
| | | > x
| | | > 2
> +
| > *
| | > 3
| | > x
| > 2
"""
if right.power not in left.coefficients.keys():
raise NotImplementedError("No degree in common")
left_mono = left.monomials[right.power]
add_coefs = Tree("+", left_mono, right)
left_top = [mo for deg, mo in left.monomials.items() if deg > right.power][::-1]
left_bot = [mo for deg, mo in left.monomials.items() if deg < right.power][::-1]
adds = left_top + [add_coefs] + left_bot
return Tree.from_list("+", adds)
@add.register(MOMonomial, MOpolynomial)
@special_case(add_filter)
def momonomial_mopolynomial(left, right):
""" Add a monomial to a polynomial
:example:
>>> a = MOMonomial(10, "x", 2)
>>> b = MOpolynomial("x", [2, 3, 4])
>>> print(add(a, b))
+
> +
| > *
| | > 10
| | > ^
| | | > x
| | | > 2
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
> +
| > *
| | > 3
| | > x
| > 2
>>> b = MOpolynomial("x", [2, 3, 4, 5])
>>> print(add(a, b))
+
> +
| > *
| | > 5
| | > ^
| | | > x
| | | > 3
| > +
| | > *
| | | > 10
| | | > ^
| | | | > x
| | | | > 2
| | > *
| | | > 4
| | | > ^
| | | | > x
| | | | > 2
> +
| > *
| | > 3
| | > x
| > 2
"""
if left.power not in right.coefficients.keys():
raise NotImplementedError("No degree in common")
right_mono = right.monomials[left.power]
add_coefs = Tree("+", left, right_mono)
right_top = [mo for deg, mo in right.monomials.items() if deg > left.power][::-1]
right_bot = [mo for deg, mo in right.monomials.items() if deg < left.power][::-1]
adds = right_top + [add_coefs] + right_bot
return Tree.from_list("+", adds)
@add.register(MOpolynomial, MOMonomial)
@special_case(add_filter)
def mopolynomial_momonomial(left, right):
""" Add a monomial to a polynomial
:example:
>>> a = MOpolynomial("x", [2, 3, 4])
>>> b = MOMonomial(10, "x", 2)
>>> print(add(a, b))
+
> +
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
| > *
| | > 10
| | > ^
| | | > x
| | | > 2
> +
| > *
| | > 3
| | > x
| > 2
>>> a = MOpolynomial("x", [2, 3, 4, 5])
>>> print(add(a, b))
+
> +
| > *
| | > 5
| | > ^
| | | > x
| | | > 3
| > +
| | > *
| | | > 4
| | | > ^
| | | | > x
| | | | > 2
| | > *
| | | > 10
| | | > ^
| | | | > x
| | | | > 2
> +
| > *
| | > 3
| | > x
| > 2
"""
if right.power not in left.coefficients.keys():
raise NotImplementedError("No degree in common")
left_mono = left.monomials[right.power]
add_coefs = Tree("+", left_mono, right)
left_top = [mo for deg, mo in left.monomials.items() if deg > right.power][::-1]
left_bot = [mo for deg, mo in left.monomials.items() if deg < right.power][::-1]
adds = left_top + [add_coefs] + left_bot
return Tree.from_list("+", adds)
@add.register(MOpolynomial, MOpolynomial)
@special_case(add_filter)
def mopolynomial_mopolynomial(left, right):
""" Add a polynomial to a polynomial
:example:
>>> a = MOpolynomial("x", [2, 3, 4])
>>> b = MOpolynomial("x", [5, 6, 7])
>>> print(add(a, b))
+
> +
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
| > *
| | > 7
| | > ^
| | | > x
| | | > 2
> +
| > +
| | > *
| | | > 3
| | | > x
| | > *
| | | > 6
| | | > x
| > +
| | > 2
| | > 5
>>> b = MOpolynomial("x", [0, 3, 4])
>>> print(add(a, b))
+
> +
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
> +
| > +
| | > *
| | | > 3
| | | > x
| | > *
| | | > 3
| | | > x
| > 2
>>> b = MOpolynomial("x", [0, 3, 0, 5])
>>> print(add(a, b))
+
> +
| > *
| | > 5
| | > ^
| | | > x
| | | > 3
| > *
| | > 4
| | > ^
| | | > x
| | | > 2
> +
| > +
| | > *
| | | > 3
| | | > x
| | > *
| | | > 3
| | | > x
| > 2
"""
common_degree = set(left.monomials.keys()).intersection(right.monomials.keys())
if not common_degree:
raise NotImplementedError("No degree in common, no calculus to do")
merge_monomials = {**left.monomials, **right.monomials}
for deg in common_degree:
merge_monomials[deg] = Tree("+", left.monomials[deg], right.monomials[deg])
return Tree.from_list("+", list(merge_monomials.values())[::-1])
@add.register(MOstr, MOMonomial)
@special_case(add_filter)
def mostr_momonomial(left, right):
""" Add a str to a Monomial
:example:
>>> a = MOstr("x")
>>> b = MOMonomial(2, "x")
>>> print(add(a, b))
*
> +
| > 1
| > 2
> x
"""
if right.power != 1:
raise NotImplementedError("Monomial is more than deg 1")
add_scal = Tree("+", 1, right.coefficient)
return Tree("*", add_scal, left)
@add.register(MOMonomial, MOstr)
@special_case(add_filter)
def momonomial_mostr(left, right):
""" Add a str to a Monomial
:example:
>>> a = MOMonomial(2, "x")
>>> b = MOstr("x")
>>> print(add(a, b))
*
> +
| > 2
| > 1
> x
"""
if left.power != 1:
raise NotImplementedError("Monomial is more than deg 1")
add_scal = Tree("+", left.coefficient, 1)
return Tree("*", add_scal, right)
@add.register(MOstrPower, MOMonomial)
@special_case(add_filter)
def mostrpower_momonomial(left, right):
""" Add a strpower to a Monomial
:example:
>>> a = MOstrPower("x", 2)
>>> b = MOMonomial(3, "x", 2)
>>> print(add(a, b))
*
> +
| > 1
| > 3
> ^
| > x
| > 2
"""
if right.power != left.power:
raise NotImplementedError("MOs does not have same degree")
add_scal = Tree("+", 1, right.coefficient)
return Tree("*", add_scal, left)
@add.register(MOMonomial, MOstrPower)
@special_case(add_filter)
def momonomial_mostrpower(left, right):
""" Add a strpower to a Monomial
:example:
>>> a = MOMonomial(3, "x", 2)
>>> b = MOstrPower("x", 2)
>>> print(add(a, b))
*
> +
| > 3
| > 1
> ^
| > x
| > 2
"""
if left.power != right.power:
raise NotImplementedError("MOs does not have same degree")
add_scal = Tree("+", left.coefficient, 1)
return Tree("*", add_scal, right)
@add.register(MOMonomial, MOMonomial)
@special_case(add_filter)
def momonomial_momonomial(left, right):
""" Add a Monomial to a Monomial
:example:
>>> a = MOMonomial(3, "x", 2)
>>> b = MOMonomial(4, "x", 2)
>>> print(add(a, b))
*
> +
| > 3
| > 4
> ^
| > x
| > 2
"""
if left.power != right.power:
raise NotImplementedError("MOs does not have same degree")
add_scal = Tree("+", left.coefficient, right.coefficient)
return Tree("*", add_scal, right.strpower)
# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del