phylogician-ts/lib/Tree.d.ts

Module to read, manipulate and write phylogenetic trees. Written in TypeScript

import { LogLevelDescType } from 'loglevel-colored-prefix';
import * as newick from 'newick-reader';
import { TreeNode } from './TreeNode';
export declare class Tree {
    nodes: TreeNode[];
    protected numberOfNodes: number;
    private logger;
    private logLevel;
    constructor(loglevel?: LogLevelDescType);
    /**
     * Builds a Tree from newick string
     *
     * @param {string} data
     * @memberof Tree
     */
    buildTree(data: string): this;
    /**
     * Returns the maximum hops to child leafs to all nodes.
     *
     * @returns {number[]}
     * @memberof Tree
     */
    getAllMaxHopsToChildLeafs(): number[];
    /**
     * Returns the sum of branch lengths from the node to the root
     *
     * @param {number} nodeId
     * @returns {number}
     * @memberof Tree
     */
    getDistanceToRoot(nodeId: number): number;
    /**
     * Returns the number of hops from node to root
     *
     * @param {number} nodeId
     * @returns {number}
     * @memberof Tree
     */
    getHopsToRoot(nodeId: number): number;
    /**
     * Returns the path of internal nodes to root
     *
     * @param {number} nodeId
     * @returns {number}
     * @memberof Tree
     */
    getPathToRoot(nodeId: number): number[];
    /**
     * Returns the maximum distance to the root.
     *
     * @returns {number}
     * @memberof Tree
     */
    getMaxDistanceToRoot(): number;
    /**
     * Returns maximum number of node hops to the root.
     *
     * @returns {number}
     * @memberof Tree
     */
    getMaxHopsToRoot(): number;
    /**
     * Return the common ancestor node between two nodes and the number of hops from the node passed in the first argument
     *
     * @param {number} node1
     * @param {number} node2
     * @returns {{ancestor: number, hops: number}}
     * @memberof Tree
     */
    getCommonAncestor(node1: number, node2: number): {
        ancestor: number;
        hops: number;
    };
    /**
     * Return information about the common ancestor between the node passed in the argument and all leafs
     *
     * @param {number} node
     * @returns {Array<{ ancestor: number; hops: number; nodeId: number }>}
     * @memberof Tree
     */
    getCommonAncestorWithEachLeaf(node: number, subtreeNodeId: number): Array<{
        ancestor: number;
        hops: number;
        nodeId: number;
    }>;
    /**
     * Get TreeNode with the given id
     *
     * @param {number} id
     * @returns {TreeNode}
     * @memberof Tree
     */
    getNode(id: number): TreeNode;
    /**
     * Find node by exact name
     *
     * @param {string} name
     * @returns {TreeNode[]}
     * @memberof Tree
     */
    findNodeByExactName(name: string): TreeNode[];
    /**
     * Find nodes that match a Regular Expression
     *
     * @param {RegExp} regex
     * @returns {TreeNode[]}
     * @memberof Tree
     */
    findNodeByMatch(regex: RegExp): TreeNode[];
    /**
     * Returns how many leafs the tree has.
     *
     * @returns {number}
     * @memberof Tree
     */
    getNumberOfLeafs(): number;
    /**
     * Return root node
     *
     * @private
     * @returns {TreeNode}
     * @memberof Tree
     */
    getRootNode(): TreeNode | null;
    /**
     * Return array of node ids of internal nodes
     *
     * @returns {number[]}
     * @memberof Tree
     */
    getInternalIds(): number[];
    /**
     * Sets the node with Id passed as root. Avoids setting 2 root nodes.
     * This DOES NOT re-root the tree, yet.
     *
     * @param {number} id
     * @returns {this}
     * @memberof Tree
     */
    setAsRoot(id: number): this;
    /**
     * Return ids of all child nodes.
     *
     * @param {number} id
     * @returns {number[]}
     * @memberof Tree
     */
    getChildrenIds(id: number): number[];
    /**
     * Return the ids of leafs of the node passed as argument
     *
     * @param {number} id
     * @returns {number[]}
     * @memberof Tree
     */
    getLeafsIds(id: number): number[];
    getAllLeafIds(): number[];
    /**
     * Ladderizes the subtree from the node passed in argument
     *
     * @param {number} id
     * @returns {this}
     * @memberof Tree
     */
    ladderize(id: number): this;
    /**
     * Returns a newick of the subtree from parentId. If nothing is passed, it will return the entire tree.
     *
     * @param {number} [parentId=-1]
     * @returns {string}
     * @memberof Tree
     */
    writeNewick(parentId?: number): string;
    /**
     * Selects a balanced sample of N leafs in the subtree of the nodeId node.
     *
     * @param {number[]} [picked=[]]
     * @param {number} nodeId
     * @param {number} N
     * @returns {number[]}
     * @memberof Tree
     */
    selectBalancedLeafs(picked: number[] | undefined, nodeId: number, N: number): number[];
    selectBalancedSample(picked: number[] | undefined, baseNodeId: number, N: number, add?: boolean, seed?: string): number[];
    selectBalancedSampleMixed(picked: number[] | undefined, baseNodeId: number, N: number, add?: boolean, seed?: string): number[];
    /**
     * Return a subTree as a Tree object
     * It rework the indexes of nodes and parents.
     *
     * @param {number} nodeId
     * @returns
     * @memberof Tree
     */
    getSubTree(nodeId: number): Tree;
    /**
     * Return a list of nodes under a internal node.
     *
     * @param {number} nodeId
     * @returns
     * @memberof Tree
     */
    getListOfNodesInSubTree(nodeId: number): TreeNode[];
    /**
     * Set the color of branches of child nodes.
     *
     * @param {number} id
     * @param {string} color
     * @returns {this}
     * @memberof Tree
     */
    setChildrenBranchColor(id: number, color: string): this;
    /**
     * Order nodes for ladderization
     *
     * @protected
     * @param {number} id
     * @returns {number[]}
     * @memberof Tree
     */
    protected lad(id: number): number[];
    /**
     * Writes a newick.ITree object from a parent node.
     *
     * @private
     * @param {number} [parentId=-1]
     * @returns {newick.ITree}
     * @memberof Tree
     */
    protected writeITreeObj(parentId?: number): newick.ITree;
    /**
     * Builds the this.nodes array by scanning the treeObject
     *
     * @private
     * @param {newick.ITree} treeObject
     * @returns {TreeNode}
     * @memberof Tree
     */
    private makeTree;
    /**
     * Set default policy to show only labels of leafs
     *
     * @private
     * @returns
     * @memberof Tree
     */
    private setDefaultLabelDisplay;
}