wgsdZddlmZmZmZmZddlmZmZm Z ddl m Z ddl m Z ddlmZddlmZddlmZd d iZGd d ZGd dZGddZGddZ ddZedd ddZy)ad This module contains the functionality to arrange the nodes of a diagram on an abstract grid, and then to produce a graphical representation of the grid. The currently supported back-ends are Xy-pic [Xypic]. Layout Algorithm ================ This section provides an overview of the algorithms implemented in :class:`DiagramGrid` to lay out diagrams. The first step of the algorithm is the removal composite and identity morphisms which do not have properties in the supplied diagram. The premises and conclusions of the diagram are then merged. The generic layout algorithm begins with the construction of the "skeleton" of the diagram. The skeleton is an undirected graph which has the objects of the diagram as vertices and has an (undirected) edge between each pair of objects between which there exist morphisms. The direction of the morphisms does not matter at this stage. The skeleton also includes an edge between each pair of vertices `A` and `C` such that there exists an object `B` which is connected via a morphism to `A`, and via a morphism to `C`. The skeleton constructed in this way has the property that every object is a vertex of a triangle formed by three edges of the skeleton. This property lies at the base of the generic layout algorithm. After the skeleton has been constructed, the algorithm lists all triangles which can be formed. Note that some triangles will not have all edges corresponding to morphisms which will actually be drawn. Triangles which have only one edge or less which will actually be drawn are immediately discarded. The list of triangles is sorted according to the number of edges which correspond to morphisms, then the triangle with the least number of such edges is selected. One of such edges is picked and the corresponding objects are placed horizontally, on a grid. This edge is recorded to be in the fringe. The algorithm then finds a "welding" of a triangle to the fringe. A welding is an edge in the fringe where a triangle could be attached. If the algorithm succeeds in finding such a welding, it adds to the grid that vertex of the triangle which was not yet included in any edge in the fringe and records the two new edges in the fringe. This process continues iteratively until all objects of the diagram has been placed or until no more weldings can be found. An edge is only removed from the fringe when a welding to this edge has been found, and there is no room around this edge to place another vertex. When no more weldings can be found, but there are still triangles left, the algorithm searches for a possibility of attaching one of the remaining triangles to the existing structure by a vertex. If such a possibility is found, the corresponding edge of the found triangle is placed in the found space and the iterative process of welding triangles restarts. When logical groups are supplied, each of these groups is laid out independently. Then a diagram is constructed in which groups are objects and any two logical groups between which there exist morphisms are connected via a morphism. This diagram is laid out. Finally, the grid which includes all objects of the initial diagram is constructed by replacing the cells which contain logical groups with the corresponding laid out grids, and by correspondingly expanding the rows and columns. The sequential layout algorithm begins by constructing the underlying undirected graph defined by the morphisms obtained after simplifying premises and conclusions and merging them (see above). The vertex with the minimal degree is then picked up and depth-first search is started from it. All objects which are located at distance `n` from the root in the depth-first search tree, are positioned in the `n`-th column of the resulting grid. The sequential layout will therefore attempt to lay the objects out along a line. References ========== .. [Xypic] https://xy-pic.sourceforge.net/ )CompositeMorphismIdentityMorphism NamedMorphismDiagram)DictSymboldefault_sort_key)latex) FiniteSet)iterable)doctest_depends_on)chain)preview_diagrampygletcZeZdZdZdZedZedZdZdZ dZ dZ d Z d Z y ) _GrowableGrida Holds a growable grid of objects. Explanation =========== It is possible to append or prepend a row or a column to the grid using the corresponding methods. Prepending rows or columns has the effect of changing the coordinates of the already existing elements. This class currently represents a naive implementation of the functionality with little attempt at optimisation. c||_||_t|Dcgc]}t|Dcgc]}dc}c}}|_ycc}wcc}}wN)_width_heightrange_array)selfwidthheightijs e/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/categories/diagram_drawing.py__init__z_GrowableGrid.__init__rs;  =B6]KeEl33K 3KsA  A A A c|jSr)rrs rrz_GrowableGrid.widthxs {{c|jSr)rr!s rrz_GrowableGrid.height|s ||r"c0|\}}|j||S)zZ Returns the element located at in the i-th line and j-th column. rri_jrrs r __getitem__z_GrowableGrid.__getitem__s 1{{1~a  r"c2|\}}||j||<y)zW Sets the element located at in the i-th line and j-th column. Nr%)rr'newvaluerrs r __setitem__z_GrowableGrid.__setitem__s 1$ Aqr"c|xjdz c_|jjt|jDcgc]}dc}ycc}w)z3 Appends an empty row to the grid. N)rrappendrrrrs r append_rowz_GrowableGrid.append_rows;   % *<=QD=>=s Ac|xjdz c_t|jD] }|j|j d"y)z6 Appends an empty column to the grid. r-N)rrrrr.rrs r append_columnz_GrowableGrid.append_columns@ q t||$ (A KKN ! !$ ' (r"c|xjdz c_|jjdt|jDcgc]}dc}ycc}w)z6 Prepends the grid with an empty row. r-rN)rrinsertrrr/s r prepend_rowz_GrowableGrid.prepend_rows=   1U4;;-?@t@A@s A c|xjdz c_t|jD]!}|j|j dd#y)z9 Prepends the grid with an empty column. r-rN)rrrrr5r2s rprepend_columnz_GrowableGrid.prepend_columnsB q t||$ +A KKN ! !!T * +r"N)__name__ __module__ __qualname____doc__rpropertyrrr(r+r0r3r6r8r"rrrcsT L !%?(B+r"rceZdZdZedZedZedZedZedZ edZ edZ ed Z ed Z ed Zed Zed ZedZedZedZedZedZedZedZedZedZedZedZedZedZedZd#dZe dZ!e dZ"d Z#e d!Z$d"Z%y)$ DiagramGrida Constructs and holds the fitting of the diagram into a grid. Explanation =========== The mission of this class is to analyse the structure of the supplied diagram and to place its objects on a grid such that, when the objects and the morphisms are actually drawn, the diagram would be "readable", in the sense that there will not be many intersections of moprhisms. This class does not perform any actual drawing. It does strive nevertheless to offer sufficient metadata to draw a diagram. Consider the following simple diagram. >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> from sympy import pprint >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) The simplest way to have a diagram laid out is the following: >>> grid = DiagramGrid(diagram) >>> (grid.width, grid.height) (2, 2) >>> pprint(grid) A B C Sometimes one sees the diagram as consisting of logical groups. One can advise ``DiagramGrid`` as to such groups by employing the ``groups`` keyword argument. Consider the following diagram: >>> D = Object("D") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> h = NamedMorphism(D, A, "h") >>> k = NamedMorphism(D, B, "k") >>> diagram = Diagram([f, g, h, k]) Lay it out with generic layout: >>> grid = DiagramGrid(diagram) >>> pprint(grid) A B D C Now, we can group the objects `A` and `D` to have them near one another: >>> grid = DiagramGrid(diagram, groups=[[A, D], B, C]) >>> pprint(grid) B C A D Note how the positioning of the other objects changes. Further indications can be supplied to the constructor of :class:`DiagramGrid` using keyword arguments. The currently supported hints are explained in the following paragraphs. :class:`DiagramGrid` does not automatically guess which layout would suit the supplied diagram better. Consider, for example, the following linear diagram: >>> E = Object("E") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> h = NamedMorphism(C, D, "h") >>> i = NamedMorphism(D, E, "i") >>> diagram = Diagram([f, g, h, i]) When laid out with the generic layout, it does not get to look linear: >>> grid = DiagramGrid(diagram) >>> pprint(grid) A B C D E To get it laid out in a line, use ``layout="sequential"``: >>> grid = DiagramGrid(diagram, layout="sequential") >>> pprint(grid) A B C D E One may sometimes need to transpose the resulting layout. While this can always be done by hand, :class:`DiagramGrid` provides a hint for that purpose: >>> grid = DiagramGrid(diagram, layout="sequential", transpose=True) >>> pprint(grid) A B C D E Separate hints can also be provided for each group. For an example, refer to ``tests/test_drawing.py``, and see the different ways in which the five lemma [FiveLemma] can be laid out. See Also ======== Diagram References ========== .. [FiveLemma] https://en.wikipedia.org/wiki/Five_lemma ci}|jD].\}}t|tr|st|tr*|||<0|S)a- Given a dictionary mapping morphisms to their properties, returns a new dictionary in which there are no morphisms which do not have properties, and which are compositions of other morphisms included in the dictionary. Identities are dropped as well. )items isinstancerr) morphisms newmorphismsmorphismpropss r_simplify_morphismszDiagramGrid._simplify_morphisms2sS (0 /OHe($56uH&67). X&  /r"cdtt|j|jS)a- Given two dictionaries of morphisms and their properties, produces a single dictionary which includes elements from both dictionaries. If a morphism has some properties in premises and also in conclusions, the properties in conclusions take priority. )dictrrB)premises conclusionss r_merge_premises_conclusionsz'DiagramGrid._merge_premises_conclusionsEs&E(..*K,=,=,?@AAr"c@||z}t|dk7ry||z ||z zS)aO If ``edge1`` and ``edge2`` have precisely one common endpoint, returns an edge which would form a triangle with ``edge1`` and ``edge2``. If ``edge1`` and ``edge2`` do not have a common endpoint, returns ``None``. If ``edge1`` and ``edge`` are the same edge, returns ``None``. r-Nlen)edge1edge2 intersections r_juxtapose_edgeszDiagramGrid._juxtapose_edgesPs4u} |  ! $)=>>r"cB||vr||j|y|g||<y)a If ``edge`` is not in ``dictionary``, adds ``edge`` to the dictionary and sets its value to ``[elem]``. Otherwise appends ``elem`` to the value of existing entry. Note that edges are undirected, thus `(A, B) = (B, A)`. N)r.) dictionaryedgeelems r_add_edge_appendzDiagramGrid._add_edge_appendes+ :  t  # #D ) $vJt r"ci}|D]8}tj|t|j|jg|:t |}|D],}|D]%}tj ||}|s||vs!g||<'.|S)a Creates a dictionary which maps edges to corresponding morphisms. Thus for a morphism `f:A ightarrow B`, the edge `(A, B)` will be associated with `f`. This function also adds to the list those edges which are formed by juxtaposition of two edges already in the list. These new edges are not associated with any morphism and are only added to assure that the diagram can be decomposed into triangles. )r@rY frozensetdomaincodomainrJrT)rDedgesrFedges1wvwvs r_build_skeletonzDiagramGrid._build_skeletonss! RH  ( (y(//83D3D!EF R R e #A # 11!Q7"E/ "E"I # #  r"c t}|D]D}|D]=}tj||}|s||vs!|jt |||g?F|S)z Builds the set of triangles formed by the supplied edges. The triangles are arbitrary and need not be commutative. A triangle is a set that contains all three of its sides. )setr@rTaddr[)r^ trianglesr`rarbs r_list_triangleszDiagramGrid._list_trianglesscE  9A 9 11!Q7"+MM)Q2J"78 9 9 r"c |Dcgc]&}t|Dcgc] }||s | c}dk\r|(c}}Scc}wcc}}w)z Returns a list which contains only those triangles who have morphisms associated with at least two edges. rO)rgskeletontries r_drop_redundant_trianglesz%DiagramGrid._drop_redundant_trianglessD )>36a(1+671<> >6>s: 55::cNt|trt|jSy)z Returns the length of a morphism. The length of a morphism is the number of components it consists of. A non-composite morphism is of length 1. r-)rCrrP components)rFs r_morphism_lengthzDiagramGrid._morphism_lengths# h 1 2x**+ +r"cni}|D]-}d}|D]}||}|s |td|Dz }!|||</|S)a Returns a dictionary mapping triangles to their minimal sizes. The minimal size of a triangle is the sum of maximal lengths of morphisms associated to the sides of the triangle. The length of a morphism is the number of components it consists of. A non-composite morphism is of length 1. Sorting triangles by this metric attempts to address two aspects of layout. For triangles with only simple morphisms in the edge, this assures that triangles with all three edges visible will get typeset after triangles with less visible edges, which sometimes minimizes the necessity in diagonal arrows. For triangles with composite morphisms in the edges, this assures that objects connected with shorter morphisms will be laid out first, resulting the visual proximity of those objects which are connected by shorter morphisms. rc3FK|]}tj|ywr)r@rq).0ms r z:DiagramGrid._compute_triangle_min_sizes..s# 4$%!, < )==X1vsHdD #MM1a&) qTQqT\tQqTAX~H1qtaxJ%99*q!fc8TCKA$!q.aD!A$(N )==YAXtE #MM1a&)((c4H#1~q 1"1~q 13 qTF1I qtfQi/ 0 qTF1I qtfQi/ 0 ;'![)9:;r"cjttj|t}||t|fS)z Returns a key for the supplied triangle. It should be the same independently of the hash randomisation. key)sortedr@r~r )rlrxobjectss r _triangle_keyzDiagramGrid._triangle_keys6   ) )# .4DFs#%5g%>??r"c|Dcgc]}||rt|t}}t|t}tt|dtScc}w)z For a given triangle always picks the same root edge. The root edge is the edge that will be placed first on the grid. rr)rr r})rlrkrm candidatessorted_candidatess r_pick_root_edgezDiagramGrid._pick_root_edges] #3hqkQ$453 3":3CDV-a06FGHH 3sAcv|Dcgc])}|jtj|r(|+c}Scc}w)z} Returns only those triangles whose set of objects is not completely included in ``placed_objects``. ) issupersetr@r~)rgplaced_objectsrls r_drop_irrelevant_trianglesz&DiagramGrid._drop_irrelevant_triangless; )10I0I  ) )# .101 11s)66c t|jD][}t|jD]?}|||fsfd}|Dcgc] }||s |} }| s/| d}t|D cgc] } || s |  c} d} | D cgc] } | vs|  } } | d} t | t gz d}|dz |f||dzf|dz|f||dz f|dz |dz f|dz |dzf|dz|dz f|dz|dzfg}|D]s}t j||st j||||}||dz }||dz }|d|dz|d|dzf}|j||f|f|cccSB^ycc}wcc} wcc} w)aj Starting from an object in the existing structure on the ``grid``, adds an edge to which a triangle from ``triangles`` could be welded. If this method has found a way to do so, it returns the object it has just added. This method should be applied when ``_weld_triangle`` cannot find weldings any more. cbtj|}|vxr|hz ztk(Sr)r@r~re)rlobjsrrs r good_trianglez2DiagramGrid._grow_pseudopod..good_triangles;&88=D$;A&$#,735@Ar"rc.t|jSr)r sort_key)rms rz-DiagramGrid._grow_pseudopod..s)Q-2H2H2Jr"rr-N) rrrrr}r[r@rrr.)rgrrrkrrrrrltrisrmrr^rW other_obj neighboursrrrs ` @r_grow_pseudopodzDiagramGrid._grow_pseudopodst{{#B )A4::&A )1a4jA (1GM#4FGG1g $$C1x{Q$C(JL $.;q#(;;Qx!$C5)9"9:1= !1uaj1a!e*q1uaj1a!e* 1ua!enq1ua!enq1ua!enqSTuVWZ[V[n^ % )B"//D9"-!8!8 4"9VAYVAY efQi/A1BC 1vrl3(( )kA )B )JkH$%D;s$ E8E8. E= 9E= FFc fd}d}iit|ttfr3i}|jD]\}}||} ||| <||||}n-g}|D]$}||} |j | || d&|}g} |D]B} | j } | j } | | k7s'| j t| | dDtt| fdtjDcgc]+tfdtjD-}}tjDcgc]+tfdtjD-}}tt|t|}d}d}tjD]}tjD]h}||f}|vrL|}t|jD].t|jD]|f||z|zf<0n||||f<|||z }jd}|||z }|Scc}wcc}w) a+ Given the slightly preprocessed morphisms of the diagram, produces a grid laid out according to ``groups``. If a group has hints, it is laid out with those hints only, without any influence from ``hints``. Otherwise, it is laid out with ``hints``. ct|trL|D]}||< |rtj|fi||<ytj|fi|<y||<y)a If ``group`` is a set of objects, uses a ``DiagramGrid`` to lay it out and returns the grid. Otherwise returns the object (i.e., ``group``). If ``local_hints`` is not empty, it is supplied to ``DiagramGrid`` as the dictionary of hints. Otherwise, the ``hints`` argument of ``_handle_groups`` is used. N)rCr r@subdiagram_from_objects)group local_hintsrdiagram groups_gridshints obj_groupss r lay_out_groupz1DiagramGrid._handle_groups..lay_out_group!s%+!,C&+JsO,*577>+OBM+OL'+677>+IBG+IL'%* 5!r"c,t|rt|S|S)zh Converts ``group`` to a :class:``FiniteSet`` if it is an iterable. )r r )rs rgroup_to_finitesetz6DiagramGrid._handle_groups..group_to_finiteset:s  %(( r"NdummycH|vr|}|j|jfSy)z For the supplied group (or object, eventually), returns the size of the cell that will hold this group (object). )r-r-r)rrrs r group_sizez.DiagramGrid._handle_groups..group_sizers-  $#E* TZZ00r"c3>K|]}|fdyw)rNr>)rtrrrtop_grids rrvz-DiagramGrid._handle_groups..}s+; &hq!tn5a8;c3>K|]}|fdywr-Nr>)rtrrrrs rrvz-DiagramGrid._handle_groups..s+>!"(A7:>rr)rCrJrrBr.r\r]rr@rrrrwrrsum)rgroupsmerged_morphismsrrrfiniteset_groupsrrfiniteset_group new_morphismsrFdomcodr row_heightsr column_widthsrreal_row real_column logical_rowlogical_columnr local_gridrrrrs` ` ` ` @@@@r_handle_groupszDiagramGrid._handle_groupss *2    ftTl +! &,lln 2"{"4U";4? 1e[1 2&F!  5"4U"; ''8ot4 5&F ( GHX__-CX../Ccz $$]3W%EF Gw}56 !&hoo 68;$)(..$9;;8 8 #("79>&+HOO&<>>9 9S/[1AB  1 1K"'"7 ={N:;,&".c!2J":#4#45D!&z'7'7!8DA3=ad3C!A +a"01DD 36D;./}^<<  = K  K0 0H% 1( A89s 0I 0Ict|j}t|dk(rtdd}t |d|d<|St j |}tdd}t|dk(r#t|t}|d|d<|d|d<|St j|}t j||}t j||t|fd}t j|d|}|\|d<|d<dg}t|} | |k7rt j|||} | rG| \} } t j| | |||} | r@| jt j!| n)t j#||||| }|s|| z }|j%t'|}t |}|j(|j(z}t+|j,|j,}t||}t/|j(D](}t/|j,D]}|||f|||f<*|j(}t/|j,D]+}t/|j(D]}|||f||||zf<-|S| j1|t j3|| }| |k7r|S) zG Produces the generic layout for the supplied diagram. r-rrrjrrr-c0tj|Sr)r@r)rlrxs rrz-DiagramGrid._generic_layout..s&44S.Ir")rr)rerrPrr}r@rcrr rhrnr{rrrupdater~rrr rrwrrrfr)rr all_objectsrrkrrg root_edgerrweldingryrrestart_requirednew_objremaining_objectsremaining_diagramremaining_grid final_width final_height final_gridrrstart_jrxs @r_generic_layoutzDiagramGrid._generic_layouts '//* { q !A&D{+A.DJK../?@Q" x=A [.>?G DJ DJK//9 99)XN $@@ x!9+JK  // ! hG !*T DJ"#Y +!8864)G+2(<#.#=#=lFD($D #%%11(;= &55vtX~G )4n(D%(/(G(G!#45)7%%01B%CN#'**~/C/C"CK#&t{{N4I4I#JL!.{L!IJ"4::.:!&t{{!3:A/3AqDzJq!t,::#jjG">#8#89N!&~';';!<NA9G19MJq'A+~6NN&%""7+#>>>+Ie +j r"c,i}|D]}g||< |D]R}||jj|j||jj|jT|jD]}||j t |S)z Given the objects and the relevant morphisms of a diagram, returns the adjacency lists of the underlying undirected graph. r)r\r.r]keyssortr )rradjlistsrrFs r_get_undirected_graphz!DiagramGrid._get_undirected_graphs CHSM ) @H X__ % , ,X->-> ? X&& ' . .x ? @ ==? 5C SM  #3  4 5r"c|j}t|t}tj ||t |fd}t dd|d<|h}fdd|S)z Lays out the diagram in "sequential" layout. This method will attempt to produce a result as close to a line as possible. For linear diagrams, the result will actually be a line. rc t|SrrO)xrs rrz0DiagramGrid._sequential_layout..%sXa[1Ar"r-rc|d|ddzf}|D]U}||vrtj||g|j||j|||ddz|df}W|S)z Does depth-first search in the underlying graph of the diagram and places the objects en route. rr-)r@rrfr)rrnew_pt adjacent_objrr place_objectss rrz5DiagramGrid._sequential_layout..place_objects+s eRUQY'F (b 2 4 >1'' dBG""<0%%mFN&KL )a-3 4" !r")rrr r@rminr) rrrsorted_objectsrootrrrrs @@@r_sequential_layoutzDiagramGrid._sequential_layoutso//-=>44W>NO>'ABQ"T  "* fn- r"cb|Dcgc]}|j|jk7s| }}|Scc}w)z Removes those morphisms which should appear in the diagram, but which have no relevance to object layout. Currently this removes "loop" morphisms: the non-identity morphisms with the same domains and codomains. )r\r])rrurDs r_drop_inessential_morphismsz'DiagramGrid._drop_inessential_morphismsDs2!1K1AHH 4JQK KLs,,c  i |D]}d |< tj|| fd d} D]} |  |||dz }t|Dcgc]}g}} jD]\}}||j |g}|D]r}i} |D](} | j |vs| j |vs!|| | | <*t|dk(rt| t|d<|j t| t|Scc}w)z Given a container of morphisms, returns a list of connected components formed by these morphisms. A connected component is represented by a diagram consisting of the corresponding morphisms. NcB||<|D]}| ||y)zq Does a depth-first search traversal of the component containing ``object``. Nr>)object current_indexoadjlistcomponent_indextraverse_components rrzADiagramGrid._get_connected_components..traverse_component_s7 '4OF #V_ 9"1%-&q-8 9r"rr-) r@rrrBr.r\r]rPr rr)rrrrrcomponent_objectsidxcomponent_morphisms componentcurrent_morphismsrurrrs @@@r_get_connected_componentsz%DiagramGrid._get_connected_componentsPs[ &A!%OA  &33G=MN 9  #Aq!)"1m4"  # */})=>AR>>%++- -FAs c " ) )! , -!* CI " % ?HH ) i0G+;A+>%a( ?9~"ENK!"29Q<"@A  & &w/@'A B C#"7?s D Nc tj|j}tj|j}tj ||}tj |}||_tj|j|}|r.||jk7rtj|||||_ nt|dkDrg} t|t}|D]} t| fi|} | j| !td| D} t!d| D} t#| | } d}| D]T}t%|j&D]+}t%|j(D]}|||f| |||zf<-||j(z }V| |_ nCd|vr$|ddk(r7tj+|||_ ntj-|||_ |j/drt#|jj&|jj(} t%|jj&D]<}t%|jj(D]}|j||f| ||f<>| |_ yy) Nr-rc34K|]}|jywr)rrtgs rrvz'DiagramGrid.__init__..s5!agg5c34K|]}|jywr)rrs rrvz'DiagramGrid.__init__..s7Aqxx7r!rlayout sequential transpose)r@rHrKrLrMr _morphismsrrr_gridrPrr r.rrwrrrrr rr)rrrrrKrLall_merged_morphismsrrpgridsrr total_width total_heightrr rrs rrzDiagramGrid.__init__si2273C3CD!55g6I6IJ *FF k #&BB "/ :: OO13  v0$33!15:DJ _q E 0@AJ' # "966 T" # 5u55K777L l;DG #qxx7A"177^7/0AwQ! ^,77177"  #DJ  X,.(;;-/ %44W>NODJ 99[ ! !2!2DJJ4D4DED4::,,- 2tzz//02A!%AqD!1DAJ2 2DJ "r"c.|jjS)a Returns the number of columns in this diagram layout. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) >>> grid = DiagramGrid(diagram) >>> grid.width 2 )r'rr!s rrzDiagramGrid.widths*zzr"c.|jjS)a Returns the number of rows in this diagram layout. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) >>> grid = DiagramGrid(diagram) >>> grid.height 2 )r'rr!s rrzDiagramGrid.heights*zz   r"c.|\}}|j||fS)a Returns the object placed in the row ``i`` and column ``j``. The indices are 0-based. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) >>> grid = DiagramGrid(diagram) >>> (grid[0, 0], grid[0, 1]) (Object("A"), Object("B")) >>> (grid[1, 0], grid[1, 1]) (None, Object("C")) )r'r&s rr(zDiagramGrid.__getitem__s .1zz!Q$r"c|jS)a Returns those morphisms (and their properties) which are sufficiently meaningful to be drawn. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) >>> grid = DiagramGrid(diagram) >>> grid.morphisms {NamedMorphism(Object("A"), Object("B"), "f"): EmptySet, NamedMorphism(Object("B"), Object("C"), "g"): EmptySet} )r&r!s rrDzDiagramGrid.morphismss.r"c@t|jjS)a Produces a string representation of this class. This method returns a string representation of the underlying list of lists of objects. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import Diagram, DiagramGrid >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g]) >>> grid = DiagramGrid(diagram) >>> print(grid) [[Object("A"), Object("B")], [None, Object("C")]] )reprr'rr!s r__str__zDiagramGrid.__str__/s0DJJ%%&&r"r)&r9r:r;r< staticmethodrHrMrTrYrcrhrnrqr{r~rrrrrrrrrrrrrr rrrr=rrr(rDr2r>r"rr@r@stAD$BB??( & &4 >>  :22LL  B: ^^@@@ I I11OObEEN^^@*++Z  ;#;#z>@  ,!!, 40'r"r@ceZdZdZdZdZy)ArrowStringDescriptionah Stores the information necessary for producing an Xy-pic description of an arrow. The principal goal of this class is to abstract away the string representation of an arrow and to also provide the functionality to produce the actual Xy-pic string. ``unit`` sets the unit which will be used to specify the amount of curving and other distances. ``horizontal_direction`` should be a string of ``"r"`` or ``"l"`` specifying the horizontal offset of the target cell of the arrow relatively to the current one. ``vertical_direction`` should specify the vertical offset using a series of either ``"d"`` or ``"u"``. ``label_position`` should be either ``"^"``, ``"_"``, or ``"|"`` to specify that the label should be positioned above the arrow, below the arrow or just over the arrow, in a break. Note that the notions "above" and "below" are relative to arrow direction. ``label`` stores the morphism label. This works as follows (disregard the yet unexplained arguments): >>> from sympy.categories.diagram_drawing import ArrowStringDescription >>> astr = ArrowStringDescription( ... unit="mm", curving=None, curving_amount=None, ... looping_start=None, looping_end=None, horizontal_direction="d", ... vertical_direction="r", label_position="_", label="f") >>> print(str(astr)) \ar[dr]_{f} ``curving`` should be one of ``"^"``, ``"_"`` to specify in which direction the arrow is going to curve. ``curving_amount`` is a number describing how many ``unit``'s the morphism is going to curve: >>> astr = ArrowStringDescription( ... unit="mm", curving="^", curving_amount=12, ... looping_start=None, looping_end=None, horizontal_direction="d", ... vertical_direction="r", label_position="_", label="f") >>> print(str(astr)) \ar@/^12mm/[dr]_{f} ``looping_start`` and ``looping_end`` are currently only used for loop morphisms, those which have the same domain and codomain. These two attributes should store a valid Xy-pic direction and specify, correspondingly, the direction the arrow gets out into and the direction the arrow gets back from: >>> astr = ArrowStringDescription( ... unit="mm", curving=None, curving_amount=None, ... looping_start="u", looping_end="l", horizontal_direction="", ... vertical_direction="", label_position="_", label="f") >>> print(str(astr)) \ar@(u,l)[]_{f} ``label_displacement`` controls how far the arrow label is from the ends of the arrow. For example, to position the arrow label near the arrow head, use ">": >>> astr = ArrowStringDescription( ... unit="mm", curving="^", curving_amount=12, ... looping_start=None, looping_end=None, horizontal_direction="d", ... vertical_direction="r", label_position="_", label="f") >>> astr.label_displacement = ">" >>> print(str(astr)) \ar@/^12mm/[dr]_>{f} Finally, ``arrow_style`` is used to specify the arrow style. To get a dashed arrow, for example, use "{-->}" as arrow style: >>> astr = ArrowStringDescription( ... unit="mm", curving="^", curving_amount=12, ... looping_start=None, looping_end=None, horizontal_direction="d", ... vertical_direction="r", label_position="_", label="f") >>> astr.arrow_style = "{-->}" >>> print(str(astr)) \ar@/^12mm/@{-->}[dr]_{f} Notes ===== Instances of :class:`ArrowStringDescription` will be constructed by :class:`XypicDiagramDrawer` and provided for further use in formatters. The user is not expected to construct instances of :class:`ArrowStringDescription` themselves. To be able to properly utilise this class, the reader is encouraged to checkout the Xy-pic user guide, available at [Xypic]. See Also ======== XypicDiagramDrawer References ========== .. [Xypic] https://xy-pic.sourceforge.net/ c ||_||_||_||_||_||_||_||_| |_d|_ d|_ d|_ y)NF) unitcurvingcurving_amount looping_start looping_endhorizontal_directionvertical_directionlabel_positionlabellabel_displacement arrow_styleforced_label_position) rr8r9r:r;r<r=r>r?r@s rrzArrowStringDescription.__init__sc  ,*&$8!"4, "$ &+"r"c |jr'd|j|j|jfz}nd}|jr*|jrd|jd|jd}nd}|j rd|j z}nd}d|||d|j |jd |j|jd |jd S) Nz @/%s%d%s/r7z@(,)@z\ar[]{}) r9r:r8r;r<rBr=r>r?rAr@)r curving_str looping_str style_strs rr2zArrowStringDescription.__str__s <<%t7J7J)-)44KK   $"2"2(,(:(:Dr"rr5r5Js`B+*5r"r5ceZdZdZdZedZedZedZdZ edZ edZ ed Z d Z ed Zed ZddZy )XypicDiagramDrawera Given a :class:`~.Diagram` and the corresponding :class:`DiagramGrid`, produces the Xy-pic representation of the diagram. The most important method in this class is ``draw``. Consider the following triangle diagram: >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g], {g * f: "unique"}) To draw this diagram, its objects need to be laid out with a :class:`DiagramGrid`:: >>> grid = DiagramGrid(diagram) Finally, the drawing: >>> drawer = XypicDiagramDrawer() >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\ C & } For further details see the docstring of this method. To control the appearance of the arrows, formatters are used. The dictionary ``arrow_formatters`` maps morphisms to formatter functions. A formatter is accepts an :class:`ArrowStringDescription` and is allowed to modify any of the arrow properties exposed thereby. For example, to have all morphisms with the property ``unique`` appear as dashed arrows, and to have their names prepended with `\exists !`, the following should be done: >>> def formatter(astr): ... astr.label = r"\exists !" + astr.label ... astr.arrow_style = "{-->}" >>> drawer.arrow_formatters["unique"] = formatter >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\ C & } To modify the appearance of all arrows in the diagram, set ``default_arrow_formatter``. For example, to place all morphism labels a little bit farther from the arrow head so that they look more centred, do as follows: >>> def default_formatter(astr): ... astr.label_displacement = "(0.45)" >>> drawer.default_arrow_formatter = default_formatter >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\ C & } In some diagrams some morphisms are drawn as curved arrows. Consider the following diagram: >>> D = Object("D") >>> E = Object("E") >>> h = NamedMorphism(D, A, "h") >>> k = NamedMorphism(D, B, "k") >>> diagram = Diagram([f, g, h, k]) >>> grid = DiagramGrid(diagram) >>> drawer = XypicDiagramDrawer() >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\ & C & } To control how far the morphisms are curved by default, one can use the ``unit`` and ``default_curving_amount`` attributes: >>> drawer.unit = "cm" >>> drawer.default_curving_amount = 1 >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\ & C & } In some diagrams, there are multiple curved morphisms between the same two objects. To control by how much the curving changes between two such successive morphisms, use ``default_curving_step``: >>> drawer.default_curving_step = 1 >>> h1 = NamedMorphism(A, D, "h1") >>> diagram = Diagram([f, g, h, k, h1]) >>> grid = DiagramGrid(diagram) >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\ & C & } The default value of ``default_curving_step`` is 4 units. See Also ======== draw, ArrowStringDescription cJd|_d|_d|_i|_d|_y)Nmm)r8default_curving_amountdefault_curving_steparrow_formattersdefault_arrow_formatterr!s rrzXypicDiagramDrawer.__init__Ms- &'#$%!!#(,$r"cd}d}d}d}gd} |||f} |jD]3\} } | j| k(r{| j| k(rl| j| j}} | |fdk(r| dxxdz cc<n>| |fdk(r| dxxdz cc<n)| |fdk(r| d xxdz cc<n| |fd k(r | d xxdz cc<| j| k(r|| j\}}d }n%| j| k(r|| j\}}d }n||z }||z }| j }|dk7rm|dk7rh|dkDr|dkDr| dxxdz cc<|dkDr|dkr| dxxdz cc<,|dkr|dkr| d xxdz cc<E|dksL|dkDsS| d xxdz cc<b|dk(rd|dkDr |rd}d }nd }d}n |rd }d}nd}d }|r*|dk(r| |xxdz cc<|dk(s| |xxdz cc<| |xxdz cc<| |xxdz cc<|dk(s|dkr |rd}d}nd}d}n |rd }d }nd }d }|r*|dk(r| |xxdz cc<|dk(s | |xxdz cc<| |xxdz cc<| |xxdz cc<6d}t dD]}| || |ks|}gd|\}}||||fS)z Produces the information required for constructing the string representation of a loop morphism. This function is invoked from ``_process_morphism``. See Also ======== _process_morphism r7^)rrrrrurr-r]lr_drjrar\rSTF_rT)r[r^r`rb)rBr\r]r;r<r9r)rrrmorphisms_str_info object_coordsr9 label_posr;r<quadrantrru m_str_infol_sl_eend_iend_jgoes_outd_id_j m_curvingupper_quadrantlower_quadrant left_quadrantright_quadrantfreest_quadrants r_process_loop_morphismz)XypicDiagramDrawer._process_loop_morphismZs@    1a4j/557d 2MAzCajjC&7)66 8N8Nc:+QK1$K3Z:-QK1$K3Z:-QK1$K3Z:-QK1$Kxx3!.qzz!:s"!.qxx!8 !)C!)C"**Iqsax!G#'QK1$KAgC!GQK1$KAgC!GQK1$KAgC!GQK1$K 7)*)*)*)*)*)*)*)* C' 0A50"c) 0A50^,1,^,1, 7() )*() )*() )*() )* C' /14/"c) 0A50]+q0+^,1,Id 2Nq $A{Xo66"# $ (44C(E$ M;??r"c8d}|}|}||kr||}}d}g} g} g} t|dz|D]} ||| f} | s |D]}|j| k(r||j\}}n#|j| k(r||j\}}nH||kDr| j|_||kr| j|v||jr| j|t | t | krZ|rd}d}nd}d}| D]F}||j\}}||j\}}||}||krd|_nd|_d|_H||fS|rd}d}nd}d}| D]F}||j\}}||j\}}||}||krd|_nd|_d|_H||fS)z Produces the information required for constructing the string representation of a horizontal morphism. This function is invoked from ``_process_morphism``. See Also ======== _process_morphism FTr-rcrZrr\r]r.r9rPr?rC)rrtarget_jrrdre backwardsstartendupdownstraight_horizontalrrrurkrlr9rfrrrrrhs r_process_horizontal_morphismz/XypicDiagramDrawer._process_horizontal_morphisms   ;CUI4 uqy#& 2Aq!t*C' 288s?%21::%>NUEZZ3&%2188%NUEZZ3&%2188%|r 0``, repeats ``str_gt`` ``times`` times. Otherwise, repeats ``str_lt`` ``-times`` times. rr>)timesstr_gtstr_lts rrepeat_string_condz@XypicDiagramDrawer._process_morphism..repeat_string_conds" qy~%%((r"cztDcgc]!}|j|jh||hk(r|#c}Scc}w)zu Counts how many processed morphisms there are between the two supplied objects. )rPr\r])rBrurds rcount_morphisms_undirectedzHXypicDiagramDrawer._process_morphism..count_morphisms_undirectedsE #5=aHHajj1aV;=> >=s&8c tjDcgc]3\}}|j|jf||fk(r|j|k(r|5c}}Scc}}w)z Counts the processed morphisms which go out of ``dom`` into ``cod`` with curving ``curving``. )rPrBr\r]r9)rrr9rurhrds rcount_morphisms_filteredzFXypicDiagramDrawer._process_morphism..count_morphisms_filtereds` /A/G/G/I9maHHajj1c3Z?#++w69: :9s8A rar]r\r_r7rZrr-zid_{%s}z\circ )r\r]rPrvrrrrUrVrCrr rrprnamereversejoinrr5r8)rrrrFrerDrdrrrrrrrydelta_idelta_jr>r=r9rfr;r<countr:filtered_morphisms morphism_namercomponent_namess ` r_process_morphismz$XypicDiagramDrawer._process_morphisms  ) > :x/A,X->->?8Q,Q,/03S:1'25s <   qLw!|/EEAt/@ Wi lQ\!2Q!6#5#R#R1h&8-$I WilQ\!2Q!6#5#P#P1h&8-$I Wi+8??Hrtrdom_irs rrvzBXypicDiagramDrawer._check_free_space_horizontal..Fs"1$uqy!|,1r-c32K|]}dz|fywrr>rs rrvzBXypicDiagramDrawer._check_free_space_horizontal..Ms" 7qUQY\ 2 7r)allrrany) rdom_jcod_jrr{r|rzfree_up free_downs ` ` r_check_free_space_horizontalz/XypicDiagramDrawer._check_free_space_horizontal4s 5=!5CUI!5CUI A:G1sQw/11G DKK!O #I 7 %eS1W 5 777II..r"c||kr||}}d}n||}}d}dk(rd}n#tfdt||dzD }jdz k(rd}n#tfdt||dzD }|||fS)z For a vertical morphism, checks whether there is free space (i.e., space not occupied by any objects) to the left of the morphism or to the right of it. FTrc32K|]}|dz fywrr>rtrrrs rrvz@XypicDiagramDrawer._check_free_space_vertical..ds" 7qQ \ 2 7rr-c32K|]}|dzfywrr>rs rrvz@XypicDiagramDrawer._check_free_space_vertical..js"!8al!3!8r)rrr) rcod_irrr{r|rz free_left free_rights `` r_check_free_space_verticalz-XypicDiagramDrawer._check_free_space_verticalRs 5=!5CUI!5CUI A:I 7 %eS1W 5 777I DJJN "J !8!&ucAg!6!888J:y11r"cd}||kr||kr ||}}||} }d} n||kDr||kDr ||}}||} }d} ||kr||kDr ||}}||} }d} n||kDr||kr ||}}||} }d} tz  z z } d} d} |||D]}| s| sn}||| D]o}| s| s||f||fk(r||k(rd}nt||z ||z z }|||fs7|dk(st|t| kDrd} Vt|t| ksnd} q| |  fS)z For a diagonal morphism, checks whether there is free space (i.e., space not occupied by any objects) above the morphism or below it. cH||krt||dzSt||dzS)Nr-)r)r{r|s r abs_xrangezAXypicDiagramDrawer._check_free_space_diagonal..abs_xrangevs+s{UC!G,,S%!),,r"FTinf)floatr)rrrrrrstart_irrkrlrzalpharrrralpha1s r_check_free_space_diagonalz-XypicDiagramDrawer._check_free_space_diagonalos - 5=UU]#(gW#UEUI U]uu}#(gW#UEUI 5=UU]#(gW#UEUI U]uu}#(gW#UEUI6ego&8 GU+ (A9/ (yq6gw//<"F"1w;/W=F1:%S[3u:-E$) Vs5z1"'! (  (,I..r"c d}|jD]\}}|js |jr|j|jk(r9||j\}}||j\} } || k(r*t j ||| |\} } } || | dd| ||| k(r*t j|| ||\}}} |||dd| |t j|| || |\} } } || | dd| |y)z For all straight morphisms which form the visual boundary of the laid out diagram, puts their labels on their outer sides. cB|r||}}|r |s||_y|r |s||_yyy)a Given the information about room available to one side and to the other side of a morphism (``free1`` and ``free2``), sets the position of the morphism label in such a way that it is on the freer side. This latter operations involves choice between ``pos1`` and ``pos2``, taking ``backwards`` in consideration. Thus this function will do nothing if either both ``free1 == True`` and ``free2 == True`` or both ``free1 == False`` and ``free2 == False``. In either case, choosing one side over the other presents no advantage. N)r?)free1free2pos1pos2rzrhs rset_label_positionz?XypicDiagramDrawer._push_labels_out..set_label_positions1 $dtU,0 )u,0 ) %r"rZrcN) rBr9rCr\r]rPrrr)rrdrrerrurhrrrrrrrzrrs r_push_labels_outz#XypicDiagramDrawer._push_labels_outs9  1,0557& :MAz!!Z%E%Exx1::%*1884NUE*1::6NUE~1MME5$0)#7IsC#,j:%1KKE5$0J#9j#s#,j: 1KKE5%7)#7IsC#,j:K& :r"c0||j\}}||j\}}|j|jk(rddt|fS||k(rdt||z t|fS||k(rdt||z t|fSddt|fS)a Provides a morphism sorting key such that horizontal or vertical morphisms between neighbouring objects come first, then horizontal or vertical morphisms between more far away objects, and finally, all other morphisms. rSrr-rj)r\r]r r)rFrerrrrys r_morphism_sort_keyz%XypicDiagramDrawer._morphism_sort_key sx/A,X->->?8 ??h// /q*845 5 q=s8a<(*:8*DE E q=s8a<(*:8*DE E1&x011r"ci}|jD]}g||< |D] }||jj|"d|z}t|jD]} t|j D]T} || | f}|r1|t |dzz }||} | D]}|t||dzz }| |j dz ksP|dz }V| |jdz kr|dz }|dz }|dz }|S)z Given a collection of :class:`ArrowStringDescription` describing the morphisms of a diagram and the object layout information of a diagram, produces the final Xy-pic picture. z \xymatrix%s{  r-z& z\\ z} )rr\r.rrrr str) rrrDrddiagram_formatobject_morphismsrrFresultrrmorphisms_to_draws r_build_xypic_stringz&XypicDiagramDrawer._build_xypic_string& s3?? 'C$& S ! '! ?H X__ - 4 4X > ?#^3t{{# A4::& #1a4jeCj3..F(8(=%$5J#&8&B"Cc"IIJtzzA~%dNF #4;;?"&  dNF# & % r"Nc |s |j}n.i}|jjD]\}}||vr |||<it|jD]0}t|jD]} ||| fs || f||| f<2t |fd} i} | D]~} |j ||| | | } |jr|j| || D]<}|j|jvs|j|j}|| >| | | <|j| |tj||| | |S)a Returns the Xy-pic representation of ``diagram`` laid out in ``grid``. Consider the following simple triangle diagram. >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g], {g * f: "unique"}) To draw this diagram, its objects need to be laid out with a :class:`DiagramGrid`:: >>> grid = DiagramGrid(diagram) Finally, the drawing: >>> drawer = XypicDiagramDrawer() >>> print(drawer.draw(diagram, grid)) \xymatrix{ A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\ C & } The argument ``masked`` can be used to skip morphisms in the presentation of the diagram: >>> print(drawer.draw(diagram, grid, masked=[g * f])) \xymatrix{ A \ar[r]^{f} & B \ar[ld]^{g} \\ C & } Finally, the ``diagram_format`` argument can be used to specify the format string of the diagram. For example, to increase the spacing by 1 cm, proceeding as follows: >>> print(drawer.draw(diagram, grid, diagram_format="@+1cm")) \xymatrix@+1cm{ A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\ C & } c0tj|Sr)rPr)rures rrz)XypicDiagramDrawer.draw.. s);)N)N -*1r"r) rDrBrrrrrrXrrWrrPr)rrrmaskedrmorphisms_propsrurGrrrDrdrFstring_descriptionprop formatterres @rdrawzXypicDiagramDrawer.drawO s`"nnO O NN002 +5;%*" + t{{# 7A4::& 71:12AM$q!t*- 7 7 ? 12  ! >H!%!7!7x ""$ ++,,-?@'1 299 5 55 $ 5 5dii @I01  2 ,> x ( >" 0$ F!55 T9&8.J Jr")Nr7)r9r:r;r<rr3rvrrrrrrrrrrr>r"rrPrPsrf ,L@L@\z$z$xh$h$Ta&F//:228W/W/rA:F222&&P|Jr"rPNc Xt||fi|}t}|j||||S)aa Provides a shortcut combining :class:`DiagramGrid` and :class:`XypicDiagramDrawer`. Returns an Xy-pic presentation of ``diagram``. The argument ``masked`` is a list of morphisms which will be not be drawn. The argument ``diagram_format`` is the format string inserted after "\xymatrix". ``groups`` should be a set of logical groups. The ``hints`` will be passed directly to the constructor of :class:`DiagramGrid`. For more information about the arguments, see the docstrings of :class:`DiagramGrid` and ``XypicDiagramDrawer.draw``. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy.categories import xypic_draw_diagram >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> diagram = Diagram([f, g], {g * f: "unique"}) >>> print(xypic_draw_diagram(diagram)) \xymatrix{ A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\ C & } See Also ======== XypicDiagramDrawer, DiagramGrid )r@rPr)rrrrrrdrawers rxypic_draw_diagramr s3H w 0% 0D  !F ;;wfn ==r")r dvipng)r)exemodulesc Fddlm}t||||fi|} || |||dy)a Combines the functionality of ``xypic_draw_diagram`` and ``sympy.printing.preview``. The arguments ``masked``, ``diagram_format``, ``groups``, and ``hints`` are passed to ``xypic_draw_diagram``, while ``output``, ``viewer, and ``euler`` are passed to ``preview``. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy.categories import preview_diagram >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g], {g * f: "unique"}) >>> preview_diagram(d) See Also ======== XypicDiagramDrawer r)preview)xypicN)sympy.printingrr) rrrroutputviewereulerrr latex_outputs rrr s28'%gv~&,7057L L&&%r"rrsSh6655& .8-h7I+I+XX'X'v$L5L5^rJrJj=?"&>R+[ADH59=B=r"