403WebShell

403Webshell
Server IP : 93.86.61.54 / Your IP : 216.73.216.206
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/
Upload File :
[ Back ]
Current File : /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/intpoly.cpython-310.pyc
o

�8Vaը�@sPdZddlmZddlmZmZmZddlmZm	Z	m
Z
mZddlm
Z
ddlmZmZmZmZddlmZmZmZddlmZd:d
d	d�dd
�Zdd�Zd:dd�Zd:dd�Zdd�Zdd�Zdd�Zdd�Z dd�Z!				d;dd�Z"d d!�Z#d<d#d$�Z$d:d%d&�Z%d'd(�Z&d)d*�Z'd=d+d,�Z(d>d.d/�Z)d0d1�Z*d2d3�Z+d4d5�Z,d6d7�Z-d8d9�Z.d	S)?a�
Module to implement integration of uni/bivariate polynomials over
2D Polytopes and uni/bi/trivariate polynomials over 3D Polytopes.

Uses evaluation techniques as described in Chin et al. (2015) [1].


References
===========

.. [1] Chin, Eric B., Jean B. Lasserre, and N. Sukumar. "Numerical integration
of homogeneous functions on convex and nonconvex polygons and polyhedra."
Computational Mechanics 56.6 (2015): 967-981

PDF link : http://dilbert.engr.ucdavis.edu/~suku/quadrature/cls-integration.pdf
�)�
cmp_to_key��x�y�z)�S�diff�Expr�Symbol)�_sympify)�	Segment2D�Polygon�Point�Point2D)�LC�gcd_list�degree_list)�	nsimplifyNF)�	clockwise�
max_degreecs�|rt�t�rtt�j�ddi��ntd��t�t�r#t��}�j}n]t�d�dkr^t���t�dd�dkrZ��fdd�td��D���}t�����fdd�td��D�}n&t	d	���d}�d
d�}t||�}|dur�|durytd��t
||||�S|dur�i}t|t�s�|dur�td
��t|dd�dkr�t
d||||�}ntd|||�}|dur�|S|D]8�t
����|vr�jr�tj|tj<q�tj}	t�dd�}
|
D]}t|�}t|�\}}
|	||
|7}	q�|	|�<q�|S|dur�td��t|||�S)a;Integrates polynomials over 2/3-Polytopes.

    Explanation
    ===========

    This function accepts the polytope in ``poly`` and the function in ``expr``
    (uni/bi/trivariate polynomials are implemented) and returns
    the exact integral of ``expr`` over ``poly``.

    Parameters
    ==========

    poly : The input Polygon.

    expr : The input polynomial.

    clockwise : Binary value to sort input points of 2-Polytope clockwise.(Optional)

    max_degree : The maximum degree of any monomial of the input polynomial.(Optional)

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy.geometry.polygon import Polygon
    >>> from sympy.geometry.point import Point
    >>> from sympy.integrals.intpoly import polytope_integrate
    >>> polygon = Polygon(Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
    >>> polys = [1, x, y, x*y, x**2*y, x*y**2]
    >>> expr = x*y
    >>> polytope_integrate(polygon, expr)
    1/4
    >>> polytope_integrate(polygon, polys, max_degree=3)
    {1: 1, x: 1/2, y: 1/2, x*y: 1/4, x*y**2: 1/6, x**2*y: 1/6}
    �evaluateFz>clockwise=True works for only 2-PolytopeV-representation inputr�cs(g|]}t�|d��|d��qS)��plane2D)�intersection��.0�i)�plen�poly��9/usr/lib/python3/dist-packages/sympy/integrals/intpoly.py�
<listcomp>Os
��z&polytope_integrate.<locals>.<listcomp>cs&g|]}t�|�|d���qS�r)rr)�
intersections�lintsr r!r"Ts
��z<Integration for H-representation 3Dcase not implemented yet.rNz3Input expression be mustbe a valid SymPy expressionz-Input polynomials must be list of expressions�T)�separate)�
isinstancer
�
point_sort�vertices�	TypeError�hyperplane_parameters�sides�len�range�NotImplementedError�main_integrate3d�list�main_integrater�is_zeror�Zero�	decomposer�strip)r�exprrr�	hp_params�facetsr*�result�result_dict�integral_value�monoms�monom�coeff�mr )r$r%rrr!�polytope_integratesn$

��

