n_admissible_tree

phyllotaxis_analysis.n_admissible_tree

nAdmissibleTree

nAdmissibleTree()

Bases: PropertyTree

A class that adds some methods to PropertyTree to construct and explore an n-admissible tree.

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def __init__(self):
    self.maxLevel = -1
    PropertyTree.__init__(self)

addChild

addChild(parent, value, level, pbAngle=None, logPbAngle=None, questionMark=False, orderIndex=None)

Add child with properties to the tree.

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

    def addChild(self, parent, value, level, pbAngle = None, logPbAngle = None, questionMark = False, orderIndex = None):
        """
        Add child with properties to the tree.
        """
        for childId in self.children(parent):
            prop = self.get_vertex_property(childId)
            if ( prop["value"] == value) and  (prop["level"] == level) :
#                print "Already in the tree"
                return childId
                break
        else:
            if level > self.maxLevel:
                self.maxLevel = level
            return self.add_child(parent, value = value, level = level, nodePrb = pbAngle, nodeLogProb = logPbAngle, questionMark = questionMark, orderIndex = orderIndex)

addListValueLevelProb

addListValueLevelProb(currentId, ListValueLevel)

add vertexes given their ids and values to a vertex and updates the probability and order index of the vetex

:Parameters: - currentID - vertex id to which new vertexes should be added - ListValueLevel - list of values, levels, probabilities, log of probabilities, and order indexes of children

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def addListValueLevelProb(self, currentId, ListValueLevel):
    """
    add vertexes given their ids and values to a vertex and updates the probability and order index of the vetex

    :Parameters:
    -    currentID    -    vertex id to which new vertexes should be added 
    -    ListValueLevel    -    list of values, levels, probabilities, log of probabilities, and order indexes of children  
    """
    for node in ListValueLevel:            
        currentId = self.addChild(parent = currentId, value = node[0], level = node[1], pbAngle = node[2], logPbAngle = node[3], orderIndex = node[4])

add_child

add_child(parent, child=None, **properties)

Add a child at the end of children

:param parent: The parent identifier. :param child: The child identifier.

:returns: vertex id

Source code in src/phyllotaxis_analysis/tree/tree.py

def add_child(self, parent, child=None, **properties):
    '''
    Add a child at the end of children

    :param parent: The parent identifier.
    :param child: The child identifier.

    :returns: vertex id
    '''

    child = super(PropertyTree, self).add_child(parent, child)

    # Update the properties
    self._add_vertex_properties(child, properties)

    return child

add_child_tree

add_child_tree(parent, tree)

Add a tree after the children of the parent vertex. Complexity have to be O(1) if tree == sub_tree()

:param parent: vertex identifier :param tree: a rooted tree

Source code in src/phyllotaxis_analysis/tree/tree.py

def add_child_tree(self, parent, tree):
    """
    Add a tree after the children of the parent vertex.
    Complexity have to be O(1) if tree == sub_tree()

    :param parent: vertex identifier
    :param tree: a rooted tree
    """
    treeid_id = super(PropertyTree, self).add_child_tree(parent, tree)
    for tid, vid in treeid_id.items():
        for name in tree.properties():
            v = tree.property(name).get(tid)
            if v is not None:
                self._properties[name][vid] = v

    return treeid_id

add_property

add_property(property_name)

Add a new map between vid and a data Do not fill this property for any vertex

Source code in src/phyllotaxis_analysis/tree/tree.py

def add_property(self, property_name):
    """
    Add a new map between vid and a data
    Do not fill this property for any vertex
    """
    self._properties[property_name] = {}

add_vertex

add_vertex(vid=None)

Add a vertex to the graph.

:param vid: the id of the vertex to be added. :type vid: vid :returns: the vid of the added vertex :rtype: vid

Source code in src/phyllotaxis_analysis/tree/tree.py

def add_vertex(self, vid=None):
    """
    Add a vertex to the graph.

    :param vid: the id of the vertex to be added.
    :type vid: vid
    :returns: the vid of the added vertex
    :rtype: vid
    """
    if vid is None:
        vid = self._id + 1
        self._id = vid
    elif vid <= self._id:
        raise InvalidVertex(f'Vertex identifier already used: {vid}')
    else:
        self._id = vid

    self._parent[vid] = None
    return vid

allPathsAll

allPathsAll()

allPathsAll returns a list of values, probabilities , question marks, as well as the total logarithmic probability of all the vertexes on the paths from leaves to the root.

