a SG5d@sddlmZddlmZddlmZddlmZmZm Z ddl m Z ddl m Z ddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddZ;ddZdd Z?d!d"Z@d#d$ZAdfd&d'ZBdgd(d)ZCd*d+ZDdhd-d.ZEd/d0ZFdid1d2ZGd3d4ZHdjd6d7ZId8d9ZJdkd:d;ZKdd?ZMd@dAZNdldBdCZOdmdDdEZPdndFdGZQdHdIZRdodJdKZSdLdMZTdNdOZUe:reVeWe8e;eeNeOePeQeLeReSf\Z;ZZNZOZPZQZLZRZSeBe;feCe;fe7gZXeIeBe;feCe;fe;gfZYeNeEe;feNeEeHe;fe7gZZe@eHfe7gZ[e@e?e@eKe@eMe@e;fZ\e@e?eGe@e?eIfeBeDeIe@feZeXeFeYe@eFeFe[fe7gZ]dPdQfdRdSZ^dpdTdUZ_dV`ZaebeVeceaeVeWedjeeaZfdWdXZgd5ahdqdYdZZid[d\Zjd]d^Zkd_d`ZldadbZmdcddZnd5S)r) defaultdictAdd)Expr)Factors gcd_terms factor_terms expand_mul)Mul)piI)Pow)S)orderedDummy)sympify bottom_up)binomial)coshsinhtanhcothsechcschHyperbolicFunction)cossintancotseccscsqrtTrigonometricFunction) perfect_power)factor)greedy)identitydebug) SYMPY_DEBUGcCs|S)zSimplification of rational polynomials, trying to simplify the expression, e.g. combine things like 3*x + 2*x, etc.... )normalr'expandrvr0M/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/simplify/fu.pyTR0sr2cCsdd}t||S)zReplace sec, csc with 1/cos, 1/sin Examples ======== >>> from sympy.simplify.fu import TR1, sec, csc >>> from sympy.abc import x >>> TR1(2*csc(x) + sec(x)) 1/cos(x) + 2/sin(x) cSsHt|tr"|jd}tjt|St|trD|jd}tjt|S|SNr) isinstancer"argsrOnerr#rr/ar0r0r1f4s    zTR1..frr/r9r0r0r1TR1(s  r;cCsdd}t||S)a@Replace tan and cot with sin/cos and cos/sin Examples ======== >>> from sympy.simplify.fu import TR2 >>> from sympy.abc import x >>> from sympy import tan, cot, sin, cos >>> TR2(tan(x)) sin(x)/cos(x) >>> TR2(cot(x)) cos(x)/sin(x) >>> TR2(tan(tan(x) - sin(x)/cos(x))) 0 cSsLt|tr$|jd}t|t|St|trH|jd}t|t|S|Sr3)r4r r5rrr!r7r0r0r1r9Rs    zTR2..frr:r0r0r1TR2@s r<Fcsfdd}t||S)aConverts ratios involving sin and cos as follows:: sin(x)/cos(x) -> tan(x) sin(x)/(cos(x) + 1) -> tan(x/2) if half=True Examples ======== >>> from sympy.simplify.fu import TR2i >>> from sympy.abc import x, a >>> from sympy import sin, cos >>> TR2i(sin(x)/cos(x)) tan(x) Powers of the numerator and denominator are also recognized >>> TR2i(sin(x)**2/(cos(x) + 1)**2, half=True) tan(x/2)**2 The transformation does not take place unless assumptions allow (i.e. the base must be positive or the exponent must be an integer for both numerator and denominator) >>> TR2i(sin(x)**a/(cos(x) + 1)**a) sin(x)**a/(cos(x) + 1)**a cs|js |S|\js"jr&|SfddfddtD}s^|SfddtD}s|Sfdd}||||g}D]}t|tr~t|j dd d }|vr"||kr"| t |j d|d|<|<nZrd |}|vr||kr| t |j dd |d|<|<qt|trt|j dd d }|vr||kr| t |j d| d|<|<qr|j r|j dt jurt|j d trt|j d j dd d }|vr||kr|jsT|jr| t |j dd | d|<|<q|rt|d dDtddD}|tdd|Dtdd|D9}|S)NcsF|js |joD|jttfvpDoD|joDt|jdkoDtdd|jDS)Ncss&|]}tddt|DVqdS)css(|] }t|tp|jo|jtuVqdSN)r4ris_Powbase).0air0r0r1 sz8TR2i..f..ok...N)anyr make_argsrAr8r0r0r1rCsz.TR2i..f..ok..) is_integer is_positivefuncrris_Addlenr5rD)kehalfr0r1oks  zTR2i..f..okcs(g|] }||s||fqSr0poprArL)nrPr0r1 z#TR2i..f..cs(g|] }||s||fqSr0rQrS)drPr0r1rUrVcsg}|D]B}|jrt|jdkrr,t|nt|}||kr|||fq|rt|D]\}\}}||=|||<qXt|}|D]6}||||}||r|||<q|||fq~dSN) rJrKr5r'rappend enumerater as_powers_dict)rWddoneZnewkrLZknewiv)rOrPr0r1 factorizes"    z"TR2i..f..factorizerFevaluaterYr=cSsg|]\}}|r||qSr0r0rAbrMr0r0r1rUrVcSsg|]\}}|r||qSr0r0rcr0r0r1rUrVcSsg|]\}}||qSr0r0rcr0r0r1rUrV)is_Mulas_numer_denomis_Atomr\listkeysr4rrr5rZr rJrr6rGrHr items)r/Zndoner]r`trLr8a1rN)rWrTrPr1r9zsb         $"(zTR2i..fr)r/rOr9r0rNr1TR2i^s Urmcs"ddlmfdd}t||S)aRInduced formula: example sin(-a) = -sin(a) Examples ======== >>> from sympy.simplify.fu import TR3 >>> from sympy.abc import x, y >>> from sympy import pi >>> from sympy import cos >>> TR3(cos(y - x*(y - x))) cos(x*(x - y) + y) >>> cos(pi/2 + x) -sin(x) >>> cos(30*pi/2 + x) -cos(x) rsignsimpc st|ts|S||jd}t|ts0|S|jdtjdjtjd|jdjurhdurnn.f)sympy.simplify.simplifyrorr:r0rnr1TR3s rtcCs|S)aIdentify values of special angles. a= 0 pi/6 pi/4 pi/3 pi/2 ---------------------------------------------------- sin(a) 0 1/2 sqrt(2)/2 sqrt(3)/2 1 cos(a) 1 sqrt(3)/2 sqrt(2)/2 1/2 0 tan(a) 0 sqt(3)/3 1 sqrt(3) -- Examples ======== >>> from sympy import pi >>> from sympy import cos, sin, tan, cot >>> for s in (0, pi/6, pi/4, pi/3, pi/2): ... print('%s %s %s %s' % (cos(s), sin(s), tan(s), cot(s))) ... 1 0 0 zoo sqrt(3)/2 1/2 sqrt(3)/3 sqrt(3) sqrt(2)/2 sqrt(2)/2 1 1 1/2 sqrt(3)/2 sqrt(3) sqrt(3)/3 0 1 zoo 0 r0r.r0r0r1TR4srucsfdd}t||S)a+Helper for TR5 and TR6 to replace f**2 with h(g**2) Options ======= max : controls size of exponent that can appear on f e.g. if max=4 then f**4 will be changed to h(g**2)**2. pow : controls whether the exponent must be a perfect power of 2 e.g. if pow=True (and max >= 6) then f**6 will not be changed but f**8 will be changed to h(g**2)**4 >>> from sympy.simplify.fu import _TR56 as T >>> from sympy.abc import x >>> from sympy import sin, cos >>> h = lambda x: 1 - x >>> T(sin(x)**3, sin, cos, h, 4, False) (1 - cos(x)**2)*sin(x) >>> T(sin(x)**6, sin, cos, h, 6, False) (1 - cos(x)**2)**3 >>> T(sin(x)**6, sin, cos, h, 6, True) sin(x)**6 >>> T(sin(x)**8, sin, cos, h, 10, True) (1 - cos(x)**2)**4 cs$|jr|jjks|S|jjs"|S|jdkdkr4|S|jkdkrF|S|jdkrT|S|jdkrv|jjddS|jddkr|jd}|jjd|jjdd|S|jdkrd}n:s|jdr|S|jd}nt|j}|s|S|jd}|jjdd|SdS)NrTrYr=rp)r?r@rIexpis_realr5r&)r/rMpr9ghmaxpowr0r1_f1s4   ,     z_TR56.._fr)r/r9rzr{r|r}r~r0ryr1_TR56s#rrpcCst|ttdd||dS)aReplacement of sin**2 with 1 - cos(x)**2. See _TR56 docstring for advanced use of ``max`` and ``pow``. Examples ======== >>> from sympy.simplify.fu import TR5 >>> from sympy.abc import x >>> from sympy import sin >>> TR5(sin(x)**2) 1 - cos(x)**2 >>> TR5(sin(x)**-2) # unchanged sin(x)**(-2) >>> TR5(sin(x)**4) (1 - cos(x)**2)**2 cSsd|SrXr0xr0r0r1irVzTR5..r|r})rrrr/r|r}r0r0r1TR5WsrcCst|ttdd||dS)aReplacement of cos**2 with 1 - sin(x)**2. See _TR56 docstring for advanced use of ``max`` and ``pow``. Examples ======== >>> from sympy.simplify.fu import TR6 >>> from sympy.abc import x >>> from sympy import cos >>> TR6(cos(x)**2) 1 - sin(x)**2 >>> TR6(cos(x)**-2) #unchanged cos(x)**(-2) >>> TR6(cos(x)**4) (1 - sin(x)**2)**2 cSsd|SrXr0rr0r0r1r~rVzTR6..r)rrrrr0r0r1TR6lsrcCsdd}t||S)aLowering the degree of cos(x)**2. Examples ======== >>> from sympy.simplify.fu import TR7 >>> from sympy.abc import x >>> from sympy import cos >>> TR7(cos(x)**2) cos(2*x)/2 + 1/2 >>> TR7(cos(x)**2 + 1) cos(2*x)/2 + 3/2 cSs<|jr|jjtkr|jdks |Sdtd|jjddS)Nr=rYr)r?r@rIrrvr5r.r0r0r1r9szTR7..frr:r0r0r1TR7srTcsfdd}t||S)aqConverting products of ``cos`` and/or ``sin`` to a sum or difference of ``cos`` and or ``sin`` terms. Examples ======== >>> from sympy.simplify.fu import TR8 >>> from sympy import cos, sin >>> TR8(cos(2)*cos(3)) cos(5)/2 + cos(1)/2 >>> TR8(cos(2)*sin(3)) sin(5)/2 + sin(1)/2 >>> TR8(sin(2)*sin(3)) -cos(5)/2 + cos(1)/2 c s|js0|jr,|jjttfvr,|jjs0|jjs0|Srdd| D\}}t |dd}t |dd}||ksr||krt ||}|jr|j dj rt|j dkr|j djrt|}|Stgtgdgi}tt|D]}|jttfvr|t||j dq|jr\|jjr\|jdkr\|jjttfvr\|t|j|jj dg|jq|d|q|t}|t}|r|st|dkst|dks|S|d}tt|t|}t|D]8} |} |} |t| | t| | dqt|dkrH|} |} |t| | t| | dq|r`|t|t|dkr|} |} |t| |  t| | dq`|r|t|t tt|S)NcSsg|] }t|qSr0r rAr^r0r0r1rUrVz"TR8..f..Ffirstrr=rY)rer?r@rIrrrvrGrHrfTR8rr5 is_RationalrKrJr as_coeff_MulrrErrrZ is_IntegerextendminrangerRr ) r/rTrWnewnnewdr5r8csr^rla2rr0r1r9sp      &( &&(zTR8..frr/rr9r0rr1rs 7rcCsdd}t||S)acSum of ``cos`` or ``sin`` terms as a product of ``cos`` or ``sin``. Examples ======== >>> from sympy.simplify.fu import TR9 >>> from sympy import cos, sin >>> TR9(cos(1) + cos(2)) 2*cos(1/2)*cos(3/2) >>> TR9(cos(1) + 2*sin(1) + 2*sin(2)) cos(1) + 4*sin(3/2)*cos(1/2) If no change is made by TR9, no re-arrangement of the expression will be made. For example, though factoring of common term is attempted, if the factored expression was not changed, the original expression will be returned: >>> TR9(cos(3) + cos(3)*cos(2)) cos(3) + cos(2)*cos(3) cs"|js |Sdfdd t|S)NTcs|js |Stt|j}t|dkrd}tt|D]p}||}|durJq4t|dt|D]F}||}|durrq\||}|} | |kr\| ||<d||<d}q4q\q4|rtdd|D}|jrʈ|}|St|} | s|S| \} } } }}}|rf| | kr*| | dt||dt||dS| dkr>||}}d| t ||dt ||dS| | kr| | dt ||dt||dS| dkr||}}d| t||dt ||dSdS) Nr=FrYTcSsg|] }|r|qSr0r0rAr~r0r0r1rU#rVz.TR9..f..do..r rJrhrr5rKrr trig_splitrr)r/rr5hitr^rBjajwasnewsplitgcdn1n2r8rdZiscosdor0r1rsP  ,  ( ,  zTR9..f..do)T)rJprocess_common_addendsr.r0rr1r9s>zTR9..frr:r0r0r1TR9sDrcsfdd}t||S)aSeparate sums in ``cos`` and ``sin``. Examples ======== >>> from sympy.simplify.fu import TR10 >>> from sympy.abc import a, b, c >>> from sympy import cos, sin >>> TR10(cos(a + b)) -sin(a)*sin(b) + cos(a)*cos(b) >>> TR10(sin(a + b)) sin(a)*cos(b) + sin(b)*cos(a) >>> TR10(sin(a + b + c)) (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + (sin(a)*cos(b) + sin(b)*cos(a))*cos(c) cs|jttfvr|S|j}|jd}|jrr>tt|j}n t|j}|}t |}|jr|tkrt|t t|ddt|t t|ddSt|t t|ddt|t t|ddSnH|tkrt|t|t|t|St|t|t|t|S|S)NrFr) rIrrr5rJrhrrRr _from_argsTR10)r/r9argr5r8rdrr0r1r9Ts,     zTR10..frrr0rr1rBs rcCs tdurtdd}t||S)aSum of products to function of sum. Examples ======== >>> from sympy.simplify.fu import TR10i >>> from sympy import cos, sin, sqrt >>> from sympy.abc import x >>> TR10i(cos(1)*cos(3) + sin(1)*sin(3)) cos(2) >>> TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) cos(3) + sin(4) >>> TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) 2*sqrt(2)*x*sin(x + pi/6) Nc s|js |Sd fdd t|dd}|jrtt}|jD]^}d}|jr|jD]4}|jrR|jtj urR|j j rR|| |d}qqR|s>|tj  |q>g}|D]}t|tfD]}||vrtt||D]}|||durqtt||D]j}|||durqt||||||} | } | | kr| | d|||<d|||<qqqqq|rt|dd |D}q(|}qq(|S) NTcsb|js |Stt|j}t|dkrd}tt|D]p}||}|durJq4t|dt|D]F}||}|durrq\||}|} | |kr\| ||<d||<d}q4q\q4|rtdd|D}|jrʈ|}|St|ddi} | s|S| \} } } }}}|r,| | } | | kr| t||S| t||S| | } | | krN| t ||S| t ||SdS)Nr=FrYTcSsg|] }|r|qSr0r0rr0r0r1rUrVz0TR10i..f..do..twor)r/rr5rr^rBrrrrrrrrr8rdsamerr0r1rsL    zTR10i..f..docSstt|jSr>)tupler free_symbolsrr0r0r1rrVz"TR10i..f..rrYcSsg|]}tdd|DqS)cSsg|] }|r|qSr0r0rr0r0r1rUrVz/TR10i..f...r)rAr_r0r0r1rUsz$TR10i..f..)T)rJrrrhr5rer?rvrHalfr@rrZr6_ROOT3 _invROOT3rrKrvalues) r/Zbyradr8rrBr5rdr^rrrr0rr1r9sX8         zTR10i..f)_ROOT2_rootsrr:r0r0r1TR10irskrNcsfdd}t||S)anFunction of double angle to product. The ``base`` argument can be used to indicate what is the un-doubled argument, e.g. if 3*pi/7 is the base then cosine and sine functions with argument 6*pi/7 will be replaced. Examples ======== >>> from sympy.simplify.fu import TR11 >>> from sympy import cos, sin, pi >>> from sympy.abc import x >>> TR11(sin(2*x)) 2*sin(x)*cos(x) >>> TR11(cos(2*x)) -sin(x)**2 + cos(x)**2 >>> TR11(sin(4*x)) 4*(-sin(x)**2 + cos(x)**2)*sin(x)*cos(x) >>> TR11(sin(4*x/3)) 4*(-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3) If the arguments are simply integers, no change is made unless a base is provided: >>> TR11(cos(2)) cos(2) >>> TR11(cos(4), 2) -sin(2)**2 + cos(2)**2 There is a subtle issue here in that autosimplification will convert some higher angles to lower angles >>> cos(6*pi/7) + cos(3*pi/7) -cos(pi/7) + cos(3*pi/7) The 6*pi/7 angle is now pi/7 but can be targeted with TR11 by supplying the 3*pi/7 base: >>> TR11(_, 3*pi/7) -sin(3*pi/7)**2 + cos(3*pi/7)**2 + cos(3*pi/7) cs4|jttfvr|Sr|j}|d}tj}|jr@|\}}|jttfvrR|S|jd|jdkrt}t}|tur|d|d|Sd|||S|S|jdjs0|jdjdd\}}|j ddkr0|j d||j }t t|}t t|}|jtkr d||}n|d|d}|S)Nr=rT)rational) rIrrrr6rerr5 is_NumberrxqTR11)r/r9rkcorrmrr@r0r1r9 s6     zTR11..fr)r/r@r9r0rr1rs* #rcCsdd}t||S)a Helper for TR11 to find half-arguments for sin in factors of num/den that appear in cos or sin factors in the den/num. Examples ======== >>> from sympy.simplify.fu import TR11, _TR11 >>> from sympy import cos, sin >>> from sympy.abc import x >>> TR11(sin(x/3)/(cos(x/6))) sin(x/3)/cos(x/6) >>> _TR11(sin(x/3)/(cos(x/6))) 2*sin(x/6) >>> TR11(sin(x/6)/(sin(x/3))) sin(x/6)/sin(x/3) >>> _TR11(sin(x/6)/(sin(x/3))) 1/(2*cos(x/6)) cSsLt|ts|Sdd}t||\}}dd}||||}||||}|S)NcSs\tt}t|D]D}|\}}|jr|dkr|jttfvr|t | |j dq|Sr3) rsetr rE as_base_exprrIrrrraddr5)flatr5firdrMr0r0r1 sincos_args_s z%_TR11..f..sincos_argscSsX|tD]J}|d}||tvr&t}n||tvrt}nqt||}|||q|SNr=)rrrremove)r/num_argsden_argsnargrOrIr0r0r1 handle_matchks    z&_TR11..f..handle_match)r4rmaprf)r/rrrrr0r0r1r9[s    z_TR11..frr:r0r0r1_TR11Fs%rcsfdd}t||S)zSeparate sums in ``tan``. Examples ======== >>> from sympy.abc import x, y >>> from sympy import tan >>> from sympy.simplify.fu import TR12 >>> TR12(tan(x + y)) (tan(x) + tan(y))/(-tan(x)*tan(y) + 1) cs|jtks|S|jd}|jrr2tt|j}n t|j}|}t|}|jrft t|dd}nt|}t||dt||S|S)NrFrrY) rIr r5rJrhrrRrrTR12)r/rr5r8rdtbrr0r1r9s    zTR12..frrr0rr1rs rcCsdd}t||S)aKCombine tan arguments as (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y). Examples ======== >>> from sympy.simplify.fu import TR12i >>> from sympy import tan >>> from sympy.abc import a, b, c >>> ta, tb, tc = [tan(i) for i in (a, b, c)] >>> TR12i((ta + tb)/(-ta*tb + 1)) tan(a + b) >>> TR12i((ta + tb)/(ta*tb - 1)) -tan(a + b) >>> TR12i((-ta - tb)/(ta*tb - 1)) tan(a + b) >>> eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1)) >>> TR12i(eq.expand()) -3*tan(a + b)*tan(a + c)/(2*(tan(a) + tan(b) - 1)) cSs|js|js|js|S|\}}|jr.|js2|Si}dd}tt|}t|D]\}}||}|r|\} } t dd| jD} t j || <| ||<qT|jrt |}|jr| |jt j ||<qT|jrT|jjs|jjrT||j}|r |\} } t dd| jD} |j|| <| |j||<qTt |}|jrT| |jt j ||<qT|sP|Sdd}ttt|} d} t| D]@\}}||}|sH|| }|rt j| |<n|jrt |}|jrv| |jt j | |<qvnh|jrv|jjs|jjrv||j}|rt j | |<n*t |}|jrv| |jt j | |<qvnqvn t j | |<d} t d d|D} || }|t j }|dur|r||| <n || | |t|  9<qv| rt| t|td d|D}|S) NcSsTt|}|rP|\}}}|tjurP|jrPt|jdkrPtdd|jDrP||fSdS)Nr=css|]}t|tVqdSr>)r4r )rArr0r0r1rCrVz/TR12i..f..ok..) as_f_sign_1r NegativeOnererKr5all)dirrzr9rr0r0r1rPs zTR12i..f..okcSsg|]}|jdqSrr5rA_r0r0r1rUrVz$TR12i..f..cSsg|]}|jdqSrrrr0r0r1rUrVcSs>|jr:t|jdkr:|j\}}t|tr:t|tr:||fSdSr)rJrKr5r4r )nir8rdr0r0r1rPs FTcSsg|]}|jdqSrrrr0r0r1rUrVcSs,g|]$\}}tdd|jDd|qS)cSsg|] }t|qSr0)r rFr0r0r1rUsz/TR12i..f...rY)rr5)rAr^rMr0r0r1rUs)rJrer?rfr5rhr rEr[rrr6r'rrvrGr@rHrrextract_additivelyrRr rj)r/rTrWdokrPZd_argsr^rrrzrkrZn_argsrredZnewedr0r0r1r9s                       zTR12i..frr:r0r0r1TR12iscrcCsdd}t||S)aChange products of ``tan`` or ``cot``. Examples ======== >>> from sympy.simplify.fu import TR13 >>> from sympy import tan, cot >>> TR13(tan(3)*tan(2)) -tan(2)/tan(5) - tan(3)/tan(5) + 1 >>> TR13(cot(3)*cot(2)) cot(2)*cot(5) + 1 + cot(3)*cot(5) cSsp|js |Stgtgdgi}tt|D]:}|jttfvrT|t||j dq(|d|q(|t}|t}t |dkrt |dkr|S|d}t |dkr| }| }|dt|t||t|t||q|r|t| t |dkrP| }| }|dt|t||t|t||q|rh|t| t|S)Nrr=rY) rer r!rr rErIrrrZr5rKrR)r/r5r8rkrt1t2r0r0r1r9/s2 44zTR13..frr:r0r0r1TR13!srcsdfdd t|S)aReturns cos(x)*cos(2*x)*...*cos(2**(k-1)*x) -> sin(2**k*x)/(2**k*sin(x)) Examples ======== >>> from sympy.simplify.fu import TRmorrie, TR8, TR3 >>> from sympy.abc import x >>> from sympy import Mul, cos, pi >>> TRmorrie(cos(x)*cos(2*x)) sin(4*x)/(4*sin(x)) >>> TRmorrie(7*Mul(*[cos(x) for x in range(10)])) 7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3)) Sometimes autosimplification will cause a power to be not recognized. e.g. in the following, cos(4*pi/7) automatically simplifies to -cos(3*pi/7) so only 2 of the 3 terms are recognized: >>> TRmorrie(cos(pi/7)*cos(2*pi/7)*cos(4*pi/7)) -sin(3*pi/7)*cos(3*pi/7)/(4*sin(pi/7)) A touch by TR8 resolves the expression to a Rational >>> TR8(_) -1/8 In this case, if eq is unsimplified, the answer is obtained directly: >>> eq = cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9) >>> TRmorrie(eq) 1/16 But if angles are made canonical with TR3 then the answer is not simplified without further work: >>> TR3(eq) sin(pi/18)*cos(pi/9)*cos(2*pi/9)/2 >>> TRmorrie(_) sin(pi/18)*sin(4*pi/9)/(8*sin(pi/9)) >>> TR8(_) cos(7*pi/18)/(16*sin(pi/9)) >>> TR3(_) 1/16 The original expression would have resolve to 1/16 directly with TR8, however: >>> TR8(eq) 1/16 References ========== .. [1] https://en.wikipedia.org/wiki/Morrie%27s_law Tcs|js |S|r.|\}}|d|dStti}g}|jD]T}|\}}|jrt|tr|jd \} } |  | |||<qD| |qDg} D]H} | }| |rd} |d} }| |vr| d7} | d9} q| dkrt d| || d| t || }d}g}t | D]@}| d} t| | dd}| | t|||pb||}q(t | D]B}|} t| | dd}|||8<||sr|| qr| ||qt|d| }| |||qq| rt| |fddD}|S)NrrYr=Fracs*g|]"}|D]}t||ddqqS)Fra)r)rAr8rLrr0r1rUsz'TRmorrie..f..)rerfrrhr5rrr4rrrZsortrrrrRrr )r/rrTrWZcossotherrrdrMrr8rrLcccinewargtakeZccsr^keyr9rr1r9s`         (     zTRmorrie..f)Trr.r0rr1TRmorriePs;9rcsfdd}t||S)aConvert factored powers of sin and cos identities into simpler expressions. Examples ======== >>> from sympy.simplify.fu import TR14 >>> from sympy.abc import x, y >>> from sympy import cos, sin >>> TR14((cos(x) - 1)*(cos(x) + 1)) -sin(x)**2 >>> TR14((sin(x) - 1)*(sin(x) + 1)) -cos(x)**2 >>> p1 = (cos(x) + 1)*(cos(x) - 1) >>> p2 = (cos(y) - 1)*2*(cos(y) + 1) >>> p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1)) >>> TR14(p1*p2*p3*(x - 1)) -18*(x - 1)*sin(x)**2*sin(y)**4 c sF|js |SrX|\}}|tjurXt|dd}t|dd}||ksL||krT||}|Sg}g}|jD]}|jr|\}} | js|j s| |qf|}ntj} t |} | r| dj t tfvr| tjur| |qf| || qf| \} } } | | | j| | | |fqftt|}t|}ttd}\} }} } } }|r,|d|r|d| jrz| jrz| | kr| | kr|dt| | }| |krfdd|D}|| |8<|d|n<| |kr(fdd|D}|| |8<|d|t| t r>t}nt }| |  | || jdd |q8n| | kr| | kr| | kr|d| }t| t rt}nt }| |  | || jdd |q8| || q8t||krBt|}|S) NFrrYrcsg|] }|qSr0r0r)Br0r1rUrVz#TR14..f..csg|] }|qSr0r0r)Ar0r1rUrVr=)rerfrr6TR14r5r?rrGrHrZrrIrrrrhrrKrrRrinsertr4r )r/rTrWrrrprocessr8rdrMrrzr9siZnotherrirkrremr)rrr1r9s               2 2zTR14..frrr0rr1rs `rcsfdd}t||S)aConvert sin(x)**-2 to 1 + cot(x)**2. See _TR56 docstring for advanced use of ``max`` and ``pow``. Examples ======== >>> from sympy.simplify.fu import TR15 >>> from sympy.abc import x >>> from sympy import sin >>> TR15(1 - 1/sin(x)**2) -cot(x)**2 cstt|trt|jts|S|j}|ddkrDt|j|d|jSd|}t|ttddd}||krp|}|S)Nr=rYcSsd|SrXr0rr0r0r1rYrVz!TR15..f..r)r4rr@rrvTR15rr!r/rMiar8rr0r1r9Ps zTR15..frr/r|r}r9r0rr1r@srcsfdd}t||S)aConvert cos(x)**-2 to 1 + tan(x)**2. See _TR56 docstring for advanced use of ``max`` and ``pow``. Examples ======== >>> from sympy.simplify.fu import TR16 >>> from sympy.abc import x >>> from sympy import cos >>> TR16(1 - 1/cos(x)**2) -tan(x)**2 cstt|trt|jts|S|j}|ddkrDt|j|d|jSd|}t|ttddd}||krp|}|S)Nr=rYcSsd|SrXr0rr0r0r1rzrVz!TR16..f..r)r4rr@rrvrrr rrr0r1r9qs zTR16..frrr0rr1TR16asrcCsdd}t||S)aDConvert f(x)**-i to g(x)**i where either ``i`` is an integer or the base is positive and f, g are: tan, cot; sin, csc; or cos, sec. Examples ======== >>> from sympy.simplify.fu import TR111 >>> from sympy.abc import x >>> from sympy import tan >>> TR111(1 - 1/tan(x)**2) 1 - cot(x)**2 cSst|tr"|jjs&|jjr"|jjs&|St|jtrJt|jj d|j St|jt rnt |jj d|j St|jt rt |jj d|j S|Sr3)r4rr@rHrvrG is_negativer r!r5rr#rr"r.r0r0r1r9s    zTR111..frr:r0r0r1TR111srcsfdd}t||S)ahConvert tan(x)**2 to sec(x)**2 - 1 and cot(x)**2 to csc(x)**2 - 1. See _TR56 docstring for advanced use of ``max`` and ``pow``. Examples ======== >>> from sympy.simplify.fu import TR22 >>> from sympy.abc import x >>> from sympy import tan, cot >>> TR22(1 + tan(x)**2) sec(x)**2 >>> TR22(1 + cot(x)**2) csc(x)**2 csRt|tr|jjttfvs|St|ttddd}t|ttddd}|S)NcSs|dSrXr0rr0r0r1rrVz!TR22..f..rcSs|dSrXr0rr0r0r1rrV) r4rr@rIr!r rr"r#r.rr0r1r9s zTR22..frrr0rr1TR22srcCsdd}t||S)aConvert sin(x)**n and cos(x)**n with positive n to sums. Examples ======== >>> from sympy.simplify.fu import TRpower >>> from sympy.abc import x >>> from sympy import cos, sin >>> TRpower(sin(x)**6) -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 + 5/16 >>> TRpower(sin(x)**3*cos(2*x)**4) (3*sin(x)/4 - sin(3*x)/4)*(cos(4*x)/2 + cos(8*x)/8 + 3/8) References ========== .. [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae cst|trt|jttfs|S|\}|jdjrjrj rt|trddt fddt ddD}nj rt|trddt j ddt fddt ddD}njrt|trddt fddt dD}nNjrjt|trjddt j dt fddt dD}jr|d td7}|S) Nrr=rYcs*g|]"}t|td|qSr=rrrSrTrr0r1rUsz&TRpower..f..cs4g|],}t|tj|td|qSr)rrrrrSrr0r1rUs cs*g|]"}t|td|qSrrrSrr0r1rUscs4g|],}t|tj|td|qSr)rrrrrSrr0r1rUs )r4rr@rrrr5rrHis_oddrrrris_evenr)r/rdr0rr1r9s0   *  & zTRpower..frr:r0r0r1TRpowersrcCst|tS)zReturn count of trigonometric functions in expression. Examples ======== >>> from sympy.simplify.fu import L >>> from sympy.abc import x >>> from sympy import cos, sin >>> L(cos(x)+sin(x)) 2 )rcountr%r.r0r0r1Ls rcCst||fSr>)r count_opsrr0r0r1r!rVrcstt}tt}|}t|}t|tsD|jfdd|jDSt|}| t t r||}||krt|}| t t rt |}| t tr||}tt|}t||||gd}tt||dS)aHAttempt to simplify expression by using transformation rules given in the algorithm by Fu et al. :func:`fu` will try to minimize the objective function ``measure``. By default this first minimizes the number of trig terms and then minimizes the number of total operations. Examples ======== >>> from sympy.simplify.fu import fu >>> from sympy import cos, sin, tan, pi, S, sqrt >>> from sympy.abc import x, y, a, b >>> fu(sin(50)**2 + cos(50)**2 + sin(pi/6)) 3/2 >>> fu(sqrt(6)*cos(x) + sqrt(2)*sin(x)) 2*sqrt(2)*sin(x + pi/3) CTR1 example >>> eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2 >>> fu(eq) cos(x)**4 - 2*cos(y)**2 + 2 CTR2 example >>> fu(S.Half - cos(2*x)/2) sin(x)**2 CTR3 example >>> fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b))) sqrt(2)*sin(a + b + pi/4) CTR4 example >>> fu(sqrt(3)*cos(x)/2 + sin(x)/2) sin(x + pi/3) Example 1 >>> fu(1-sin(2*x)**2/4-sin(y)**2-cos(x)**4) -cos(x)**2 + cos(y)**2 Example 2 >>> fu(cos(4*pi/9)) sin(pi/18) >>> fu(cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9)) 1/16 Example 3 >>> fu(tan(7*pi/18)+tan(5*pi/18)-sqrt(3)*tan(5*pi/18)*tan(7*pi/18)) -sqrt(3) Objective function example >>> fu(sin(x)/cos(x)) # default objective function tan(x) >>> fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) # maximize op count sin(x)/cos(x) References ========== .. [1] https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.657.2478&rep=rep1&type=pdf csg|]}t|dqS)measure)furFrr0r1rUmrVzfu..)r)r(RL1RL2rr4rrIr5r;hasr r!r<rrrrrrm)r/rZfRL1ZfRL2rZrv1Zrv2r0rr1r!s$F       rcCstt}|rX|jD]B}|\}}|dkr6| }| }|||rF||ndf|qn2|r|jD]}|tj||f|qbntdg}d}|D]h} || } | \}} t| dkrt | ddi} || } | | kr| } d}||| q||| dq|rt |}|S)aApply ``do`` to addends of ``rv`` that (if ``key1=True``) share at least a common absolute value of their coefficient and the value of ``key2`` when applied to the argument. If ``key1`` is False ``key2`` must be supplied and will be the only key applied. rrYzmust have at least one keyFrbT) rrhr5rrZrr6 ValueErrorrKr)r/rkey2key1Zabscr8rr5rrLr_rrMrr0r0r1r|s8  "  rz~ TR0 TR1 TR2 TR3 TR4 TR5 TR6 TR7 TR8 TR9 TR10 TR10i TR11 TR12 TR13 L TR2i TRmorrie TR12i TR14 TR15 TR16 TR111 TR22cCstdtdaadtadS)Nr=rY)r$rrrr0r0r0r1rsrcs*tdurtdd||fD\}}||\}}||}d}}tj|jvrh|tj}| }ntj|jvr|tj}| }dd||fD\}}dd}|||} | durdS| \} } } |||} | durdS| \} }}| s|s| r$t | t r$| ||| | | f\} } } } }}||}}|sr| p2| }|p<|}t ||j sPdS||||j d|j dt |t fS| s | s | r |r | r |r t | | j t ||j urdSd d | | fDtfd d ||fDsdS|||| j d| j dt | | j fS| r| sP|r"|sP|rT| dur<| dusP|durT|durTdS| p\| }|pf|}|j |j krzdS| stj} | stj} | | ur|t9}||||j dtd dfS| | tkr|d| 9}||||j dtddfS| | tkr&|d| 9}||||j dtddfSdS)a)Return the gcd, s1, s2, a1, a2, bool where If two is False (default) then:: a + b = gcd*(s1*f(a1) + s2*f(a2)) where f = cos if bool else sin else: if bool, a + b was +/- cos(a1)*cos(a2) +/- sin(a1)*sin(a2) and equals n1*gcd*cos(a - b) if n1 == n2 else n1*gcd*cos(a + b) else a + b was +/- cos(a1)*sin(a2) +/- sin(a1)*cos(a2) and equals n1*gcd*sin(a + b) if n1 = n2 else n1*gcd*sin(b - a) Examples ======== >>> from sympy.simplify.fu import trig_split >>> from sympy.abc import x, y, z >>> from sympy import cos, sin, sqrt >>> trig_split(cos(x), cos(y)) (1, 1, 1, x, y, True) >>> trig_split(2*cos(x), -2*cos(y)) (2, 1, -1, x, y, True) >>> trig_split(cos(x)*sin(y), cos(y)*sin(y)) (sin(y), 1, 1, x, y, True) >>> trig_split(cos(x), -sqrt(3)*sin(x), two=True) (2, 1, -1, x, pi/6, False) >>> trig_split(cos(x), sin(x), two=True) (sqrt(2), 1, 1, x, pi/4, False) >>> trig_split(cos(x), -sin(x), two=True) (sqrt(2), 1, -1, x, pi/4, False) >>> trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) (2*sqrt(2), 1, -1, x, pi/6, False) >>> trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) (-2*sqrt(2), 1, 1, x, pi/3, False) >>> trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) (sqrt(6)/3, 1, 1, x, pi/6, False) >>> trig_split(-sqrt(6)*cos(x)*sin(y), -sqrt(2)*sin(x)*sin(y), two=True) (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False) >>> trig_split(cos(x), sin(x)) >>> trig_split(cos(x), sin(z)) >>> trig_split(2*cos(x), -sin(x)) >>> trig_split(cos(x), -sqrt(3)*sin(x)) >>> trig_split(cos(x)*cos(y), sin(x)*sin(z)) >>> trig_split(cos(x)*cos(y), sin(x)*sin(y)) >>> trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) NcSsg|] }t|qSr0rrr0r0r1rUrVztrig_split..rYcSsg|] }|qSr0as_exprrr0r0r1rUrVcSsld}}tj}|jr|\}}t|jdks4|s8dS|jrJt|j}n|g}|d}t|t rj|}n0t|t rz|}n |j r|j tj ur||9}ndS|r|d}t|t r|r|}q|}n:t|t r|r|}q|}n |j r|j tj ur||9}ndS|tjur |nd||fSt|t r&|}nt|t r6|}|durN|durNdS|tjur^|nd}|||fS)aReturn ``a`` as a tuple (r, c, s) such that ``a = (r or 1)*(c or 1)*(s or 1)``. Three arguments are returned (radical, c-factor, s-factor) as long as the conditions set by ``two`` are met; otherwise None is returned. If ``two`` is True there will be one or two non-None values in the tuple: c and s or c and r or s and r or s or c with c being a cosine function (if possible) else a sine, and s being a sine function (if possible) else oosine. If ``two`` is False then there will only be a c or s term in the tuple. ``two`` also require that either two cos and/or sin be present (with the condition that if the functions are the same the arguments are different or vice versa) or that a single cosine or a single sine be present with an optional radical. If the above conditions dictated by ``two`` are not met then None is returned. Nr=r)rr6rerrKr5rhrRr4rrr?rvr)r8rrrrr5rdr0r0r1 pow_cos_sinsN           ztrig_split..pow_cos_sinrcSsh|] }|jqSr0r)rArr0r0r1 PrVztrig_split..c3s|]}|jvVqdSr>rrrr0r1rCQrVztrig_split..rpFr=r r)rrr,rr rrfactorsquor4rrIr5rrr6r rr)r8rdruaubrrrr rZcoacasaZcobcbsbrrr0rr1rs3    B       " $     rc CsX|jrt|jdkrdS|j\}}|tjtjfvrvtj}|jrl|jdjrl|jddkrl| | }}| }|||fSdd|jD\}}||\}}| | }tj|j vr| tj}d}d}n*tj|j vr| tj}d}d}nd}}dd||fD\}}|tjur(||}}||}}|dkr>| }| }|tjurT|||fSdS) aIf ``e`` is a sum that can be written as ``g*(a + s)`` where ``s`` is ``+/-1``, return ``g``, ``a``, and ``s`` where ``a`` does not have a leading negative coefficient. Examples ======== >>> from sympy.simplify.fu import as_f_sign_1 >>> from sympy.abc import x >>> as_f_sign_1(x + 1) (1, x, 1) >>> as_f_sign_1(x - 1) (1, x, -1) >>> as_f_sign_1(-x + 1) (-1, x, -1) >>> as_f_sign_1(-x - 1) (-1, x, 1) >>> as_f_sign_1(2*x + 2) (2, x, 1) r=NrcSsg|] }t|qSr0r rr0r0r1rUrVzas_f_sign_1..rYcSsg|] }|qSr0r rr0r0r1rUrV) rJrKr5rrr6rerr,rr rr) rMr8rdrzrrrrrr0r0r1rjs<            rcsfdd}t||S)a2Replace all hyperbolic functions with trig functions using the Osborne rule. Notes ===== ``d`` is a dummy variable to prevent automatic evaluation of trigonometric/hyperbolic functions. References ========== .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function cst|ts|S|jd}|js&|ntfdd|jD}t|trVtt|St|t rht |St|t r~tt |St|t rt|tSt|trt|St|trt|tStd|jdS)Nrcsg|] }|qSr0r0rrWr0r1rUrVz'_osborne..f.. unhandled %s)r4rr5rJrrrr rrrrr rr!rr"rr#NotImplementedErrorrIr7rr0r1r9s"  (          z_osborne..frrMrWr9r0rr1_osbornes rcsfdd}t||S)a1Replace all trig functions with hyperbolic functions using the Osborne rule. Notes ===== ``d`` is a dummy variable to prevent automatic evaluation of trigonometric/hyperbolic functions. References ========== .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function cst|ts|S|jdjdd\}}|tji|t}t|trTt |tSt|t rft |St|t r|t |tSt|trt|tSt|trt|St|trt|tStd|jdS)NrT)as_Addr)r4r%r5as_independentxreplacerr6r rrrrr rr!rr"rr#rrrI)r/constrr8rr0r1r9s"           z_osbornei..frrr0rr1 _osborneis r!csnddlmddlm|t}dd|D|t}ddDtt |fddfS) aReturn an expression containing hyperbolic functions in terms of trigonometric functions. Any trigonometric functions initially present are replaced with Dummy symbols and the function to undo the masking and the conversion back to hyperbolics is also returned. It should always be true that:: t, f = hyper_as_trig(expr) expr == f(t) Examples ======== >>> from sympy.simplify.fu import hyper_as_trig, fu >>> from sympy.abc import x >>> from sympy import cosh, sinh >>> eq = sinh(x)**2 + cosh(x)**2 >>> t, f = hyper_as_trig(eq) >>> f(fu(t)) cosh(2*x) References ========== .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function rrn)collectcSsg|]}|tfqSr0r)rArkr0r0r1rUrVz!hyper_as_trig..cSsg|]\}}||fqSr0r0)rArLr_r0r0r1rUrVcs t|ttjSr>)r!rdictr ImaginaryUnitrr"rWrepsror0r1rszhyper_as_trig..) rsrosympy.simplify.radsimpr"atomsr%rr#rr)r/trigsmaskedr0r%r1 hyper_as_trigs   r+cCs$|tts|Sttt|SdS)aConvert products and powers of sin and cos to sums. Explanation =========== Applied power reduction TRpower first, then expands products, and converts products to sums with TR8. Examples ======== >>> from sympy.simplify.fu import sincos_to_sum >>> from sympy.abc import x >>> from sympy import cos, sin >>> sincos_to_sum(16*sin(x)**3*cos(2*x)**2) 7*sin(x) - 5*sin(3*x) + 3*sin(5*x) - sin(7*x) N)rrrrr r)exprr0r0r1 sincos_to_sums r-)F)rpF)rpF)T)T)N)T)T)rpF)rpF)rpF)NT)F)o collectionsrZsympy.core.addrsympy.core.exprrZsympy.core.exprtoolsrrrsympy.core.functionr Zsympy.core.mulr sympy.core.numbersr r sympy.core.powerrZsympy.core.singletonrsympy.core.sortingrsympy.core.symbolrsympy.core.sympifyrsympy.core.traversalr(sympy.functions.combinatorial.factorialsr%sympy.functions.elementary.hyperbolicrrrrrrr(sympy.functions.elementary.trigonometricrrr r!r"r#r$r%sympy.ntheory.factor_r&sympy.polys.polytoolsr'sympy.strategies.treer(sympy.strategies.corer)r*sympyr+r2r;r<rmrtrurrrrrrrrrrrrrrrrrrrrrrhrZCTR1ZCTR2ZCTR3ZCTR4rrrrrZfufuncsr#ziplocalsgetFUrrrrrr!r+r-r0r0r0r1s            $(      t*@   K^ 0 P= #{/w y ! ! .    [ *  79('+