rino 0.1.0

data/ext/src/ichicant.h

@@ -0,0 +1,379 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+#ifndef __INCHICANT_H__
+#define __INCHICANT_H__
+
+/******************************************************/
+/*                                                    */
+/*                 Canonicalization definitions       */
+/*                                                    */
+/******************************************************/
+#include "ichisize.h"
+
+
+#ifndef INCHI_US_SHORT_DEF
+typedef signed short S_SHORT;
+typedef unsigned short U_SHORT;
+#define INCHI_US_SHORT_DEF
+#endif
+
+/*typedef unsigned long  INCHI_MODE;*/
+
+typedef union tagSplitLong {
+    unsigned long  ul;
+    U_SHORT        us[2];
+}SU_LONG;
+
+#define _HI 1                            /* Intel platform */
+#define _LO 0
+
+#define NEIGH_LIST_LEN 4
+#define U_LONG_LEN  2
+
+#ifndef defined_NEIGH_LIST
+typedef AT_RANK  *NEIGH_LIST;
+#define defined_NEIGH_LIST
+#endif
+
+typedef struct tagEQUIV_INFO {
+    int nNumSets;
+    int *nCutVertexAtom; /* cut-vertex atom for the set of equivalent atoms */
+    int *nFirstInSet;    /* first of equivalent atoms in the connected to the cut-vertex atom parts of the structure */
+    int *nNumInSet;      /* number of the equivalent atoms connected to the cut-vertex atom */
+    int *nAtomNo;        /* eqivalent atom number */
+    int *nAddToRank;     /* number to add to the rank to normalize */
+} EQUIV_INFO;
+
+#define MOL_PART_MASK  (~0x0U ^ 0x07U)
+
+
+typedef struct tagAtData_dch {
+     char element[3];
+     int valence;
+   }AT_DATA;
+
+
+#define MAXVAL 20       /* maximum valence */
+ 
+#define ATOM_EL_LEN 6
+
+typedef struct tagAtomInvariantBytes {
+    S_CHAR cNotExactlyHillOrderNumber;
+    S_CHAR cNumberOfConnections;
+    /* S_CHAR cNumberOfNonHydrogenBonds; */
+    S_CHAR cAtomicNumber;
+#if( HYDROGENS_IN_INIT_RANKS == 1 ) 
+    S_CHAR cNumberOfAttachedHydrogens;
+#endif
+} ATOM_INVARIANT_BYTES;
+
+typedef struct tagAtomInvariant {
+    /* non-isotopic part */
+#if( USE_DISTANCES_FOR_RANKING == 1 )
+    AT_RANK         nDistanceFromTerminal;
+#endif
+    ATOM_INVARIANT_BYTES b;
+    AT_RANK         cNum_tautomer;        /* 0 or for tautomer endpoint: number of endpoints in the group */
+    AT_RANK         cNum_tautomer_num[T_NUM_NO_ISOTOPIC]; /* 0 or numbers from t_gtroup */
+    /* isotopic part */
+    AT_ISO_SORT_KEY iso_sort_key;
+    AT_RANK         cNum_tautomer_iso[T_NUM_ISOTOPIC]; /* 0 or numbers from t_group */
+} ATOM_INVARIANT;
+/**********************************/
+typedef enum tagAtInvariantIndexes {
+    AT_INV_HILL_ORDER,
+    AT_INV_NUM_CONNECTIONS,
+    AT_INV_NUM_H,
+    /* for endpoint + undirected graph, otherwise 0 */
+    AT_INV_NUM_TG_ENDPOINTS,
+    AT_INV_TG_NUMBERS,       /* num H, num (-) */
+    AT_INV_NUM_H_FIX = AT_INV_TG_NUMBERS+T_NUM_NO_ISOTOPIC,
+    AT_INV_BREAK1,
+    /* here compare iso sort key */
+    AT_INV_TAUT_ISO = AT_INV_BREAK1,
+    AT_INV_LENGTH   = AT_INV_TAUT_ISO + T_NUM_ISOTOPIC
+} AT_INV_INDEXES;
+
+typedef struct tagAtomInvariant2 {
+    AT_NUMB         val[AT_INV_LENGTH];
+    AT_ISO_SORT_KEY iso_sort_key;
+    S_CHAR          iso_aux_key;
+} ATOM_INVARIANT2;
+
+/******************* Partition **********************************/
+typedef struct tagPartition {
+    AT_RANK *Rank;
+    AT_NUMB *AtNumber;
+} Partition;
+
+/********************* BFCN *************************************/
+typedef struct tagFixHOrTautCanonNumbering {
+
+    int             num_at_tg;  /* = num_atoms for non-taut */
+    int             num_atoms;
+    int             nCanonFlags;
+    NEIGH_LIST     *NeighList;  /* length = num_at_tg */
+    /****************************/
+    /*     base structure       */
+    /****************************/
+    AT_RANK        *LinearCt;      /* connection table atoms (+taut. groups, directed graph)*/
+    int             nLenLinearCtAtOnly;
+    int             nLenLinearCt;
+    int             nMaxLenLinearCt;
+
+    Partition       PartitionCt;  /* canonical numbering */
+    AT_RANK        *nSymmRankCt;  /* orbits */
+
+    /* orig. fixed by tautomerism H positions */
+    NUM_H          *nNumHOrig;  /* original  H atoms positions + taut. info, excluding tautomeric H */
+    NUM_H          *nNumH;      /* canonical H atoms positions + taut. info, excluding tautomeric H */
+    int             nLenNumH;   /* length = num_atoms + 2*num_taut_groups */
+
+    /* fixed H: original positions of tautomeric H; exists obly for tautomeric structures */
+    NUM_H          *nNumHOrigFixH;  /* original fixed positions of tautomeric H */
+    NUM_H          *nNumHFixH;      /* canonical fixed positions of tautomeric H */
+    int             nLenNumHFixH;   /* length = num_atoms */
+
+    /*******************************************************************************/
+    /* the following exists only if isotopic and isotopic results requested        */
+    /*******************************************************************************/
+    Partition       PartitionCtIso;     /* canonical numbering of isotopic base structure, defined later */
+    AT_RANK        *nSymmRankCtIso;     /* orbits of isotopic structure */
+    AT_ISO_SORT_KEY *iso_sort_keys;     /* original isotopic sort keys for atoms and taut groups */
+    AT_ISO_SORT_KEY *iso_sort_keysOrig; /* canonical isotopic sort keys for atoms and taut groups */
+    int              len_iso_sort_keys;
+    S_CHAR          *iso_exchg_atnos;     /* canonical: 0=> tautomeric or may have isotopic H exchanged */
+    S_CHAR          *iso_exchg_atnosOrig; /* original: 0=> tautomeric or may have isotopic H exchanged */
+    
+} FTCN;
+
+/******************** BCN *************************************/
+typedef struct tagBaseCanonNumbering {
+
+    AT_RANK            **pRankStack;
+    int                  nMaxLenRankStack;
+    int                  num_max;        /* allocated nRank[] arrays lengths in pRankStack */
+    int                  num_at_tg;  /* all of the following arrays have this length */
+    int                  num_atoms;
+    struct tagInchiTime *ulTimeOutTime;
+    FTCN                 ftcn[TAUT_NUM];
+
+} BCN;
+
+/***********************************
+ *
+ *  CANON_STAT
+ */
+typedef struct tagCanonStat {
+    /*  statistics */
+    long                 lNumBreakTies;
+    long                 lNumNeighListIter;
+    long                 lNumTotCT;
+    long                 lNumDecreasedCT;
+    long                 lNumRejectedCT;
+    long                 lNumEqualCT;
+    struct tagInchiTime *ulTimeOutTime;
+    long                 lTotalTime;
+
+    /* control */
+    int                  bFirstCT;
+    int                  bKeepSymmRank;
+    int                  bStereoIsBetter;
+
+    int nCanonFlags;
+
+    /* data : */
+
+    AT_NUMB          *LinearCT;        /* connection table only */
+    AT_ISOTOPIC      *LinearCTIsotopic;
+    AT_ISO_TGROUP    *LinearCTIsotopicTautomer;
+    AT_STEREO_DBLE   *LinearCTStereoDble;
+    AT_STEREO_CARB   *LinearCTStereoCarb;
+    AT_STEREO_DBLE   *LinearCTStereoDbleInv;
+    AT_STEREO_CARB   *LinearCTStereoCarbInv;
+    AT_STEREO_DBLE   *LinearCTIsotopicStereoDble;
+    AT_STEREO_CARB   *LinearCTIsotopicStereoCarb;
+    AT_STEREO_DBLE   *LinearCTIsotopicStereoDbleInv;
+    AT_STEREO_CARB   *LinearCTIsotopicStereoCarbInv;
+    AT_TAUTOMER      *LinearCTTautomer;  /*  minimal */
+
+/* second copies of line notation arrays */
+
+    AT_NUMB          *LinearCT2;   /* to save non-isotopic CT */
+
+    int               nLenLinearCTStereoDble;
+    int               nLenLinearCTStereoDbleInv;
+    int               nMaxLenLinearCTStereoDble;  /* new */
+
+    int               bCmpStereo;         /* 0 => no stereo to invert;
+                                             1 => StereoCtInv < StereoCt;
+                                             2 => StereoCtInv = StereoCt;
+                                             3 => StereoCtInv > StereoCt;
+                                           */  
+    int               nLenLinearCTStereoCarb;
+    int               nLenLinearCTStereoCarbInv;
+    int               nMaxLenLinearCTStereoCarb;  /* new */
+    
+    int               nLenLinearCTIsotopic;
+    int               nMaxLenLinearCTIsotopic;
+
+    int               nLenLinearCTIsotopicTautomer;
+    int               nMaxLenLinearCTIsotopicTautomer;
+
+    int               nLenLinearCT;         /* connection table only  */
+    int               nLenLinearCT2;        /* connection table only, non-isotopic result  */
+    int               nLenLinearCTAtOnly;   /* connection table only without tautomeric pseudoatoms  */
+    int               nLenLinearCTAtOnly2;  /* connection table only, non-isotopic result without tautomeric pseudoatoms  */
+    int               nMaxLenLinearCT;      /* connection table only  */
+
+    int               nLenLinearCTTautomer;
+    int               nMaxLenLinearCTTautomer;
+    
+    int               bCmpIsotopicStereo; /* 0 => no stereo to invert;
+                                             1 => StereoCtInv < StereoCt;
+                                             2 => StereoCtInv = StereoCt;
+                                             3 => StereoCtInv > StereoCt;
+                                           */  
+    int               nLenLinearCTIsotopicStereoDble;
+    int               nLenLinearCTIsotopicStereoDbleInv;
+    int               nMaxLenLinearCTIsotopicStereoDble;
+
+    int               nLenLinearCTIsotopicStereoCarb; /*  new */
+    int               nLenLinearCTIsotopicStereoCarbInv; /*  new */
+    int               nMaxLenLinearCTIsotopicStereoCarb;
+    S_CHAR           *bRankUsedForStereo;  /* canon. rank used for stereo mapping */
+    S_CHAR           *bAtomUsedForStereo;  /* 0 if not a stereo atom or during a canon. rank being mapped on this atom; */
+                                           /* STEREO_AT_MARK if an unpapped stereogenic atom */
+                                           /* or a number of stereogenic bonds adjacent to an atom */
+    
+    AT_RANK          *nPrevAtomNumber;
+
+    AT_RANK          *nCanonOrd;       /* atom numbers in order of increasing canon. ranks  */
+    AT_RANK          *nSymmRank;       /* symmetry numbers in order of atoms  */
+    AT_RANK          *nCanonOrdTaut;   /* t-group numbers numbers in order of increasing canon. ranks  */
+    AT_RANK          *nSymmRankTaut;   /* t-group symmetry numbers in order of t-groups  */
+
+    AT_RANK          *nCanonOrdStereo;     /* atom numbers in order of increasing canon. ranks */
+    AT_RANK          *nCanonOrdStereoInv;     /* atom numbers in order of increasing canon. ranks */
+    AT_RANK          *nCanonOrdStereoTaut; /* t-group numbers in order of increasing canon. ranks */
+    
+    AT_RANK          *nSymmRankIsotopic;
+    AT_RANK          *nCanonOrdIsotopic;        /* atom numbers in order of increasing canon. ranks */
+    AT_RANK          *nSymmRankIsotopicTaut;    /* !!! */
+    AT_RANK          *nCanonOrdIsotopicTaut;    /*/ t-group numbers in order of increasing canon. ranks */
+
+    AT_RANK          *nCanonOrdIsotopicStereo;
+    AT_RANK          *nCanonOrdIsotopicStereoInv;
+    AT_RANK          *nCanonOrdIsotopicStereoTaut;    /*  !!! */
+
+                      /* actual lengths if successfully calculated */
+
+    int               nLenCanonOrd;               /* Superceded by any of the following > 0 */
+    int               nLenCanonOrdTaut;           /* !!! Superceded by any of the following > 0 */
+    int               nLenCanonOrdIsotopic;
+    int               nLenCanonOrdIsotopicTaut;   /* !!! */
+    int               nLenCanonOrdStereo;
+    int               nLenCanonOrdStereoTaut;     /* !!! */
+    int               nLenCanonOrdIsotopicStereo;
+    int               nLenCanonOrdIsotopicStereoTaut; /* !!! */
+
+                      /*  other */
+
+    int               bHasIsotopicInTautomerGroups;
+    T_GROUP_INFO     *t_group_info;
+    int               bIgnoreIsotopic;
+    int               bDoubleBondSquare; /* 0 or 2 */
+    INCHI_MODE         nMode;
+#if( bRELEASE_VERSION == 0 )
+    int               bExtract;          /* for debug only */
+#endif
+    NEIGH_LIST       *NeighList;
+    BCN              *pBCN;
+    S_CHAR    *nNum_H;      /* number of terminal hydrogen atoms on each atom except tautomeric [num_atoms], in order of canonical numbers */
+    S_CHAR    *nNum_H_fixed;/* number of terminal hydrogen atoms on tautomeric atoms (for non-atautomeric representation) [num_atoms] */
+    S_CHAR    *nExchgIsoH;
+} CANON_STAT;
+
+/**************************************************/
+typedef struct tagCanonData {
+    
+    /* same names/types as in ConTable; here the order is from original numbering */
+    
+    AT_NUMB *LinearCT;  /* output ?? */
+    
+    int      nMaxLenLinearCT;
+    int      nLenLinearCT;
+    int      nLenCTAtOnly;
+    int      nCanonFlags;
+    /* hydrogen atoms fixed in tautomeric representation:
+       compare before diff sign inversion: (+) <=> Ct1->() > Ct2->() */
+    NUM_H          *NumH;      
+    int             lenNumH;    /* used length */
+    int             maxlenNumH; /*  n + T_NUM_NO_ISOTOPIC*(n_tg-n) + 1 */
+
+    /* hydrogen atoms fixed in non-tautomeric representation only:
+       compare before diff sign inversion: (+) <=> Ct1->() > Ct2->() */
+    NUM_H           *NumHfixed;          
+    int              lenNumHfixed;       /* used length */   
+    int              maxlenNumHfixed;    /* max length = n+1  */
+
+    /* isotopic atoms (without tautomeric H) and isotopic tautomeric groups */
+    /* note: AT_ISO_SORT_KEY and T_GROUP_ISOWT are identical types: long    */
+    AT_ISO_SORT_KEY *iso_sort_key;        
+    int              len_iso_sort_key;    /* used length */
+    int              maxlen_iso_sort_key; /* max length = n_tg+1 */
+    S_CHAR          *iso_exchg_atnos;
+    int              len_iso_exchg_atnos;    /* used length */
+    int              maxlen_iso_exchg_atnos;
+
+    /* isotopic hydrogen atoms fixed in non-tautomeric representation only */
+#if ( USE_ISO_SORT_KEY_HFIXED == 1 )       
+    AT_ISO_SORT_KEY *iso_sort_key_Hfixed;     
+    int              len_iso_sort_key_Hfixed;    /* used length */    
+    int              maxlen_iso_sort_key_Hfixed; /* max length = n+1  */
+#endif
+    /* auxiliary ranking */
+
+    AT_RANK  *nAuxRank;
+
+    struct tagInchiTime *ulTimeOutTime;  /* timeout */
+
+} CANON_DATA;
+/**************************************************/
+
+typedef struct tagCanonCounts {
+    long     lNumBreakTies;
+    long     lNumDecreasedCT;
+    long     lNumRejectedCT;
+    long     lNumEqualCT;
+    long     lNumTotCT;
+    double    dGroupSize;
+    long     lNumGenerators;
+    long     lNumStoredIsomorphisms;
+
+} CANON_COUNTS;
+/***********************************************
+ tree structure: one segment
+
+   canon. rank
+   at.no          orig. atom numbers on which the canon. rank has been successfully mapped
+   ...
+   at.no          except the last at.no: it is not known if it has been mapped until all atoms are mapped
+   num.at+1       number of atoms in this segment
+*/
+
+typedef struct tagCurTree {
+    AT_NUMB   *tree;
+    int       max_len;  /* allocated length of tree in sizeof(tree[0]) units */
+    int       cur_len;  /* currently used length */
+    int       incr_len; /* reallocation increment */
+} CUR_TREE;
+
+#endif /* __INCHICANT_H__ */