:Returns: - [valueList, probList ,questionList, logProb] - list of lists of values, probability , question marks, as well as the total logarithmic probability of all the vertexes on the paths from leaves to the root

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def allPathsAll(self):
    """
    `allPathsAll` returns a list of values, probabilities , question marks, as well as the total logarithmic probability of all the vertexes on the paths from leaves to the root.

    :Returns:
    -    `[valueList, probList ,questionList, logProb]`    -    list of lists of values, probability , question marks, as well as the total logarithmic probability of all the vertexes on the paths from leaves to the root
    """
    for vid in self.vertices():
        if self.is_leaf(vid):
            valueList = list()
            probList = list()
            questionList = list()
            logProb = 0.0
            while not (vid == self.root):
                valueList.append(self.get_vertex_property(vid)["value"])
                probList.append(self.get_vertex_property(vid)["nodePrb"])
                logProb += self.get_vertex_property(vid)["nodeLogProb"]
                if self.get_vertex_property(vid)["questionMark"]:
                    questionList.append([self.get_vertex_property(vid)["value"], self.get_vertex_property(vid)["level"] ])
                vid = self.parent(vid)
            valueList.reverse()
            probList.reverse()
            questionList.reverse()
            yield [valueList, probList ,questionList, logProb]

children

children(vid)

Return the children of vid.

:returns: list of vertex identifiers

Source code in src/phyllotaxis_analysis/tree/tree.py

def children(self, vid):
    """
    Return the children of `vid`.

    :returns: list of vertex identifiers
    """
    if vid not in self:
        raise InvalidVertex(vid)

    return list(self._children.get(vid, []))

clear

clear()

Remove all vertices and edges from the graph.

Source code in src/phyllotaxis_analysis/tree/tree.py

def clear(self):
    """
    Remove all vertices and edges from the graph.
    """
    self._children.clear()
    self._parent.clear()
    self._parent[self._root] = None

copy

copy()

Deep copy of the tree.

Source code in src/phyllotaxis_analysis/tree/tree.py

def copy(self):
    """ Deep copy of the tree.
    """
    return deepcopy(self)

edges_iter

edges_iter()

Iter on the edges of the tree.

Source code in src/phyllotaxis_analysis/tree/tree.py

def edges_iter(self):
    """
    Iter on the edges of the tree.
    """
    return ((parent, child) for child, parent in self._parent.items())

getMaxLevel

getMaxLevel()

get the maximum level of leaves.

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def getMaxLevel(self):
    """
    get the maximum level of leaves.
    """
    return self.maxLevel     

get_vertex_property

get_vertex_property(vid)

Returns all the properties defined on a vertex.

Source code in src/phyllotaxis_analysis/tree/tree.py

def get_vertex_property(self, vid):
    """ Returns all the properties defined on a vertex.
    """
    p = self.properties()
    return dict((name, p[name][vid]) for name in p if vid in p[name])

has_vertex

has_vertex(vid)

Determines whether a given vertex is in the graph.

Parameters:

Name	Type	Description	Default
vid	int or str	The identifier of the vertex to be checked for existence in the graph.	required

Returns:

Type	Description
bool	Returns True if the vertex is present in the graph, False otherwise.

Source code in src/phyllotaxis_analysis/tree/tree.py

def has_vertex(self, vid):
    """Determines whether a given vertex is in the graph.

    Parameters
    ----------
    vid : int or str
        The identifier of the vertex to be checked for existence in the graph.

    Returns
    -------
    bool
        Returns ``True`` if the vertex is present in the graph, ``False`` otherwise.
    """
    return vid in self._parent

insert_parent

insert_parent(vid, parent_id=None, **properties)

Insert parent_id between vid and its actual parent. Inherit of the complex of the parent of vid.

:Parameters: - vid: a vertex identifier - parent_id: a vertex identifier

Source code in src/phyllotaxis_analysis/tree/tree.py

def insert_parent(self, vid, parent_id=None, **properties):
    '''
    Insert parent_id between vid and its actual parent.
    Inherit of the complex of the parent of vid.

    :Parameters:
     - `vid`: a vertex identifier
     - `parent_id`: a vertex identifier
    '''

    parent_id = super(PropertyTree, self).insert_parent(vid, parent_id)
    self._add_vertex_properties(parent_id, properties)

    return parent_id

insert_sibling

insert_sibling(vid_1, vid_2=None, **properties)

Insert vid2 before vid1.

:Parameters: - vid1: a vertex identifier - vid2: the vertex to insert

Source code in src/phyllotaxis_analysis/tree/tree.py

def insert_sibling(self, vid_1, vid_2=None, **properties):
    '''
    Insert vid2 before vid1.

    :Parameters:
     - `vid1`: a vertex identifier
     - `vid2`: the vertex to insert
    '''

    vid_2 = super(PropertyTree, self).insert_sibling(vid_1, vid_2)

    # Update the properties
    self._add_vertex_properties(vid_2, properties)

    return vid_2

