Mercurial > repos > rliterman > csp2

annotate CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/lib/python3.8/site-packages/Bio/cpairwise2module.c @ 68:5028fdace37b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 16:23:26 -0400
parents
children
rev   line source
jpayne@68 1 /* Copyright 2002 by Jeffrey Chang.
jpayne@68 2 * Copyright 2016, 2019 by Markus Piotrowski.
jpayne@68 3 * All rights reserved.
jpayne@68 4 *
jpayne@68 5 * This file is part of the Biopython distribution and governed by your
jpayne@68 6 * choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
jpayne@68 7 * Please see the LICENSE file that should have been included as part of this
jpayne@68 8 * package.
jpayne@68 9 *
jpayne@68 10 * cpairwise2module.c
jpayne@68 11 * Created 30 Sep 2001
jpayne@68 12 *
jpayne@68 13 * Optimized C routines that complement pairwise2.py.
jpayne@68 14 */
jpayne@68 15
jpayne@68 16 #include "Python.h"
jpayne@68 17
jpayne@68 18
jpayne@68 19 #define _PRECISION 1000
jpayne@68 20 #define rint(x) (int)((x)*_PRECISION+0.5)
jpayne@68 21
jpayne@68 22 /* Functions in this module. */
jpayne@68 23
jpayne@68 24 static double calc_affine_penalty(int length, double open, double extend,
jpayne@68 25 int penalize_extend_when_opening)
jpayne@68 26 {
jpayne@68 27 double penalty;
jpayne@68 28
jpayne@68 29 if(length <= 0)
jpayne@68 30 return 0.0;
jpayne@68 31 penalty = open + extend * length;
jpayne@68 32 if(!penalize_extend_when_opening)
jpayne@68 33 penalty -= extend;
jpayne@68 34 return penalty;
jpayne@68 35 }
jpayne@68 36
jpayne@68 37 static double _get_match_score(PyObject *py_sequenceA, PyObject *py_sequenceB,
jpayne@68 38 PyObject *py_match_fn, int i, int j,
jpayne@68 39 char *sequenceA, char *sequenceB,
jpayne@68 40 int use_sequence_cstring,
jpayne@68 41 double match, double mismatch,
jpayne@68 42 int use_match_mismatch_scores)
jpayne@68 43 {
jpayne@68 44 PyObject *py_A=NULL, *py_B=NULL;
jpayne@68 45 PyObject *py_arglist=NULL, *py_result=NULL;
jpayne@68 46 double score = 0;
jpayne@68 47
jpayne@68 48 if(use_sequence_cstring && use_match_mismatch_scores) {
jpayne@68 49 score = (sequenceA[i] == sequenceB[j]) ? match : mismatch;
jpayne@68 50 return score;
jpayne@68 51 }
jpayne@68 52 /* Calculate the match score. */
jpayne@68 53 if(!(py_A = PySequence_GetItem(py_sequenceA, i)))
jpayne@68 54 goto _get_match_score_cleanup;
jpayne@68 55 if(!(py_B = PySequence_GetItem(py_sequenceB, j)))
jpayne@68 56 goto _get_match_score_cleanup;
jpayne@68 57 if(!(py_arglist = Py_BuildValue("(OO)", py_A, py_B)))
jpayne@68 58 goto _get_match_score_cleanup;
jpayne@68 59
jpayne@68 60 if(!(py_result = PyEval_CallObject(py_match_fn, py_arglist)))
jpayne@68 61 goto _get_match_score_cleanup;
jpayne@68 62 score = PyFloat_AsDouble(py_result);
jpayne@68 63
jpayne@68 64 _get_match_score_cleanup:
jpayne@68 65 if(py_A) {
jpayne@68 66 Py_DECREF(py_A);
jpayne@68 67 }
jpayne@68 68 if(py_B) {
jpayne@68 69 Py_DECREF(py_B);
jpayne@68 70 }
jpayne@68 71 if(py_arglist) {
jpayne@68 72 Py_DECREF(py_arglist);
jpayne@68 73 }
jpayne@68 74 if(py_result) {
jpayne@68 75 Py_DECREF(py_result);
jpayne@68 76 }
jpayne@68 77 return score;
jpayne@68 78 }
jpayne@68 79
jpayne@68 80 #if PY_MAJOR_VERSION >= 3
jpayne@68 81 static PyObject* _create_bytes_object(PyObject* o)
jpayne@68 82 {
jpayne@68 83 PyObject* b;
jpayne@68 84 if (PyBytes_Check(o)) {
jpayne@68 85 return o;
jpayne@68 86 }
jpayne@68 87 if (!PyUnicode_Check(o)) {
jpayne@68 88 return NULL;
jpayne@68 89 }
jpayne@68 90 b = PyUnicode_AsASCIIString(o);
jpayne@68 91 if (!b) {
jpayne@68 92 PyErr_Clear();
jpayne@68 93 return NULL;
jpayne@68 94 }
jpayne@68 95 return b;
jpayne@68 96 }
jpayne@68 97 #endif
jpayne@68 98
jpayne@68 99 /* This function is a more-or-less straightforward port of the
jpayne@68 100 * equivalent function in pairwise2. Please see there for algorithm
jpayne@68 101 * documentation.
jpayne@68 102 */
jpayne@68 103 static PyObject *cpairwise2__make_score_matrix_fast(PyObject *self,
jpayne@68 104 PyObject *args)
jpayne@68 105 {
jpayne@68 106 int i;
jpayne@68 107 int row, col;
jpayne@68 108 PyObject *py_sequenceA, *py_sequenceB, *py_match_fn;
jpayne@68 109 #if PY_MAJOR_VERSION >= 3
jpayne@68 110 PyObject *py_bytesA, *py_bytesB;
jpayne@68 111 #endif
jpayne@68 112 char *sequenceA=NULL, *sequenceB=NULL;
jpayne@68 113 int use_sequence_cstring;
jpayne@68 114 double open_A, extend_A, open_B, extend_B;
jpayne@68 115 int penalize_extend_when_opening, penalize_end_gaps_A, penalize_end_gaps_B;
jpayne@68 116 int align_globally, score_only;
jpayne@68 117
jpayne@68 118 PyObject *py_match=NULL, *py_mismatch=NULL;
jpayne@68 119 double first_A_gap, first_B_gap;
jpayne@68 120 double match, mismatch;
jpayne@68 121 double score;
jpayne@68 122 double best_score = 0;
jpayne@68 123 double local_max_score = 0;
jpayne@68 124 int use_match_mismatch_scores;
jpayne@68 125 int lenA, lenB;
jpayne@68 126 double *score_matrix = NULL;
jpayne@68 127 unsigned char *trace_matrix = NULL;
jpayne@68 128 PyObject *py_score_matrix=NULL, *py_trace_matrix=NULL;
jpayne@68 129
jpayne@68 130 double *col_cache_score = NULL;
jpayne@68 131 PyObject *py_retval = NULL;
jpayne@68 132
jpayne@68 133 if(!PyArg_ParseTuple(args, "OOOddddi(ii)ii", &py_sequenceA, &py_sequenceB,
jpayne@68 134 &py_match_fn, &open_A, &extend_A, &open_B, &extend_B,
jpayne@68 135 &penalize_extend_when_opening,
jpayne@68 136 &penalize_end_gaps_A, &penalize_end_gaps_B,
jpayne@68 137 &align_globally, &score_only))
jpayne@68 138 return NULL;
jpayne@68 139 if(!PySequence_Check(py_sequenceA) || !PySequence_Check(py_sequenceB)) {
jpayne@68 140 PyErr_SetString(PyExc_TypeError,
jpayne@68 141 "py_sequenceA and py_sequenceB should be sequences.");
jpayne@68 142 return NULL;
jpayne@68 143 }
jpayne@68 144
jpayne@68 145 /* Optimize for the common case. Check to see if py_sequenceA and
jpayne@68 146 py_sequenceB are strings. If they are, use the c string
jpayne@68 147 representation. */
jpayne@68 148 #if PY_MAJOR_VERSION < 3
jpayne@68 149 use_sequence_cstring = 0;
jpayne@68 150 if(PyString_Check(py_sequenceA) && PyString_Check(py_sequenceB)) {
jpayne@68 151 sequenceA = PyString_AS_STRING(py_sequenceA);
jpayne@68 152 sequenceB = PyString_AS_STRING(py_sequenceB);
jpayne@68 153 use_sequence_cstring = 1;
jpayne@68 154 }
jpayne@68 155 #else
jpayne@68 156 py_bytesA = _create_bytes_object(py_sequenceA);
jpayne@68 157 py_bytesB = _create_bytes_object(py_sequenceB);
jpayne@68 158 if (py_bytesA && py_bytesB) {
jpayne@68 159 sequenceA = PyBytes_AS_STRING(py_bytesA);
jpayne@68 160 sequenceB = PyBytes_AS_STRING(py_bytesB);
jpayne@68 161 use_sequence_cstring = 1;
jpayne@68 162 }
jpayne@68 163 else {
jpayne@68 164 Py_XDECREF(py_bytesA);
jpayne@68 165 Py_XDECREF(py_bytesB);
jpayne@68 166 use_sequence_cstring = 0;
jpayne@68 167 }
jpayne@68 168 #endif
jpayne@68 169
jpayne@68 170 if(!PyCallable_Check(py_match_fn)) {
jpayne@68 171 PyErr_SetString(PyExc_TypeError, "py_match_fn must be callable.");
jpayne@68 172 return NULL;
jpayne@68 173 }
jpayne@68 174 /* Optimize for the common case. Check to see if py_match_fn is
jpayne@68 175 an identity_match. If so, pull out the match and mismatch
jpayne@68 176 member variables and calculate the scores myself. */
jpayne@68 177 match = mismatch = 0;
jpayne@68 178 use_match_mismatch_scores = 0;
jpayne@68 179 if(!(py_match = PyObject_GetAttrString(py_match_fn, "match")))
jpayne@68 180 goto cleanup_after_py_match_fn;
jpayne@68 181 match = PyFloat_AsDouble(py_match);
jpayne@68 182 if(match==-1.0 && PyErr_Occurred())
jpayne@68 183 goto cleanup_after_py_match_fn;
jpayne@68 184 if(!(py_mismatch = PyObject_GetAttrString(py_match_fn, "mismatch")))
jpayne@68 185 goto cleanup_after_py_match_fn;
jpayne@68 186 mismatch = PyFloat_AsDouble(py_mismatch);
jpayne@68 187 if(mismatch==-1.0 && PyErr_Occurred())
jpayne@68 188 goto cleanup_after_py_match_fn;
jpayne@68 189 use_match_mismatch_scores = 1;
jpayne@68 190
jpayne@68 191 cleanup_after_py_match_fn:
jpayne@68 192 if(PyErr_Occurred())
jpayne@68 193 PyErr_Clear();
jpayne@68 194 if(py_match) {
jpayne@68 195 Py_DECREF(py_match);
jpayne@68 196 }
jpayne@68 197 if(py_mismatch) {
jpayne@68 198 Py_DECREF(py_mismatch);
jpayne@68 199 }
jpayne@68 200 /* Cache some commonly used gap penalties */
jpayne@68 201 first_A_gap = calc_affine_penalty(1, open_A, extend_A,
jpayne@68 202 penalize_extend_when_opening);
jpayne@68 203 first_B_gap = calc_affine_penalty(1, open_B, extend_B,
jpayne@68 204 penalize_extend_when_opening);
jpayne@68 205
jpayne@68 206 /* Allocate matrices for storing the results and initialize first row and col. */
jpayne@68 207 lenA = PySequence_Length(py_sequenceA);
jpayne@68 208 lenB = PySequence_Length(py_sequenceB);
jpayne@68 209 score_matrix = malloc((lenA+1)*(lenB+1)*sizeof(*score_matrix));
jpayne@68 210 if(!score_matrix) {
jpayne@68 211 PyErr_SetString(PyExc_MemoryError, "Out of memory");
jpayne@68 212 goto _cleanup_make_score_matrix_fast;
jpayne@68 213 }
jpayne@68 214 for(i=0; i<(lenB+1); i++)
jpayne@68 215 score_matrix[i] = 0;
jpayne@68 216 for(i=0; i<(lenA+1)*(lenB+1); i += (lenB+1))
jpayne@68 217 score_matrix[i] = 0;
jpayne@68 218 /* If we only want the score, we don't need the trace matrix. */
jpayne@68 219 if (!score_only){
jpayne@68 220 trace_matrix = malloc((lenA+1)*(lenB+1)*sizeof(*trace_matrix));
jpayne@68 221 if(!trace_matrix) {
jpayne@68 222 PyErr_SetString(PyExc_MemoryError, "Out of memory");
jpayne@68 223 goto _cleanup_make_score_matrix_fast;
jpayne@68 224 }
jpayne@68 225 for(i=0; i<(lenB+1); i++)
jpayne@68 226 trace_matrix[i] = 0;
jpayne@68 227 for(i=0; i<(lenA+1)*(lenB+1); i += (lenB+1))
jpayne@68 228 trace_matrix[i] = 0;
jpayne@68 229 }
jpayne@68 230 else
jpayne@68 231 trace_matrix = malloc(1);
jpayne@68 232
jpayne@68 233 /* Initialize the first row and col of the score matrix. */
jpayne@68 234 for(i=0; i<=lenA; i++) {
jpayne@68 235 if(penalize_end_gaps_B)
jpayne@68 236 score = calc_affine_penalty(i, open_B, extend_B,
jpayne@68 237 penalize_extend_when_opening);
jpayne@68 238 else
jpayne@68 239 score = 0;
jpayne@68 240 score_matrix[i*(lenB+1)] = score;
jpayne@68 241 }
jpayne@68 242 for(i=0; i<=lenB; i++) {
jpayne@68 243 if(penalize_end_gaps_A)
jpayne@68 244 score = calc_affine_penalty(i, open_A, extend_A,
jpayne@68 245 penalize_extend_when_opening);
jpayne@68 246 else
jpayne@68 247 score = 0;
jpayne@68 248 score_matrix[i] = score;
jpayne@68 249 }
jpayne@68 250
jpayne@68 251 /* Now initialize the col cache. */
jpayne@68 252 col_cache_score = malloc((lenB+1)*sizeof(*col_cache_score));
jpayne@68 253 memset((void *)col_cache_score, 0, (lenB+1)*sizeof(*col_cache_score));
jpayne@68 254 for(i=0; i<=lenB; i++) {
jpayne@68 255 col_cache_score[i] = calc_affine_penalty(i, (2*open_B), extend_B,
jpayne@68 256 penalize_extend_when_opening);
jpayne@68 257 }
jpayne@68 258
jpayne@68 259 /* Fill in the score matrix. The row cache is calculated on the fly.*/
jpayne@68 260 for(row=1; row<=lenA; row++) {
jpayne@68 261 double row_cache_score = calc_affine_penalty(row, (2*open_A), extend_A,
jpayne@68 262 penalize_extend_when_opening);
jpayne@68 263 for(col=1; col<=lenB; col++) {
jpayne@68 264 double match_score, nogap_score;
jpayne@68 265 double row_open, row_extend, col_open, col_extend;
jpayne@68 266 int best_score_rint, row_score_rint, col_score_rint;
jpayne@68 267 unsigned char row_trace_score, col_trace_score, trace_score;
jpayne@68 268
jpayne@68 269 /* Calculate the best score. */
jpayne@68 270 match_score = _get_match_score(py_sequenceA, py_sequenceB,
jpayne@68 271 py_match_fn, row-1, col-1,
jpayne@68 272 sequenceA, sequenceB,
jpayne@68 273 use_sequence_cstring,
jpayne@68 274 match, mismatch,
jpayne@68 275 use_match_mismatch_scores);
jpayne@68 276 if(match_score==-1.0 && PyErr_Occurred())
jpayne@68 277 goto _cleanup_make_score_matrix_fast;
jpayne@68 278 nogap_score = score_matrix[(row-1)*(lenB+1)+col-1] + match_score;
jpayne@68 279
jpayne@68 280 if (!penalize_end_gaps_A && row==lenA) {
jpayne@68 281 row_open = score_matrix[(row)*(lenB+1)+col-1];
jpayne@68 282 row_extend = row_cache_score;
jpayne@68 283 }
jpayne@68 284 else {
jpayne@68 285 row_open = score_matrix[(row)*(lenB+1)+col-1] + first_A_gap;
jpayne@68 286 row_extend = row_cache_score + extend_A;
jpayne@68 287 }
jpayne@68 288 row_cache_score = (row_open > row_extend) ? row_open : row_extend;
jpayne@68 289
jpayne@68 290 if (!penalize_end_gaps_B && col==lenB){
jpayne@68 291 col_open = score_matrix[(row-1)*(lenB+1)+col];
jpayne@68 292 col_extend = col_cache_score[col];
jpayne@68 293 }
jpayne@68 294 else {
jpayne@68 295 col_open = score_matrix[(row-1)*(lenB+1)+col] + first_B_gap;
jpayne@68 296 col_extend = col_cache_score[col] + extend_B;
jpayne@68 297 }
jpayne@68 298 col_cache_score[col] = (col_open > col_extend) ? col_open : col_extend;
jpayne@68 299
jpayne@68 300 best_score = (row_cache_score > col_cache_score[col]) ? row_cache_score : col_cache_score[col];
jpayne@68 301 if(nogap_score > best_score)
jpayne@68 302 best_score = nogap_score;
jpayne@68 303
jpayne@68 304 if (best_score > local_max_score)
jpayne@68 305 local_max_score = best_score;
jpayne@68 306
jpayne@68 307 if(!align_globally && best_score < 0)
jpayne@68 308 score_matrix[row*(lenB+1)+col] = 0;
jpayne@68 309 else
jpayne@68 310 score_matrix[row*(lenB+1)+col] = best_score;
jpayne@68 311
jpayne@68 312 if (!score_only) {
jpayne@68 313 row_score_rint = rint(row_cache_score);
jpayne@68 314 col_score_rint = rint(col_cache_score[col]);
jpayne@68 315 row_trace_score = 0;
jpayne@68 316 col_trace_score = 0;
jpayne@68 317 if (rint(row_open) == row_score_rint)
jpayne@68 318 row_trace_score = row_trace_score|1;
jpayne@68 319 if (rint(row_extend) == row_score_rint)
jpayne@68 320 row_trace_score = row_trace_score|8;
jpayne@68 321 if (rint(col_open) == col_score_rint)
jpayne@68 322 col_trace_score = col_trace_score|4;
jpayne@68 323 if (rint(col_extend) == col_score_rint)
jpayne@68 324 col_trace_score = col_trace_score|16;
jpayne@68 325
jpayne@68 326 trace_score = 0;
jpayne@68 327 best_score_rint = rint(best_score);
jpayne@68 328 if (rint(nogap_score) == best_score_rint)
jpayne@68 329 trace_score = trace_score|2;
jpayne@68 330 if (row_score_rint == best_score_rint)
jpayne@68 331 trace_score += row_trace_score;
jpayne@68 332 if (col_score_rint == best_score_rint)
jpayne@68 333 trace_score += col_trace_score;
jpayne@68 334 trace_matrix[row*(lenB+1)+col] = trace_score;
jpayne@68 335 }
jpayne@68 336 }
jpayne@68 337 }
jpayne@68 338
jpayne@68 339 if (!align_globally)
jpayne@68 340 best_score = local_max_score;
jpayne@68 341
jpayne@68 342 /* Save the score and traceback matrices into real python objects. */
jpayne@68 343 if(!score_only) {
jpayne@68 344 if(!(py_score_matrix = PyList_New(lenA+1)))
jpayne@68 345 goto _cleanup_make_score_matrix_fast;
jpayne@68 346 if(!(py_trace_matrix = PyList_New(lenA+1)))
jpayne@68 347 goto _cleanup_make_score_matrix_fast;
jpayne@68 348
jpayne@68 349 for(row=0; row<=lenA; row++) {
jpayne@68 350 PyObject *py_score_row, *py_trace_row;
jpayne@68 351 if(!(py_score_row = PyList_New(lenB+1)))
jpayne@68 352 goto _cleanup_make_score_matrix_fast;
jpayne@68 353 PyList_SET_ITEM(py_score_matrix, row, py_score_row);
jpayne@68 354 if(!(py_trace_row = PyList_New(lenB+1)))
jpayne@68 355 goto _cleanup_make_score_matrix_fast;
jpayne@68 356 PyList_SET_ITEM(py_trace_matrix, row, py_trace_row);
jpayne@68 357
jpayne@68 358 for(col=0; col<=lenB; col++) {
jpayne@68 359 PyObject *py_score, *py_trace;
jpayne@68 360 int offset = row*(lenB+1) + col;
jpayne@68 361
jpayne@68 362 /* Set py_score_matrix[row][col] to the score. */
jpayne@68 363 if(!(py_score = PyFloat_FromDouble(score_matrix[offset])))
jpayne@68 364 goto _cleanup_make_score_matrix_fast;
jpayne@68 365 PyList_SET_ITEM(py_score_row, col, py_score);
jpayne@68 366
jpayne@68 367 /* Set py_trace_matrix[row][col] to a list of indexes. On
jpayne@68 368 the edges of the matrix (row or column is 0), the
jpayne@68 369 matrix should be [None]. */
jpayne@68 370 if(!row || !col) {
jpayne@68 371 if(!(py_trace = Py_BuildValue("B", 1)))
jpayne@68 372 goto _cleanup_make_score_matrix_fast;
jpayne@68 373 Py_INCREF(Py_None);
jpayne@68 374 PyList_SET_ITEM(py_trace_row, col, Py_None);
jpayne@68 375 }
jpayne@68 376 else {
jpayne@68 377 if(!(py_trace = Py_BuildValue("B", trace_matrix[offset])))
jpayne@68 378 goto _cleanup_make_score_matrix_fast;
jpayne@68 379 PyList_SET_ITEM(py_trace_row, col, py_trace);
jpayne@68 380
jpayne@68 381 }
jpayne@68 382 }
jpayne@68 383 }
jpayne@68 384 }
jpayne@68 385 else {
jpayne@68 386 py_score_matrix = PyList_New(1);
jpayne@68 387 py_trace_matrix = PyList_New(1);
jpayne@68 388 }
jpayne@68 389 py_retval = Py_BuildValue("(OOd)", py_score_matrix, py_trace_matrix, best_score);
jpayne@68 390
jpayne@68 391 _cleanup_make_score_matrix_fast:
jpayne@68 392 if(score_matrix)
jpayne@68 393 free(score_matrix);
jpayne@68 394 if(trace_matrix)
jpayne@68 395 free(trace_matrix);
jpayne@68 396 if(col_cache_score)
jpayne@68 397 free(col_cache_score);
jpayne@68 398 if(py_score_matrix){
jpayne@68 399 Py_DECREF(py_score_matrix);
jpayne@68 400 }
jpayne@68 401 if(py_trace_matrix){
jpayne@68 402 Py_DECREF(py_trace_matrix);
jpayne@68 403 }
jpayne@68 404
jpayne@68 405 #if PY_MAJOR_VERSION >= 3
jpayne@68 406 if (py_bytesA != NULL && py_bytesA != py_sequenceA) Py_DECREF(py_bytesA);
jpayne@68 407 if (py_bytesB != NULL && py_bytesB != py_sequenceB) Py_DECREF(py_bytesB);
jpayne@68 408 #endif
jpayne@68 409
jpayne@68 410 return py_retval;
jpayne@68 411 }
jpayne@68 412
jpayne@68 413 static PyObject *cpairwise2_rint(PyObject *self, PyObject *args,
jpayne@68 414 PyObject *keywds)
jpayne@68 415 {
jpayne@68 416 double x;
jpayne@68 417 int precision = _PRECISION;
jpayne@68 418 int rint_x;
jpayne@68 419
jpayne@68 420 static char *kwlist[] = {"x", "precision", NULL};
jpayne@68 421
jpayne@68 422 if(!PyArg_ParseTupleAndKeywords(args, keywds, "d|l", kwlist,
jpayne@68 423 &x, &precision))
jpayne@68 424 return NULL;
jpayne@68 425 rint_x = (int)(x * precision + 0.5);
jpayne@68 426 #if PY_MAJOR_VERSION >= 3
jpayne@68 427 return PyLong_FromLong((long)rint_x);
jpayne@68 428 #else
jpayne@68 429 return PyInt_FromLong((long)rint_x);
jpayne@68 430 #endif
jpayne@68 431 }
jpayne@68 432
jpayne@68 433 /* Module definition stuff */
jpayne@68 434
jpayne@68 435 static PyMethodDef cpairwise2Methods[] = {
jpayne@68 436 {"_make_score_matrix_fast",
jpayne@68 437 (PyCFunction)cpairwise2__make_score_matrix_fast, METH_VARARGS, ""},
jpayne@68 438 {"rint", (PyCFunction)cpairwise2_rint, METH_VARARGS|METH_KEYWORDS, ""},
jpayne@68 439 {NULL, NULL, 0, NULL}
jpayne@68 440 };
jpayne@68 441
jpayne@68 442 static char cpairwise2__doc__[] =
jpayne@68 443 "Optimized C routines that complement pairwise2.py. These are called from within pairwise2.py.\n\
jpayne@68 444 \n\
jpayne@68 445 ";
jpayne@68 446
jpayne@68 447 #if PY_MAJOR_VERSION >= 3
jpayne@68 448
jpayne@68 449 static struct PyModuleDef moduledef = {
jpayne@68 450 PyModuleDef_HEAD_INIT,
jpayne@68 451 "cpairwise2",
jpayne@68 452 cpairwise2__doc__,
jpayne@68 453 -1,
jpayne@68 454 cpairwise2Methods,
jpayne@68 455 NULL,
jpayne@68 456 NULL,
jpayne@68 457 NULL,
jpayne@68 458 NULL
jpayne@68 459 };
jpayne@68 460
jpayne@68 461 PyObject *
jpayne@68 462 PyInit_cpairwise2(void)
jpayne@68 463
jpayne@68 464 #else
jpayne@68 465
jpayne@68 466 void
jpayne@68 467 /* for Windows: _declspec(dllexport) initcpairwise2(void) */
jpayne@68 468 initcpairwise2(void)
jpayne@68 469 #endif
jpayne@68 470
jpayne@68 471 {
jpayne@68 472 #if PY_MAJOR_VERSION >= 3
jpayne@68 473 PyObject* module = PyModule_Create(&moduledef);
jpayne@68 474 if (module==NULL) return NULL;
jpayne@68 475 return module;
jpayne@68 476 #else
jpayne@68 477 (void) Py_InitModule3("cpairwise2", cpairwise2Methods, cpairwise2__doc__);
jpayne@68 478 #endif
jpayne@68 479 }