��rBcCs0|jrdS|jr|dfSt|�}|t|�|fS)N)rrr)r4�	is_numberrr)r?r@r r r!r7�sr7c!Cs�i}tttf}t|�}|r�t|d�}dd�|D�}	|	D]}
d||
d<qt|�D]a\}}|d|d}
}|||d}t|	�D]G\}}|\}}}}}}}}|||}|jr\tj}nt	|||
||||||||||||�}||d<||||t
|
�||||7<qAq(|Stj}t|�}|D]B}tj}d}t|�D],\}}||}|djr�q�t|||||||�} || |dt
t
|d��7}|d7}q�|||}||7}q�|S)aXFunction to translate the problem of integrating uni/bi/tri-variate
    polynomials over a 3-Polytope to integrating over its faces.
    This is done using Generalized Stokes' Theorem and Euler's Theorem.

    Parameters
    ==========

    expr :
        The input polynomial.
    facets :
        Faces of the 3-Polytope(expressed as indices of `vertices`).
    vertices :
        Vertices that constitute the Polytope.
    hp_params :
        Hyperplane Parameters of the facets.
    max_degree : optional
        Max degree of constituent monomial in given list of polynomial.

    Examples
    ========

    >>> from sympy.integrals.intpoly import main_integrate3d,     hyperplane_parameters
    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),                (5, 0, 5), (5, 5, 0), (5, 5, 5)],                [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],                [3, 1, 0, 2], [0, 4, 6, 2]]
    >>> vertices = cube[0]
    >>> faces = cube[1:]
    >>> hp_params = hyperplane_parameters(faces, vertices)
    >>> main_integrate3d(1, faces, vertices, hp_params)
    -125
    r&cSs$g|]}|D]	}|D]}|�q
qqSr r )r�z_terms�x_term�termr r r!r"�s���z$main_integrate3d.<locals>.<listcomp>rr�)rrrr.�gradient_terms�	enumerater4rr5�integration_reduction_dynamic�normr6�polygon_integrate�tuple)!r8r:r*r9rr;�dims�
dim_length�
grad_terms�	flat_listrF�facet_count�hp�a�b�x0rr?�x_d�y_d�z_d�z_index�y_index�x_index�_�degree�value_over_facer=�polynomials�deg�poly_contribute�facet�pir r r!r1�s`"

��

�
��
�

r1cCs�ttf}t|�}i}tj}|r�gd�gt|�}t|�D]p\}	}
|
d|
d}}||	jd}
t|�D]W\}}|\}}}}|�|d�}tj}|j	rNtj}n||}t
||	|||||||||
||�
}||d<|dur}||||t|�||7<q4||t|�||||<q4q|St|�}|D]8}tj}d}	|D]$}
t
||	|
d|
d||||�}|||
dt|
d�7}|	d7}	q�|||}||7}q�|S)a�Function to translate the problem of integrating univariate/bivariate
    polynomials over a 2-Polytope to integrating over its boundary facets.
    This is done using Generalized Stokes's Theorem and Euler's Theorem.

    Parameters
    ==========

    expr :
        The input polynomial.
    facets :
        Facets(Line Segments) of the 2-Polytope.
    hp_params :
        Hyperplane Parameters of the facets.
    max_degree : optional
        The maximum degree of any monomial of the input polynomial.

    >>> from sympy.abc import x, y
    >>> from sympy.integrals.intpoly import main_integrate,    hyperplane_parameters
    >>> from sympy.geometry.polygon import Polygon
    >>> from sympy.geometry.point import Point
    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
    >>> facets = triangle.sides
    >>> hp_params = hyperplane_parameters(triangle)
    >>> main_integrate(x**2 + y**2, facets, hp_params)
    325/6
    )rrrrrrNr&)rrr.rr5rHrI�points�getr4rJrKr6�integration_reduction)r8r:r9rrNrOr;r=rPrRrSrTrUrVrr?rArWrXr]�valuer^�value_over_boundaryr`rarbr r r!r3�sh
��

�
�
�
���

