rdkit.Chem.Pharm2D.Utils

Package rdkit :: Package Chem :: Package Pharm2D :: Module Utils |
[hide private]
[frames] | no frames]

# Module Utils

source code

    utility functionality for the 2D pharmacophores code

    See Docs/Chem/Pharm2D.triangles.jpg for an illustration of the way
    pharmacophores are broken into triangles and labelled.

    See Docs/Chem/Pharm2D.signatures.jpg for an illustration of bit
    numbering

Functions | [hide private]
GetTriangles(nPts) returns a tuple with the distance indices for... | source code
_fact(x) | source code
BinsTriangleInequality(d1, d2, d3) checks the triangle inequality for combinations of distance bins. | source code
ScaffoldPasses(combo, bins=None) checks the scaffold passed in to see if all contributing triangles can satisfy the triangle inequality | source code
NumCombinations(nItems, nSlots) returns the number of ways to fit nItems into nSlots | source code
CountUpTo(nItems, nSlots, vs, idx=0, startAt=0) Figures out where a given combination of indices would occur in the combinatorial explosion generated by _GetIndexCombinations_ | source code
GetIndexCombinations(nItems, nSlots, slot=0, lastItemVal=0) Generates all combinations of nItems in nSlots without including duplicates | source code
GetAllCombinations(choices, noDups=1, which=0) Does the combinatorial explosion of the possible combinations of the elements of _choices_. | source code
GetUniqueCombinations(choices, classes, which=0) Does the combinatorial explosion of the possible combinations of the elements of _choices_. | source code
UniquifyCombinations(combos) uniquifies the combinations in the argument | source code
GetPossibleScaffolds(nPts, bins, useTriangleInequality=True) gets all realizable scaffolds (passing the triangle inequality) with the... | source code
OrderTriangle(featIndices, dists) put the distances for a triangle into canonical order | source code
_test() | source code

Variables | [hide private]
| nPointDistDict = ``{`2`:` `(``(`0`,` 1`)``)``,` 3`:` `(``(`0`,` 1`)``,` `(`0`,` 2`)``,` `(`1`,` 2`)``)``,` 4`:``...``
| nDistPointDict = ``{`1`:` 2`,` 3`:` 3`,` 5`:` 4`,` 7`:` 5`,` 9`:` 6`,` 11`:` 7`,` 13`:` 8`,` `...``
| _trianglesInPharmacophore = ``{`3`:` `(``(`0`,` 1`,` 2`)``)``}``
| _numCombDict = ``{``(`8`,` 2`)``:` 36`,` `(`8`,` 3`)``:` 120`}``
| _verbose = `0`
| _countCache = ``{``}``
| _indexCombinations = ``{``}``
| __package__ = ``'``rdkit.Chem.Pharm2D``'``

Imports: numpy

Function Details | [hide private]

### GetTriangles(nPts) | source code
    returns a tuple with the distance indices for
    triangles composing an nPts-pharmacophore

### BinsTriangleInequality(d1, d2, d3) | source code
    checks the triangle inequality for combinations
    of distance bins.

    the general triangle inequality is:
       d1 + d2 >= d3
    the conservative binned form of this is:
       d1(upper) + d2(upper) >= d3(lower)

### ScaffoldPasses(combo, bins=None) | source code
    checks the scaffold passed in to see if all
    contributing triangles can satisfy the triangle inequality

    the scaffold itself (encoded in combo) is a list of binned distances

### NumCombinations(nItems, nSlots) | source code
    returns the number of ways to fit nItems into nSlots

    We assume that (x,y) and (y,x) are equivalent, and
    (x,x) is allowed.

    General formula is, for N items and S slots:
      res = (N+S-1)! / ( (N-1)! * S! )

### CountUpTo(nItems, nSlots, vs, idx=0, startAt=0) | source code
    Figures out where a given combination of indices would
     occur in the combinatorial explosion generated by _GetIndexCombinations_

     **Arguments**

       - nItems: the number of items to distribute

       - nSlots: the number of slots in which to distribute them

       - vs: a sequence containing the values to find

       - idx: used in the recursion

       - startAt: used in the recursion

    **Returns**

       an integer

### GetIndexCombinations(nItems, nSlots, slot=0, lastItemVal=0) | source code
    Generates all combinations of nItems in nSlots without including
      duplicates

    **Arguments**

      - nItems: the number of items to distribute

      - nSlots: the number of slots in which to distribute them

      - slot: used in recursion

      - lastItemVal: used in recursion

    **Returns**

      a list of lists

### GetAllCombinations(choices, noDups=1, which=0) | source code
    Does the combinatorial explosion of the possible combinations
    of the elements of _choices_.

    **Arguments**

      - choices: sequence of sequences with the elements to be enumerated

      - noDups: (optional) if this is nonzero, results with duplicates,
        e.g. (1,1,0), will not be generated

      - which: used in recursion

    **Returns**

      a list of lists

    >>> GetAllCombinations([(0,),(1,),(2,)])
    [[0, 1, 2]]
    >>> GetAllCombinations([(0,),(1,3),(2,)])
    [[0, 1, 2], [0, 3, 2]]

    >>> GetAllCombinations([(0,1),(1,3),(2,)])
    [[0, 1, 2], [0, 3, 2], [1, 3, 2]]

### UniquifyCombinations(combos) | source code
    uniquifies the combinations in the argument

    **Arguments**:

      - combos: a sequence of sequences

    **Returns**

      - a list of tuples containing the unique combos

### GetPossibleScaffolds(nPts, bins, useTriangleInequality=True) | source code
    gets all realizable scaffolds (passing the triangle inequality) with the
    given number of points and returns them as a list of tuples

### OrderTriangle(featIndices, dists) | source code
    put the distances for a triangle into canonical order

    It's easy if the features are all different:
    >>> OrderTriangle([0,2,4],[1,2,3])
    ([0, 2, 4], [1, 2, 3])

    It's trickiest if they are all the same:
    >>> OrderTriangle([0,0,0],[1,2,3])
    ([0, 0, 0], [3, 2, 1])
    >>> OrderTriangle([0,0,0],[2,1,3])
    ([0, 0, 0], [3, 2, 1])
    >>> OrderTriangle([0,0,0],[1,3,2])
    ([0, 0, 0], [3, 2, 1])
    >>> OrderTriangle([0,0,0],[3,1,2])
    ([0, 0, 0], [3, 2, 1])
    >>> OrderTriangle([0,0,0],[3,2,1])
    ([0, 0, 0], [3, 2, 1])

    >>> OrderTriangle([0,0,1],[3,2,1])
    ([0, 0, 1], [3, 2, 1])
    >>> OrderTriangle([0,0,1],[1,3,2])
    ([0, 0, 1], [1, 3, 2])
    >>> OrderTriangle([0,0,1],[1,2,3])
    ([0, 0, 1], [1, 3, 2])
    >>> OrderTriangle([0,0,1],[1,3,2])
    ([0, 0, 1], [1, 3, 2])

Variables Details | [hide private]

  ### nPointDistDict Value:
      {2: ((0, 1)),
       3: ((0, 1), (0, 2), (1, 2)),
       4: ((0, 1), (0, 2), (0, 3), (1, 2), (2, 3)),
       5: ((0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (2, 3), (3, 4)),
       6: ((0, 1),
           (0, 2),
           (0, 3),
           (0, 4),
      ...

  ### nDistPointDict Value:
      {1: 2, 3: 3, 5: 4, 7: 5, 9: 6, 11: 7, 13: 8, 15: 9, 17: 10}