function ddpackage.fsmi2cansmi ( 
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER 
         ) 
    => VARCHAR2_OR_CLOB

Internally, there are two separate entrypoints provided within Daycart:

function ddpackage.fsmi2cansmi (
             smiles IN VARCHAR2,
             type IN NUMBER
         )
    => VARCHAR2

function ddpackage.fsmi2cansmi (
             smiles IN CLOB,
             type IN NUMBER
         )
    => CLOB

Note that if the string argument passed into smi2cansmi() is a VARCHAR2, then the function will always return a VARCHAR2. Similarly, if the string argument is a CLOB, the function will always return a CLOB.

In general, Daycart functions which return strings will return the same string type which was passed into the function as the 'key' string parameter. In the above example, it is obvious that since the smiles input argument is being operated on, that the type returned should match the input smiles type.

The only Daycart functions which take multiple input strings and also return a string are the partnorm(), atomnorm(), and bondnorm() functions. For these three functions, the 'key' argument is the ntuple-list data. This is the data being operated on in the function and hence is the input string type which determines the returned type.

function ddpackage.fsetdebug ( 
             value IN NUMBER
         )
    => NUMBER

Controls the level of detail of messages logged to the file: "/tmp/extproc.log". Sets the new value of the logging level to 'value'. Returns the prior value. Valid values are integers the range of 0 - 9.

    0 - No logging at all.
    1 - Error messages only (the default value).
    5 - Warnings and errors.
    9 - Notes, warnings, and errors.

This value is set on a per-session basis. Other values are reserved for future use.