r3c
Cs�t|�}|jr
tjStj}||d}tt|��D]&}	|||	|||	dt|�f}
|t||
|d�t||	|
||�7}q|jslt|t	�|dt|t
�|dt|t�|d}|t|||||||d�7}||d}|S)a�Helper function to integrate the input uni/bi/trivariate polynomial
    over a certain face of the 3-Polytope.

    Parameters
    ==========

    facet :
        Particular face of the 3-Polytope over which ``expr`` is integrated.
    index :
        The index of ``facet`` in ``facets``.
    facets :
        Faces of the 3-Polytope(expressed as indices of `vertices`).
    vertices :
        Vertices that constitute the facet.
    expr :
        The input polynomial.
    degree :
        Degree of ``expr``.

    Examples
    ========

    >>> from sympy.integrals.intpoly import polygon_integrate
    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),                 (5, 0, 5), (5, 5, 0), (5, 5, 5)],                 [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],                 [3, 1, 0, 2], [0, 4, 6, 2]]
    >>> facet = cube[1]
    >>> facets = cube[1:]
    >>> vertices = cube[0]
    >>> polygon_integrate(facet, [(0, 1, 0), 5], 0, facets, vertices, 1, 0)
    -25
    rrr)
rr4r5r/r.�distance_to_side�lineseg_integraterCrrrrrL)rc�hp_param�indexr:r*r8r^r;rVr�sider r r!rL<s&"$�"��rLcs��\���fdd��D�}��fdd�tdd�D���fdd�tdd�D��td|�����fdd�tdd�D��t��fd	d�tdd�D��}|S)
axHelper function to compute the signed distance between given 3D point
    and a line segment.

    Parameters
    ==========

    point : 3D Point
    line_seg : Line Segment

    Examples
    ========

    >>> from sympy.integrals.intpoly import distance_to_side
    >>> point = (0, 0, 0)
    >>> distance_to_side(point, [(0, 0, 1), (0, 1, 0)], (1, 0, 0))
    -sqrt(2)/2
    cs g|]}dt|�t���qS)���)rrKr)�Ar r!r"�� z$distance_to_side.<locals>.<listcomp>c�g|]
}�|�|�qSr r r)�x1�x2r r!r"��rr&csg|]
}�|t���qSr )rKr)�vectorr r!r"�ru)rrrcs g|]}�d|�|�qS�rr r)�line_seg�pointr r!r"�rqcsg|]
}�|�|�qSr r r)�n_side�vectorx0r r!r"�ru)r/�
cross_product�sum)ryrxrp�
rev_normal�dot_productr )rprxrzryrvr{rsrtr!rjpsrjc	s�t|�}|jr
tjStj}�d}tt�fdd�td�D���}t|t�rCt	�ddt
�ddt�ddi}|||�|�7}n|||7}t
|t	�|dt
|t
�|dt
|t�|d}|t||�||d�7}||d}|S)a�Helper function to compute the line integral of ``expr`` over ``line_seg``.

    Parameters
    ===========

    polygon :
        Face of a 3-Polytope.
    index :
        Index of line_seg in polygon.
    line_seg :
        Line Segment.

    Examples
    ========

    >>> from sympy.integrals.intpoly import lineseg_integrate
    >>> polygon = [(0, 5, 0), (5, 5, 0), (5, 5, 5), (0, 5, 5)]
    >>> line_seg = [(0, 5, 0), (5, 5, 0)]
    >>> lineseg_integrate(polygon, 0, line_seg, 1, 0)
    5
    rcs$g|]}�d|�d|�qS)rrr r�rxr r!r"�s$z%lineseg_integrate.<locals>.<listcomp>r&rr)rr4rr5rKrMr/r(r	rrr�subsrrk)	�polygonrmrxr8r^r;rV�distance�	expr_dictr r�r!rk�s*
�
�"�rkc
Cs�t|�}|jr	|Stj}||jd}t|�}	ttf}
t||
d�|dt||
d�|d}|dkrC|t	|||||||d�7}|t
|	|||||
�7}|t|�|dS)a,Helper method for main_integrate. Returns the value of the input
    expression evaluated over the polytope facet referenced by a given index.

    Parameters
    ===========

    facets :
        List of facets of the polytope.
    index :
        Index referencing the facet to integrate the expression over.
    a :
        Hyperplane parameter denoting direction.
    b :
        Hyperplane parameter denoting distance.
    expr :
        The expression to integrate over the facet.
    dims :
        List of symbols denoting axes.
    degree :
        Degree of the homogeneous polynomial.

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy.integrals.intpoly import integration_reduction,    hyperplane_parameters
    >>> from sympy.geometry.point import Point
    >>> from sympy.geometry.polygon import Polygon
    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
    >>> facets = triangle.sides
    >>> a, b = hyperplane_parameters(triangle)[0]
    >>> integration_reduction(facets, 0, a, b, 1, (x, y), 0)
    5
    rr)rr4rr5rer.rrrrg�left_integral2D)r:rmrTrUr8rNr^rhrVrA�gens�
inner_productr r r!rg�s$,
�rgcCs�tj}td|�D]n}d}||d|ks||d|kr&t||||d�}|rvtttdd�||���}	t|�rvt|t	�rpt
|�dkrX|d|d|d|d|d|di}
n|d|d|d|di}
||	|�|
�7}q||	|7}q|S)	a�Computes the left integral of Eq 10 in Chin et al.
    For the 2D case, the integral is just an evaluation of the polynomial
    at the intersection of two facets which is multiplied by the distance
    between the first point of facet and that intersection.

    Parameters
    ==========

    m :
        No. of hyperplanes.
    index :
        Index of facet to find intersections with.
    facets :
        List of facets(Line Segments in 2D case).
    x0 :
        First point on facet referenced by index.
    expr :
        Input polynomial
    gens :
        Generators which generate the polynomial

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy.integrals.intpoly import left_integral2D
    >>> from sympy.geometry.point import Point
    >>> from sympy.geometry.polygon import Polygon
    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
    >>> facets = triangle.sides
    >>> left_integral2D(3, 0, facets, facets[0].points[0], 1, (x, y))
    5
    rr r�	segment2DcSs||S�Nr )rrr r r!�<lambda>sz!left_integral2D.<locals>.<lambda>r&r)rr5r/rrKrM�map�	is_vertexr(r	r.r�)rArmr:rVr8r�rh�j�	intersect�distance_originr�r r r!r��s." �
���r�cCs�tj}t|�}|tjkr|St|�dkrb|jsV||\}}}}|dkr+||	|dnd}|dkr5|dnd}||d||d}}||||
d|||
d7}|t||||
||�7}np|	}|js�|||||}}}|dkr�||d|d|dnd}|dkr�||d||dnd}|dkr�||d||ddnd}||||
d|||
d|||
d7}|t||||
||�7}|t|�|dS)aThe same integration_reduction function which uses a dynamic
    programming approach to compute terms by using the values of the integral
    of previously computed terms.

    Parameters
    ==========

    facets :
        Facets of the Polytope.
    index :
        Index of facet to find intersections with.(Used in left_integral()).
    a, b :
        Hyperplane parameters.
    expr :
        Input monomial.
    degree :
        Total degree of ``expr``.
    dims :
        Tuple denoting axes variables.
    x_index :
        Exponent of 'x' in ``expr``.
    y_index :
        Exponent of 'y' in ``expr``.
    max_index :
        Maximum exponent of any monomial in ``monomial_values``.
    x0 :
        First point on ``facets[index]``.
    monomial_values :
        List of monomial values constituting the polynomial.
    monom_index :
        Index of monomial whose integration is being found.
    vertices : optional
        Coordinates of vertices constituting the 3-Polytope.
    hp_param : optional
        Hyperplane Parameter of the face of the facets[index].

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy.integrals.intpoly import (integration_reduction_dynamic,             hyperplane_parameters)
    >>> from sympy.geometry.point import Point
    >>> from sympy.geometry.polygon import Polygon
    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
    >>> facets = triangle.sides
    >>> a, b = hyperplane_parameters(triangle)[0]
    >>> x0 = facets[0].points[0]
    >>> monomial_values = [[0, 0, 0, 0], [1, 0, 0, 5],                           [y, 0, 1, 15], [x, 1, 0, None]]
    >>> integration_reduction_dynamic(facets, 0, a, b, x, 1, (x, y), 1, 0, 1,                                      x0, monomial_values, 3)
    25/2
    rrrr&rG)rr5r.rCr��left_integral3D)r:rmrTrUr8r^rNr\r[�	max_indexrV�monomial_values�monom_indexr*rlrhrAr]�x_degree�y_degree�x_value�y_valuerZ�z_degree�z_valuer r r!rJ,sX:
�����$
������� �
�rJc	Csxtj}||}||d}tt|��D]&}	|||	|||	dt|�f}
|t||
|d�t||	|
||�7}q|S)a�Computes the left integral of Eq 10 in Chin et al.

    Explanation
    ===========

    For the 3D case, this is the sum of the integral values over constituting
    line segments of the face (which is accessed by facets[index]) multiplied
    by the distance between the first point of facet and that line segment.

    Parameters
    ==========

    facets :
        List of faces of the 3-Polytope.
    index :
        Index of face over which integral is to be calculated.
    expr :
        Input polynomial.
    vertices :
        List of vertices that constitute the 3-Polytope.
    hp_param :
        The hyperplane parameters of the face.
    degree :
        Degree of the ``expr``.

    Examples
    ========

    >>> from sympy.integrals.intpoly import left_integral3D
    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),                 (5, 0, 5), (5, 5, 0), (5, 5, 5)],                 [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],                 [3, 1, 0, 2], [0, 4, 6, 2]]
    >>> facets = cube[1:]
    >>> vertices = cube[0]
    >>> left_integral3D(facets, 3, 1, vertices, ([0, -1, 0], -5), 0)
    -50
    rr)rr5r/r.rjrk)r:rmr8r*rlr^rhrcrVrrnr r r!r��s'$�r�rcCs�|dkrAd}dgt|dd|dd�}td|d�D] }td||d�D]}t|t|||dg||<|d7}q)q|Sdd�td|d�D�}|S)anReturns a list of all the possible monomials between
    0 and y**binomial_power for 2D case and z**binomial_power
    for 3D case.

    Parameters
    ==========

    binomial_power :
        Power upto which terms are generated.
    no_of_gens :
        Denotes whether terms are being generated for 2D or 3D case.

    Examples
    ========

    >>> from sympy.integrals.intpoly import gradient_terms
    >>> gradient_terms(2)
    [[1, 0, 0, 0], [y, 0, 1, 0], [y**2, 0, 2, 0], [x, 1, 0, 0],
    [x*y, 1, 1, 0], [x**2, 2, 0, 0]]
    >>> gradient_terms(2, 3)
    [[[[1, 0, 0, 0, 0, 0, 0, 0]]], [[[y, 0, 1, 0, 1, 0, 0, 0],
    [z, 0, 0, 1, 1, 0, 1, 0]], [[x, 1, 0, 0, 1, 1, 0, 0]]],
    [[[y**2, 0, 2, 0, 2, 0, 0, 0], [y*z, 0, 1, 1, 2, 0, 1, 0],
    [z**2, 0, 0, 2, 2, 0, 2, 0]], [[x*y, 1, 1, 0, 2, 1, 0, 0],
    [x*z, 1, 0, 1, 2, 1, 1, 0]], [[x**2, 2, 0, 0, 2, 2, 0, 0]]]]
    rrNr&rcs(g|]��fdd�td�d�D��qS)cs,g|]���fdd�t��dd�D��qS)c
sLg|]"}t�t|t�|��|�|����|�dg�qSrwr)r�y_count)�x_count�z_countr r!r"�s���z8gradient_terms.<locals>.<listcomp>.<listcomp>.<listcomp>ro�r/�r�r�)r�r!r"�s
�
�z-gradient_terms.<locals>.<listcomp>.<listcomp>rrr�r�r r�r!r"�s

�
�z"gradient_terms.<locals>.<listcomp>)�intr/rr)�binomial_power�
no_of_gens�count�termsr�r�r r r!rH�s"�
���rHcs�t|t�rot|j�|jdg�dgt��d}tt��d�D]K}�|��|d}�d|d}|d�d}|d�d|d�d}t|||g�}t|�|}t|�|t|�|f}	|	|f||<q!|Sdgt|�}t|�D]E\}}
�fdd�|
dd�D�\�}}t	�||��t
��fdd�tdd�D��}t����jr�d��fdd��D��|�}�|f||<qz|S)	a�A helper function to return the hyperplane parameters
    of which the facets of the polytope are a part of.

    Parameters
    ==========

    poly :
        The input 2/3-Polytope.
    vertices :
        Vertex indices of 3-Polytope.

    Examples
    ========

    >>> from sympy.geometry.point import Point
    >>> from sympy.geometry.polygon import Polygon
    >>> from sympy.integrals.intpoly import hyperplane_parameters
    >>> hyperplane_parameters(Polygon(Point(0, 3), Point(5, 3), Point(1, 1)))
    [((0, 1), 3), ((1, -2), -1), ((-2, -1), -3)]
    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),                (5, 0, 5), (5, 5, 0), (5, 5, 5)],                [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],                [3, 1, 0, 2], [0, 4, 6, 2]]
    >>> hyperplane_parameters(cube[1:], cube[0])
    [([0, -1, 0], -5), ([0, 0, -1], -5), ([-1, 0, 0], -5),
    ([0, 1, 0], 0), ([1, 0, 0], 0), ([0, 0, 1], 0)]
    rNrcsg|]}�|�qSr r )r�vertex)r*r r!r"�z)hyperplane_parameters.<locals>.<listcomp>r&c�g|]
}�|�|�qSr r �rr�)�normal�v1r r!r"rucsg|]}|��qSr r r�)�facr r!r""r�)r(r
r2r*r.r/rrrIr|r}r4)rr*�paramsr�v2�a1�a2rU�factorrTr��v3r )r�r�r�r*r!r,�s4
 
