Quelle labels.xml Sprache: XML

#############################################################################
##
#W labels.xml
#Y Copyright (C) 2019 James D. Mitchell
## Wilf A. Wilson
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##

<#GAPDoc Label="DigraphVertexLabel">
<ManSection>
 <Oper Name = "DigraphVertexLabel" Arg="digraph, i"/>
 <Oper Name ="SetDigraphVertexLabel" Arg="digraph, i, obj"/>
 <Description>
 If <A>digraph</A> is a digraph, then the first operation returns the label
 of the vertex <A>i</A>. The second operation can be used to set the label
 of the vertex <A>i</A> in <A>digraph</A> to the arbitrary &GAP; object
 <A>obj</A>. 

 The label of a vertex can be changed an arbitrary number of times. If no
 label has been set for the vertex <A>i</A>, then the default value is
 <A>i</A>. 

 If <A>digraph</A> is a digraph created from a record with a component
 <C>DigraphVertices</C>, then the labels of the vertices are set to
 the value of this component.

 Induced subdigraphs, and some other operations which create new digraphs from
 old ones, inherit their labels from their parents.

 <Example><![CDATA[
gap> D := DigraphFromDigraph6String("&DHUEe_");
<immutable digraph with 5 vertices, 11 edges>
gap> DigraphVertexLabel(D, 3);
3
gap> D := Digraph(["a", "b", "c"], [], []);
<immutable empty digraph with 3 vertices>
gap> DigraphVertexLabel(D, 2);
"b"
gap> SetDigraphVertexLabel(D, 2, "d");
gap> DigraphVertexLabel(D, 2);
"d"
gap> D := InducedSubdigraph(D, [1, 2]);
<immutable empty digraph with 2 vertices>
gap> DigraphVertexLabel(D, 2);
"d"
gap> D := Digraph(IsMutableDigraph, ["e", "f", "g"], [], []);
<mutable empty digraph with 3 vertices>
gap> DigraphVertexLabel(D, 1);
"e"
gap> SetDigraphVertexLabel(D, 1, "h");
gap> DigraphVertexLabel(D, 1);
"h"
gap> InducedSubdigraph(D, [1, 2]);
<mutable empty digraph with 2 vertices>
gap> DigraphVertexLabel(D, 1);
"h"
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphVertexLabels">
<ManSection>
 <Oper Name="DigraphVertexLabels" Arg="digraph"/>
 <Oper Name="SetDigraphVertexLabels" Arg="digraph, list"/>
 <Description>
 If <A>digraph</A> is a digraph, then <C>DigraphVertexLabels</C> returns a
 copy of the labels of the vertices in <A>digraph</A>.
 <C>SetDigraphVertexLabels</C> can be used to set the labels of the vertices
 in <A>digraph</A> to the list of
 arbitrary &GAP; objects <A>list</A>, which must be of the same length
 as the number of vertices of <A>digraph</A>. 

 If the list <A>list</A> is immutable, then the vertex labels are set to a
 mutable copy of <A>list</A>. Otherwise, the labels are set to exactly
 <A>list</A>. 

 The label of a vertex can be changed an arbitrary number of times. If no
 label has been set for the vertex <A>i</A>, then the default value is
 <A>i</A>. 

 If <A>digraph</A> is a digraph created from a record with a component
 <C>DigraphVertices</C>, then the labels of the vertices are set to the
 value of this component. As in the above, if the component is immutable
 then the digraph's vertex labels are set to a mutable copy of
 <C>DigraphVertices</C>. Otherwise, they are set to exactly
 <C>DigraphVertices</C>. 

 Induced subdigraphs, and other operations which create new digraphs from
 old ones, inherit their labels from their parents.

 <Example><![CDATA[
gap> D := DigraphFromDigraph6String("&DHUEe_");
<immutable digraph with 5 vertices, 11 edges>
gap> DigraphVertexLabels(D);
[ 1 .. 5 ]
gap> D := Digraph(["a", "b", "c"], [], []);
<immutable empty digraph with 3 vertices>
gap> DigraphVertexLabels(D);
[ "a", "b", "c" ]
gap> SetDigraphVertexLabel(D, 2, "d");
gap> DigraphVertexLabels(D);
[ "a", "d", "c" ]
gap> D := InducedSubdigraph(D, [1, 3]);
<immutable empty digraph with 2 vertices>
gap> DigraphVertexLabels(D);
[ "a", "c" ]
gap> D := Digraph(IsMutableDigraph, ["e", "f", "g"], [], []);
<mutable empty digraph with 3 vertices>
gap> SetDigraphVertexLabels(D, ["h", "i", "j"]);
gap> DigraphVertexLabels(D);
[ "h", "i", "j" ]
gap> InducedSubdigraph(D, [1, 3]);
<mutable empty digraph with 2 vertices>
gap> DigraphVertexLabels(D);
[ "h", "j" ]
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphEdgeLabel">
<ManSection>
 <Oper Name = "DigraphEdgeLabel" Arg="digraph, i, j"/>
 <Oper Name = "SetDigraphEdgeLabel" Arg="digraph, i, j, obj"/>
 <Description>
 If <A>digraph</A> is a digraph without multiple edges, then the first
 operation returns the label of the edge from vertex <A>i</A> to vertex
 <A>j</A>. The second operation can be used to set the label of the edge
 between vertex <A>i</A> and vertex <A>j</A> to the arbitrary &GAP; object
 <A>obj</A>. 

 The label of an edge can be changed an arbitrary number of times. If no
 label has been set for the edge, then the default value is <A>1</A>. 

 Induced subdigraphs, and some other operations which create new digraphs from
 old ones, inherit their edge labels from their parents.

 See also <Ref Oper="DigraphEdgeLabels"/>.

 <Example><![CDATA[
gap> D := DigraphFromDigraph6String("&DHUEe_");
<immutable digraph with 5 vertices, 11 edges>
gap> DigraphEdgeLabel(D, 3, 1);
1
gap> SetDigraphEdgeLabel(D, 2, 5, [42]);
gap> DigraphEdgeLabel(D, 2, 5);
[ 42 ]
gap> D := InducedSubdigraph(D, [2, 5]);
<immutable digraph with 2 vertices, 3 edges>
gap> DigraphEdgeLabel(D, 1, 2);
[ 42 ]
gap> D := ChainDigraph(IsMutableDigraph, 5);
<mutable digraph with 5 vertices, 4 edges>
gap> DigraphEdgeLabel(D, 2, 3);
1
gap> SetDigraphEdgeLabel(D, 4, 5, [1729]);
gap> DigraphEdgeLabel(D, 4, 5);
[ 1729 ]
gap> InducedSubdigraph(D, [4, 5]);
<mutable digraph with 2 vertices, 1 edge>
gap> DigraphEdgeLabel(D, 1, 2);
[ 1729 ]
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphEdgeLabels">
<ManSection>
 <Oper Name="DigraphEdgeLabels" Arg="digraph"/>
 <Oper Name="SetDigraphEdgeLabels" Arg="digraph, labels"
 Label="for a digraph and a list of lists"/>
 <Oper Name="SetDigraphEdgeLabels" Arg="digraph, func"
 Label="for a digraph and a function"/>
 <Description>
 If <A>digraph</A> is a digraph without multiple edges, then
 <C>DigraphEdgeLabels</C> returns a copy of the labels of the edges
 in <A>digraph</A> as a list of lists <C>labels</C> such that
 <C>labels[i][j]</C> is the label on the edge from vertex <C>i</C>
 to vertex <C>OutNeighbours(digraph)[i][j]</C>.

 <C>SetDigraphEdgeLabels</C> can be used to set the labels of the edges in
 <A>digraph</A> without multiple edges to the list <A>labels</A> of lists of
 arbitrary &GAP; objects such that <C>list[i][j]</C> is the label on the edge
 from vertex <C>i</C> to the vertex <C>OutNeighbours(digraph>[i][j]</C>.

 Alternatively <C>SetDigraphEdgeLabels</C> can be called with binary function
 <A>func</A> that as its second argument that when passed two vertices <C>i</C>
 and <C>j</C> returns the label for the edge between vertex <C>i</C> and vertex
 <C>j</C>. 

 The label of an edge can be changed an arbitrary number of times. If no
 label has been set for an edge, then the default value is <C>1</C>. 

 Induced subdigraphs, and some other operations which create new digraphs
 from old ones, inherit their labels from their parents.

 <Example><![CDATA[
gap> D := DigraphFromDigraph6String("&DHUEe_");
<immutable digraph with 5 vertices, 11 edges>
gap> DigraphEdgeLabels(D);
[ [ 1 ], [ 1, 1, 1 ], [ 1 ], [ 1, 1, 1 ], [ 1, 1, 1 ] ]
gap> SetDigraphEdgeLabel(D, 2, 1, "d");
gap> DigraphEdgeLabels(D);
[ [ 1 ], [ "d", 1, 1 ], [ 1 ], [ 1, 1, 1 ], [ 1, 1, 1 ] ]
gap> D := InducedSubdigraph(D, [1, 2, 3]);
<immutable digraph with 3 vertices, 4 edges>
gap> DigraphEdgeLabels(D);
[ [ 1 ], [ "d", 1 ], [ 1 ] ]
gap> OutNeighbours(D);
[ [ 3 ], [ 1, 3 ], [ 1 ] ]
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 2, 3);
<mutable digraph with 5 vertices, 12 edges>
gap> DigraphEdgeLabels(D);
[ [ 1, 1, 1 ], [ 1, 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ] ]
gap> SetDigraphEdgeLabel(D, 2, 4, "a");
gap> DigraphEdgeLabels(D);
[ [ 1, 1, 1 ], [ 1, "a", 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ] ]
gap> InducedSubdigraph(D, [1, 2, 3, 4]);
<mutable digraph with 4 vertices, 8 edges>
gap> DigraphEdgeLabels(D);
[ [ 1, 1 ], [ 1, "a" ], [ 1, 1 ], [ 1, 1 ] ]
gap> OutNeighbors(D);
[ [ 3, 4 ], [ 3, 4 ], [ 1, 2 ], [ 1, 2 ] ]
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

quality98%

¤ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.