Regina Calculation Engine
|
Represents a 2-tangle in the 3-ball. More...
#include <link/tangle.h>
Public Member Functions | |
Tangle & | operator= (const Tangle &)=delete |
std::string | str () const |
Returns a short text representation of this object. More... | |
std::string | utf8 () const |
Returns a short text representation of this object using unicode characters. More... | |
std::string | detail () const |
Returns a detailed text representation of this object. More... | |
Constructors and Destructors | |
Tangle () | |
Constructs the zero tangle. More... | |
Tangle (int twists) | |
Constructs a tangle from the given number of twists. More... | |
Tangle (int num, int den) | |
Constructs a rational tangle with the given parameters. More... | |
Tangle (const Link &knot) | |
Creates a tangle from two parallel copies of the given knot. More... | |
Tangle (const Tangle ©) | |
Constructs a new copy of the given tangle. More... | |
~Tangle () | |
Destroys this tangle. More... | |
Crossings and Strings | |
char | type () const |
Returns the type of this tangle. More... | |
size_t | size () const |
Returns the number of crossings in this tangle. More... | |
Crossing * | crossing (size_t index) const |
Returns a pointer to the crossing at the given index within this tangle. More... | |
StrandRef | begin (int string) const |
Returns the crossing closest to the beginning of the given string. More... | |
StrandRef | end (int string) const |
Returns the crossing closest to the end of the given string. More... | |
StrandRef | translate (const StrandRef &other) const |
Translates a strand reference for some other tangle into the corresponding strand reference for this tangle. More... | |
Editing | |
void | swapContents (Tangle &other) |
Swaps the contents of this and the given tangle. More... | |
void | twist (int sign=1) |
Adds a twist to the right-hand end of this tangle. More... | |
void | turn (int direction=1) |
Rotates this tangle by 90 degrees. More... | |
void | changeAll () |
Switches the upper and lower strands of every crossing in the tangle. More... | |
bool | r1 (Crossing *crossing, bool check=true, bool perform=true) |
Tests for and/or performs a type I Reidemeister move to remove a crossing. More... | |
bool | r2 (StrandRef arc, bool check=true, bool perform=true) |
Tests for and/or performs a type II Reidemeister move to remove two crossings. More... | |
bool | r2 (Crossing *crossing, bool check=true, bool perform=true) |
Tests for and/or performs a type II Reidemeister move to remove two crossings. More... | |
bool | simplifyToLocalMinimum (bool perform=true) |
Uses type I and II Reidemeister moves to reduce the tangle monotonically to some local minimum number of crossings. More... | |
Algebra on Tangles | |
void | add (const Tangle &other) |
Adds the given tangle to the right-hand side of this tangle. More... | |
void | negate () |
Reflects this tangle through the diagonal axis running from the top-left to bottom-right corners of the diagram. More... | |
void | box (const Tangle &topLeft, const Tangle &topRight, const Tangle &bottomLeft, const Tangle &bottomRight) |
Encloses this tangle with the four given tangles in a box configuration. More... | |
Link * | numClosure () const |
Forms the numerator closure of this tangle. More... | |
Link * | denClosure () const |
Forms the denominator closure of this tangle. More... | |
Output | |
void | writeTextShort (std::ostream &out) const |
Writes a short text representation of this tangle to the given output stream. More... | |
void | writeTextLong (std::ostream &out) const |
Writes a detailed text representation of this tangle to the given output stream. More... | |
Exporting Tangles | |
std::string | orientedGauss () const |
Outputs an oriented Gauss code for this tangle. More... | |
void | orientedGauss (std::ostream &out) const |
Writes an oriented Gauss code for this tangle to the given output stream. More... | |
Static Public Member Functions | |
Building Tangles | |
static Tangle * | fromOrientedGauss (const std::string &str) |
Creates a new tangle from an oriented Gauss code. More... | |
template<typename Iterator > | |
static Tangle * | fromOrientedGauss (Iterator begin, Iterator end) |
Creates a new tangle from an oriented Gauss code. More... | |
Represents a 2-tangle in the 3-ball.
Regina does not allow closed components in a tangle; in other words, a tangle in Regina is a proper embedding of exactly two arcs in the 3-ball with the corresponding four endpoints attached to four marked points on the 3-ball boundary.
Regina stores tangles as projections, with the four endpoints fixed at the top-left, top-right, bottom-left and bottom-right corners of the diagram.
Each tangles has a type, indicating how the four endpoints are connected. The three possible types are:
Internally, Regina numbers the two strings 0 and 1: string 0 will always be the one attached to the top-left endpoint. Regina also assigns each string an orientation: for a horizontal or diagonal tangle this will always be from left to right, and for a vertical tangle this will always be from top to bottom.
When traversing a tangle, if you reach one of the endpoints of a string then the corresponding return value of Crossing::next() or Crossing::prev() (whichever is relevant) will be a null strand reference.
|
inline |
Constructs the zero tangle.
This is the horizontal tangle with no crossings.
regina::Tangle::Tangle | ( | int | twists | ) |
Constructs a tangle from the given number of twists.
If twists is positive, then the new tangle will consist of twists positive twists, stacked from left to right. If twists is negative, then the new tangle will consist of -(twists) negative twists, likewise stacked from left to right. If twists is zero, then the new tangle will be a horizontal tangle with no crossings at all.
In all cases, this is equivalent to calling the rational tangle constructor Tangle(twists, 1).
twists | the number of twists to perform; this may be positive, negative or zero. |
regina::Tangle::Tangle | ( | int | num, |
int | den | ||
) |
Constructs a rational tangle with the given parameters.
Here we use the following convention (following the description that Adams gives in The Knot Book):
num | the numerator of the rational number that describes this tangle. |
den | the denominator of the rational number that describes this tangle; this may be 0 (representing the infinity tangle). |
regina::Tangle::Tangle | ( | const Link & | knot | ) |
Creates a tangle from two parallel copies of the given knot.
Specifically, the tangle will consist of two parallel copies of the given knot diagram, which will be broken just before the starting strand as returned by knot.component(0)
.
The two resulting endpoints that appear just before the starting strand will form the top-left and bottom-left endpoints of this tangle, and the endpoints on the other side of the break (which will be just after the parallel copies of the final strand knot.component(0).prev()
) will form the top-right and bottom-right endpoints of this tangle.
The tangle will contain 4 * knot.size()
crossings in total.
knot | the knot to break and duplicate to form this tangle. |
regina::Tangle::Tangle | ( | const Tangle & | copy | ) |
Constructs a new copy of the given tangle.
copy | the tangle to copy. |
|
inline |
Destroys this tangle.
The Crossing objects contained in this tangle will also be destroyed.
void regina::Tangle::add | ( | const Tangle & | other | ) |
Adds the given tangle to the right-hand side of this tangle.
In Conway's notation, if this tangle is t, then this routine converts this into (t + other).
Specifically: this routine will attach the two right-hand endpoints of this tangle to the two left-hand endpoints of a copy of other.
This tangle will be changed directly. The tangle other (passed as the argumet) will be left unchanged.
It is allowed to pass this tangle as other.
other | the tangle to add to this. |
|
inline |
Returns the crossing closest to the beginning of the given string.
Recall from the class notes that string 0 is always attached to the top-left endpoint. Recall also that strings are oriented from left-to-right for a horizontal or diagonal tangle, and from top-to-bottom for a vertical tangle.
string | indicates which of the two strings in this tangle to query; this must be either 0 or 1. |
void regina::Tangle::box | ( | const Tangle & | topLeft, |
const Tangle & | topRight, | ||
const Tangle & | bottomLeft, | ||
const Tangle & | bottomRight | ||
) |
Encloses this tangle with the four given tangles in a box configuration.
The five tangles will be connected as shown, with this tangle in the centre:
\ / O---O / \ / \ | O | \ / \ / O---O / \
The top-left corner of the argument topLeft will become the top-left corner of the resulting tangle, and so on for the other three corners.
This tangle will be changed directly. The other four other tangles (passed as arguments) will be left unchanged.
You may use the same tangle for multiple arguments, and you may even use this tangle for one or more arguments.
topLeft | the tangle to connect to the top-left corner of this. |
topRight | the tangle to connect to the top-right corner of this. |
bottomLeft | the tangle to connect to the bottom-left corner of this. |
bottomRight | the tangle to connect to the bottom-right corner of this. |
void regina::Tangle::changeAll | ( | ) |
Switches the upper and lower strands of every crossing in the tangle.
This operation corresponds to reflecting the tangle through the plane on which the diagram is drawn.
|
inline |
Returns a pointer to the crossing at the given index within this tangle.
For a tangle with n crossings, the crossings are numbered from 0 to n-1 inclusive.
index | the index of the requested crossing. This must be between 0 and size()-1 inclusive. |
Link* regina::Tangle::denClosure | ( | ) | const |
Forms the denominator closure of this tangle.
This is the link created by joining the two left endpoints of this tangle, and also joining the two right endpoints.
|
inherited |
Returns a detailed text representation of this object.
This text may span many lines, and should provide the user with all the information they could want. It should be human-readable, should not contain extremely long lines (which cause problems for users reading the output in a terminal), and should end with a final newline. There are no restrictions on the underlying character set.
|
inline |
Returns the crossing closest to the end of the given string.
Recall from the class notes that string 0 is always attached to the top-left endpoint. Recall also that strings are oriented from left-to-right for a horizontal or diagonal tangle, and from top-to-bottom for a vertical tangle.
string | indicates which of the two strings in this tangle to query; this must be either 0 or 1. |
|
static |
Creates a new tangle from an oriented Gauss code.
Oriented Gauss codes for tangles are an extension of oriented Gauss codes for knots. Whilst oriented Gauss codes for knots are used elsewhere (they are based on a format used by Andreeva et al.), these codes for tangles are specific to Regina (so you should not expect other software to understand them).
The format works as follows:
-
,
| or x
to represent a horizontal, vertical or diagonal tangle respectively.+<k
, -<k
, +>k
or ->k
, where:+
indicates that you are passing over the crossing labelled k, and the symbol -
indicates that you are passing under the crossing labelled k;<
indicates that the other strand of the crossing passes from right to left, and >
indicates that the other strand passes from left to right._
to indicate that the first string has finished.+<k
, -<k
, +>k
or ->k
at every crossing that you pass.Be aware that, once the tangle has been constructed, the crossings 1, ..., n will have been reindexed as 0, ..., n-1 (since every Tangle object numbers its crossings starting from 0).
As an example, you can construct the rational tangle -3/4 using the following code:
| -<1 +>2 -<3 +>4 _ -<5 -<4 +>3 -<2 +>1 +>5
There are two variants of this routine. This variant takes a single string, where the tokens have been combined together and separated by whitespace. The other variant takes a sequence of tokens, defined by a pair of iterators.
In this variant (the string variant), the given string may contain additional leading or trailing whitespace.
str | an oriented Gauss code for a tangle, as described above. |
null
if the input was found to be invalid.
|
static |
Creates a new tangle from an oriented Gauss code.
Oriented Gauss codes for tangles are an extension of oriented Gauss codes for knots. Whilst oriented Gauss codes for knots are used elsewhere (they are based on a format used by Andreeva et al.), these codes for tangles are specific to Regina (so you should not expect other software to understand them).
See fromOrientedGauss(const std::string&) for a detailed description of this format as it is used in Regina.
There are two variants of this routine. The other variant (fromOrientedGauss(const std::string&), which offers more detailed documentation) takes a single string, where the tokens have been combined together and separated by whitespace. This variant takes a sequence of tokens, defined by a pair of iterators.
const char*
) or a C++-style string (which can be cast to const std::string&
).begin | an iterator that points to the beginning of the sequence of tokens for an oriented Gauss code. |
end | an iterator that points past the end of the sequence of tokens for an oriented Gauss code. |
null
if the input was found to be invalid. void regina::Tangle::negate | ( | ) |
Reflects this tangle through the diagonal axis running from the top-left to bottom-right corners of the diagram.
In Conway's notation, this negates the tangle.
Link* regina::Tangle::numClosure | ( | ) | const |
Forms the numerator closure of this tangle.
This is the link created by joining the two top endpoints of this tangle, and also joining the two bottom endpoints.
std::string regina::Tangle::orientedGauss | ( | ) | const |
Outputs an oriented Gauss code for this tangle.
Oriented Gauss codes for tangles are an extension of oriented Gauss codes for knots. Whilst oriented Gauss codes for knots are used elsewhere (they are based on a format used by Andreeva et al.), these codes for tangles are specific to Regina (so you should not expect other software to understand them).
For a full explanation of how oriented Gauss codes work for tangles, see the documentation for fromOrientedGauss(const std::string&), which imports tangles in this format.
The string that is returned will not contain any newlines.
void regina::Tangle::orientedGauss | ( | std::ostream & | out | ) | const |
Writes an oriented Gauss code for this tangle to the given output stream.
Oriented Gauss codes for tangles are an extension of oriented Gauss codes for knots. Whilst oriented Gauss codes for knots are used elsewhere (they are based on a format used by Andreeva et al.), these codes for tangles are specific to Regina (so you should not expect other software to understand them).
For a full explanation of how oriented Gauss codes work for tangles, see the documentation for fromOrientedGauss(const std::string&), which imports tangles in this format.
The output will not contain any newlines.
out | the output stream to which to write. |
bool regina::Tangle::r1 | ( | Crossing * | crossing, |
bool | check = true , |
||
bool | perform = true |
||
) |
Tests for and/or performs a type I Reidemeister move to remove a crossing.
Unlike links, which implement the full suite of Reidemeister moves, tangles (at present) only offer the simplifying versions of Reidemeister moves I and II.
The behaviour of this routine is identical to the r1() routine in the Link class; see Link::r1() for further details.
true
but check is false
, then it must be known in advance that this move can be performed at the given location. crossing | identifies the crossing to be removed. |
check | true if we are to check whether the move can be performed at the given location. |
perform | true if we should actually perform the move. |
true
, this function returns true
if and only if the move can be performed. If check is false
, this function always returns true
. bool regina::Tangle::r2 | ( | StrandRef | arc, |
bool | check = true , |
||
bool | perform = true |
||
) |
Tests for and/or performs a type II Reidemeister move to remove two crossings.
Unlike links, which implement the full suite of Reidemeister moves, tangles (at present) only offer the simplifying versions of Reidemeister moves I and II.
The behaviour of this routine is identical to the r2() routine in the Link class; see Link::r2() for further details.
true
but check is false
, then it must be known in advance that this move can be performed at the given location. arc | identifies one of the arcs of the bigon about which the move will be performed. |
check | true if we are to check whether the move is legal. |
perform | true if we should actually perform the move. |
true
, this function returns true
if and only if the requested move is legal. If check is false
, this function always returns true
.
|
inline |
Tests for and/or performs a type II Reidemeister move to remove two crossings.
Unlike links, which implement the full suite of Reidemeister moves, tangles (at present) only offer the simplifying versions of Reidemeister moves I and II.
The behaviour of this routine is identical to the r2() routine in the Link class; see Link::r2() for further details.
true
but check is false
, then it must be known in advance that this move can be performed at the given location. crossing | identifies the crossing at the beginning of the "upper" arc that features in this move. |
check | true if we are to check whether the move is legal. |
perform | true if we should actually perform the move. |
true
, this function returns true
if and only if the requested move is legal. If check is false
, this function always returns true
. bool regina::Tangle::simplifyToLocalMinimum | ( | bool | perform = true | ) |
Uses type I and II Reidemeister moves to reduce the tangle monotonically to some local minimum number of crossings.
Type III Reidemeister moves (which do not reduce the number of crossings) are not used in this routine.
Unlike links, tangle do not (at present) offer stronger simplification routines (such as the much better Link::intelligentSimplify() and Link::simplifyExhaustive()).
perform | true if we are to perform the simplifications, or false if we are only to investigate whether simplifications are possible (defaults to true ). |
true
, this routine returns true
if and only if the link was changed to reduce the number of crossings; if perform is false
, this routine returns true
if and only if it determines that it is capable of performing such a change.
|
inline |
Returns the number of crossings in this tangle.
|
inherited |
Returns a short text representation of this object.
This text should be human-readable, should fit on a single line, and should not end with a newline. Where possible, it should use plain ASCII characters.
__str__()
.void regina::Tangle::swapContents | ( | Tangle & | other | ) |
Swaps the contents of this and the given tangle.
All crossings that belong to this link will be moved to other, and all crossings that belong to other will be moved to this link. Likewise, all cached properties (e.g., tree decompositions) will be swapped.
In particular, any Crossing pointers or references and any StrandRef objects will remain valid.
This routine will behave correctly if other is in fact this link.
other | the link whose contents should be swapped with this. |
Translates a strand reference for some other tangle into the corresponding strand reference for this tangle.
Specifically: if other refers to some strand (upper or lower) of crossing number k of some other tangle, then the return value will refer to the same strand (upper or lower) of crossing number k of this tangle.
This routine behaves correctly even if other is a null reference.
other | the strand reference to translate. |
void regina::Tangle::turn | ( | int | direction = 1 | ) |
Rotates this tangle by 90 degrees.
direction | either 1 if the tangle should be rotated clockwise, or -1 if the tangle should be rotated anticlockwise. |
void regina::Tangle::twist | ( | int | sign = 1 | ) |
Adds a twist to the right-hand end of this tangle.
sign | either 1 if we should perform a positive twist (dragging the bottom-right endpoint up over the top-right endpoint), or -1 if we should perform a negative twist (dragging the bottom-right endpoint up beneath the top-right endpoint). |
|
inline |
Returns the type of this tangle.
This will be one of the characters -
, | or
x
, indicating a horizontal, vertical or diagonal type as described in the class notes.
|
inherited |
Returns a short text representation of this object using unicode characters.
Like str(), this text should be human-readable, should fit on a single line, and should not end with a newline. In addition, it may use unicode characters to make the output more pleasant to read. This string will be encoded in UTF-8.
void regina::Tangle::writeTextLong | ( | std::ostream & | out | ) | const |
Writes a detailed text representation of this tangle to the given output stream.
out | the output stream to which to write. |
void regina::Tangle::writeTextShort | ( | std::ostream & | out | ) | const |
Writes a short text representation of this tangle to the given output stream.
out | the output stream to which to write. |