� r,cs���fdd�tdd�D����fdd�tdd�D���d�d�d�d�d�d�d�d�d�d�d�dgS)zeReturns the cross-product of vectors (v2 - v1) and (v3 - v1)
    That is : (v2 - v1) X (v3 - v1)
    crrr r r�)r�r�r r!r",ruz!cross_product.<locals>.<listcomp>rr&crrr r r�)r�r�r r!r"-rurrr��r�r�r�r r�r!r|(s�r|cCs�|jd\}}dd�}dd�}ttf}i}	|D]}
tj|	|
<qt|�dk�rst|�dkrZ|ddkrC||�r?tj||dfS||fS|ddkrZ||�rV||dtjfS||fSt|t��r|jr�|j	D]P}|j
r�|j	d|vr�|	|j	d|j	d7<qf|j	D]1}t|j	�}
|
dkr�||vr�|	|d7<q�|
dkr�|j	d|vr�|	|j	d|j	d7<q�qfnX|jr�|j	D]1}t|j	�}
|
dkr�||vr�|	|d7<q�|
dkr�|j	d|vr�|	|j	d|j	d7<q�n|j
r�|j	d|	|j	d<n|j�r|	|d7<n||fSt
|	��dd	�d
�}	|	dd|	ddk�rM||��r7tj||df}|S||��rG||dtjf}|S||f}|S||��r]||dtjf}|S||��rmtj||df}|S||f}|S||d}|S)aHelper method for polytope_integrate. Currently not used in the main
    algorithm.

    Explanation
    ===========

    Returns a point on the lineseg whose vector inner product with the
    divergence of `expr` yields an expression with the least maximum
    total power.

    Parameters
    ==========

    a :
        Hyperplane parameter denoting direction.
    b :
        Hyperplane parameter denoting distance.
    lineseg :
        Line segment on which to find the origin.
    expr :
        The expression which determines the best point.

    Algorithm(currently works only for 2D use case)
    ===============================================

    1 > Firstly, check for edge cases. Here that would refer to vertical
        or horizontal lines.

    2 > If input expression is a polynomial containing more than one generator
        then find out the total power of each of the generators.

        x**2 + 3 + x*y + x**4*y**5 ---> {x: 7, y: 6}

        If expression is a constant value then pick the first boundary point
        of the line segment.

    3 > First check if a point exists on the line segment where the value of
        the highest power generator becomes 0. If not check if the value of
        the next highest becomes 0. If none becomes 0 within line segment
        constraints then pick the first boundary point of the line segment.
        Actually, any point lying on the segment can be picked as best origin
        in the last case.

    Examples
    ========

    >>> from sympy.integrals.intpoly import best_origin
    >>> from sympy.abc import x, y
    >>> from sympy.geometry.line import Segment2D
    >>> from sympy.geometry.point import Point
    >>> l = Segment2D(Point(0, 3), Point(1, 1))
    >>> expr = x**3*y**7
    >>> best_origin((2, 1), 3, l, expr)
    (0, 3.0)
    rcSsj|j\}}|jjr
t|�S|jjrt|�S|j|jtjkr3|j|j|j|j|j|jtjfSdS)z�Returns the point where the input line segment
        intersects the x-axis.

        Parameters
        ==========

        ls :
            Line segment
        r )rerr4rMrr5r��ls�p�qr r r!�
x_axis_cutm�

*zbest_origin.<locals>.x_axis_cutcSsj|j\}}|jjr
t|�S|jjrt|�S|j|jtjkr3tj|j|j|j|j|j|jfSdS)z�Returns the point where the input line segment
        intersects the y-axis.

        Parameters
        ==========

        ls :
            Line segment
        r )rerr4rMrr5rr�r r r!�
y_axis_cut�r�zbest_origin.<locals>.y_axis_cutrrcSst|d�S�Nr)�str)�kr r r!r��szbest_origin.<locals>.<lambda>��key)rerrrr5r.r(r	�is_Add�args�is_Pow�is_Mul�	is_Symbol�sorted�items)rTrU�linesegr8r��b1r�r�r��
power_gensr�monomial�
univariate�	term_typerFrVr r r!�best_origin3s�8
�

����

���

��

�
���r�c	si}t|t�r|js|jr||d<nq|jrI|�t���fdd�|jD�}|r-dd�|D�S|D]}|\}}|�|�rC|||7<q/|||<q/n:|j	rV|j\}}|||<n-d}|jD]}t
|j�}|dkrn|jrn|d7}q[|dkry||jd7}q[|||<n||d<|r�t|���S|S)aXDecomposes an input polynomial into homogeneous ones of
    smaller or equal degree.

    Explanation
    ===========

    Returns a dictionary with keys as the degree of the smaller
    constituting polynomials. Values are the constituting polynomials.

    Parameters
    ==========

    expr : Expr
        Polynomial(SymPy expression).
    separate : bool
        If True then simply return a list of the constituent monomials
        If not then break up the polynomial into constituent homogeneous
        polynomials.

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy.integrals.intpoly import decompose
    >>> decompose(x**2 + x*y + x + y + x**3*y**2 + y**5)
    {1: x + y, 2: x**2 + x*y, 5: x**3*y**2 + y**5}
    >>> decompose(x**2 + x*y + x + y + x**3*y**2 + y**5, True)
    {x, x**2, y, y**5, x*y, x**3*y**2}
    rcs$g|]}tt|g��R��|f�qSr )r}r�rr?��symbolsr r!r"s�zdecompose.<locals>.<listcomp>cSsh|]}|d�qSr#r r�r r r!�	<setcomp>r�zdecompose.<locals>.<setcomp>rr)
r(r	rCr�r��atomsr
r�rfr�r.�set�values)	r8r'�	poly_dict�degreesr?r^rFr]r�r r�r!r6�sB


�

�




�
r6Tcst|t�r|jn|}t|�}|dkrt|�S|rtjntj�t|d�}|dkr@tt	t
dd�|��|t	t
dd�|��|��n!tt	t
dd�|��|t	t
dd�|��|t	t
dd�|��|����fd	d
�}���fdd�}t|t|dkr||�d
�S|�d
�S)aUReturns the same polygon with points sorted in clockwise or
    anti-clockwise order.

    Note that it's necessary for input points to be sorted in some order
    (clockwise or anti-clockwise) for the integration algorithm to work.
    As a convention algorithm has been implemented keeping clockwise
    orientation in mind.

    Parameters
    ==========

    poly:
        2D or 3D Polygon.
    normal : optional
        The normal of the plane which the 3-Polytope is a part of.
    clockwise : bool, optional
        Returns points sorted in clockwise order if True and
        anti-clockwise if False.

    Examples
    ========

    >>> from sympy.integrals.intpoly import point_sort
    >>> from sympy.geometry.point import Point
    >>> point_sort([Point(0, 0), Point(1, 0), Point(1, 1)])
    [Point2D(1, 1), Point2D(1, 0), Point2D(0, 0)]
    rrcS�|jSr��r�r�r r r!r�C�zpoint_sort.<locals>.<lambda>cSr�r��rr�r r r!r�Dr�cSr�r�r�r�r r r!r�Fr�cSr�r�r�r�r r r!r�Gr�cSr�r�)rr�r r r!r�Hr�csv|j�jtjkr|j�jtjkr�S|j�jdkr'|j�jdkr'�S|j�jdkr]|j�jdkr]|j�jdksG|j�jdkrR|j|jkrP�S�S|j|jkr[�S�S|j�j|j�j|j�j|j�j}|dkr|�S|dkr��S|j�j|j�j|j�j|j�j}|j�j|j�j|j�j|j�j}||kr��S�Sr�)rrr5r)rTrU�det�first�second)�center�orderr r!�compareJs,$   ���zpoint_sort.<locals>.comparecsHt�||��t��fdd�tdd�D��}|dkr�S|dkr"�SdS)Ncr�r r r)r�r�r r!r"cruz1point_sort.<locals>.compare3d.<locals>.<listcomp>rr&)r|r}r/)rTrUr�r�r�r�)r�r!�	compare3das�zpoint_sort.<locals>.compare3dr�)