insert_sibling_tree

insert_sibling_tree(vid, tree)

Insert a tree before the vid. vid and the root of the tree are siblings. Complexity have to be O(1) if tree comes from the actual tree ( tree= self.sub_tree() )

:param vid: vertex identifier :param tree: a rooted tree

Source code in src/phyllotaxis_analysis/tree/tree.py

def insert_sibling_tree(self, vid, tree):
    """
    Insert a tree before the vid.
    vid and the root of the tree are siblings.
    Complexity have to be O(1) if tree comes from the actual tree
    ( tree= self.sub_tree() )

    :param vid: vertex identifier
    :param tree: a rooted tree
    """
    treeid_id = super(PropertyTree, self).insert_sibling_tree(vid, tree)
    for tid, vid in treeid_id.items():
        for name in tree.properties():
            v = tree.property(name).get(tid)
            if v is not None:
                self._properties[name][vid] = v

    return treeid_id

is_leaf

is_leaf(vid)

Test if vid is a leaf.

:returns: bool

Source code in src/phyllotaxis_analysis/tree/tree.py

def is_leaf(self, vid):
    """
    Test if `vid` is a leaf.

    :returns: bool
    """
    return self.nb_children(vid) == 0

is_valid

is_valid()

Checks if the object's state is valid.

Returns:

Type	Description
bool	True if the object is in a valid state, False otherwise.

Source code in src/phyllotaxis_analysis/tree/tree.py

def is_valid(self):
    """Checks if the object's state is valid.

    Returns
    -------
    bool
        ``True`` if the object is in a valid state, ``False`` otherwise.
    """
    # TODO
    return True

leaves

leaves()

return the list of leaves of the n-admisisble tree.

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def leaves(self):
    """
    return the list of leaves of the n-admisisble tree.
    """
    return [vid for vid in self.vertices() if self.is_leaf(vid)]

leavesLast

leavesLast(seqLen)

return the leaves of the tree whose level is equal to a given value.

:Parameters: - seqlen - an integer

:Returns: - list of leaves whose level is equal to seqLen

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def leavesLast(self, seqLen):
    """
    return the leaves of the tree whose level is equal to a given value.

    :Parameters:
    -    `seqlen`    -    an integer

    :Returns:
    -    list of leaves whose level is equal to `seqLen`
    """
    return [vid for vid in self.vertices() if (vid != self.root) and ( self.get_vertex_property(vid)["level"] == seqLen  ) ]

leavesNotLast

leavesNotLast(seqLen)

return the leaves of the tree whose level is different from a given value.

:Parameters: - seqlen - an integer

:Returns: - list of leaves whose level is not equal to seqLen

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def leavesNotLast(self, seqLen):
    """
    return the leaves of the tree whose level is different from a given value.

    :Parameters:
    -    `seqlen`    -    an integer

    :Returns:
    -    list of leaves whose level is not equal to `seqLen`
    """
    return [vid for vid in self.vertices() if (  self.is_leaf(vid)  and (self.get_vertex_property(vid)["level"] != seqLen  )) ]

nb_children

nb_children(vid)

Return the number of children of vid.

:returns: int

Source code in src/phyllotaxis_analysis/tree/tree.py

def nb_children(self, vid):
    """
    Return the number of children of `vid`.

    :returns: int
    """
    if vid not in self:
        raise InvalidVertex(vid)

    return len(self._children.get(vid, []))

nb_siblings

nb_siblings(vid)

Return the number of siblings of vid.

:returns: int

Source code in src/phyllotaxis_analysis/tree/tree.py

def nb_siblings(self, vid):
    """
    Return the number of siblings of `vid`.

    :returns: int
    """
    return len(self.siblings(vid))

nb_vertices

nb_vertices()

Returns the number of vertices in the graph.

Returns:

Type	Description
int	The number of vertices in the graph.

See Also

nb_edges : Returns the number of edges in the graph.

Examples:

>>> from phyllotaxis_analysis.tree import Tree
>>> g = Tree()  # initialize a new tree with a single node (the root)
>>> g.add_vertex()  # add a first vertices
>>> g.add_vertex()  # add a second vertices
>>> g.nb_vertices()
3

Source code in src/phyllotaxis_analysis/tree/tree.py