data/ext/src/ichicomn.h

@@ -0,0 +1,260 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+#ifndef __INCHICOMN_H__
+#define __INCHICOMN_H__
+
+#include "ichierr.h"
+
+
+/********************************
+ *
+ * Globals for sorting
+ */
+
+extern const NEIGH_LIST      *pNeighList_RankForSort; 
+extern const ATOM_INVARIANT2 *pAtomInvariant2ForSort;
+extern const AT_NUMB         *pNeighborsForSort;
+extern const AT_RANK         *pn_RankForSort;
+
+extern AT_RANK         nMaxAtNeighRankForSort;
+
+extern int             nNumCompNeighborsRanksCountEql;
+
+
+#define tsort insertions_sort
+
+typedef struct tagEquNeigh {
+    int     num_to;   /* number of neighbors with equal mapping ranks; one of them has min. canon. number */
+    AT_RANK to_at[4]; /* to_atom neighbors #s with equal mapping ranks */
+    AT_RANK from_at;  /* from_at neighbor # which has min. canon. number and can be mapped on any of the above to_at[] */
+    AT_RANK rank;     /* equal mapping rank value */
+    AT_RANK canon_rank;  /* min. canon. number */
+} EQ_NEIGH;
+
+#ifndef INCHI_ALL_CPP
+#ifdef  __cplusplus
+extern "C" {
+#endif
+#endif
+
+/*******************************************************************/
+/* ichiisot.c */
+int unpack_iso_sort_key( AT_ISO_SORT_KEY iso_sort_key, S_CHAR *num_1H, S_CHAR *num_2H, S_CHAR *num_3H, S_CHAR *iso_atw_diff );
+AT_ISO_SORT_KEY make_iso_sort_key( int iso_atw_diff, int num_1H, int num_2H, int num_3H);
+int set_atom_iso_sort_keys(  int num_at, sp_ATOM *at, T_GROUP_INFO* t_group_info, int *bHasIsotopicInTautomerGroups );
+/***********************************************************************/
+/* ichisort.c */
+
+void insertions_sort_NeighList_AT_NUMBERS( NEIGH_LIST base, AT_RANK *nRank );
+int insertions_sort_NeighList_AT_NUMBERS3( NEIGH_LIST base, AT_RANK *nRank );
+int insertions_sort_AT_RANK( AT_RANK *base, int num );
+void insertions_sort_NeighListBySymmAndCanonRank( NEIGH_LIST base, const AT_RANK *nSymmRank, const AT_RANK *nCanonRank );
+int CompareNeighListLex( NEIGH_LIST pp1, NEIGH_LIST pp2, const AT_RANK *nRank);
+int CompareNeighListLexUpToMaxRank( NEIGH_LIST pp1, NEIGH_LIST pp2, const AT_RANK *nRank, AT_RANK nMaxAtNeighRank );
+int compare_NeighLists( const NEIGH_LIST *op1,  const NEIGH_LIST *op2 );
+int CompNeighborsAT_NUMBER( const void* a1, const void* a2);
+int comp_AT_RANK( const void* a1, const void* a2);
+int CompRank(const void* a1, const void* a2 );
+int CompRanksOrd( const void* a1, const void* a2 );
+
+int CompAtomInvariants2Only( const void* a1, const void* a2 );
+int CompAtomInvariants2( const void* a1, const void* a2 );
+
+int CompNeighListRanks( const void* a1, const void* a2 );
+int CompNeighListRanksOrd( const void* a1, const void* a2 );
+int CompNeighLists( const void* a1, const void* a2 );
+int CompNeighListsUpToMaxRank( const void* a1, const void* a2 );
+int CompNeighborsRanksCountEql( const void* a1, const void* a2 );
+int CompRanksInvOrd( const void* a1, const void* a2 );
+int CompChemElemLex( const void *a1, const void *a2 );
+
+
+
+NEIGH_LIST *CreateNeighList( int num_atoms, int num_at_tg, sp_ATOM* at, int bDoubleBondSquare, T_GROUP_INFO *t_group_info );
+NEIGH_LIST *CreateNeighListFromLinearCT( AT_NUMB *LinearCT, int nLenCT, int num_atoms );
+
+void FreeNeighList( NEIGH_LIST *pp );
+int BreakAllTies( int num_atoms, int num_max, AT_RANK **pRankStack,
+                     NEIGH_LIST *NeighList, AT_RANK *nTempRank, CANON_STAT *pCS);
+
+/******************************************************************************/
+/* ichimap.c */
+void switch_ptrs( AT_RANK **p1, AT_RANK **p2 );
+
+int SortedEquInfoToRanks( const AT_RANK* nSymmRank, AT_RANK* nRank, const AT_RANK* nAtomNumber, int num_atoms, int *bChanged );
+int SortedRanksToEquInfo( AT_RANK* nSymmRank, const AT_RANK* nRank, const AT_RANK* nAtomNumber, int num_atoms );
+
+int SetNewRanksFromNeighLists( int num_atoms, NEIGH_LIST *NeighList, AT_RANK *nRank, AT_RANK *nNewRank,
+                             AT_RANK *nAtomNumber, int bUseAltSort, int ( *comp )(const void *, const void *) );
+int SetNewRanksFromNeighLists3( int num_atoms, NEIGH_LIST *NeighList, AT_RANK *nRank, AT_RANK *nNewRank,
+                             AT_RANK *nAtomNumber );
+int SetNewRanksFromNeighLists4( int num_atoms, NEIGH_LIST *NeighList, AT_RANK *nRank, AT_RANK *nNewRank,
+                             AT_RANK *nAtomNumber, AT_RANK nMaxAtRank );
+void SortNeighListsBySymmAndCanonRank( int num_atoms, NEIGH_LIST *NeighList, const AT_RANK *nSymmRank, const AT_RANK *nCanonRank );
+int SortNeighLists2( int num_atoms, AT_RANK *nRank, NEIGH_LIST *NeighList, AT_RANK *nAtomNumber );
+int  DifferentiateRanks2( int num_atoms, NEIGH_LIST *NeighList,
+                                 int nNumCurrRanks, AT_RANK *pnCurrRank, AT_RANK *pnPrevRank,
+                                 AT_RANK *nAtomNumber, long *lNumIter, int bUseAltSort );
+
+int  DifferentiateRanks3( int num_atoms, NEIGH_LIST *NeighList,
+                                 int nNumCurrRanks, AT_RANK *pnCurrRank, AT_RANK *pnPrevRank,
+                                 AT_RANK *nAtomNumber, long *lNumIter );
+int  DifferentiateRanks4( int num_atoms, NEIGH_LIST *NeighList,
+                          int nNumCurrRanks, AT_RANK *pnCurrRank, AT_RANK *pnPrevRank,
+                          AT_RANK *nAtomNumber, AT_RANK nMaxAtRank, long *lNumIter );
+int  DifferentiateRanksBasic( int num_atoms, NEIGH_LIST *NeighList,
+                                 int nNumCurrRanks, AT_RANK *pnCurrRank, AT_RANK *pnPrevRank,
+                                 AT_RANK *nAtomNumber, long *lNumIter, int bUseAltSort );
+
+int parity_of_mapped_atom2( int from_at, int to_at, const sp_ATOM *at, EQ_NEIGH *pEN,
+                           const AT_RANK *nCanonRankFrom, const AT_RANK *nRankFrom, const AT_RANK *nRankTo );
+
+int parity_of_mapped_half_bond( int from_at, int to_at, int from_neigh, int to_neigh,
+                           sp_ATOM *at, EQ_NEIGH *pEN,
+                           const AT_RANK *nCanonRankFrom, const AT_RANK *nRankFrom, const AT_RANK *nRankTo );
+
+int HalfStereoBondParity( sp_ATOM *at, int at_no1, int i_sb_neigh, const AT_RANK *nRank );
+
+int NumberOfTies( AT_RANK **pRankStack1, AT_RANK **pRankStack2, int length, int at_no1, int at_no2, AT_RANK *nNewRank, int *bAddStack, int *bMapped1 );
+
+int map_an_atom2( int num_atoms, int num_max, int at_no1/*from*/, int at_no2/*to*/,
+                AT_RANK *nTempRank,
+                int nNumMappedRanks, int *pnNewNumMappedRanks,
+                CANON_STAT *pCS,
+                NEIGH_LIST    *NeighList,
+                AT_RANK  **pRankStack1, AT_RANK  **pRankStack2, int *bAddStack );
+int ClearPreviousMappings( AT_RANK **pRankStack1 );
+
+int SetOneStereoBondIllDefParity( sp_ATOM *at, int jc, /* atom number*/ int k /* stereo bond ord. number*/, int new_parity );
+int RemoveOneStereoBond( sp_ATOM *at, int jc, /* atom number*/ int k /* stereo bond number*/ );
+int RemoveOneStereoCenter( sp_ATOM *at, int jc /* atom number*/ );
+int RemoveCalculatedNonStereo( sp_ATOM *at, int num_atoms, int num_at_tg,
+                              AT_RANK **pRankStack1, AT_RANK **pRankStack2, AT_RANK *nTempRank, NEIGH_LIST *NeighList,
+                              const AT_RANK *nSymmRank, AT_RANK *nCanonRank, AT_RANK *nAtomNumberCanon, CANON_STAT *pCS );
+
+
+int might_change_other_atom_parity( sp_ATOM *at, int num_atoms, int at_no, AT_RANK *nRank2, AT_RANK *nRank1 );
+
+int map_stereo_bonds4 ( 
+                sp_ATOM *at, int num_atoms, int num_at_tg, int num_max, int bAllene,
+                const AT_RANK *nCanonRankFrom, const AT_RANK *nAtomNumberCanonFrom, /*  non-stereo canon ranking */
+                AT_RANK *nCanonRankTo, /* output canonical numbering*/
+                const AT_RANK *nSymmRank,      AT_RANK **pRankStack1/*from*/,  AT_RANK **pRankStack2/*to*/,
+                AT_RANK *nTempRank,      int nNumMappedRanksInput,
+                AT_RANK *nSymmStereo,    NEIGH_LIST *NeighList,
+                CANON_STAT *pCS,         CUR_TREE *cur_tree,  int nNumMappedBonds );
+
+int map_stereo_atoms4 ( 
+                sp_ATOM *at, int num_atoms, int num_at_tg, int num_max,
+                const AT_RANK *nCanonRankFrom, const AT_RANK *nAtomNumberCanonFrom, AT_RANK *nCanonRankTo, /*  canonical numbering to be mapped */
+                const AT_RANK *nSymmRank,      AT_RANK **pRankStack1/*from*/, AT_RANK **pRankStack2/*to*/,
+                AT_RANK *nTempRank,      int nNumMappedRanksInput,
+                AT_RANK *nSymmStereo,    NEIGH_LIST *NeighList,
+                CANON_STAT *pCS,         CUR_TREE *cur_tree, int nNumMappedAtoms );
+
+
+int CurTreeAlloc( CUR_TREE *cur_tree, int num_atoms );
+int CurTreeReAlloc( CUR_TREE *cur_tree );
+void CurTreeFree( CUR_TREE *cur_tree );
+int CurTreeAddRank( CUR_TREE *cur_tree, AT_NUMB rank );
+int CurTreeRemoveLastRank( CUR_TREE *cur_tree );
+int CurTreeReplaceLastRank( CUR_TREE *cur_tree, AT_NUMB rank );
+int CurTreeFindTheRankPos( CUR_TREE *cur_tree, AT_NUMB rank );
+int CurTreeGetPos( CUR_TREE *cur_tree );
+int CurTreeSetPos( CUR_TREE *cur_tree, int len );
+int CurTreeAddAtom( CUR_TREE *cur_tree, int at_no );
+int CurTreeRemoveLastAtom( CUR_TREE *cur_tree );
+int CurTreeIsLastRank( CUR_TREE *cur_tree, AT_NUMB rank );
+int CurTreeIsLastAtomEqu( CUR_TREE *cur_tree, int at_no, AT_NUMB *nSymmStereo );
+int CurTreeRemoveIfLastAtom( CUR_TREE *cur_tree, int at_no );
+int CurTreeRemoveLastRankIfNoAtoms( CUR_TREE *cur_tree );
+void CurTreeKeepLastAtomsOnly( CUR_TREE *cur_tree, int tpos, int shift );
+
+
+void SetUseAtomForStereo( S_CHAR *bAtomUsedForStereo, sp_ATOM *at, int num_atoms );
+
+int     nJoin2Mcrs( AT_RANK *nEqArray, AT_RANK n1, AT_RANK n2 );
+AT_RANK nGetMcr( AT_RANK *nEqArray, AT_RANK n );
+int     bUniqueAtNbrFromMappingRank( AT_RANK **pRankStack, AT_RANK nAtRank, AT_NUMB *nAtNumber );
+
+int Next_SB_At_CanonRanks2( AT_RANK *canon_rank1, AT_RANK *canon_rank2, /*  canonical numbers */
+                          AT_RANK *canon_rank1_min, AT_RANK *canon_rank2_min,
+                          int *bFirstTime, S_CHAR *bAtomUsedForStereo,
+                          const ppAT_RANK pRankStack1, const ppAT_RANK pRankStack2,
+                          const AT_RANK *nCanonRankFrom, const AT_RANK *nAtomNumberCanonFrom,
+                          const sp_ATOM *at, int num_atoms, int bAllene );
+
+int Next_SC_At_CanonRank2( AT_RANK *canon_rank1,    /*  1st call input: largest canon number mapped so far or 0 */
+                                                    /*  output: suggested canon. rank > than input if success */
+                          AT_RANK *canon_rank1_min, /*  1st call:0 next calls: first tried canon. number */
+                          int *bFirstTime,          /*  1 at the time of the 1st call  */
+                          S_CHAR *bAtomUsedForStereo, /*  STEREO_AT_MARK if the atom has not been mapped yet */
+                    const ppAT_RANK pRankStack1,    /*  mapping ranks/sort order of atoms with canon. numbers (from) */
+                    const ppAT_RANK pRankStack2,    /*  mapping ranks/sort order of atoms with stereo (to) */
+                    const AT_RANK *nAtomNumberCanonFrom, /*  sorted order of the canon. numbers */
+                    int num_atoms );
+
+int NextStereoParity2Test( int *stereo_bond_parity, int *sb_parity_calc,
+                         int nNumBest, int nNumWorse, int nNumUnkn, int nNumUndf, int nNumCalc);
+
+int All_SB_Same(  AT_RANK canon_rank1, AT_RANK canon_rank2, /*  canonical numbers */
+                  const ppAT_RANK pRankStack1, const ppAT_RANK pRankStack2,
+                  const AT_RANK *nAtomNumberCanonFrom,
+                  sp_ATOM *at );
+
+int All_SC_Same(  AT_RANK canon_rank1, /*  canonical number */
+                  const ppAT_RANK pRankStack1, const ppAT_RANK pRankStack2,
+                  const AT_RANK *nAtomNumberCanonFrom,
+                  const sp_ATOM *at );
+
+
+int CompareLinCtStereoDoubleToValues( AT_STEREO_DBLE *LinearCTStereoDble,
+                              AT_RANK at_rank_canon1, AT_RANK at_rank_canon2, U_CHAR bond_parity );
+
+int CompareLinCtStereoAtomToValues( AT_STEREO_CARB *LinearCTStereoCarb,
+                              AT_RANK at_rank_canon1, U_CHAR parity );
+int CompareLinCtStereoDble ( AT_STEREO_DBLE *LinearCTStereoDble1, int nLenLinearCTStereoDble1,
+                             AT_STEREO_DBLE *LinearCTStereoDble2, int nLenLinearCTStereoDble2 );
+int CompareLinCtStereoCarb ( AT_STEREO_CARB *LinearCTStereoCarb1, int nLenLinearCTStereoCarb1,
+                             AT_STEREO_CARB *LinearCTStereoCarb2, int nLenLinearCTStereoCarb2 );
+int CompareLinCtStereo ( AT_STEREO_DBLE *LinearCTStereoDble1, int nLenLinearCTStereoDble1,
+                         AT_STEREO_CARB *LinearCTStereoCarb1, int nLenLinearCTStereoCarb1,
+                         AT_STEREO_DBLE *LinearCTStereoDble2, int nLenLinearCTStereoDble2,
+                         AT_STEREO_CARB *LinearCTStereoCarb2, int nLenLinearCTStereoCarb2 );
+/***************************************************************************/
+/* ichicans.c */
+int UnmarkNonStereo( sp_ATOM *at, int num_atoms, const AT_RANK *nRank, const AT_RANK *nAtomNumber, int bIsotopic );
+int FillSingleStereoDescriptors(sp_ATOM *at, int i, int num_trans, const AT_RANK *nRank
+                          , AT_STEREO_CARB *LinearCTStereoCarb, int *nStereoCarbLen, int nMaxStereoCarbLen
+                          , AT_STEREO_DBLE *LinearCTStereoDble, int *nStereoDbleLen, int nMaxStereoDbleLen
+                          , int bAllene );
+void SwitchAtomStereoAndIsotopicStereo( sp_ATOM *at, int num_atoms, int *bSwitched );
+void SetCtToIsotopicStereo( CANON_STAT *pCS, CANON_STAT *pCS2 );
+void SetCtToNonIsotopicStereo( CANON_STAT *pCS, CANON_STAT *pCS2 );
+int FillAllStereoDescriptors( sp_ATOM *at, int num_atoms, const AT_RANK *nCanonRank, const AT_RANK *nAtomNumberCanon, CANON_STAT *pCS );
+int FillOutStereoParities( sp_ATOM *at, int num_atoms, const AT_RANK *nCanonRank, const AT_RANK *nAtomNumberCanon,
+                           const AT_RANK *nRank, const AT_RANK *nAtomNumber, CANON_STAT *pCS, int bIsotopic );
+int InvertStereo( sp_ATOM *at, int num_at_tg,
+                  AT_RANK *nCanonRank, AT_RANK *nAtomNumberCanon,
+                  CANON_STAT *pCS, int bInvertLinearCTStereo );
+int find_atoms_with_parity( sp_ATOM *at, S_CHAR *visited, int from_atom, int cur_atom );
+int GetStereoNeighborPos( sp_ATOM *at, int iAt1, int iAt2 );
+int GetStereoBondParity(sp_ATOM *at, int i, int n, AT_RANK *nRank );
+int GetStereoCenterParity(sp_ATOM *at, int i, AT_RANK *nRank );
+int GetPermutationParity( sp_ATOM *at, AT_RANK nAvoidNeighbor, AT_RANK *nCanonRank );
+
+#ifndef INCHI_ALL_CPP
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+#endif /* __INCHICOMN_H__ */