function ddpackage.ftestlicense (
             product IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Checks the cartridge license. Takes an input parameter, which is the license type to check. [ In the current release, the only recognized value is 'daycart' ]. Returns 1 if the Daylight cartridge has a valid license, and 0 otherwise.

The license is contained in a special table which must be created and populated at cartridge install time.

function ddpackage.finfo (
             which in VARCHAR2_OR_CLOB
         )
    => VARCHAR2_OR_CLOB

Returns informational strings from DayCart. Valid input parameters are:

    'toolkit_version' -  Returns the current Daylight Toolkit version.
    'daycart_version' -  Returns the cartridge executable version.
    'extproc_pid'     -  Returns the extproc process ID for this DayCart session.
    'hostid'          -  Returns the hardware hostid used for generation of the
                         license key.

function ddpackage.fsetinfo (
             which in VARCHAR2_OR_CLOB
         )
    => NUMBER

Allows the user to set session-level options in DayCart. Valid input parameters are:

    'vcs_table_cache={on|off}' - Sets the state of the cache of the 
                                 salt and transform tables.
    'default_fpsize={nbits}'   - Sets the default number of bits for
                                 all fingerprint operations.  Valid
                                 values are 32 - 16384.

function ddpackage.fsmi2cansmi (
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator smi2cansmi (
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER
         )
     => VARCHAR2_OR_CLOB

Canonicalize an input SMILES. Returns a canonical SMILES string. Type is either 0 or 1, for unique or absolute SMILES, respectively.

function ddpackage.fsmi2xsmi (
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             explicit IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator smi2xsmi (
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             explicit IN NUMBER
         )
    => VARCHAR2_OR_CLOB

Return an exchange SMILES. Returns a SMILES string which is semantically identical to the input but which does not use Daylight-specific aromaticity conventions. Type is either 0 or 1, for unique or absolute SMILES, respectively. When 'explicit' is 1, it supplies hydrogen count and other atomic properties explicitly for every atom. Note that exchange SMILES are not canonical; the same input molecule or reaction may return different exchange SMILES depending on the input order to this function.

function ddpackage.fsmi2netch (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator smi2netch (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return the net charge of the molecule or reaction.

function ddpackage.fsmi2hcount (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator smi2hcount (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return the total hydrogen count for the molecule or reaction.

function ddpackage.fsmi2mf (
             smiles IN VARCHAR2_OR_CLOB
         )
    => VARCHAR2_OR_CLOB

operator smi2mf (
             smiles IN VARCHAR2_OR_CLOB
         )
    => VARCHAR2_OR_CLOB

Returns the molecular formula string for the molecule or reaction.

function ddpackage.fsmi2amw (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator smi2amw (
             smiles IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return the average molecular weight for a molecule or reaction. The weight used for any atoms which do not have specified isotopes is the average atomic weight. The weight used for atoms with a specified isotope is the high precision molecular weight for that atom. For example, "c1ccccc1" returns 78.1184, the average molecular weight, while "[1H][12c]1[12c]([1H])[12c]([1H])[12c]([1H])[12c]([1H])[12c]1[1H]" returns 78.0469502, the high precision molecular weight for that particular isotope.

function ddpackage.fsmi2graph (
             smiles IN VARCHAR2_OR_CLOB
         )
    => VARCHAR2_OR_CLOB 

operator smi2graph (
             smiles IN VARCHAR2_OR_CLOB
         )
    => VARCHAR2_OR_CLOB 

Return the hydrogen- and charge-suppressed canonical graph string for a given molecule or reaction.

function ddpackage.fvcs_desalt(
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             class IN NUMBER(7,0)
         )
    => VARCHAR2_OR_CLOB

operator vcs_desalt(
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             class IN NUMBER(7,0)
         )
    => VARCHAR2_OR_CLOB

Removes molecule fragments found in the c$dcischem.salts table from the SMILES. Type is either 0 or 1, for unique or absolute SMILES, respectively. The class value is the class of salts entries used from the salts table. All of the structures in the salts table with the given class are checked against the input SMILES and if found, they are removed.

function ddpackage.fvcs_normalize(
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             class IN NUMBER(7,0)
         )
    => VARCHAR2_OR_CLOB

operator vcs_normalize(
             smiles IN VARCHAR2_OR_CLOB,
             type IN NUMBER,
             class IN NUMBER(7,0)
         )
    => VARCHAR2_OR_CLOB

Performs a SMIRKS-based structure normalization on the input SMILES. All of the SMIRKS from the c$dcischem.transform table with the given class are applied to the input molecule. The resulting molecule is output as a canonical SMILES. Type is either 0 or 1 for unique or absolute SMILES, respectively.

function ddpackage.fsmi2fp (
             smiles IN VARCHAR2_OR_CLOB,
             min IN NUMBER,
             max IN NUMBER,
             nbits IN NUMBER
         )
    => VARCHAR2_OR_CLOB 

operator smi2fp (
             smiles IN VARCHAR2_OR_CLOB,
             min IN NUMBER,
             max IN NUMBER,
             nbits IN NUMBER
         )
    => VARCHAR2_OR_CLOB 

Returns the ASCII fingerprint for a given molecule or reaction. Min and max are the minimum and maximum pathlengths, respectively, and size is the number of bits in the fingerprint.

function ddpackage.fsmi2xfp (
             smiles IN VARCHAR2_OR_CLOB,
             min IN NUMBER,
             max IN NUMBER,
             nbits IN NUMBER
         )
   => VARCHAR2_OR_CLOB 

operator smi2xfp (
             smiles IN VARCHAR2_OR_CLOB,
             min IN NUMBER,
             max IN NUMBER,
             nbits IN NUMBER
         )
    => VARCHAR2_OR_CLOB 

Return the ASCII difference fingerprint for a given molecule or reaction. Min and max are the minimum and maximum pathlengths, respectively, and size is the nubmer of bits in the fingerprint.

function ddpackage.ffoldfp (
             fpstr IN VARCHAR2_OR_CLOB,
             nbits IN NUMBER,
             dens IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator foldfp (
             fpstr IN VARCHAR2_OR_CLOB,
             nbits IN NUMBER,
             dens IN NUMBER
         )
    => VARCHAR2_OR_CLOB

Fold the given fingerprint to the minimum appropriate size or density, whichever is limiting, and returns the new, folded fingerprint.

function ddpackage.fbitcount (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator bitcount (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return the number of bits on in the fingerprint.

function ddpackage.fnbits (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator nbits (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return the total size of the fingerprint, in bits. In the current Daylight toolkit this will always be a power of two.

function ddpackage.fisfp (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator isfp (
             fpstr IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Return 1 if the string is a fingerprint, 0 otherwise. The syntax of a fingerprint can never be confused with a valid SMILES. This is the bit of cleverness which allows us to overload the searching functions.

function ddpackage.fatomnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator atomnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

function ddpackage.fbondnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator bondnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

function ddpackage.fpartnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

operator partnorm (
             smiles IN VARCHAR2_OR_CLOB,
             list IN VARCHAR2_OR_CLOB,
             ntuple IN NUMBER,
             isotype IN NUMBER
         )
    => VARCHAR2_OR_CLOB

Returns a potentially reordered N-tuple string for the given list input parameter. The list string is a comma-separated list of data which is associated in order with the atoms, bonds or parts of the input SMILES. The list string is reordered based on the canonical atom, bond, or part ordering of the input SMILES. ntuple is the number of comma-separated values per atom, bond, or dot-separated part, and isotype is 0 for unique SMILES canonicalization and 1 for absolute SMILES canonicalization.

function ddpackage.fexact (
             a IN VARCHAR2_OR_CLOB,
             b IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator exact (
             a IN VARCHAR2_OR_CLOB,
             b IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if the two input strings are identical, 0 otherwise. The operator is optionally backed by the ddexact indextype.

function ddpackage.fgraph (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator graph (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if the two input SMILES share the same canonical graph, 0 otherwise. The operator is optionally backed by the ddgraph indextype.

function ddpackage.ftautomer (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator tautomer (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if the two input SMILES share the same canonical graph, net charge, and total hydrogen count, 0 otherwise. The operator is optionally backed by the ddgraph indextype.

function ddpackage.fusmiles (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator usmiles (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if the two input SMILES share the same unique canonical smiles, 0 otherwise. The operator is optionally backed by the ddgraph indextype.

function ddpackage.fasmiles (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator asmiles (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if the two input SMILES share the same absolute canonical smiles, 0 otherwise. The operator is optionally backed by the ddgraph indextype.

function ddpackage.fcomponent (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator component (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

Returns 1 if smiles2 (a molecule SMILES) is a component of smiles1 (any SMILES), otherwise returns 0. Also returns false if smiles2 is not a single-component query. The last example in the table below illustrates this problem. The operator is optionally backed by the ddrole indextype. A component is a single dot-separated part of a larger molecule or reaction SMILES. Some examples follow:

function ddpackage.freactant (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator reactant (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

function ddpackage.fagent (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER

operator agent (
             smiles1 IN VARCHAR2_OR_CLOB,
             smiles2 IN VARCHAR2_OR_CLOB
         )
    => NUMBER