def nb_vertices(self):
    """Returns the number of vertices in the graph.

    Returns
    -------
    int
        The number of vertices in the graph.

    See Also
    --------
    nb_edges : Returns the number of edges in the graph.

    Examples
    --------
    >>> from phyllotaxis_analysis.tree import Tree
    >>> g = Tree()  # initialize a new tree with a single node (the root)
    >>> g.add_vertex()  # add a first vertices
    >>> g.add_vertex()  # add a second vertices
    >>> g.nb_vertices()
    3
    """
    return len(self._parent)

parent

parent(vid)

Return the parent of vid.

:returns: vertex identifier or None if vid is the root.

Source code in src/phyllotaxis_analysis/tree/tree.py

def parent(self, vid):
    """
    Return the parent of `vid`.

    :returns: vertex identifier or None if vid is the root.
    """
    try:
        return self._parent[vid]
    except KeyError:
        raise InvalidVertex(vid)

pathToRoot

pathToRoot(vid)

return list of values of vertexes on the path from a given vertex to the root.

:Parameters: - vid - a vertex id

:Returns: valueList - list of values of vertexes on the path from the vertex to the root.

Source code in src/phyllotaxis_analysis/n_admissible_tree.py

def pathToRoot(self, vid):
    """
    return list of values of vertexes on the path from a given vertex to the root.

    :Parameters:
    -   `vid`    -    a vertex id 

    :Returns:
    `valueList`    -    list of values of vertexes on the path from the `vertex` to the root.
    """

    valueList = list()
    while not (vid == self.root):
        valueList.append(self.get_vertex_property(vid)["value"]) 
        vid = self.parent(vid)
    valueList.reverse()
    return valueList

properties

properties()

Returns all the property maps contain in the graph.

Source code in src/phyllotaxis_analysis/tree/tree.py

def properties(self):
    """
    Returns all the property maps contain in the graph.
    """
    return self._properties

property

property(name)

Returns the property map between the vid and the data. :returns: dict of {vid:data}

Source code in src/phyllotaxis_analysis/tree/tree.py

def property(self, name):
    '''
    Returns the property map between the vid and the data.
    :returns:  dict of {vid:data}
    '''
    return self._properties.get(name, {})

property_names

property_names()

names of all property maps. Properties are defined only on vertices, even edge properties. return iter of names

Source code in src/phyllotaxis_analysis/tree/tree.py

def property_names(self):
    '''
    names of all property maps.
    Properties are defined only on vertices, even edge properties.
    return iter of names
    '''
    return self._properties.keys()

property_names_iter

property_names_iter()

iter on names of all property maps. Properties are defined only on vertices, even edge properties. return iter of names

Source code in src/phyllotaxis_analysis/tree/tree.py

def property_names_iter(self):
    '''
    iter on names of all property maps.
    Properties are defined only on vertices, even edge properties.
    return iter of names
    '''
    return iter(self._properties.keys())

remove_property

remove_property(property_name)

Remove the property map called property_name from the graph.

Source code in src/phyllotaxis_analysis/tree/tree.py

def remove_property(self, property_name):
    """
    Remove the property map called property_name from the graph.
    """
    del self._properties[property_name]

remove_tree

remove_tree(vid)

Remove the sub tree rooted on vid.

:returns: bool

Source code in src/phyllotaxis_analysis/tree/tree.py

def remove_tree(self, vid):
    """
    Remove the sub tree rooted on `vid`.

    :returns: bool
    """
    vids = super(PropertyTree, self).remove_tree(vid)
    for vid in vids:
        self._remove_vertex_properties(vid)
    return vids

remove_vertex

remove_vertex(vid, reparent_child=False)

remove a specified vertex of the graph remove all the edges attached to it

:param vid: the id of the vertex to remove :type vid: vid

Source code in src/phyllotaxis_analysis/tree/tree.py

def remove_vertex(self, vid, reparent_child=False):
    """
    remove a specified vertex of the graph
    remove all the edges attached to it

    :param vid: the id of the vertex to remove
    :type vid: vid
    """
    vid = super(PropertyTree, self).remove_vertex(vid, reparent_child=reparent_child)
    self._remove_vertex_properties(vid)

replace_parent

replace_parent(vid, new_parent_id)

Change the parent of vid to new_parent_id. vid parent is removed.

:param vid: vertex to change the parent of :param new_parent_id: new parent

Source code in src/phyllotaxis_analysis/tree/tree.py