r(r
r*r.r2r�One�NegativeOnerr}r�r�r)rr�r�pts�n�dimr�r�r r�r!r)s"��"r)cCs�tj}t|ttf�rtdd�|D��|St|t�r:t|t�r+|jd|j	d|S|jd|j	d|j
|St|t�rLtdd�|��D��|SdS)a>Returns the Euclidean norm of a point from origin.

    Parameters
    ==========

    point:
        This denotes a point in the dimension_al spac_e.

    Examples
    ========

    >>> from sympy.integrals.intpoly import norm
    >>> from sympy.geometry.point import Point
    >>> norm(Point(2, 7))
    sqrt(53)
    cSsg|]}|d�qS)rr )r�coordr r r!r"r�znorm.<locals>.<listcomp>rcss�|]}|dVqdS)rNr rr r r!�	<genexpr>�s�znorm.<locals>.<genexpr>N)
r�Halfr(r2rMr}rrrrr�dictr�)ry�halfr r r!rKls


�rKcCs�|dd�dkr�|dkr)|jd\}}|jd\}}|jd\}}|jd\}	}
n$|dkrM|jd\}}}|jd\}}}|jd\}}}
|jd\}	}
}||||
||||	}|r�||||}||
|	|}t|||	|||�|t|||
|||�|fS|dd�dkr�|d	kr�|d\}}|d\}}|d|d}}||||}|r�t||||�|t||||�|fSdSdSdS)
a�Returns intersection between geometric objects.

    Explanation
    ===========

    Note that this function is meant for use in integration_reduction and
    at that point in the calling function the lines denoted by the segments
    surely intersect within segment boundaries. Coincident lines are taken
    to be non-intersecting. Also, the hyperplane intersection for 2D case is
    also implemented.

    Parameters
    ==========

    geom_1, geom_2:
        The input line segments.

    Examples
    ========

    >>> from sympy.integrals.intpoly import intersection
    >>> from sympy.geometry.point import Point
    >>> from sympy.geometry.line import Segment2D
    >>> l1 = Segment2D(Point(1, 1), Point(3, 5))
    >>> l2 = Segment2D(Point(2, 0), Point(2, 5))
    >>> intersection(l1, l2, "segment2D")
    (2, 3)
    >>> p1 = ((-1, 0), 0)
    >>> p2 = ((0, 1), 1)
    >>> intersection(p1, p2, "plane2D")
    (0, 1)
    N����segmentr�rr�	segment3D�planer)rer)�geom_1�geom_2�intersection_typers�y1rt�y2�x3�y3�x4�y4�z1�z2�z3�z4�denom�t1�t2�a1x�a1y�a2x�a2yr��b2r r r!r�s>! ���rcCs0t|t�rt|�dvr
dSdSt|t�rdSdS)a�If the input entity is a vertex return True.

    Parameter
    =========

    ent :
        Denotes a geometric entity representing a point.

    Examples
    ========

    >>> from sympy.geometry.point import Point
    >>> from sympy.integrals.intpoly import is_vertex
    >>> is_vertex((2, 3))
    True
    >>> is_vertex((2, 3, 6))
    True
    >>> is_vertex(Point(2, 3))
    True
    )rr&TF)r(rMr.r)�entr r r!r��s

�r�cCs~ddlm}m}ttdd�|j��}ttdd�|j��}|�|jdj�|�|jdj�|||�}||dd�}|�	�dS)	z�Plots the 2D polytope using the functions written in plotting
    module which in turn uses matplotlib backend.

    Parameter
    =========

    poly:
        Denotes a 2-Polytope.
    r)�Plot�List2DSeriescSr�r�r�r�r r r!r��r�zplot_polytope.<locals>.<lambda>cSr�r�r�r�r r r!r��r�zlabel_axes=True)�axesN)
�sympy.plotting.plotrrr2r�r*�appendrr�show)rrr�xl�yl�l2dsr�r r r!�
plot_polytope�s

rcCs:ddlm}m}|j}t|�dkr||�dS||�dS)z�Plots the polynomial using the functions written in
    plotting module which in turn uses matplotlib backend.

    Parameter
    =========

    expr:
        Denotes a polynomial(SymPy expression).
    r)�plot3d�plotrN)r
rr�free_symbolsr.)r8rrr�r r r!�plot_polynomial�s

rr�)NN)rr)F)NT)/�__doc__�	functoolsr�	sympy.abcrrr�
sympy.corerrr	r
�sympy.core.sympifyr�sympy.geometryrr
rr�sympy.polys.polytoolsrrr�sympy.simplify.simplifyrrBr7r1r3rLrjrkrgr�rJr�rHr,r|r�r6r)rKrr�rrr r r r!�<module>sBn


WQ4-8;
�a
1
.<
)
DM?
Youez - 2016 - github.com/yon3zu
LinuXploit