def replace_parent(self, vid, new_parent_id):
    """
    Change the parent of `vid` to `new_parent_id`.
    vid parent is removed.

    :param vid: vertex to change the parent of
    :param new_parent_id: new parent
    """
    if vid not in self:
        raise InvalidVertex(vid)
    if new_parent_id not in self:
        raise InvalidVertex(new_parent_id)

    old_parent = self.parent(vid)
    if old_parent is None:
        raise InvalidVertex("Cannot replace parent of the root")

    # Update parent
    self._parent[vid] = new_parent_id

    # Update children
    self._children[old_parent].remove(vid)
    if new_parent_id in self._children:
        self._children[new_parent_id].append(vid)
    else:
        self._children[new_parent_id] = [vid]

set_root

set_root(vid)

Set the root of the tree.

Source code in src/phyllotaxis_analysis/tree/tree.py

def set_root(self, vid):
    """
    Set the root of the tree.
    """
    if vid not in self:
        self.add_vertex(vid)
    self._root = vid

siblings

siblings(vid)

Return the siblings of vid.

:returns: list of vertex identifiers

Source code in src/phyllotaxis_analysis/tree/tree.py

def siblings(self, vid):
    """
    Return the siblings of `vid`.

    :returns: list of vertex identifiers
    """
    if vid not in self:
        raise InvalidVertex(vid)

    parent = self.parent(vid)
    if parent is None:
        return []
    else:
        sibs = list(self.children(parent))
        sibs.remove(vid)
        return sibs

sub_tree

sub_tree(vid, copy=True)

Return the subtree rooted on vid.

The induced subtree of the tree has the vertices in the ancestors of vid.

:Parameters: - vid: A vertex of the original tree. - copy:
If True, return a new tree holding the subtree. If False, the subtree is created using the original tree by deleting all vertices not in the subtree.

:returns: A sub tree of the tree. If copy=True, a new Tree is returned. Else the subtree is created inplace by modifying the original tree.

Source code in src/phyllotaxis_analysis/tree/tree.py

def sub_tree(self, vid, copy=True):
    """Return the subtree rooted on `vid`.

    The induced subtree of the tree has the vertices in the ancestors of vid.

    :Parameters:
      - `vid`: A vertex of the original tree.
      - `copy`:  
        If True, return a new tree holding the subtree. If False, the subtree is
        created using the original tree by deleting all vertices not in the subtree.

    :returns: A sub tree of the tree. If copy=True, a new Tree is returned. 
        Else the subtree is created inplace by modifying the original tree. 
    """
    from phyllotaxis_analysis.tree import pre_order
    if not copy:
        # remove all vertices not in the sub_tree
        bunch = set(pre_order(self, vid))
        remove_bunch = set(self) - bunch

        for vid in remove_bunch:
            self._remove_vertex_properties(vid)

            # remove parent edge
            pid = self.parent(vid)
            if pid is not None:
                self._children[pid].remove(vid)
                del self._parent[vid]
            # remove children edges
            for cid in self.children(vid):
                self._parent[cid] = None
            if vid in self._children:
                del self._children[vid]

        self.root = vid
        return self
    else:
        treeid_id = {}
        tree = self.__class__()
        tree.root = 0

        for name in self.properties():
            tree.add_property(name)

        treeid_id[vid] = tree.root
        tree._add_vertex_properties(tree.root, self.get_vertex_property(vid))
        subtree = pre_order(self, vid)
        next(subtree)
        for vid in subtree:
            pid = self.parent(vid)
            if pid is not None:
                parent = treeid_id[pid]
                v = tree.add_child(parent)
                treeid_id[vid] = v

            tree._add_vertex_properties(v, self.get_vertex_property(vid))

        return tree

vertices

vertices()

Returns the list of vertices in the graph.

Returns:

Type	Description
list	A list of the vertices in the graph.

Source code in src/phyllotaxis_analysis/tree/tree.py

def vertices(self):
    """Returns the list of vertices in the graph.

    Returns
    -------
    list
        A list of the vertices in the graph.
    """
    return list(self.vertices_iter())

vertices_iter

vertices_iter()

Generates an iterator for the vertices in the graph.

This method is a generator that yields each vertex in the graph as a string, which corresponds to the key of the vertex in the internal dictionary representation of the graph. The order in which vertices are returned by this iterator is not guaranteed to be consistent between different calls or even different yields.

Returns:

Type	Description
iterator	An iterator that produces the vertices of the graph as strings.

Source code in src/phyllotaxis_analysis/tree/tree.py

def vertices_iter(self):
    """Generates an iterator for the vertices in the graph.

    This method is a generator that yields each vertex in the graph as a string,
    which corresponds to the key of the vertex in the internal dictionary representation
    of the graph. The order in which vertices are returned by this iterator is not
    guaranteed to be consistent between different calls or even different yields.

    Returns
    -------
    iterator
        An iterator that produces the vertices of the graph as strings.
    """
    return iter(self._parent.keys())