[Scipy-svn] r2510 - trunk/Lib/sparse/sparsetools
scipy-svn at scipy.org
scipy-svn at scipy.org
Tue Jan 9 06:36:51 EST 2007
Author: wnbell
Date: 2007-01-09 05:36:44 -0600 (Tue, 09 Jan 2007)
New Revision: 2510
Modified:
trunk/Lib/sparse/sparsetools/numpy.i
trunk/Lib/sparse/sparsetools/sparsetools.h
trunk/Lib/sparse/sparsetools/sparsetools.i
trunk/Lib/sparse/sparsetools/sparsetools.py
trunk/Lib/sparse/sparsetools/sparsetools_wrap.cxx
Log:
Templated index types in sparsetools.h
Consolidated redundant code in sparsetools.i
regenerated SWIG wrappers
Modified: trunk/Lib/sparse/sparsetools/numpy.i
===================================================================
--- trunk/Lib/sparse/sparsetools/numpy.i 2007-01-09 05:49:05 UTC (rev 2509)
+++ trunk/Lib/sparse/sparsetools/numpy.i 2007-01-09 11:36:44 UTC (rev 2510)
@@ -41,11 +41,14 @@
/* Given a Numeric typecode, return a string describing the type.
*/
-char* typecode_string(int typecode) {
- char* type_names[20] = {"char","unsigned byte","byte","short",
- "unsigned short","int","unsigned int","long",
- "float","double","complex float","complex double",
- "object","ntype","unkown"};
+char* type_names[20] = {"char","unsigned byte","byte","short",
+ "unsigned short","int","unsigned int","long",
+ "float","double","complex float","complex double",
+ "object","ntype","unkown"};
+ char* typecode_string(int typecode) {
+ if(typecode < 0 || typecode > 19)
+ typecode = 19;
+
return type_names[typecode];
}
@@ -298,7 +301,7 @@
/* Define concrete examples of the TYPEMAP_IN1 macros */
TYPEMAP_IN1(char, PyArray_CHAR )
TYPEMAP_IN1(unsigned char, PyArray_UBYTE )
-TYPEMAP_IN1(signed char, PyArray_SBYTE )
+TYPEMAP_IN1(signed char, PyArray_BYTE )
TYPEMAP_IN1(short, PyArray_SHORT )
TYPEMAP_IN1(int, PyArray_INT )
TYPEMAP_IN1(long, PyArray_LONG )
@@ -310,7 +313,7 @@
TYPEMAP_IN1(npy_clongdouble, PyArray_CLONGDOUBLE)
TYPEMAP_IN1(const char, PyArray_CHAR )
TYPEMAP_IN1(const unsigned char, PyArray_UBYTE )
-TYPEMAP_IN1(const signed char, PyArray_SBYTE )
+TYPEMAP_IN1(const signed char, PyArray_BYTE )
TYPEMAP_IN1(const short, PyArray_SHORT )
TYPEMAP_IN1(const int, PyArray_INT )
TYPEMAP_IN1(const long, PyArray_LONG )
@@ -344,7 +347,7 @@
/* Define concrete examples of the TYPEMAP_IN2 macros */
TYPEMAP_IN2(char, PyArray_CHAR )
TYPEMAP_IN2(unsigned char, PyArray_UBYTE )
-TYPEMAP_IN2(signed char, PyArray_SBYTE )
+TYPEMAP_IN2(signed char, PyArray_BYTE )
TYPEMAP_IN2(short, PyArray_SHORT )
TYPEMAP_IN2(int, PyArray_INT )
TYPEMAP_IN2(long, PyArray_LONG )
@@ -356,7 +359,7 @@
TYPEMAP_IN2(npy_clongdouble, PyArray_CLONGDOUBLE)
TYPEMAP_IN2(const char, PyArray_CHAR )
TYPEMAP_IN2(const unsigned char, PyArray_UBYTE )
-TYPEMAP_IN2(const signed char, PyArray_SBYTE )
+TYPEMAP_IN2(const signed char, PyArray_BYTE )
TYPEMAP_IN2(const short, PyArray_SHORT )
TYPEMAP_IN2(const int, PyArray_INT )
TYPEMAP_IN2(const long, PyArray_LONG )
@@ -408,7 +411,7 @@
/* Define concrete examples of the TYPEMAP_INPLACE1 macro */
TYPEMAP_INPLACE1(char, PyArray_CHAR )
TYPEMAP_INPLACE1(unsigned char, PyArray_UBYTE )
-TYPEMAP_INPLACE1(signed char, PyArray_SBYTE )
+TYPEMAP_INPLACE1(signed char, PyArray_BYTE )
TYPEMAP_INPLACE1(short, PyArray_SHORT )
TYPEMAP_INPLACE1(int, PyArray_INT )
TYPEMAP_INPLACE1(long, PyArray_LONG )
@@ -420,7 +423,7 @@
TYPEMAP_INPLACE1(npy_clongdouble, PyArray_CLONGDOUBLE)
TYPEMAP_INPLACE1(const char, PyArray_CHAR )
TYPEMAP_INPLACE1(const unsigned char, PyArray_UBYTE )
-TYPEMAP_INPLACE1(const signed char, PyArray_SBYTE )
+TYPEMAP_INPLACE1(const signed char, PyArray_BYTE )
TYPEMAP_INPLACE1(const short, PyArray_SHORT )
TYPEMAP_INPLACE1(const int, PyArray_INT )
TYPEMAP_INPLACE1(const long, PyArray_LONG )
@@ -450,7 +453,7 @@
/* Define concrete examples of the TYPEMAP_INPLACE2 macro */
TYPEMAP_INPLACE2(char, PyArray_CHAR )
TYPEMAP_INPLACE2(unsigned char, PyArray_UBYTE )
-TYPEMAP_INPLACE2(signed char, PyArray_SBYTE )
+TYPEMAP_INPLACE2(signed char, PyArray_BYTE )
TYPEMAP_INPLACE2(short, PyArray_SHORT )
TYPEMAP_INPLACE2(int, PyArray_INT )
TYPEMAP_INPLACE2(long, PyArray_LONG )
@@ -462,7 +465,7 @@
TYPEMAP_INPLACE2(npy_clongdouble, PyArray_CLONGDOUBLE)
TYPEMAP_INPLACE2(const char, PyArray_CHAR )
TYPEMAP_INPLACE2(const unsigned char, PyArray_UBYTE )
-TYPEMAP_INPLACE2(const signed char, PyArray_SBYTE )
+TYPEMAP_INPLACE2(const signed char, PyArray_BYTE )
TYPEMAP_INPLACE2(const short, PyArray_SHORT )
TYPEMAP_INPLACE2(const int, PyArray_INT )
TYPEMAP_INPLACE2(const long, PyArray_LONG )
@@ -521,7 +524,7 @@
/* Define concrete examples of the TYPEMAP_ARGOUT1 macro */
TYPEMAP_ARGOUT1(char, PyArray_CHAR )
TYPEMAP_ARGOUT1(unsigned char, PyArray_UBYTE )
-TYPEMAP_ARGOUT1(signed char, PyArray_SBYTE )
+TYPEMAP_ARGOUT1(signed char, PyArray_BYTE )
TYPEMAP_ARGOUT1(short, PyArray_SHORT )
TYPEMAP_ARGOUT1(int, PyArray_INT )
TYPEMAP_ARGOUT1(long, PyArray_LONG )
@@ -549,7 +552,7 @@
/* Define concrete examples of the TYPEMAP_ARGOUT2 macro */
TYPEMAP_ARGOUT2(char, PyArray_CHAR )
TYPEMAP_ARGOUT2(unsigned char, PyArray_UBYTE )
-TYPEMAP_ARGOUT2(signed char, PyArray_SBYTE )
+TYPEMAP_ARGOUT2(signed char, PyArray_BYTE )
TYPEMAP_ARGOUT2(short, PyArray_SHORT )
TYPEMAP_ARGOUT2(int, PyArray_INT )
TYPEMAP_ARGOUT2(long, PyArray_LONG )
Modified: trunk/Lib/sparse/sparsetools/sparsetools.h
===================================================================
--- trunk/Lib/sparse/sparsetools/sparsetools.h 2007-01-09 05:49:05 UTC (rev 2509)
+++ trunk/Lib/sparse/sparsetools/sparsetools.h 2007-01-09 11:36:44 UTC (rev 2510)
@@ -10,6 +10,7 @@
* Nathan Bell
*
* Revisions:
+ * 01/09/2007 - index type is now templated
* 01/06/2007 - initial inclusion into SciPy
*
*/
@@ -25,6 +26,10 @@
/*
* Return zero of the appropriate type
+ *
+ * this is a workaround for NumPy complex types
+ * where T x = 0; doesn't make sense.
+ *
*/
template <class T>
T ZERO(){
@@ -43,16 +48,16 @@
* - convert CSC->CSR
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
*
* Output Arguments:
- * vec<int> Bp - row pointer
- * vec<int> Bj - column indices
- * vec<T> Bx - nonzeros
+ * vec<I> Bp - row pointer
+ * vec<I> Bj - column indices
+ * vec<T> Bx - nonzeros
*
* Note:
* Output arrays Bp,Bj,Bx will be allocated within in the method
@@ -64,43 +69,43 @@
* Complexity: Linear. Specifically O(nnz(A) + max(n_row,n_col))
*
*/
-template <class T>
-void csrtocsc(const int n_row,
- const int n_col,
- const int Ap[],
- const int Aj[],
- const T Ax[],
- std::vector<int>* Bp,
- std::vector<int>* Bi,
- std::vector<T>* Bx)
+template <class I, class T>
+void csrtocsc(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Aj[],
+ const T Ax[],
+ std::vector<I>* Bp,
+ std::vector<I>* Bi,
+ std::vector<T>* Bx)
{
- int NNZ = Ap[n_row];
+ I NNZ = Ap[n_row];
- *Bp = std::vector<int>(n_col+1);
- *Bi = std::vector<int>(NNZ);
+ *Bp = std::vector<I>(n_col+1);
+ *Bi = std::vector<I>(NNZ);
*Bx = std::vector<T>(NNZ);
- std::vector<int> nnz_per_col(n_col,0); //temp array
+ std::vector<I> nnz_per_col(n_col,0); //temp array
//compute number of non-zero entries per column of A
- for (int i = 0; i < NNZ; i++){
+ for (I i = 0; i < NNZ; i++){
nnz_per_col[Aj[i]]++;
}
//cumsum the nnz_per_col to get Bp[]
- for(int i = 0, cumsum = 0; i < n_col; i++){
+ for(I i = 0, cumsum = 0; i < n_col; i++){
(*Bp)[i] = cumsum;
cumsum += nnz_per_col[i];
nnz_per_col[i] = 0; //reset count
}
(*Bp)[n_col] = NNZ;
- for(int i = 0; i < n_row; i++){
- int row_start = Ap[i];
- int row_end = Ap[i+1];
- for(int j = row_start; j < row_end; j++){
- int col = Aj[j];
- int k = (*Bp)[col] + nnz_per_col[col];
+ for(I i = 0; i < n_row; i++){
+ I row_start = Ap[i];
+ I row_end = Ap[i+1];
+ for(I j = row_start; j < row_end; j++){
+ I col = Aj[j];
+ I k = (*Bp)[col] + nnz_per_col[col];
(*Bi)[k] = i;
(*Bx)[k] = Ax[j];
@@ -120,16 +125,16 @@
* - convert CSC->COO
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
*
* Output Arguments:
- * vec<int> Bi - row indices
- * vec<int> Bj - column indices
- * vec<T> Bx - nonzeros
+ * vec<I> Bi - row indices
+ * vec<I> Bj - column indices
+ * vec<T> Bx - nonzeros
*
* Note:
* Output arrays Bi,Bj,Bx will be allocated within in the method
@@ -138,20 +143,20 @@
* Complexity: Linear.
*
*/
-template<class T>
-void csrtocoo(const int n_row,
- const int n_col,
- const int Ap [],
- const int Aj[],
- const T Ax[],
- std::vector<int>* Bi,
- std::vector<int>* Bj,
+template <class I, class T>
+void csrtocoo(const I n_row,
+ const I n_col,
+ const I Ap [],
+ const I Aj[],
+ const T Ax[],
+ std::vector<I>* Bi,
+ std::vector<I>* Bj,
std::vector<T>* Bx)
{
- for(int i = 0; i < n_row; i++){
- int row_start = Ap[i];
- int row_end = Ap[i+1];
- for(int jj = row_start; jj < row_end; jj++){
+ for(I i = 0; i < n_row; i++){
+ I row_start = Ap[i];
+ I row_end = Ap[i+1];
+ for(I jj = row_start; jj < row_end; jj++){
Bi->push_back(i);
Bj->push_back(Aj[jj]);
Bx->push_back(Ax[jj]);
@@ -166,18 +171,18 @@
*
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in B (hence C is n_row by n_col)
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
- * int Bp[?] - row pointer
- * int Bj[nnz(B)] - column indices
- * T Bx[nnz(B)] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in B (hence C is n_row by n_col)
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
+ * I Bp[?] - row pointer
+ * I Bj[nnz(B)] - column indices
+ * T Bx[nnz(B)] - nonzeros
* Output Arguments:
- * vec<int> Cp - row pointer
- * vec<int> Cj - column indices
- * vec<T> Cx - nonzeros
+ * vec<I> Cp - row pointer
+ * vec<I> Cj - column indices
+ * vec<T> Cx - nonzeros
*
* Note:
* Output arrays Cp,Cj, and Cx will be allocated within in the method
@@ -201,36 +206,34 @@
* http://www.mgnet.org/~douglas/ccd-codes.html
*
*/
-template<class T>
-void csrmucsr(const int n_row,
- const int n_col,
- const int Ap [],
- const int Aj[],
+template <class I, class T>
+void csrmucsr(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Aj[],
const T Ax[],
- const int Bp[],
- const int Bj[],
+ const I Bp[],
+ const I Bj[],
const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Cj,
+ std::vector<I>* Cp,
+ std::vector<I>* Cj,
std::vector<T>* Cx)
{
- *Cp = std::vector<int>(n_row+1,0);
- Cj->clear();
- Cx->clear();
+ *Cp = std::vector<I>(n_row+1,0);
const T zero = ZERO<T>();
- std::vector<int> index(n_col,-1);
+ std::vector<I> index(n_col,-1);
std::vector<T> sums(n_col,zero);
- for(int i = 0; i < n_row; i++){
- int istart = -1;
- int length = 0;
+ for(I i = 0; i < n_row; i++){
+ I istart = -1;
+ I length = 0;
- for(int jj = Ap[i]; jj < Ap[i+1]; jj++){
- int j = Aj[jj];
- for(int kk = Bp[j]; kk < Bp[j+1]; kk++){
- int k = Bj[kk];
+ for(I jj = Ap[i]; jj < Ap[i+1]; jj++){
+ I j = Aj[jj];
+ for(I kk = Bp[j]; kk < Bp[j+1]; kk++){
+ I k = Bj[kk];
sums[k] += Ax[jj]*Bx[kk];
@@ -242,13 +245,13 @@
}
}
- for(int jj = 0; jj < length; jj++){
+ for(I jj = 0; jj < length; jj++){
if(sums[istart] != zero){
Cj->push_back(istart);
Cx->push_back(sums[istart]);
}
- int temp = istart;
+ I temp = istart;
istart = index[istart];
index[temp] = -1; //clear arrays
@@ -267,18 +270,18 @@
*
*
* Input Arguments:
- * int n_row - number of rows in A (and B)
- * int n_col - number of columns in A (and B)
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
- * int Bp[?] - row pointer
- * int Bj[nnz(B)] - column indices
- * T Bx[nnz(B)] - nonzeros
+ * I n_row - number of rows in A (and B)
+ * I n_col - number of columns in A (and B)
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
+ * I Bp[?] - row pointer
+ * I Bj[nnz(B)] - column indices
+ * T Bx[nnz(B)] - nonzeros
* Output Arguments:
- * vec<int> Cp - row pointer
- * vec<int> Cj - column indices
- * vec<T> Cx - nonzeros
+ * vec<I> Cp - row pointer
+ * vec<I> Cj - column indices
+ * vec<T> Cx - nonzeros
*
* Note:
* Output arrays Cp,Cj, and Cx will be allocated within in the method
@@ -289,36 +292,34 @@
* Cx will not contain any zero entries
*
*/
-template <class T>
-void csrplcsr(const int n_row,
- const int n_col,
- const int Ap[],
- const int Aj[],
- const T Ax[],
- const int Bp[],
- const int Bj[],
- const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Cj,
- std::vector<T> * Cx)
+template <class I, class T>
+void csrplcsr(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Aj[],
+ const T Ax[],
+ const I Bp[],
+ const I Bj[],
+ const T Bx[],
+ std::vector<I>* Cp,
+ std::vector<I>* Cj,
+ std::vector<T>* Cx)
{
- *Cp = std::vector<int>(n_row+1,0);
- Cj->clear();
- Cx->clear();
+ *Cp = std::vector<I>(n_row+1,0);
const T zero = ZERO<T>();
- std::vector<int> index(n_col,-1);
- std::vector<T> sums(n_col,zero);
+ std::vector<I> index(n_col,-1);
+ std::vector<T> sums(n_col,zero);
- for(int i = 0; i < n_row; i++){
- int istart = -1;
- int length = 0;
+ for(I i = 0; i < n_row; i++){
+ I istart = -1;
+ I length = 0;
//add a row of A to sums
- for(int jj = Ap[i]; jj < Ap[i+1]; jj++){
- int j = Aj[jj];
+ for(I jj = Ap[i]; jj < Ap[i+1]; jj++){
+ I j = Aj[jj];
sums[j] += Ax[jj];
if(index[j] == -1){
@@ -329,8 +330,8 @@
}
//add a row of B to sums
- for(int jj = Bp[i]; jj < Bp[i+1]; jj++){
- int j = Bj[jj];
+ for(I jj = Bp[i]; jj < Bp[i+1]; jj++){
+ I j = Bj[jj];
sums[j] += Bx[jj];
if(index[j] == -1){
@@ -341,13 +342,13 @@
}
- for(int jj = 0; jj < length; jj++){
+ for(I jj = 0; jj < length; jj++){
if(sums[istart] != zero){
Cj->push_back(istart);
Cx->push_back(sums[istart]);
}
- int temp = istart;
+ I temp = istart;
istart = index[istart];
index[temp] = -1;
@@ -364,18 +365,18 @@
* (elmul) - elementwise multiplication
*
* Input Arguments:
- * int n_row - number of rows in A (and B)
- * int n_col - number of columns in A (and B)
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
- * int Bp[?] - row pointer
- * int Bj[nnz(B)] - column indices
- * T Bx[nnz(B)] - nonzeros
+ * I n_row - number of rows in A (and B)
+ * I n_col - number of columns in A (and B)
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
+ * I Bp[?] - row pointer
+ * I Bj[nnz(B)] - column indices
+ * T Bx[nnz(B)] - nonzeros
* Output Arguments:
- * vec<int> Cp - row pointer
- * vec<int> Cj - column indices
- * vec<T> Cx - nonzeros
+ * vec<I> Cp - row pointer
+ * vec<I> Cj - column indices
+ * vec<T> Cx - nonzeros
*
* Note:
* Output arrays Cp,Cj, and Cx will be allocated within in the method
@@ -386,36 +387,34 @@
* Cx will not contain any zero entries
*
*/
-template <class T>
-void csrelmulcsr(const int n_row,
- const int n_col,
- const int Ap [],
- const int Aj[],
- const T Ax[],
- const int Bp[],
- const int Bj[],
- const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Cj,
- std::vector<T>* Cx)
+template <class I, class T>
+void csrelmulcsr(const I n_row,
+ const I n_col,
+ const I Ap [],
+ const I Aj[],
+ const T Ax[],
+ const I Bp[],
+ const I Bj[],
+ const T Bx[],
+ std::vector<I>* Cp,
+ std::vector<I>* Cj,
+ std::vector<T>* Cx)
{
- *Cp = std::vector<int>(n_row+1,0);
- Cj->clear();
- Cx->clear();
+ *Cp = std::vector<I>(n_row+1,0);
const T zero = ZERO<T>();
- std::vector<int> index(n_col,-1);
+ std::vector<I> index(n_col,-1);
std::vector<T> A_row(n_col,zero);
std::vector<T> B_row(n_col,zero);
- for(int i = 0; i < n_row; i++){
- int istart = -1;
- int length = 0;
+ for(I i = 0; i < n_row; i++){
+ I istart = -1;
+ I length = 0;
//add a row of A to A_row
- for(int jj = Ap[i]; jj < Ap[i+1]; jj++){
- int j = Aj[jj];
+ for(I jj = Ap[i]; jj < Ap[i+1]; jj++){
+ I j = Aj[jj];
A_row[j] += Ax[jj];
@@ -427,8 +426,8 @@
}
//add a row of B to B_row
- for(int jj = Bp[i]; jj < Bp[i+1]; jj++){
- int j = Bj[jj];
+ for(I jj = Bp[i]; jj < Bp[i+1]; jj++){
+ I j = Bj[jj];
B_row[j] += Bx[jj];
@@ -440,7 +439,7 @@
}
- for(int jj = 0; jj < length; jj++){
+ for(I jj = 0; jj < length; jj++){
T prod = A_row[istart] * B_row[istart];
if(prod != zero){
@@ -448,7 +447,7 @@
Cx->push_back(prod);
}
- int temp = istart;
+ I temp = istart;
istart = index[istart];
index[temp] = -1;
@@ -466,15 +465,15 @@
*
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ai[nnz(A)] - row indices
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ai[nnz(A)] - row indices
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
* Output Arguments:
- * vec<int> Bp - row pointer
- * vec<int> Bj - column indices
- * vec<T> Bx - nonzeros
+ * vec<I> Bp - row pointer
+ * vec<I> Bj - column indices
+ * vec<T> Bx - nonzeros
*
* Note:
* Output arrays Bp,Bj,Bx will be allocated within in the method
@@ -488,28 +487,28 @@
* Complexity: Linear. Specifically O(nnz(A) + max(n_row,n_col))
*
*/
-template<class T>
-void cootocsr(const int n_row,
- const int n_col,
- const int NNZ,
- const int Ai[],
- const int Aj[],
- const T Ax[],
- std::vector<int>* Bp,
- std::vector<int>* Bj,
+template <class I, class T>
+void cootocsr(const I n_row,
+ const I n_col,
+ const I NNZ,
+ const I Ai[],
+ const I Aj[],
+ const T Ax[],
+ std::vector<I>* Bp,
+ std::vector<I>* Bj,
std::vector<T>* Bx)
{
- std::vector<int> tempBp(n_row+1,0);
- std::vector<int> tempBj(NNZ);
- std::vector<T> tempBx(NNZ);
+ std::vector<I> tempBp(n_row+1,0);
+ std::vector<I> tempBj(NNZ);
+ std::vector<T> tempBx(NNZ);
- std::vector<int> nnz_per_row(n_row,0); //temp array
+ std::vector<I> nnz_per_row(n_row,0); //temp array
//compute nnz per row, then compute Bp
- for(int i = 0; i < NNZ; i++){
+ for(I i = 0; i < NNZ; i++){
nnz_per_row[Ai[i]]++;
}
- for(int i = 0, cumsum = 0; i < n_row; i++){
+ for(I i = 0, cumsum = 0; i < n_row; i++){
tempBp[i] = cumsum;
cumsum += nnz_per_row[i];
nnz_per_row[i] = 0; //reset count
@@ -517,10 +516,10 @@
tempBp[n_row] = NNZ;
- //write Aj,Ax into tempBj,tempBx
- for(int i = 0; i < NNZ; i++){
- int row = Ai[i];
- int n = tempBp[row] + nnz_per_row[row];
+ //write Aj,Ax Io tempBj,tempBx
+ for(I i = 0; i < NNZ; i++){
+ I row = Ai[i];
+ I n = tempBp[row] + nnz_per_row[row];
tempBj[n] = Aj[i];
tempBx[n] = Ax[i];
@@ -531,12 +530,12 @@
//use (tempB + 0) to sum duplicates
- std::vector<int> Xp(n_row+1,0); //row pointer for an empty matrix
+ std::vector<I> Xp(n_row+1,0); //row pointer for an empty matrix
- csrplcsr<T>(n_row,n_col,
- &tempBp[0],&tempBj[0],&tempBx[0],
- &Xp[0],NULL,NULL,
- Bp,Bj,Bx);
+ csrplcsr<I,T>(n_row,n_col,
+ &tempBp[0],&tempBj[0],&tempBx[0],
+ &Xp[0],NULL,NULL,
+ Bp,Bj,Bx);
}
@@ -548,12 +547,12 @@
*
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[n_col] - nonzeros
- * T Xx[n_col] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[n_col] - nonzeros
+ * T Xx[n_col] - nonzeros
*
* Output Arguments:
* vec<T> Yx - nonzeros (real part)
@@ -564,25 +563,25 @@
* Complexity: Linear. Specifically O(nnz(A) + max(n_row,n_col))
*
*/
-template <class T>
-void csrmux(const int n_row,
- const int n_col,
- const int Ap [],
- const int Aj[],
- const T Ax[],
- const T Xx[],
+template <class I, class T>
+void csrmux(const I n_row,
+ const I n_col,
+ const I Ap [],
+ const I Aj[],
+ const T Ax[],
+ const T Xx[],
std::vector<T>* Yx)
{
const T zero = ZERO<T>();
*Yx = std::vector<T>(n_row,zero);
- for(int i = 0; i < n_row; i++){
- int row_start = Ap[i];
- int row_end = Ap[i+1];
+ for(I i = 0; i < n_row; i++){
+ I row_start = Ap[i];
+ I row_end = Ap[i+1];
T& Yx_i = (*Yx)[i];
- for(int jj = row_start; jj < row_end; jj++){
+ for(I jj = row_start; jj < row_end; jj++){
Yx_i += Ax[jj] * Xx[Aj[jj]];
}
}
@@ -595,10 +594,10 @@
*
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ap[n_row+1] - column pointer
- * int Ai[nnz(A)] - row indices
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ap[n_row+1] - column pointer
+ * I Ai[nnz(A)] - row indices
* T Ax[n_col] - nonzeros (real part)
* T Xx[n_col] - nonzeros (real part)
* bool do_complex - switch scalar/complex modes
@@ -612,25 +611,25 @@
* Complexity: Linear. Specifically O(nnz(A) + max(n_row,n_col))
*
*/
-template <class T>
-void cscmux(const int n_row,
- const int n_col,
- const int Ap[],
- const int Ai[],
- const T Ax[],
- const T Xx[],
+template <class I, class T>
+void cscmux(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ const T Xx[],
std::vector<T>* Yx)
{
const T zero = ZERO<T>();
*Yx = std::vector<T>(n_row,zero);
- for(int j = 0; j < n_col; j++){
- int col_start = Ap[j];
- int col_end = Ap[j+1];
+ for(I j = 0; j < n_col; j++){
+ I col_start = Ap[j];
+ I col_end = Ap[j+1];
- for(int ii = col_start; ii < col_end; ii++){
- int row = Ai[ii];
+ for(I ii = col_start; ii < col_end; ii++){
+ I row = Ai[ii];
(*Yx)[row] += Ax[ii] * Xx[j];
}
}
@@ -643,16 +642,16 @@
* Construct CSC matrix A from diagonals
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int n_diags - number of diagonals
- * int diags_indx[n_diags] - where to place each diagonal
- * T diags[n_diags][min(n_row,n_col)] - diagonals
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I n_diags - number of diagonals
+ * I diags_indx[n_diags] - where to place each diagonal
+ * T diags[n_diags][min(n_row,n_col)] - diagonals
*
* Output Arguments:
- * vec<int> Ap - row pointer
- * vec<int> Aj - column indices
- * vec<T> Ax - nonzeros
+ * vec<I> Ap - row pointer
+ * vec<I> Aj - column indices
+ * vec<T> Ax - nonzeros
*
* Note:
* Output arrays Ap,Aj,Ax will be allocated within in the method
@@ -663,30 +662,30 @@
* Complexity: Linear
*
*/
-template<class T>
-void spdiags(const int n_row,
- const int n_col,
- const int n_diag,
- const int offsets[],
- const T diags[],
- std::vector<int> * Ap,
- std::vector<int> * Ai,
- std::vector<T> * Ax)
+template <class I, class T>
+void spdiags(const I n_row,
+ const I n_col,
+ const I n_diag,
+ const I offsets[],
+ const T diags[],
+ std::vector<I> * Ap,
+ std::vector<I> * Ai,
+ std::vector<T> * Ax)
{
- const int diags_length = std::min(n_row,n_col);
+ const I diags_length = std::min(n_row,n_col);
Ap->push_back(0);
- for(int i = 0; i < n_col; i++){
- for(int j = 0; j < n_diag; j++){
+ for(I i = 0; i < n_col; i++){
+ for(I j = 0; j < n_diag; j++){
if(offsets[j] <= 0){ //sub-diagonal
- int row = i - offsets[j];
+ I row = i - offsets[j];
if (row >= n_row){ continue; }
Ai->push_back(row);
Ax->push_back(diags[j*diags_length + i]);
} else { //super-diagonal
- int row = i - offsets[j];
+ I row = i - offsets[j];
if (row < 0 || row >= n_row){ continue; }
Ai->push_back(row);
@@ -703,36 +702,36 @@
* Compute M = A for CSR matrix A, dense matrix M
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
* T Ax[nnz(A)] - nonzeros
* T Mx[n_row*n_col] - dense matrix
*
* Note:
- * Output arrays Mx are assumed to be allocated and
+ * Output array Mx is assumed to be allocated and
* initialized to 0 by the caller.
*
*/
-template<class T>
-void csrtodense(const int n_row,
- const int n_col,
- const int Ap[],
- const int Aj[],
- const T Ax[],
- T Mx[])
+template <class I, class T>
+void csrtodense(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Aj[],
+ const T Ax[],
+ T Mx[])
{
- int row_base = 0;
- for(int i = 0; i < n_row; i++){
- int row_start = Ap[i];
- int row_end = Ap[i+1];
- for(int jj = row_start; jj < row_end; jj++){
- int j = Aj[jj];
+ I row_base = 0;
+ for(I i = 0; i < n_row; i++){
+ I row_start = Ap[i];
+ I row_end = Ap[i+1];
+ for(I jj = row_start; jj < row_end; jj++){
+ I j = Aj[jj];
Mx[row_base + j] = Ax[jj];
}
- row_base += n_col;
+ row_base += n_col;
}
}
@@ -742,31 +741,31 @@
* Compute A = M for CSR matrix A, dense matrix M
*
* Input Arguments:
- * int n_row - number of rows in A
- * int n_col - number of columns in A
- * T Mx[n_row*n_col] - dense matrix
- * int Ap[n_row+1] - row pointer
- * int Aj[nnz(A)] - column indices
- * T Ax[nnz(A)] - nonzeros
+ * I n_row - number of rows in A
+ * I n_col - number of columns in A
+ * T Mx[n_row*n_col] - dense matrix
+ * I Ap[n_row+1] - row pointer
+ * I Aj[nnz(A)] - column indices
+ * T Ax[nnz(A)] - nonzeros
*
* Note:
* Output arrays Ap,Aj,Ax will be allocated within the method
*
*/
-template<class T>
-void densetocsr(const int n_row,
- const int n_col,
- const T Mx[],
- std::vector<int>* Ap,
- std::vector<int>* Aj,
- std::vector<T>* Ax)
+template <class I, class T>
+void densetocsr(const I n_row,
+ const I n_col,
+ const T Mx[],
+ std::vector<I>* Ap,
+ std::vector<I>* Aj,
+ std::vector<T>* Ax)
{
- const T zero = ZERO<T>();
+ const T zero = ZERO<T>();
const T* x_ptr = Mx;
Ap->push_back(0);
- for(int i = 0; i < n_row; i++){
- for(int j = 0; j < n_col; j++){
+ for(I i = 0; i < n_row; i++){
+ for(I j = 0; j < n_col; j++){
if(*x_ptr != zero){
Aj->push_back(j);
Ax->push_back(*x_ptr);
@@ -782,81 +781,81 @@
/*
* Derived methods
*/
-template <class T>
-void csctocsr(const int n_row,
- const int n_col,
- const int Ap[],
- const int Ai[],
- const T Ax[],
- std::vector<int>* Bp,
- std::vector<int>* Bj,
- std::vector<T>* Bx)
-{ csrtocsc<T>(n_col,n_row,Ap,Ai,Ax,Bp,Bj,Bx); }
+template <class I, class T>
+void csctocsr(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ std::vector<I>* Bp,
+ std::vector<I>* Bj,
+ std::vector<T>* Bx)
+{ csrtocsc<I,T>(n_col,n_row,Ap,Ai,Ax,Bp,Bj,Bx); }
-template<class T>
-void csctocoo(const int n_row,
- const int n_col,
- const int Ap[],
- const int Ai[],
- const T Ax[],
- std::vector<int>* Bi,
- std::vector<int>* Bj,
- std::vector<T>* Bx)
-{ csrtocoo<T>(n_col,n_row,Ap,Ai,Ax,Bj,Bi,Bx); }
+template <class I, class T>
+void csctocoo(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ std::vector<I>* Bi,
+ std::vector<I>* Bj,
+ std::vector<T>* Bx)
+{ csrtocoo<I,T>(n_col,n_row,Ap,Ai,Ax,Bj,Bi,Bx); }
-template<class T>
-void cscmucsc(const int n_row,
- const int n_col,
- const int Ap [],
- const int Ai[],
- const T Ax[],
- const int Bp[],
- const int Bi[],
- const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Ci,
- std::vector<T> * Cx)
-{ csrmucsr<T>(n_col,n_row,Bp,Bi,Bx,Ap,Ai,Ax,Cp,Ci,Cx); }
+template <class I, class T>
+void cscmucsc(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ const I Bp[],
+ const I Bi[],
+ const T Bx[],
+ std::vector<I>* Cp,
+ std::vector<I>* Ci,
+ std::vector<T>* Cx)
+{ csrmucsr<I,T>(n_col,n_row,Bp,Bi,Bx,Ap,Ai,Ax,Cp,Ci,Cx); }
-template <class T>
-void cscplcsc(const int n_row,
- const int n_col,
- const int Ap [],
- const int Ai[],
- const T Ax[],
- const int Bp[],
- const int Bi[],
- const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Ci,
- std::vector<T>* Cx)
-{ csrplcsr<T>(n_col,n_row,Ap,Ai,Ax,Bp,Bi,Bx,Cp,Ci,Cx); }
+template <class I, class T>
+void cscplcsc(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ const I Bp[],
+ const I Bi[],
+ const T Bx[],
+ std::vector<I>* Cp,
+ std::vector<I>* Ci,
+ std::vector<T>* Cx)
+{ csrplcsr<I,T>(n_col,n_row,Ap,Ai,Ax,Bp,Bi,Bx,Cp,Ci,Cx); }
-template <class T>
-void cscelmulcsc(const int n_row,
- const int n_col,
- const int Ap [],
- const int Ai[],
- const T Ax[],
- const int Bp[],
- const int Bi[],
- const T Bx[],
- std::vector<int>* Cp,
- std::vector<int>* Ci,
- std::vector<T>* Cx)
-{ csrelmulcsr<T>(n_col,n_row,Ap,Ai,Ax,Bp,Bi,Bx,Cp,Ci,Cx); }
+template <class I, class T>
+void cscelmulcsc(const I n_row,
+ const I n_col,
+ const I Ap[],
+ const I Ai[],
+ const T Ax[],
+ const I Bp[],
+ const I Bi[],
+ const T Bx[],
+ std::vector<I>* Cp,
+ std::vector<I>* Ci,
+ std::vector<T>* Cx)
+{ csrelmulcsr<I,T>(n_col,n_row,Ap,Ai,Ax,Bp,Bi,Bx,Cp,Ci,Cx); }
-template<class T>
-void cootocsc(const int n_row,
- const int n_col,
- const int NNZ,
- const int Ai[],
- const int Aj[],
- const T Ax[],
- std::vector<int>* Bp,
- std::vector<int>* Bi,
- std::vector<T>* Bx)
-{ cootocsr<T>(n_col,n_row,NNZ,Aj,Ai,Ax,Bp,Bi,Bx); }
+template<class I, class T>
+void cootocsc(const I n_row,
+ const I n_col,
+ const I NNZ,
+ const I Ai[],
+ const I Aj[],
+ const T Ax[],
+ std::vector<I>* Bp,
+ std::vector<I>* Bi,
+ std::vector<T>* Bx)
+{ cootocsr<I,T>(n_col,n_row,NNZ,Aj,Ai,Ax,Bp,Bi,Bx); }
Modified: trunk/Lib/sparse/sparsetools/sparsetools.i
===================================================================
--- trunk/Lib/sparse/sparsetools/sparsetools.i 2007-01-09 05:49:05 UTC (rev 2509)
+++ trunk/Lib/sparse/sparsetools/sparsetools.i 2007-01-09 11:36:44 UTC (rev 2510)
@@ -49,14 +49,10 @@
}
return where;
}
+%} //end inline code
-
-%}
-
-
-
/*
* Use STL vectors for ARGOUTs
*/
@@ -76,366 +72,205 @@
-
+ /*
+ * make typechecks - used for overloading
+ */
%include "typemaps.i"
-%typemap(typecheck) int *, const int *, int [], const int []
+%define NPY_TYPECHECK( ctype, atype )
+%typemap(typecheck) ctype *, const ctype *, ctype [], const ctype []
{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_INT)) ? 1 : 0;
+ $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_##atype)) ? 1 : 0;
};
+%enddef
-%typemap(typecheck) float *, const float *, float [], const float []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_FLOAT)) ? 1 : 0;
-};
+NPY_TYPECHECK( int, INT )
+NPY_TYPECHECK( long, LONG )
+NPY_TYPECHECK( float, FLOAT )
+NPY_TYPECHECK( double, DOUBLE )
+NPY_TYPECHECK( npy_cfloat, CFLOAT )
+NPY_TYPECHECK( npy_cdouble, CDOUBLE )
-%typemap(typecheck) double *, const double *, double [], const double []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_DOUBLE)) ? 1 : 0;
-};
-%typemap(typecheck) long double *, const long double *, long double [], const long double []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_LONGDOUBLE)) ? 1 : 0;
-};
-%typemap(typecheck) npy_cfloat *, const npy_cfloat *, npy_cfloat [], const npy_cfloat []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_CFLOAT)) ? 1 : 0;
+ /*
+ * IN types
+ */
+%define I_IN_ARRAY1( ctype )
+%apply ctype * IN_ARRAY1 {
+ const ctype Ap [ ],
+ const ctype Ai [ ],
+ const ctype Aj [ ],
+ const ctype Bp [ ],
+ const ctype Bi [ ],
+ const ctype Bj [ ],
+ const ctype offsets [ ]
};
+%enddef
-%typemap(typecheck) npy_cdouble *, const npy_cdouble *, npy_cdouble [], const npy_cdouble []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_CDOUBLE)) ? 1 : 0;
+%define T_IN_ARRAY1( ctype )
+%apply ctype * IN_ARRAY1 {
+ const ctype Ax [ ],
+ const ctype Bx [ ],
+ const ctype Xx [ ],
+ const ctype Yx [ ]
};
+%enddef
-%typemap(typecheck) npy_clongdouble *, const npy_clongdouble *, npy_clongdouble [], const npy_clongdouble []
-{
- $1 = (is_array($input) && PyArray_CanCastSafely(PyArray_TYPE($input),PyArray_CLONGDOUBLE)) ? 1 : 0;
+%define T_IN_ARRAY2( ctype )
+%apply ctype * IN_ARRAY2 {
+ const ctype Mx [ ],
+ const ctype diags [ ]
};
+%enddef
+I_IN_ARRAY1( int )
+I_IN_ARRAY1( long )
+T_IN_ARRAY1( int )
+T_IN_ARRAY1( long )
+T_IN_ARRAY1( float )
+T_IN_ARRAY1( double )
+T_IN_ARRAY1( npy_cfloat )
+T_IN_ARRAY1( npy_cdouble )
+T_IN_ARRAY2( int )
+T_IN_ARRAY2( long )
+T_IN_ARRAY2( float )
+T_IN_ARRAY2( double )
+T_IN_ARRAY2( npy_cfloat )
+T_IN_ARRAY2( npy_cdouble )
-/*
- * IN types
- */
-%apply int * IN_ARRAY1 {
- const int Ap [ ],
- const int Ai [ ],
- const int Aj [ ],
- const int Bp [ ],
- const int Bi [ ],
- const int Bj [ ],
- const int offsets [ ]
-};
-%apply float * IN_ARRAY1 {
- const float Ax [ ],
- const float Bx [ ],
- const float Xx [ ],
- const float Yx [ ]
+ /*
+ * OUT types
+ */
+%define I_ARRAY_ARGOUT( ctype, atype )
+VEC_ARRAY_ARGOUT( ctype, atype )
+%apply std::vector<ctype>* array_argout {
+ std::vector<ctype>* Ap,
+ std::vector<ctype>* Ai,
+ std::vector<ctype>* Aj,
+ std::vector<ctype>* Bp,
+ std::vector<ctype>* Bi,
+ std::vector<ctype>* Bj,
+ std::vector<ctype>* Cp,
+ std::vector<ctype>* Ci,
+ std::vector<ctype>* Cj
};
+%enddef
-%apply double * IN_ARRAY1 {
- const double Ax [ ],
- const double Bx [ ],
- const double Xx [ ],
- const double Yx [ ]
+%define T_ARRAY_ARGOUT( ctype, atype )
+VEC_ARRAY_ARGOUT( ctype, atype )
+%apply std::vector<ctype>* array_argout {
+ std::vector<ctype>* Ax,
+ std::vector<ctype>* Bx,
+ std::vector<ctype>* Cx,
+ std::vector<ctype>* Xx,
+ std::vector<ctype>* Yx
};
+%enddef
-%apply long double * IN_ARRAY1 {
- const long double Ax [ ],
- const long double Bx [ ],
- const long double Xx [ ],
- const long double Yx [ ]
-};
-%apply npy_cfloat * IN_ARRAY1 {
- const npy_cfloat Ax [ ],
- const npy_cfloat Bx [ ],
- const npy_cfloat Xx [ ],
- const npy_cfloat Yx [ ]
-};
-%apply npy_cdouble * IN_ARRAY1 {
- const npy_cdouble Ax [ ],
- const npy_cdouble Bx [ ],
- const npy_cdouble Xx [ ],
- const npy_cdouble Yx [ ]
-};
+I_ARRAY_ARGOUT( int, INT)
+I_ARRAY_ARGOUT( long, LONG)
-%apply npy_clongdouble * IN_ARRAY1 {
- const npy_clongdouble Ax [ ],
- const npy_clongdouble Bx [ ],
- const npy_clongdouble Xx [ ],
- const npy_clongdouble Yx [ ]
-};
+T_ARRAY_ARGOUT( int, INT )
+T_ARRAY_ARGOUT( long, LONG )
+T_ARRAY_ARGOUT( float, FLOAT )
+T_ARRAY_ARGOUT( double, DOUBLE )
+T_ARRAY_ARGOUT( npy_cfloat, CFLOAT )
+T_ARRAY_ARGOUT( npy_cdouble, CDOUBLE )
-%apply float * IN_ARRAY2 { const float Mx[] }
-%apply double * IN_ARRAY2 { const double Mx[] }
-%apply long double * IN_ARRAY2 { const long double Mx[] }
-%apply npy_cfloat * IN_ARRAY2 { const npy_cfloat Mx[] }
-%apply npy_cdouble * IN_ARRAY2 { const npy_cdouble Mx[] }
-%apply npy_clongdouble * IN_ARRAY2 { const npy_longdouble Mx[] }
-
-%apply float * IN_ARRAY2 { const float diags[] }
-%apply double * IN_ARRAY2 { const double diags[] }
-%apply long double * IN_ARRAY2 { const long double diags[] }
-%apply npy_cfloat * IN_ARRAY2 { const npy_cfloat diags[] }
-%apply npy_cdouble * IN_ARRAY2 { const npy_cdouble diags[] }
-%apply npy_clongdouble * IN_ARRAY2 { const npy_longdouble diags[] }
-
-
-
-/*
- * OUT types
- */
-VEC_ARRAY_ARGOUT( int, INT )
-%apply std::vector<int>* array_argout {
- std::vector<int>* Ap,
- std::vector<int>* Ai,
- std::vector<int>* Aj,
- std::vector<int>* Bp,
- std::vector<int>* Bi,
- std::vector<int>* Bj,
- std::vector<int>* Cp,
- std::vector<int>* Ci,
- std::vector<int>* Cj
+ /*
+ * INOUT types
+ */
+%define T_INPLACE_ARRAY2( ctype )
+%apply ctype * INPLACE_ARRAY2 {
+ ctype Mx [ ]
};
+%enddef
-VEC_ARRAY_ARGOUT( float, FLOAT )
-%apply std::vector<float>* array_argout {
- std::vector<float>* Ax,
- std::vector<float>* Bx,
- std::vector<float>* Cx,
- std::vector<float>* Xx,
- std::vector<float>* Yx
-};
+T_INPLACE_ARRAY2( int )
+T_INPLACE_ARRAY2( long )
+T_INPLACE_ARRAY2( float )
+T_INPLACE_ARRAY2( double )
+T_INPLACE_ARRAY2( npy_cfloat )
+T_INPLACE_ARRAY2( npy_cdouble )
-VEC_ARRAY_ARGOUT( double, DOUBLE )
-%apply std::vector<double>* array_argout {
- std::vector<double>* Ax,
- std::vector<double>* Bx,
- std::vector<double>* Cx,
- std::vector<double>* Xx,
- std::vector<double>* Yx
-};
-VEC_ARRAY_ARGOUT( long double, LONGDOUBLE )
-%apply std::vector<long double>* array_argout {
- std::vector<long double>* Ax,
- std::vector<long double>* Bx,
- std::vector<long double>* Cx,
- std::vector<long double>* Xx,
- std::vector<long double>* Yx
-};
-VEC_ARRAY_ARGOUT( npy_cfloat, CFLOAT )
-%apply std::vector<npy_cfloat>* array_argout {
- std::vector<npy_cfloat>* Ax,
- std::vector<npy_cfloat>* Bx,
- std::vector<npy_cfloat>* Cx,
- std::vector<npy_cfloat>* Xx,
- std::vector<npy_cfloat>* Yx
-};
-VEC_ARRAY_ARGOUT( npy_cdouble, CDOUBLE )
-%apply std::vector<npy_cdouble>* array_argout {
- std::vector<npy_cdouble>* Ax,
- std::vector<npy_cdouble>* Bx,
- std::vector<npy_cdouble>* Cx,
- std::vector<npy_cdouble>* Xx,
- std::vector<npy_cdouble>* Yx
-};
-
-
-VEC_ARRAY_ARGOUT( npy_clongdouble, CLONGDOUBLE )
-%apply std::vector<npy_clongdouble>* array_argout {
- std::vector<npy_clongdouble>* Ax,
- std::vector<npy_clongdouble>* Bx,
- std::vector<npy_clongdouble>* Cx,
- std::vector<npy_clongdouble>* Xx,
- std::vector<npy_clongdouble>* Yx
-};
-
-
-
-/*
- * INOUT types
- */
-%apply float * INPLACE_ARRAY2 { float Mx [] }
-%apply double * INPLACE_ARRAY2 { double Mx [] }
-%apply long double * INPLACE_ARRAY2 { long double Mx[] }
-%apply npy_cfloat * INPLACE_ARRAY2 { npy_cfloat Mx[] }
-%apply npy_cdouble * INPLACE_ARRAY2 { npy_cdouble Mx[] }
-%apply npy_clongdouble * INPLACE_ARRAY2 { npy_longdouble Mx[] }
-
-
-
-
-
-
%include "sparsetools.h"
+ /*
+ * Order may be important here, list float before npy_float64, scalar before complex
+ */
+%define INSTANTIATE_ALL( f_name )
+%template(f_name) f_name<int,int>;
+%template(f_name) f_name<int,long>;
+%template(f_name) f_name<int,float>;
+%template(f_name) f_name<int,double>;
+%template(f_name) f_name<int,npy_cfloat>;
+%template(f_name) f_name<int,npy_cdouble>;
+/* 64-bit indices would go here */
+%enddef
- /*
- * Order may be important here, list float before double
- */
/*
* CSR->CSC or CSC->CSR or CSR = CSR^T or CSC = CSC^T
*/
-%template(csrtocsc) csrtocsc<float>;
-%template(csrtocsc) csrtocsc<double>;
-%template(csrtocsc) csrtocsc<long double>;
-%template(csrtocsc) csrtocsc<npy_cfloat>;
-%template(csrtocsc) csrtocsc<npy_cdouble>;
-%template(csrtocsc) csrtocsc<npy_clongdouble>;
+INSTANTIATE_ALL(csrtocsc)
+INSTANTIATE_ALL(csctocsr)
-%template(csctocsr) csctocsr<float>;
-%template(csctocsr) csctocsr<double>;
-%template(csctocsr) csctocsr<long double>;
-%template(csctocsr) csctocsr<npy_cfloat>;
-%template(csctocsr) csctocsr<npy_cdouble>;
-%template(csctocsr) csctocsr<npy_clongdouble>;
-
-
/*
* CSR<->COO and CSC<->COO
*/
-%template(csrtocoo) csrtocoo<float>;
-%template(csrtocoo) csrtocoo<double>;
-%template(csrtocoo) csrtocoo<long double>;
-%template(csrtocoo) csrtocoo<npy_cfloat>;
-%template(csrtocoo) csrtocoo<npy_cdouble>;
-%template(csrtocoo) csrtocoo<npy_clongdouble>;
+INSTANTIATE_ALL(csrtocoo)
+INSTANTIATE_ALL(csctocoo)
+INSTANTIATE_ALL(cootocsr)
+INSTANTIATE_ALL(cootocsc)
-%template(cootocsr) cootocsr<float>;
-%template(cootocsr) cootocsr<double>;
-%template(cootocsr) cootocsr<long double>;
-%template(cootocsr) cootocsr<npy_cfloat>;
-%template(cootocsr) cootocsr<npy_cdouble>;
-%template(cootocsr) cootocsr<npy_clongdouble>;
-
-%template(csctocoo) csctocoo<float>;
-%template(csctocoo) csctocoo<double>;
-%template(csctocoo) csctocoo<long double>;
-%template(csctocoo) csctocoo<npy_cfloat>;
-%template(csctocoo) csctocoo<npy_cdouble>;
-%template(csctocoo) csctocoo<npy_clongdouble>;
-
-%template(cootocsc) cootocsc<float>;
-%template(cootocsc) cootocsc<double>;
-%template(cootocsc) cootocsc<long double>;
-%template(cootocsc) cootocsc<npy_cfloat>;
-%template(cootocsc) cootocsc<npy_cdouble>;
-%template(cootocsc) cootocsc<npy_clongdouble>;
-
-
/*
* CSR+CSR and CSC+CSC
*/
-%template(csrplcsr) csrplcsr<float>;
-%template(csrplcsr) csrplcsr<double>;
-%template(csrplcsr) csrplcsr<long double>;
-%template(csrplcsr) csrplcsr<npy_cfloat>;
-%template(csrplcsr) csrplcsr<npy_cdouble>;
-%template(csrplcsr) csrplcsr<npy_clongdouble>;
+INSTANTIATE_ALL(csrplcsr)
+INSTANTIATE_ALL(cscplcsc)
-%template(cscplcsc) cscplcsc<float>;
-%template(cscplcsc) cscplcsc<double>;
-%template(cscplcsc) cscplcsc<long double>;
-%template(cscplcsc) cscplcsc<npy_cfloat>;
-%template(cscplcsc) cscplcsc<npy_cdouble>;
-%template(cscplcsc) cscplcsc<npy_clongdouble>;
-
-
-
/*
* CSR*CSR and CSC*CSC
*/
-%template(csrmucsr) csrmucsr<float>;
-%template(csrmucsr) csrmucsr<double>;
-%template(csrmucsr) csrmucsr<long double>;
-%template(csrmucsr) csrmucsr<npy_cfloat>;
-%template(csrmucsr) csrmucsr<npy_cdouble>;
-%template(csrmucsr) csrmucsr<npy_clongdouble>;
+INSTANTIATE_ALL(csrmucsr)
+INSTANTIATE_ALL(cscmucsc)
-%template(cscmucsc) cscmucsc<float>;
-%template(cscmucsc) cscmucsc<double>;
-%template(cscmucsc) cscmucsc<long double>;
-%template(cscmucsc) cscmucsc<npy_cfloat>;
-%template(cscmucsc) cscmucsc<npy_cdouble>;
-%template(cscmucsc) cscmucsc<npy_clongdouble>;
-
/*
* CSR*x and CSC*x
*/
-%template(csrmux) csrmux<float>;
-%template(csrmux) csrmux<double>;
-%template(csrmux) csrmux<long double>;
-%template(csrmux) csrmux<npy_cfloat>;
-%template(csrmux) csrmux<npy_cdouble>;
-%template(csrmux) csrmux<npy_clongdouble>;
+INSTANTIATE_ALL(csrmux)
+INSTANTIATE_ALL(cscmux)
-%template(cscmux) cscmux<float>;
-%template(cscmux) cscmux<double>;
-%template(cscmux) cscmux<long double>;
-%template(cscmux) cscmux<npy_cfloat>;
-%template(cscmux) cscmux<npy_cdouble>;
-%template(cscmux) cscmux<npy_clongdouble>;
-
-
/*
* CSR(elmul)CSR and CSC(elmul)CSC
*/
-%template(csrelmulcsr) csrelmulcsr<float>;
-%template(csrelmulcsr) csrelmulcsr<double>;
-%template(csrelmulcsr) csrelmulcsr<long double>;
-%template(csrelmulcsr) csrelmulcsr<npy_cfloat>;
-%template(csrelmulcsr) csrelmulcsr<npy_cdouble>;
-%template(csrelmulcsr) csrelmulcsr<npy_clongdouble>;
+INSTANTIATE_ALL(csrelmulcsr)
+INSTANTIATE_ALL(cscelmulcsc)
-%template(cscelmulcsc) cscelmulcsc<float>;
-%template(cscelmulcsc) cscelmulcsc<double>;
-%template(cscelmulcsc) cscelmulcsc<long double>;
-%template(cscelmulcsc) cscelmulcsc<npy_cfloat>;
-%template(cscelmulcsc) cscelmulcsc<npy_cdouble>;
-%template(cscelmulcsc) cscelmulcsc<npy_clongdouble>;
-
/*
* spdiags->CSC
*/
-%template(spdiags) spdiags<float>;
-%template(spdiags) spdiags<double>;
-%template(spdiags) spdiags<long double>;
-%template(spdiags) spdiags<npy_cfloat>;
-%template(spdiags) spdiags<npy_cdouble>;
-%template(spdiags) spdiags<npy_clongdouble>;
+INSTANTIATE_ALL(spdiags)
-
/*
* CSR<->Dense
*/
-%template(csrtodense) csrtodense<float>;
-%template(csrtodense) csrtodense<double>;
-%template(csrtodense) csrtodense<long double>;
-%template(csrtodense) csrtodense<npy_cfloat>;
-%template(csrtodense) csrtodense<npy_cdouble>;
-%template(csrtodense) csrtodense<npy_clongdouble>;
-
-%template(densetocsr) densetocsr<float>;
-%template(densetocsr) densetocsr<double>;
-%template(densetocsr) densetocsr<long double>;
-%template(densetocsr) densetocsr<npy_cfloat>;
-%template(densetocsr) densetocsr<npy_cdouble>;
-%template(densetocsr) densetocsr<npy_clongdouble>;
+INSTANTIATE_ALL(csrtodense)
+INSTANTIATE_ALL(densetocsr)
Modified: trunk/Lib/sparse/sparsetools/sparsetools.py
===================================================================
--- trunk/Lib/sparse/sparsetools/sparsetools.py 2007-01-09 05:49:05 UTC (rev 2509)
+++ trunk/Lib/sparse/sparsetools/sparsetools.py 2007-01-09 11:36:44 UTC (rev 2510)
@@ -52,358 +52,348 @@
def csrtocsc(*args):
"""
+ csrtocsc(int n_row, int n_col, int Ap, int Aj, int Ax, std::vector<(int)> Bp,
+ std::vector<(int)> Bi, std::vector<(int)> Bx)
+ csrtocsc(int n_row, int n_col, int Ap, int Aj, long Ax, std::vector<(int)> Bp,
+ std::vector<(int)> Bi, std::vector<(long)> Bx)
csrtocsc(int n_row, int n_col, int Ap, int Aj, float Ax, std::vector<(int)> Bp,
std::vector<(int)> Bi, std::vector<(float)> Bx)
csrtocsc(int n_row, int n_col, int Ap, int Aj, double Ax, std::vector<(int)> Bp,
std::vector<(int)> Bi, std::vector<(double)> Bx)
- csrtocsc(int n_row, int n_col, int Ap, int Aj, long double Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bi,
- std::vector<(long double)> Bx)
csrtocsc(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(npy_cfloat)> Bx)
csrtocsc(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(npy_cdouble)> Bx)
- csrtocsc(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bi,
- std::vector<(npy_clongdouble)> Bx)
"""
return _sparsetools.csrtocsc(*args)
def csctocsr(*args):
"""
+ csctocsr(int n_row, int n_col, int Ap, int Ai, int Ax, std::vector<(int)> Bp,
+ std::vector<(int)> Bj, std::vector<(int)> Bx)
+ csctocsr(int n_row, int n_col, int Ap, int Ai, long Ax, std::vector<(int)> Bp,
+ std::vector<(int)> Bj, std::vector<(long)> Bx)
csctocsr(int n_row, int n_col, int Ap, int Ai, float Ax, std::vector<(int)> Bp,
std::vector<(int)> Bj, std::vector<(float)> Bx)
csctocsr(int n_row, int n_col, int Ap, int Ai, double Ax, std::vector<(int)> Bp,
std::vector<(int)> Bj, std::vector<(double)> Bx)
- csctocsr(int n_row, int n_col, int Ap, int Ai, long double Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bj,
- std::vector<(long double)> Bx)
csctocsr(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(npy_cfloat)> Bx)
csctocsr(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(npy_cdouble)> Bx)
- csctocsr(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bj,
- std::vector<(npy_clongdouble)> Bx)
"""
return _sparsetools.csctocsr(*args)
def csrtocoo(*args):
"""
+ csrtocoo(int n_row, int n_col, int Ap, int Aj, int Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(int)> Bx)
+ csrtocoo(int n_row, int n_col, int Ap, int Aj, long Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(long)> Bx)
csrtocoo(int n_row, int n_col, int Ap, int Aj, float Ax, std::vector<(int)> Bi,
std::vector<(int)> Bj, std::vector<(float)> Bx)
csrtocoo(int n_row, int n_col, int Ap, int Aj, double Ax, std::vector<(int)> Bi,
std::vector<(int)> Bj, std::vector<(double)> Bx)
- csrtocoo(int n_row, int n_col, int Ap, int Aj, long double Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(long double)> Bx)
csrtocoo(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
std::vector<(int)> Bi, std::vector<(int)> Bj,
std::vector<(npy_cfloat)> Bx)
csrtocoo(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
std::vector<(int)> Bi, std::vector<(int)> Bj,
std::vector<(npy_cdouble)> Bx)
- csrtocoo(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(npy_clongdouble)> Bx)
"""
return _sparsetools.csrtocoo(*args)
+def csctocoo(*args):
+ """
+ csctocoo(int n_row, int n_col, int Ap, int Ai, int Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(int)> Bx)
+ csctocoo(int n_row, int n_col, int Ap, int Ai, long Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(long)> Bx)
+ csctocoo(int n_row, int n_col, int Ap, int Ai, float Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(float)> Bx)
+ csctocoo(int n_row, int n_col, int Ap, int Ai, double Ax, std::vector<(int)> Bi,
+ std::vector<(int)> Bj, std::vector<(double)> Bx)
+ csctocoo(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
+ std::vector<(int)> Bi, std::vector<(int)> Bj,
+ std::vector<(npy_cfloat)> Bx)
+ csctocoo(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
+ std::vector<(int)> Bi, std::vector<(int)> Bj,
+ std::vector<(npy_cdouble)> Bx)
+ """
+ return _sparsetools.csctocoo(*args)
+
def cootocsr(*args):
"""
+ cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, int Ax,
+ std::vector<(int)> Bp, std::vector<(int)> Bj,
+ std::vector<(int)> Bx)
+ cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, long Ax,
+ std::vector<(int)> Bp, std::vector<(int)> Bj,
+ std::vector<(long)> Bx)
cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, float Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(float)> Bx)
cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, double Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(double)> Bx)
- cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, long double Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bj,
- std::vector<(long double)> Bx)
cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_cfloat Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(npy_cfloat)> Bx)
cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_cdouble Ax,
std::vector<(int)> Bp, std::vector<(int)> Bj,
std::vector<(npy_cdouble)> Bx)
- cootocsr(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_clongdouble Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bj,
- std::vector<(npy_clongdouble)> Bx)
"""
return _sparsetools.cootocsr(*args)
-def csctocoo(*args):
- """
- csctocoo(int n_row, int n_col, int Ap, int Ai, float Ax, std::vector<(int)> Bi,
- std::vector<(int)> Bj, std::vector<(float)> Bx)
- csctocoo(int n_row, int n_col, int Ap, int Ai, double Ax, std::vector<(int)> Bi,
- std::vector<(int)> Bj, std::vector<(double)> Bx)
- csctocoo(int n_row, int n_col, int Ap, int Ai, long double Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(long double)> Bx)
- csctocoo(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(npy_cfloat)> Bx)
- csctocoo(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(npy_cdouble)> Bx)
- csctocoo(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- std::vector<(int)> Bi, std::vector<(int)> Bj,
- std::vector<(npy_clongdouble)> Bx)
- """
- return _sparsetools.csctocoo(*args)
-
def cootocsc(*args):
"""
+ cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, int Ax,
+ std::vector<(int)> Bp, std::vector<(int)> Bi,
+ std::vector<(int)> Bx)
+ cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, long Ax,
+ std::vector<(int)> Bp, std::vector<(int)> Bi,
+ std::vector<(long)> Bx)
cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, float Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(float)> Bx)
cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, double Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(double)> Bx)
- cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, long double Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bi,
- std::vector<(long double)> Bx)
cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_cfloat Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(npy_cfloat)> Bx)
cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_cdouble Ax,
std::vector<(int)> Bp, std::vector<(int)> Bi,
std::vector<(npy_cdouble)> Bx)
- cootocsc(int n_row, int n_col, int NNZ, int Ai, int Aj, npy_clongdouble Ax,
- std::vector<(int)> Bp, std::vector<(int)> Bi,
- std::vector<(npy_clongdouble)> Bx)
"""
return _sparsetools.cootocsc(*args)
def csrplcsr(*args):
"""
+ csrplcsr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+ int Bj, int Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(int)> Cx)
+ csrplcsr(int n_row, int n_col, int Ap, int Aj, long Ax, int Bp,
+ int Bj, long Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(long)> Cx)
csrplcsr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
int Bj, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(float)> Cx)
csrplcsr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
int Bj, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(double)> Cx)
- csrplcsr(int n_row, int n_col, int Ap, int Aj, long double Ax,
- int Bp, int Bj, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(long double)> Cx)
csrplcsr(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
int Bp, int Bj, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cfloat)> Cx)
csrplcsr(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
int Bp, int Bj, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cdouble)> Cx)
- csrplcsr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- int Bp, int Bj, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.csrplcsr(*args)
def cscplcsc(*args):
"""
+ cscplcsc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+ int Bi, int Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(int)> Cx)
+ cscplcsc(int n_row, int n_col, int Ap, int Ai, long Ax, int Bp,
+ int Bi, long Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(long)> Cx)
cscplcsc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
int Bi, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(float)> Cx)
cscplcsc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
int Bi, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(double)> Cx)
- cscplcsc(int n_row, int n_col, int Ap, int Ai, long double Ax,
- int Bp, int Bi, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(long double)> Cx)
cscplcsc(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
int Bp, int Bi, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cfloat)> Cx)
cscplcsc(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
int Bp, int Bi, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cdouble)> Cx)
- cscplcsc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- int Bp, int Bi, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.cscplcsc(*args)
def csrmucsr(*args):
"""
+ csrmucsr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+ int Bj, int Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(int)> Cx)
+ csrmucsr(int n_row, int n_col, int Ap, int Aj, long Ax, int Bp,
+ int Bj, long Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(long)> Cx)
csrmucsr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
int Bj, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(float)> Cx)
csrmucsr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
int Bj, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(double)> Cx)
- csrmucsr(int n_row, int n_col, int Ap, int Aj, long double Ax,
- int Bp, int Bj, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(long double)> Cx)
csrmucsr(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
int Bp, int Bj, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cfloat)> Cx)
csrmucsr(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
int Bp, int Bj, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cdouble)> Cx)
- csrmucsr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- int Bp, int Bj, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.csrmucsr(*args)
def cscmucsc(*args):
"""
+ cscmucsc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+ int Bi, int Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(int)> Cx)
+ cscmucsc(int n_row, int n_col, int Ap, int Ai, long Ax, int Bp,
+ int Bi, long Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(long)> Cx)
cscmucsc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
int Bi, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(float)> Cx)
cscmucsc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
int Bi, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(double)> Cx)
- cscmucsc(int n_row, int n_col, int Ap, int Ai, long double Ax,
- int Bp, int Bi, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(long double)> Cx)
cscmucsc(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
int Bp, int Bi, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cfloat)> Cx)
cscmucsc(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
int Bp, int Bi, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cdouble)> Cx)
- cscmucsc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- int Bp, int Bi, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.cscmucsc(*args)
def csrmux(*args):
"""
+ csrmux(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx,
+ std::vector<(int)> Yx)
+ csrmux(int n_row, int n_col, int Ap, int Aj, long Ax, long Xx,
+ std::vector<(long)> Yx)
csrmux(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx,
std::vector<(float)> Yx)
csrmux(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx,
std::vector<(double)> Yx)
- csrmux(int n_row, int n_col, int Ap, int Aj, long double Ax,
- long double Xx, std::vector<(long double)> Yx)
csrmux(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
npy_cfloat Xx, std::vector<(npy_cfloat)> Yx)
csrmux(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
npy_cdouble Xx, std::vector<(npy_cdouble)> Yx)
- csrmux(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- npy_clongdouble Xx, std::vector<(npy_clongdouble)> Yx)
"""
return _sparsetools.csrmux(*args)
def cscmux(*args):
"""
+ cscmux(int n_row, int n_col, int Ap, int Ai, int Ax, int Xx,
+ std::vector<(int)> Yx)
+ cscmux(int n_row, int n_col, int Ap, int Ai, long Ax, long Xx,
+ std::vector<(long)> Yx)
cscmux(int n_row, int n_col, int Ap, int Ai, float Ax, float Xx,
std::vector<(float)> Yx)
cscmux(int n_row, int n_col, int Ap, int Ai, double Ax, double Xx,
std::vector<(double)> Yx)
- cscmux(int n_row, int n_col, int Ap, int Ai, long double Ax,
- long double Xx, std::vector<(long double)> Yx)
cscmux(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
npy_cfloat Xx, std::vector<(npy_cfloat)> Yx)
cscmux(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
npy_cdouble Xx, std::vector<(npy_cdouble)> Yx)
- cscmux(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- npy_clongdouble Xx, std::vector<(npy_clongdouble)> Yx)
"""
return _sparsetools.cscmux(*args)
def csrelmulcsr(*args):
"""
+ csrelmulcsr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+ int Bj, int Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(int)> Cx)
+ csrelmulcsr(int n_row, int n_col, int Ap, int Aj, long Ax, int Bp,
+ int Bj, long Bx, std::vector<(int)> Cp, std::vector<(int)> Cj,
+ std::vector<(long)> Cx)
csrelmulcsr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
int Bj, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(float)> Cx)
csrelmulcsr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
int Bj, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(double)> Cx)
- csrelmulcsr(int n_row, int n_col, int Ap, int Aj, long double Ax,
- int Bp, int Bj, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(long double)> Cx)
csrelmulcsr(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
int Bp, int Bj, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cfloat)> Cx)
csrelmulcsr(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
int Bp, int Bj, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Cj, std::vector<(npy_cdouble)> Cx)
- csrelmulcsr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- int Bp, int Bj, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Cj, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.csrelmulcsr(*args)
def cscelmulcsc(*args):
"""
+ cscelmulcsc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+ int Bi, int Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(int)> Cx)
+ cscelmulcsc(int n_row, int n_col, int Ap, int Ai, long Ax, int Bp,
+ int Bi, long Bx, std::vector<(int)> Cp, std::vector<(int)> Ci,
+ std::vector<(long)> Cx)
cscelmulcsc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
int Bi, float Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(float)> Cx)
cscelmulcsc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
int Bi, double Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(double)> Cx)
- cscelmulcsc(int n_row, int n_col, int Ap, int Ai, long double Ax,
- int Bp, int Bi, long double Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(long double)> Cx)
cscelmulcsc(int n_row, int n_col, int Ap, int Ai, npy_cfloat Ax,
int Bp, int Bi, npy_cfloat Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cfloat)> Cx)
cscelmulcsc(int n_row, int n_col, int Ap, int Ai, npy_cdouble Ax,
int Bp, int Bi, npy_cdouble Bx, std::vector<(int)> Cp,
std::vector<(int)> Ci, std::vector<(npy_cdouble)> Cx)
- cscelmulcsc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble Ax,
- int Bp, int Bi, npy_clongdouble Bx, std::vector<(int)> Cp,
- std::vector<(int)> Ci, std::vector<(npy_clongdouble)> Cx)
"""
return _sparsetools.cscelmulcsc(*args)
def spdiags(*args):
"""
+ spdiags(int n_row, int n_col, int n_diag, int offsets, int diags,
+ std::vector<(int)> Ap, std::vector<(int)> Ai,
+ std::vector<(int)> Ax)
+ spdiags(int n_row, int n_col, int n_diag, int offsets, long diags,
+ std::vector<(int)> Ap, std::vector<(int)> Ai,
+ std::vector<(long)> Ax)
spdiags(int n_row, int n_col, int n_diag, int offsets, float diags,
std::vector<(int)> Ap, std::vector<(int)> Ai,
std::vector<(float)> Ax)
spdiags(int n_row, int n_col, int n_diag, int offsets, double diags,
std::vector<(int)> Ap, std::vector<(int)> Ai,
std::vector<(double)> Ax)
- spdiags(int n_row, int n_col, int n_diag, int offsets, long double diags,
- std::vector<(int)> Ap, std::vector<(int)> Ai,
- std::vector<(long double)> Ax)
spdiags(int n_row, int n_col, int n_diag, int offsets, npy_cfloat diags,
std::vector<(int)> Ap, std::vector<(int)> Ai,
std::vector<(npy_cfloat)> Ax)
spdiags(int n_row, int n_col, int n_diag, int offsets, npy_cdouble diags,
std::vector<(int)> Ap, std::vector<(int)> Ai,
std::vector<(npy_cdouble)> Ax)
- spdiags(int n_row, int n_col, int n_diag, int offsets, npy_clongdouble diags,
- std::vector<(int)> Ap, std::vector<(int)> Ai,
- std::vector<(npy_clongdouble)> Ax)
"""
return _sparsetools.spdiags(*args)
def csrtodense(*args):
"""
+ csrtodense(int n_row, int n_col, int Ap, int Aj, int Ax, int Mx)
+ csrtodense(int n_row, int n_col, int Ap, int Aj, long Ax, long Mx)
csrtodense(int n_row, int n_col, int Ap, int Aj, float Ax, float Mx)
csrtodense(int n_row, int n_col, int Ap, int Aj, double Ax, double Mx)
- csrtodense(int n_row, int n_col, int Ap, int Aj, long double Ax,
- long double Mx)
csrtodense(int n_row, int n_col, int Ap, int Aj, npy_cfloat Ax,
npy_cfloat Mx)
csrtodense(int n_row, int n_col, int Ap, int Aj, npy_cdouble Ax,
npy_cdouble Mx)
- csrtodense(int n_row, int n_col, int Ap, int Aj, npy_clongdouble Ax,
- npy_clongdouble Mx)
"""
return _sparsetools.csrtodense(*args)
def densetocsr(*args):
"""
+ densetocsr(int n_row, int n_col, int Mx, std::vector<(int)> Ap,
+ std::vector<(int)> Aj, std::vector<(int)> Ax)
+ densetocsr(int n_row, int n_col, long Mx, std::vector<(int)> Ap,
+ std::vector<(int)> Aj, std::vector<(long)> Ax)
densetocsr(int n_row, int n_col, float Mx, std::vector<(int)> Ap,
std::vector<(int)> Aj, std::vector<(float)> Ax)
densetocsr(int n_row, int n_col, double Mx, std::vector<(int)> Ap,
std::vector<(int)> Aj, std::vector<(double)> Ax)
- densetocsr(int n_row, int n_col, long double Mx, std::vector<(int)> Ap,
- std::vector<(int)> Aj, std::vector<(long double)> Ax)
densetocsr(int n_row, int n_col, npy_cfloat Mx, std::vector<(int)> Ap,
std::vector<(int)> Aj, std::vector<(npy_cfloat)> Ax)
densetocsr(int n_row, int n_col, npy_cdouble Mx, std::vector<(int)> Ap,
std::vector<(int)> Aj, std::vector<(npy_cdouble)> Ax)
- densetocsr(int n_row, int n_col, npy_clongdouble Mx, std::vector<(int)> Ap,
- std::vector<(int)> Aj, std::vector<(npy_clongdouble)> Ax)
"""
return _sparsetools.densetocsr(*args)
Modified: trunk/Lib/sparse/sparsetools/sparsetools_wrap.cxx
===================================================================
--- trunk/Lib/sparse/sparsetools/sparsetools_wrap.cxx 2007-01-09 05:49:05 UTC (rev 2509)
+++ trunk/Lib/sparse/sparsetools/sparsetools_wrap.cxx 2007-01-09 11:36:44 UTC (rev 2510)
@@ -2466,16 +2466,14 @@
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_char swig_types[0]
-#define SWIGTYPE_p_npy_clongdouble swig_types[1]
-#define SWIGTYPE_p_std__vectorTdouble_t swig_types[2]
-#define SWIGTYPE_p_std__vectorTfloat_t swig_types[3]
-#define SWIGTYPE_p_std__vectorTint_t swig_types[4]
-#define SWIGTYPE_p_std__vectorTlong_double_t swig_types[5]
-#define SWIGTYPE_p_std__vectorTnpy_cdouble_t swig_types[6]
-#define SWIGTYPE_p_std__vectorTnpy_cfloat_t swig_types[7]
-#define SWIGTYPE_p_std__vectorTnpy_clongdouble_t swig_types[8]
-static swig_type_info *swig_types[10];
-static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__vectorTdouble_t swig_types[1]
+#define SWIGTYPE_p_std__vectorTfloat_t swig_types[2]
+#define SWIGTYPE_p_std__vectorTint_t swig_types[3]
+#define SWIGTYPE_p_std__vectorTlong_t swig_types[4]
+#define SWIGTYPE_p_std__vectorTnpy_cdouble_t swig_types[5]
+#define SWIGTYPE_p_std__vectorTnpy_cfloat_t swig_types[6]
+static swig_type_info *swig_types[8];
+static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -2613,11 +2611,14 @@
/* Given a Numeric typecode, return a string describing the type.
*/
-char* typecode_string(int typecode) {
- char* type_names[20] = {"char","unsigned byte","byte","short",
- "unsigned short","int","unsigned int","long",
- "float","double","complex float","complex double",
- "object","ntype","unkown"};
+char* type_names[20] = {"char","unsigned byte","byte","short",
+ "unsigned short","int","unsigned int","long",
+ "float","double","complex float","complex double",
+ "object","ntype","unkown"};
+ char* typecode_string(int typecode) {
+ if(typecode < 0 || typecode > 19)
+ typecode = 19;
+
return type_names[typecode];
}
@@ -2859,10 +2860,6 @@
}
-
-
-
-
#include <limits.h>
#ifndef LLONG_MIN
# define LLONG_MIN LONG_LONG_MIN
@@ -3018,10 +3015,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<float > *arg8 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3034,7 +3031,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<float > *tmp8 ;
+ std::vector<int > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3050,7 +3047,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<float>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3084,11 +3081,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
- csrtocsc<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3106,8 +3103,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3141,10 +3138,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<double > *arg8 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg8 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3157,7 +3154,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<double > *tmp8 ;
+ std::vector<long > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3173,7 +3170,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<double>();
+ tmp8 = new std::vector<long>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3207,11 +3204,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
- csrtocsc<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3229,8 +3226,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3264,10 +3261,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg8 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg8 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3280,7 +3277,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<long double > *tmp8 ;
+ std::vector<float > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3296,7 +3293,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<long double>();
+ tmp8 = new std::vector<float>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3330,11 +3327,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
- csrtocsc<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3352,8 +3349,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3387,10 +3384,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg8 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3403,7 +3400,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cfloat > *tmp8 ;
+ std::vector<double > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3419,7 +3416,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cfloat>();
+ tmp8 = new std::vector<double>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3453,11 +3450,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
- csrtocsc<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3475,8 +3472,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3510,10 +3507,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3526,7 +3523,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cdouble > *tmp8 ;
+ std::vector<npy_cfloat > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3542,7 +3539,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cdouble>();
+ tmp8 = new std::vector<npy_cfloat>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3576,11 +3573,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
- csrtocsc<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3598,8 +3595,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3633,10 +3630,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg8 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3649,7 +3646,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_clongdouble > *tmp8 ;
+ std::vector<npy_cdouble > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3665,7 +3662,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_clongdouble>();
+ tmp8 = new std::vector<npy_cdouble>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocsc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -3699,11 +3696,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
- csrtocsc<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6,arg7,arg8);
+ csrtocsc<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -3721,8 +3718,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -3781,7 +3778,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_1(self, args);
@@ -3812,7 +3809,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_2(self, args);
@@ -3843,7 +3840,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_3(self, args);
@@ -3874,7 +3871,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_4(self, args);
@@ -3905,7 +3902,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_5(self, args);
@@ -3936,7 +3933,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocsc__SWIG_6(self, args);
@@ -3948,7 +3945,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtocsc'.\n Possible C/C++ prototypes are:\n csrtocsc<(float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrtocsc<(double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrtocsc<(long double)>(int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csrtocsc<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrtocsc<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csrtocsc<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtocsc'.\n Possible C/C++ prototypes are:\n csrtocsc<(int,int)>(int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csrtocsc<(int,long)>(int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csrtocsc<(int,float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrtocsc<(int,double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrtocsc<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrtocsc<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -3959,10 +3956,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<float > *arg8 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -3975,7 +3972,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<float > *tmp8 ;
+ std::vector<int > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -3991,7 +3988,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<float>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4025,11 +4022,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
- csctocsr<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4047,8 +4044,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4082,10 +4079,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<double > *arg8 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg8 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4098,7 +4095,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<double > *tmp8 ;
+ std::vector<long > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4114,7 +4111,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<double>();
+ tmp8 = new std::vector<long>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4148,11 +4145,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
- csctocsr<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4170,8 +4167,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4205,10 +4202,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg8 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg8 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4221,7 +4218,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<long double > *tmp8 ;
+ std::vector<float > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4237,7 +4234,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<long double>();
+ tmp8 = new std::vector<float>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4271,11 +4268,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
- csctocsr<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4293,8 +4290,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4328,10 +4325,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg8 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4344,7 +4341,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cfloat > *tmp8 ;
+ std::vector<double > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4360,7 +4357,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cfloat>();
+ tmp8 = new std::vector<double>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4394,11 +4391,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
- csctocsr<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4416,8 +4413,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4451,10 +4448,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4467,7 +4464,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cdouble > *tmp8 ;
+ std::vector<npy_cfloat > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4483,7 +4480,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cdouble>();
+ tmp8 = new std::vector<npy_cfloat>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4517,11 +4514,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
- csctocsr<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4539,8 +4536,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4574,10 +4571,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg8 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4590,7 +4587,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_clongdouble > *tmp8 ;
+ std::vector<npy_cdouble > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4606,7 +4603,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_clongdouble>();
+ tmp8 = new std::vector<npy_cdouble>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocsr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4640,11 +4637,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
- csctocsr<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6,arg7,arg8);
+ csctocsr<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4662,8 +4659,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -4722,7 +4719,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_1(self, args);
@@ -4753,7 +4750,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_2(self, args);
@@ -4784,7 +4781,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_3(self, args);
@@ -4815,7 +4812,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_4(self, args);
@@ -4846,7 +4843,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_5(self, args);
@@ -4877,7 +4874,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csctocsr__SWIG_6(self, args);
@@ -4889,7 +4886,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csctocsr'.\n Possible C/C++ prototypes are:\n csctocsr<(float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csctocsr<(double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csctocsr<(long double)>(int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csctocsr<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csctocsr<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csctocsr<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csctocsr'.\n Possible C/C++ prototypes are:\n csctocsr<(int,int)>(int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csctocsr<(int,long)>(int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csctocsr<(int,float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csctocsr<(int,double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csctocsr<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csctocsr<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -4900,10 +4897,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<float > *arg8 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4916,7 +4913,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<float > *tmp8 ;
+ std::vector<int > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -4932,7 +4929,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<float>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -4966,11 +4963,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
- csrtocoo<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -4988,8 +4985,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5023,10 +5020,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<double > *arg8 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg8 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -5039,7 +5036,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<double > *tmp8 ;
+ std::vector<long > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -5055,7 +5052,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<double>();
+ tmp8 = new std::vector<long>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -5089,11 +5086,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
- csrtocoo<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -5111,8 +5108,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5146,10 +5143,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg8 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg8 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -5162,7 +5159,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<long double > *tmp8 ;
+ std::vector<float > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -5178,7 +5175,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<long double>();
+ tmp8 = new std::vector<float>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -5212,11 +5209,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
- csrtocoo<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -5234,8 +5231,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5269,10 +5266,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg8 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -5285,7 +5282,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cfloat > *tmp8 ;
+ std::vector<double > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -5301,7 +5298,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cfloat>();
+ tmp8 = new std::vector<double>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -5335,11 +5332,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
- csrtocoo<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -5357,8 +5354,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5392,10 +5389,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -5408,7 +5405,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cdouble > *tmp8 ;
+ std::vector<npy_cfloat > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -5424,7 +5421,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cdouble>();
+ tmp8 = new std::vector<npy_cfloat>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -5458,11 +5455,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
- csrtocoo<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -5480,8 +5477,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5515,10 +5512,10 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg8 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -5531,7 +5528,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_clongdouble > *tmp8 ;
+ std::vector<npy_cdouble > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -5547,7 +5544,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_clongdouble>();
+ tmp8 = new std::vector<npy_cdouble>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:csrtocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -5581,11 +5578,11 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
- csrtocoo<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6,arg7,arg8);
+ csrtocoo<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -5603,8 +5600,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -5663,7 +5660,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_1(self, args);
@@ -5694,7 +5691,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_2(self, args);
@@ -5725,7 +5722,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_3(self, args);
@@ -5756,7 +5753,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_4(self, args);
@@ -5787,7 +5784,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_5(self, args);
@@ -5818,7 +5815,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtocoo__SWIG_6(self, args);
@@ -5830,45 +5827,45 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtocoo'.\n Possible C/C++ prototypes are:\n csrtocoo<(float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrtocoo<(double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrtocoo<(long double)>(int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csrtocoo<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrtocoo<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csrtocoo<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtocoo'.\n Possible C/C++ prototypes are:\n csrtocoo<(int,int)>(int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csrtocoo<(int,long)>(int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csrtocoo<(int,float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrtocoo<(int,double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrtocoo<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrtocoo<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
int *arg5 ;
- float *arg6 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<float > *arg9 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<float > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
@@ -5876,30 +5873,29 @@
tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<float>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
+ }
+ {
+ npy_intp size[1] = {
+ -1
+ };
array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
arg4 = (int*) array4->data;
@@ -5912,16 +5908,15 @@
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
arg5 = (int*) array5->data;
}
+ csctocoo<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,arg6,arg7,arg8);
+ resultobj = SWIG_Py_Void();
{
- npy_intp size[1] = {
- -1
- };
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (float*) array6->data;
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
- cootocsr<float >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(float const (*))arg6,arg7,arg8,arg9);
- resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
@@ -5937,11 +5932,7 @@
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(float)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -5949,112 +5940,107 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
- int *arg5 ;
- double *arg6 ;
+ long *arg5 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<double > *arg9 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg8 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<int > *tmp8 ;
- std::vector<double > *tmp9 ;
+ std::vector<long > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<int>();
+ tmp8 = new std::vector<long>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<double>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (int*) array5->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (double*) array6->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (long*) array5->data;
}
- cootocsr<double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(double const (*))arg6,arg7,arg8,arg9);
+ csctocoo<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ }
+ {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6063,17 +6049,13 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(double)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6081,112 +6063,107 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
- int *arg5 ;
- long double *arg6 ;
+ float *arg5 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg9 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg8 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<int > *tmp8 ;
- std::vector<long double > *tmp9 ;
+ std::vector<float > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<int>();
+ tmp8 = new std::vector<float>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<long double>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (int*) array5->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONGDOUBLE, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (long double*) array6->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (float*) array5->data;
}
- cootocsr<long double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(long double const (*))arg6,arg7,arg8,arg9);
+ csctocoo<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ }
+ {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6195,17 +6172,13 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(long double)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6213,112 +6186,107 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
- int *arg5 ;
- npy_cfloat *arg6 ;
+ double *arg5 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg9 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg8 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<int > *tmp8 ;
- std::vector<npy_cfloat > *tmp9 ;
+ std::vector<double > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<int>();
+ tmp8 = new std::vector<double>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<npy_cfloat>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (int*) array5->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cfloat*) array6->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (double*) array5->data;
}
- cootocsr<npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cfloat const (*))arg6,arg7,arg8,arg9);
+ csctocoo<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ }
+ {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6327,17 +6295,13 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cfloat)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6345,112 +6309,107 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
- int *arg5 ;
- npy_cdouble *arg6 ;
+ npy_cfloat *arg5 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg9 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<int > *tmp8 ;
- std::vector<npy_cdouble > *tmp9 ;
+ std::vector<npy_cfloat > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<int>();
+ tmp8 = new std::vector<npy_cfloat>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<npy_cdouble>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (int*) array5->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cdouble*) array6->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (npy_cfloat*) array5->data;
}
- cootocsr<npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cdouble const (*))arg6,arg7,arg8,arg9);
+ csctocoo<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ }
+ {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6459,17 +6418,13 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cdouble)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6477,112 +6432,107 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ int *arg3 ;
int *arg4 ;
- int *arg5 ;
- npy_clongdouble *arg6 ;
+ npy_cdouble *arg5 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg9 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- PyArrayObject *array6 = NULL ;
- int is_new_object6 ;
+ std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<int > *tmp8 ;
- std::vector<npy_clongdouble > *tmp9 ;
+ std::vector<npy_cdouble > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
{
+ tmp6 = new std::vector<int>();
+ arg6 = tmp6;
+ }
+ {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<int>();
+ tmp8 = new std::vector<npy_cdouble>();
arg8 = tmp8;
}
- {
- tmp9 = new std::vector<npy_clongdouble>();
- arg9 = tmp9;
- }
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
- }
- arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (int*) array3->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (int*) array5->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CLONGDOUBLE, &is_new_object6);
- if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_clongdouble*) array6->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (npy_cdouble*) array5->data;
}
- cootocsr<npy_clongdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_clongdouble const (*))arg6,arg7,arg8,arg9);
+ csctocoo<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
+ int length = (arg6)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
+ delete arg6;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ }
+ {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6591,17 +6541,13 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_clongdouble)*length);
- delete arg9;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
+ if (is_new_object3 && array3) Py_DECREF(array3);
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6609,35 +6555,32 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return resultobj;
fail:
{
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
+ {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
- {
- if (is_new_object6 && array6) Py_DECREF(array6);
- }
return NULL;
}
-SWIGINTERN PyObject *_wrap_cootocsr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_csctocoo(PyObject *self, PyObject *args) {
int argc;
- PyObject *argv[7];
+ PyObject *argv[6];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 6); ii++) {
+ for (ii = 0; (ii < argc) && (ii < 5); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6650,8 +6593,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6662,19 +6604,14 @@
_v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_1(self, args);
- }
+ return _wrap_csctocoo__SWIG_1(self, args);
}
}
}
}
}
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6687,8 +6624,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6696,22 +6632,17 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_2(self, args);
- }
+ return _wrap_csctocoo__SWIG_2(self, args);
}
}
}
}
}
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6724,8 +6655,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6733,22 +6663,17 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONGDOUBLE)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_3(self, args);
- }
+ return _wrap_csctocoo__SWIG_3(self, args);
}
}
}
}
}
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6761,8 +6686,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6770,22 +6694,17 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_4(self, args);
- }
+ return _wrap_csctocoo__SWIG_4(self, args);
}
}
}
}
}
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6798,8 +6717,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6807,22 +6725,17 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_5(self, args);
- }
+ return _wrap_csctocoo__SWIG_5(self, args);
}
}
}
}
}
}
- if (argc == 6) {
+ if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -6835,8 +6748,7 @@
}
if (_v) {
{
- int res = SWIG_AsVal_int(argv[2], NULL);
- _v = SWIG_CheckState(res);
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -6844,15 +6756,10 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
- {
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CLONGDOUBLE)) ? 1 : 0;
- }
- if (_v) {
- return _wrap_cootocsr__SWIG_6(self, args);
- }
+ return _wrap_csctocoo__SWIG_6(self, args);
}
}
}
@@ -6861,97 +6768,99 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cootocsr'.\n Possible C/C++ prototypes are:\n cootocsr<(float)>(int const,int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cootocsr<(double)>(int const,int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cootocsr<(long double)>(int const,int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n cootocsr<(npy_cfloat)>(int const,int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cootocsr<(npy_cdouble)>(int const,int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n cootocsr<(npy_clongdouble)>(int const,int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csctocoo'.\n Possible C/C++ prototypes are:\n csctocoo<(int,int)>(int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csctocoo<(int,long)>(int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csctocoo<(int,float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csctocoo<(int,double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csctocoo<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csctocoo<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- float *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ int *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<float > *arg8 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<int > *arg9 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<float > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<int > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<float>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<int>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_INT, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (int*) array6->data;
}
- csctocoo<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,int >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -6960,13 +6869,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(int)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -6974,107 +6887,112 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- double *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ long *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<double > *arg8 = (std::vector<double > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<long > *arg9 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<double > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<long > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<double>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<long>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONG, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (long*) array6->data;
}
- csctocoo<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,long >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(long const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -7083,13 +7001,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(long)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -7097,107 +7019,112 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- long double *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ float *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg8 = (std::vector<long double > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<float > *arg9 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<long double > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<float > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<long double>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<float>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (float*) array6->data;
}
- csctocoo<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,float >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(float const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -7206,13 +7133,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(float)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -7220,107 +7151,112 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ double *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<double > *arg9 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cfloat > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<double > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cfloat>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<double>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (double*) array6->data;
}
- csctocoo<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(double const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -7329,13 +7265,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(double)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -7343,107 +7283,112 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ npy_cfloat *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<npy_cfloat > *arg9 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cdouble > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<npy_cfloat > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cdouble>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<npy_cfloat>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (npy_cfloat*) array6->data;
}
- csctocoo<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cfloat const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -7452,13 +7397,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cfloat)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -7466,107 +7415,112 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 ;
+ int arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
- std::vector<int > *arg6 = (std::vector<int > *) 0 ;
+ int *arg5 ;
+ npy_cdouble *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg8 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
+ std::vector<npy_cdouble > *arg9 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyArrayObject *array3 = NULL ;
- int is_new_object3 ;
+ int val3 ;
+ int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- std::vector<int > *tmp6 ;
+ PyArrayObject *array6 = NULL ;
+ int is_new_object6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_clongdouble > *tmp8 ;
+ std::vector<int > *tmp8 ;
+ std::vector<npy_cdouble > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ PyObject * obj5 = 0 ;
{
- tmp6 = new std::vector<int>();
- arg6 = tmp6;
- }
- {
tmp7 = new std::vector<int>();
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_clongdouble>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:csctocoo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ {
+ tmp9 = new std::vector<npy_cdouble>();
+ arg9 = tmp9;
+ }
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "csctocoo" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cootocsr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "csctocoo" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cootocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cootocsr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
{
npy_intp size[1] = {
-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
- if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (int*) array3->data;
+ array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
+ if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
+ arg4 = (int*) array4->data;
}
{
npy_intp size[1] = {
-1
};
- array4 = obj_to_array_contiguous_allow_conversion(obj3, PyArray_INT, &is_new_object4);
- if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
- arg4 = (int*) array4->data;
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
- if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
+ if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
+ arg6 = (npy_cdouble*) array6->data;
}
- csctocoo<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6,arg7,arg8);
+ cootocsr<int,npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cdouble const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
- int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
- delete arg6;
- resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
- }
- {
int length = (arg7)->size();
PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
@@ -7575,13 +7529,17 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
- if (is_new_object3 && array3) Py_DECREF(array3);
+ int length = (arg9)->size();
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cdouble)*length);
+ delete arg9;
+ resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
@@ -7589,32 +7547,35 @@
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return resultobj;
fail:
{
- if (is_new_object3 && array3) Py_DECREF(array3);
- }
- {
if (is_new_object4 && array4) Py_DECREF(array4);
}
{
if (is_new_object5 && array5) Py_DECREF(array5);
}
+ {
+ if (is_new_object6 && array6) Py_DECREF(array6);
+ }
return NULL;
}
-SWIGINTERN PyObject *_wrap_csctocoo(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_cootocsr(PyObject *self, PyObject *args) {
int argc;
- PyObject *argv[6];
+ PyObject *argv[7];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+ for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7627,7 +7588,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7635,17 +7597,22 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_1(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_INT)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_1(self, args);
+ }
}
}
}
}
}
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7658,7 +7625,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7666,17 +7634,22 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_2(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONG)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_2(self, args);
+ }
}
}
}
}
}
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7689,7 +7662,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7697,17 +7671,22 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_3(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_3(self, args);
+ }
}
}
}
}
}
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7720,7 +7699,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7728,17 +7708,22 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_4(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_4(self, args);
+ }
}
}
}
}
}
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7751,7 +7736,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7759,17 +7745,22 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_5(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_5(self, args);
+ }
}
}
}
}
}
}
- if (argc == 5) {
+ if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
@@ -7782,7 +7773,8 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
}
if (_v) {
{
@@ -7790,10 +7782,15 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
- return _wrap_csctocoo__SWIG_6(self, args);
+ {
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
+ }
+ if (_v) {
+ return _wrap_cootocsr__SWIG_6(self, args);
+ }
}
}
}
@@ -7802,7 +7799,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csctocoo'.\n Possible C/C++ prototypes are:\n csctocoo<(float)>(int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csctocoo<(double)>(int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csctocoo<(long double)>(int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csctocoo<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csctocoo<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csctocoo<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cootocsr'.\n Possible C/C++ prototypes are:\n cootocsr<(int,int)>(int const,int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n cootocsr<(int,long)>(int const,int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n cootocsr<(int,float)>(int const,int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cootocsr<(int,double)>(int const,int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cootocsr<(int,npy_cfloat)>(int const,int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cootocsr<(int,npy_cdouble)>(int const,int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -7814,10 +7811,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- float *arg6 ;
+ int *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<float > *arg9 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg9 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -7832,7 +7829,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<float > *tmp9 ;
+ std::vector<int > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -7849,7 +7846,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<float>();
+ tmp9 = new std::vector<int>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -7888,11 +7885,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_INT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (float*) array6->data;
+ arg6 = (int*) array6->data;
}
- cootocsc<float >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(float const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,int >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -7910,8 +7907,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(int)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -7946,10 +7943,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- double *arg6 ;
+ long *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<double > *arg9 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg9 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -7964,7 +7961,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<double > *tmp9 ;
+ std::vector<long > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -7981,7 +7978,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<double>();
+ tmp9 = new std::vector<long>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -8020,11 +8017,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONG, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (double*) array6->data;
+ arg6 = (long*) array6->data;
}
- cootocsc<double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(double const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,long >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(long const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -8042,8 +8039,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(long)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -8078,10 +8075,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- long double *arg6 ;
+ float *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg9 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg9 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -8096,7 +8093,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<long double > *tmp9 ;
+ std::vector<float > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -8113,7 +8110,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<long double>();
+ tmp9 = new std::vector<float>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -8152,11 +8149,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (long double*) array6->data;
+ arg6 = (float*) array6->data;
}
- cootocsc<long double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(long double const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,float >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(float const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -8174,8 +8171,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(float)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -8210,10 +8207,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- npy_cfloat *arg6 ;
+ double *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg9 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg9 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -8228,7 +8225,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<npy_cfloat > *tmp9 ;
+ std::vector<double > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -8245,7 +8242,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<npy_cfloat>();
+ tmp9 = new std::vector<double>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -8284,11 +8281,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cfloat*) array6->data;
+ arg6 = (double*) array6->data;
}
- cootocsc<npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cfloat const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,double >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(double const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -8306,8 +8303,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(double)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -8342,10 +8339,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- npy_cdouble *arg6 ;
+ npy_cfloat *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg9 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg9 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -8360,7 +8357,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<npy_cdouble > *tmp9 ;
+ std::vector<npy_cfloat > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -8377,7 +8374,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<npy_cdouble>();
+ tmp9 = new std::vector<npy_cfloat>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -8416,11 +8413,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cdouble*) array6->data;
+ arg6 = (npy_cfloat*) array6->data;
}
- cootocsc<npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cdouble const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cfloat const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -8438,8 +8435,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cfloat)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -8474,10 +8471,10 @@
int arg3 ;
int *arg4 ;
int *arg5 ;
- npy_clongdouble *arg6 ;
+ npy_cdouble *arg6 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
std::vector<int > *arg8 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg9 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg9 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -8492,7 +8489,7 @@
int is_new_object6 ;
std::vector<int > *tmp7 ;
std::vector<int > *tmp8 ;
- std::vector<npy_clongdouble > *tmp9 ;
+ std::vector<npy_cdouble > *tmp9 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -8509,7 +8506,7 @@
arg8 = tmp8;
}
{
- tmp9 = new std::vector<npy_clongdouble>();
+ tmp9 = new std::vector<npy_cdouble>();
arg9 = tmp9;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cootocsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -8548,11 +8545,11 @@
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CLONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_clongdouble*) array6->data;
+ arg6 = (npy_cdouble*) array6->data;
}
- cootocsc<npy_clongdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_clongdouble const (*))arg6,arg7,arg8,arg9);
+ cootocsc<int,npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,(npy_cdouble const (*))arg6,arg7,arg8,arg9);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
@@ -8570,8 +8567,8 @@
}
{
int length = (arg9)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg9))[0]),sizeof(npy_cdouble)*length);
delete arg9;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -8635,7 +8632,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_1(self, args);
@@ -8672,7 +8669,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_2(self, args);
@@ -8709,7 +8706,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_3(self, args);
@@ -8746,7 +8743,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_4(self, args);
@@ -8783,7 +8780,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_5(self, args);
@@ -8820,7 +8817,7 @@
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cootocsc__SWIG_6(self, args);
@@ -8833,7 +8830,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cootocsc'.\n Possible C/C++ prototypes are:\n cootocsc<(float)>(int const,int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cootocsc<(double)>(int const,int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cootocsc<(long double)>(int const,int const,int const,int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n cootocsc<(npy_cfloat)>(int const,int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cootocsc<(npy_cdouble)>(int const,int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n cootocsc<(npy_clongdouble)>(int const,int const,int const,int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cootocsc'.\n Possible C/C++ prototypes are:\n cootocsc<(int,int)>(int const,int const,int const,int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n cootocsc<(int,long)>(int const,int const,int const,int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n cootocsc<(int,float)>(int const,int const,int const,int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cootocsc<(int,double)>(int const,int const,int const,int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cootocsc<(int,npy_cfloat)>(int const,int const,int const,int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cootocsc<(int,npy_cdouble)>(int const,int const,int const,int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -8844,13 +8841,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -8869,7 +8866,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -8888,7 +8885,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -8922,9 +8919,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -8946,11 +8943,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- csrplcsr<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -8968,8 +8965,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9021,13 +9018,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -9046,7 +9043,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -9065,7 +9062,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -9099,9 +9096,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -9123,11 +9120,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- csrplcsr<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -9145,8 +9142,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9198,13 +9195,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -9223,7 +9220,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -9242,7 +9239,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -9276,9 +9273,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -9300,11 +9297,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- csrplcsr<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -9322,8 +9319,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9375,13 +9372,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -9400,7 +9397,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -9419,7 +9416,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -9453,9 +9450,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -9477,11 +9474,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- csrplcsr<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -9499,8 +9496,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9552,13 +9549,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -9577,7 +9574,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -9596,7 +9593,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -9630,9 +9627,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -9654,11 +9651,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- csrplcsr<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -9676,8 +9673,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9729,13 +9726,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -9754,7 +9751,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -9773,7 +9770,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrplcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -9807,9 +9804,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -9831,11 +9828,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- csrplcsr<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ csrplcsr<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -9853,8 +9850,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -9931,7 +9928,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -9943,7 +9940,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_1(self, args);
@@ -9977,7 +9974,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -9989,7 +9986,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_2(self, args);
@@ -10023,7 +10020,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -10035,7 +10032,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_3(self, args);
@@ -10069,7 +10066,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -10081,7 +10078,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_4(self, args);
@@ -10115,7 +10112,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -10127,7 +10124,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_5(self, args);
@@ -10161,7 +10158,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -10173,7 +10170,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrplcsr__SWIG_6(self, args);
@@ -10188,7 +10185,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrplcsr'.\n Possible C/C++ prototypes are:\n csrplcsr<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrplcsr<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrplcsr<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csrplcsr<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrplcsr<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csrplcsr<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrplcsr'.\n Possible C/C++ prototypes are:\n csrplcsr<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csrplcsr<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csrplcsr<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrplcsr<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrplcsr<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrplcsr<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -10199,13 +10196,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -10224,7 +10221,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -10243,7 +10240,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -10277,9 +10274,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -10301,11 +10298,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- cscplcsc<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -10323,8 +10320,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -10376,13 +10373,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -10401,7 +10398,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -10420,7 +10417,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -10454,9 +10451,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -10478,11 +10475,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- cscplcsc<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -10500,8 +10497,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -10553,13 +10550,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -10578,7 +10575,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -10597,7 +10594,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -10631,9 +10628,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -10655,11 +10652,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- cscplcsc<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -10677,8 +10674,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -10730,13 +10727,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -10755,7 +10752,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -10774,7 +10771,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -10808,9 +10805,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -10832,11 +10829,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- cscplcsc<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -10854,8 +10851,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -10907,13 +10904,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -10932,7 +10929,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -10951,7 +10948,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -10985,9 +10982,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -11009,11 +11006,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- cscplcsc<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -11031,8 +11028,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -11084,13 +11081,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -11109,7 +11106,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -11128,7 +11125,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscplcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -11162,9 +11159,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -11186,11 +11183,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- cscplcsc<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ cscplcsc<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -11208,8 +11205,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -11286,7 +11283,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -11298,7 +11295,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_1(self, args);
@@ -11332,7 +11329,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -11344,7 +11341,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_2(self, args);
@@ -11378,7 +11375,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -11390,7 +11387,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_3(self, args);
@@ -11424,7 +11421,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -11436,7 +11433,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_4(self, args);
@@ -11470,7 +11467,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -11482,7 +11479,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_5(self, args);
@@ -11516,7 +11513,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -11528,7 +11525,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscplcsc__SWIG_6(self, args);
@@ -11543,7 +11540,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscplcsc'.\n Possible C/C++ prototypes are:\n cscplcsc<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscplcsc<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscplcsc<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n cscplcsc<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscplcsc<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n cscplcsc<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscplcsc'.\n Possible C/C++ prototypes are:\n cscplcsc<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n cscplcsc<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n cscplcsc<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscplcsc<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscplcsc<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscplcsc<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -11554,13 +11551,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -11579,7 +11576,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -11598,7 +11595,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -11632,9 +11629,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -11656,11 +11653,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- csrmucsr<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -11678,8 +11675,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -11731,13 +11728,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -11756,7 +11753,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -11775,7 +11772,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -11809,9 +11806,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -11833,11 +11830,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- csrmucsr<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -11855,8 +11852,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -11908,13 +11905,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -11933,7 +11930,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -11952,7 +11949,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -11986,9 +11983,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -12010,11 +12007,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- csrmucsr<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -12032,8 +12029,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -12085,13 +12082,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -12110,7 +12107,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -12129,7 +12126,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -12163,9 +12160,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -12187,11 +12184,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- csrmucsr<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -12209,8 +12206,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -12262,13 +12259,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -12287,7 +12284,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -12306,7 +12303,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -12340,9 +12337,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -12364,11 +12361,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- csrmucsr<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -12386,8 +12383,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -12439,13 +12436,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -12464,7 +12461,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -12483,7 +12480,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrmucsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -12517,9 +12514,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -12541,11 +12538,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- csrmucsr<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ csrmucsr<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -12563,8 +12560,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -12641,7 +12638,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -12653,7 +12650,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_1(self, args);
@@ -12687,7 +12684,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -12699,7 +12696,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_2(self, args);
@@ -12733,7 +12730,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -12745,7 +12742,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_3(self, args);
@@ -12779,7 +12776,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -12791,7 +12788,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_4(self, args);
@@ -12825,7 +12822,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -12837,7 +12834,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_5(self, args);
@@ -12871,7 +12868,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -12883,7 +12880,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmucsr__SWIG_6(self, args);
@@ -12898,7 +12895,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrmucsr'.\n Possible C/C++ prototypes are:\n csrmucsr<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrmucsr<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrmucsr<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csrmucsr<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrmucsr<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csrmucsr<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrmucsr'.\n Possible C/C++ prototypes are:\n csrmucsr<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csrmucsr<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csrmucsr<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrmucsr<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrmucsr<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrmucsr<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -12909,13 +12906,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -12934,7 +12931,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -12953,7 +12950,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -12987,9 +12984,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -13011,11 +13008,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- cscmucsc<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13033,8 +13030,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13086,13 +13083,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -13111,7 +13108,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -13130,7 +13127,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -13164,9 +13161,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -13188,11 +13185,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- cscmucsc<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13210,8 +13207,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13263,13 +13260,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -13288,7 +13285,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -13307,7 +13304,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -13341,9 +13338,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -13365,11 +13362,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- cscmucsc<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13387,8 +13384,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13440,13 +13437,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -13465,7 +13462,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -13484,7 +13481,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -13518,9 +13515,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -13542,11 +13539,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- cscmucsc<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13564,8 +13561,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13617,13 +13614,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -13642,7 +13639,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -13661,7 +13658,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -13695,9 +13692,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -13719,11 +13716,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- cscmucsc<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13741,8 +13738,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13794,13 +13791,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -13819,7 +13816,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -13838,7 +13835,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscmucsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -13872,9 +13869,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -13896,11 +13893,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- cscmucsc<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ cscmucsc<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -13918,8 +13915,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -13996,7 +13993,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -14008,7 +14005,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_1(self, args);
@@ -14042,7 +14039,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -14054,7 +14051,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_2(self, args);
@@ -14088,7 +14085,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -14100,7 +14097,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_3(self, args);
@@ -14134,7 +14131,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -14146,7 +14143,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_4(self, args);
@@ -14180,7 +14177,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -14192,7 +14189,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_5(self, args);
@@ -14226,7 +14223,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -14238,7 +14235,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmucsc__SWIG_6(self, args);
@@ -14253,7 +14250,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscmucsc'.\n Possible C/C++ prototypes are:\n cscmucsc<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscmucsc<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscmucsc<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n cscmucsc<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscmucsc<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n cscmucsc<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscmucsc'.\n Possible C/C++ prototypes are:\n cscmucsc<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n cscmucsc<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n cscmucsc<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscmucsc<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscmucsc<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscmucsc<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -14264,9 +14261,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
- float *arg6 ;
- std::vector<float > *arg7 = (std::vector<float > *) 0 ;
+ int *arg5 ;
+ int *arg6 ;
+ std::vector<int > *arg7 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14279,7 +14276,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<float > *tmp7 ;
+ std::vector<int > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14288,7 +14285,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<float>();
+ tmp7 = new std::vector<int>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14322,24 +14319,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_INT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (float*) array6->data;
+ arg6 = (int*) array6->data;
}
- csrmux<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(float const (*))arg6,arg7);
+ csrmux<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14379,9 +14376,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
- double *arg6 ;
- std::vector<double > *arg7 = (std::vector<double > *) 0 ;
+ long *arg5 ;
+ long *arg6 ;
+ std::vector<long > *arg7 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14394,7 +14391,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<double > *tmp7 ;
+ std::vector<long > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14403,7 +14400,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<double>();
+ tmp7 = new std::vector<long>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14437,24 +14434,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONG, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (double*) array6->data;
+ arg6 = (long*) array6->data;
}
- csrmux<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(double const (*))arg6,arg7);
+ csrmux<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(long const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(long)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14494,9 +14491,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
- long double *arg6 ;
- std::vector<long double > *arg7 = (std::vector<long double > *) 0 ;
+ float *arg5 ;
+ float *arg6 ;
+ std::vector<float > *arg7 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14509,7 +14506,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<long double > *tmp7 ;
+ std::vector<float > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14518,7 +14515,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<long double>();
+ tmp7 = new std::vector<float>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14552,24 +14549,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (long double*) array6->data;
+ arg6 = (float*) array6->data;
}
- csrmux<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(long double const (*))arg6,arg7);
+ csrmux<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(float const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(float)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14609,9 +14606,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
- npy_cfloat *arg6 ;
- std::vector<npy_cfloat > *arg7 = (std::vector<npy_cfloat > *) 0 ;
+ double *arg5 ;
+ double *arg6 ;
+ std::vector<double > *arg7 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14624,7 +14621,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_cfloat > *tmp7 ;
+ std::vector<double > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14633,7 +14630,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_cfloat>();
+ tmp7 = new std::vector<double>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14667,24 +14664,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cfloat*) array6->data;
+ arg6 = (double*) array6->data;
}
- csrmux<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(npy_cfloat const (*))arg6,arg7);
+ csrmux<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(double const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(double)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14724,9 +14721,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
- npy_cdouble *arg6 ;
- std::vector<npy_cdouble > *arg7 = (std::vector<npy_cdouble > *) 0 ;
+ npy_cfloat *arg5 ;
+ npy_cfloat *arg6 ;
+ std::vector<npy_cfloat > *arg7 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14739,7 +14736,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_cdouble > *tmp7 ;
+ std::vector<npy_cfloat > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14748,7 +14745,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_cdouble>();
+ tmp7 = new std::vector<npy_cfloat>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14782,24 +14779,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cdouble*) array6->data;
+ arg6 = (npy_cfloat*) array6->data;
}
- csrmux<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(npy_cdouble const (*))arg6,arg7);
+ csrmux<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(npy_cfloat const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cfloat)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14839,9 +14836,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
- npy_clongdouble *arg6 ;
- std::vector<npy_clongdouble > *arg7 = (std::vector<npy_clongdouble > *) 0 ;
+ npy_cdouble *arg5 ;
+ npy_cdouble *arg6 ;
+ std::vector<npy_cdouble > *arg7 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -14854,7 +14851,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_clongdouble > *tmp7 ;
+ std::vector<npy_cdouble > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -14863,7 +14860,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_clongdouble>();
+ tmp7 = new std::vector<npy_cdouble>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:csrmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -14897,24 +14894,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CLONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_clongdouble*) array6->data;
+ arg6 = (npy_cdouble*) array6->data;
}
- csrmux<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(npy_clongdouble const (*))arg6,arg7);
+ csrmux<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(npy_cdouble const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cdouble)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -14979,11 +14976,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_1(self, args);
@@ -15015,11 +15012,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_2(self, args);
@@ -15051,11 +15048,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_3(self, args);
@@ -15087,11 +15084,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_4(self, args);
@@ -15123,11 +15120,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_5(self, args);
@@ -15159,11 +15156,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrmux__SWIG_6(self, args);
@@ -15176,7 +15173,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrmux'.\n Possible C/C++ prototypes are:\n csrmux<(float)>(int const,int const,int const [],int const [],float const [],float const [],std::vector<float > *)\n csrmux<(double)>(int const,int const,int const [],int const [],double const [],double const [],std::vector<double > *)\n csrmux<(long double)>(int const,int const,int const [],int const [],long double const [],long double const [],std::vector<long double > *)\n csrmux<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat const [],std::vector<npy_cfloat > *)\n csrmux<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble const [],std::vector<npy_cdouble > *)\n csrmux<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],npy_clongdouble const [],std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrmux'.\n Possible C/C++ prototypes are:\n csrmux<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],std::vector<int > *)\n csrmux<(int,long)>(int const,int const,int const [],int const [],long const [],long const [],std::vector<long > *)\n csrmux<(int,float)>(int const,int const,int const [],int const [],float const [],float const [],std::vector<float > *)\n csrmux<(int,double)>(int const,int const,int const [],int const [],double const [],double const [],std::vector<double > *)\n csrmux<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat const [],std::vector<npy_cfloat > *)\n csrmux<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble const [],std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -15187,9 +15184,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
- float *arg6 ;
- std::vector<float > *arg7 = (std::vector<float > *) 0 ;
+ int *arg5 ;
+ int *arg6 ;
+ std::vector<int > *arg7 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15202,7 +15199,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<float > *tmp7 ;
+ std::vector<int > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15211,7 +15208,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<float>();
+ tmp7 = new std::vector<int>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15245,24 +15242,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_INT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (float*) array6->data;
+ arg6 = (int*) array6->data;
}
- cscmux<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(float const (*))arg6,arg7);
+ cscmux<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(int)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15302,9 +15299,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
- double *arg6 ;
- std::vector<double > *arg7 = (std::vector<double > *) 0 ;
+ long *arg5 ;
+ long *arg6 ;
+ std::vector<long > *arg7 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15317,7 +15314,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<double > *tmp7 ;
+ std::vector<long > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15326,7 +15323,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<double>();
+ tmp7 = new std::vector<long>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15360,24 +15357,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONG, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (double*) array6->data;
+ arg6 = (long*) array6->data;
}
- cscmux<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(double const (*))arg6,arg7);
+ cscmux<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(long const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(long)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15417,9 +15414,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
- long double *arg6 ;
- std::vector<long double > *arg7 = (std::vector<long double > *) 0 ;
+ float *arg5 ;
+ float *arg6 ;
+ std::vector<float > *arg7 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15432,7 +15429,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<long double > *tmp7 ;
+ std::vector<float > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15441,7 +15438,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<long double>();
+ tmp7 = new std::vector<float>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15475,24 +15472,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_LONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_FLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (long double*) array6->data;
+ arg6 = (float*) array6->data;
}
- cscmux<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(long double const (*))arg6,arg7);
+ cscmux<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(float const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(float)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15532,9 +15529,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
- npy_cfloat *arg6 ;
- std::vector<npy_cfloat > *arg7 = (std::vector<npy_cfloat > *) 0 ;
+ double *arg5 ;
+ double *arg6 ;
+ std::vector<double > *arg7 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15547,7 +15544,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_cfloat > *tmp7 ;
+ std::vector<double > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15556,7 +15553,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_cfloat>();
+ tmp7 = new std::vector<double>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15590,24 +15587,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_DOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cfloat*) array6->data;
+ arg6 = (double*) array6->data;
}
- cscmux<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(npy_cfloat const (*))arg6,arg7);
+ cscmux<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(double const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(double)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15647,9 +15644,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
- npy_cdouble *arg6 ;
- std::vector<npy_cdouble > *arg7 = (std::vector<npy_cdouble > *) 0 ;
+ npy_cfloat *arg5 ;
+ npy_cfloat *arg6 ;
+ std::vector<npy_cfloat > *arg7 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15662,7 +15659,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_cdouble > *tmp7 ;
+ std::vector<npy_cfloat > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15671,7 +15668,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_cdouble>();
+ tmp7 = new std::vector<npy_cfloat>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15705,24 +15702,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CFLOAT, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_cdouble*) array6->data;
+ arg6 = (npy_cfloat*) array6->data;
}
- cscmux<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(npy_cdouble const (*))arg6,arg7);
+ cscmux<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(npy_cfloat const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cfloat)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15762,9 +15759,9 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
- npy_clongdouble *arg6 ;
- std::vector<npy_clongdouble > *arg7 = (std::vector<npy_clongdouble > *) 0 ;
+ npy_cdouble *arg5 ;
+ npy_cdouble *arg6 ;
+ std::vector<npy_cdouble > *arg7 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -15777,7 +15774,7 @@
int is_new_object5 ;
PyArrayObject *array6 = NULL ;
int is_new_object6 ;
- std::vector<npy_clongdouble > *tmp7 ;
+ std::vector<npy_cdouble > *tmp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -15786,7 +15783,7 @@
PyObject * obj5 = 0 ;
{
- tmp7 = new std::vector<npy_clongdouble>();
+ tmp7 = new std::vector<npy_cdouble>();
arg7 = tmp7;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cscmux",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
@@ -15820,24 +15817,24 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
-1
};
- array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CLONGDOUBLE, &is_new_object6);
+ array6 = obj_to_array_contiguous_allow_conversion(obj5, PyArray_CDOUBLE, &is_new_object6);
if (!array6 || !require_dimensions(array6,1) || !require_size(array6,size,1)) SWIG_fail;
- arg6 = (npy_clongdouble*) array6->data;
+ arg6 = (npy_cdouble*) array6->data;
}
- cscmux<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(npy_clongdouble const (*))arg6,arg7);
+ cscmux<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(npy_cdouble const (*))arg6,arg7);
resultobj = SWIG_Py_Void();
{
int length = (arg7)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg7))[0]),sizeof(npy_cdouble)*length);
delete arg7;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -15902,11 +15899,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_1(self, args);
@@ -15938,11 +15935,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_2(self, args);
@@ -15974,11 +15971,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_3(self, args);
@@ -16010,11 +16007,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_4(self, args);
@@ -16046,11 +16043,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_5(self, args);
@@ -16082,11 +16079,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscmux__SWIG_6(self, args);
@@ -16099,7 +16096,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscmux'.\n Possible C/C++ prototypes are:\n cscmux<(float)>(int const,int const,int const [],int const [],float const [],float const [],std::vector<float > *)\n cscmux<(double)>(int const,int const,int const [],int const [],double const [],double const [],std::vector<double > *)\n cscmux<(long double)>(int const,int const,int const [],int const [],long double const [],long double const [],std::vector<long double > *)\n cscmux<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat const [],std::vector<npy_cfloat > *)\n cscmux<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble const [],std::vector<npy_cdouble > *)\n cscmux<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],npy_clongdouble const [],std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscmux'.\n Possible C/C++ prototypes are:\n cscmux<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],std::vector<int > *)\n cscmux<(int,long)>(int const,int const,int const [],int const [],long const [],long const [],std::vector<long > *)\n cscmux<(int,float)>(int const,int const,int const [],int const [],float const [],float const [],std::vector<float > *)\n cscmux<(int,double)>(int const,int const,int const [],int const [],double const [],double const [],std::vector<double > *)\n cscmux<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat const [],std::vector<npy_cfloat > *)\n cscmux<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble const [],std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -16110,13 +16107,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -16135,7 +16132,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -16154,7 +16151,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -16188,9 +16185,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -16212,11 +16209,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- csrelmulcsr<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -16234,8 +16231,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -16287,13 +16284,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -16312,7 +16309,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -16331,7 +16328,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -16365,9 +16362,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -16389,11 +16386,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- csrelmulcsr<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -16411,8 +16408,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -16464,13 +16461,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -16489,7 +16486,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -16508,7 +16505,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -16542,9 +16539,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -16566,11 +16563,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- csrelmulcsr<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -16588,8 +16585,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -16641,13 +16638,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -16666,7 +16663,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -16685,7 +16682,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -16719,9 +16716,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -16743,11 +16740,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- csrelmulcsr<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -16765,8 +16762,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -16818,13 +16815,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -16843,7 +16840,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -16862,7 +16859,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -16896,9 +16893,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -16920,11 +16917,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- csrelmulcsr<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -16942,8 +16939,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -16995,13 +16992,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -17020,7 +17017,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -17039,7 +17036,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:csrelmulcsr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -17073,9 +17070,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -17097,11 +17094,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- csrelmulcsr<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ csrelmulcsr<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -17119,8 +17116,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -17197,7 +17194,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -17209,7 +17206,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_1(self, args);
@@ -17243,7 +17240,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -17255,7 +17252,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_2(self, args);
@@ -17289,7 +17286,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -17301,7 +17298,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_3(self, args);
@@ -17335,7 +17332,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -17347,7 +17344,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_4(self, args);
@@ -17381,7 +17378,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -17393,7 +17390,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_5(self, args);
@@ -17427,7 +17424,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -17439,7 +17436,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrelmulcsr__SWIG_6(self, args);
@@ -17454,7 +17451,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrelmulcsr'.\n Possible C/C++ prototypes are:\n csrelmulcsr<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrelmulcsr<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrelmulcsr<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n csrelmulcsr<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrelmulcsr<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n csrelmulcsr<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrelmulcsr'.\n Possible C/C++ prototypes are:\n csrelmulcsr<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n csrelmulcsr<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n csrelmulcsr<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n csrelmulcsr<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n csrelmulcsr<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n csrelmulcsr<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -17465,13 +17462,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
int *arg6 ;
int *arg7 ;
- float *arg8 ;
+ int *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<float > *arg11 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg11 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -17490,7 +17487,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<float > *tmp11 ;
+ std::vector<int > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -17509,7 +17506,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<float>();
+ tmp11 = new std::vector<int>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -17543,9 +17540,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
npy_intp size[1] = {
@@ -17567,11 +17564,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_INT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (float*) array8->data;
+ arg8 = (int*) array8->data;
}
- cscelmulcsc<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,(int const (*))arg6,(int const (*))arg7,(int const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -17589,8 +17586,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(int)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -17642,13 +17639,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
int *arg6 ;
int *arg7 ;
- double *arg8 ;
+ long *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<double > *arg11 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg11 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -17667,7 +17664,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<double > *tmp11 ;
+ std::vector<long > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -17686,7 +17683,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<double>();
+ tmp11 = new std::vector<long>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -17720,9 +17717,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
npy_intp size[1] = {
@@ -17744,11 +17741,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONG, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (double*) array8->data;
+ arg8 = (long*) array8->data;
}
- cscelmulcsc<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -17766,8 +17763,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -17819,13 +17816,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
int *arg6 ;
int *arg7 ;
- long double *arg8 ;
+ float *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg11 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg11 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -17844,7 +17841,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<long double > *tmp11 ;
+ std::vector<float > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -17863,7 +17860,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<long double>();
+ tmp11 = new std::vector<float>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -17897,9 +17894,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
npy_intp size[1] = {
@@ -17921,11 +17918,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_LONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_FLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (long double*) array8->data;
+ arg8 = (float*) array8->data;
}
- cscelmulcsc<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(long double const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,(int const (*))arg6,(int const (*))arg7,(float const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -17943,8 +17940,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(float)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -17996,13 +17993,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cfloat *arg8 ;
+ double *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg11 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -18021,7 +18018,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cfloat > *tmp11 ;
+ std::vector<double > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -18040,7 +18037,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cfloat>();
+ tmp11 = new std::vector<double>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -18074,9 +18071,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
npy_intp size[1] = {
@@ -18098,11 +18095,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_DOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cfloat*) array8->data;
+ arg8 = (double*) array8->data;
}
- cscelmulcsc<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,(int const (*))arg6,(int const (*))arg7,(double const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -18120,8 +18117,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(double)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -18173,13 +18170,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_cdouble *arg8 ;
+ npy_cfloat *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg11 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -18198,7 +18195,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_cdouble > *tmp11 ;
+ std::vector<npy_cfloat > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -18217,7 +18214,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_cdouble>();
+ tmp11 = new std::vector<npy_cfloat>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -18251,9 +18248,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
npy_intp size[1] = {
@@ -18275,11 +18272,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CFLOAT, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_cdouble*) array8->data;
+ arg8 = (npy_cfloat*) array8->data;
}
- cscelmulcsc<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cfloat const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -18297,8 +18294,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cfloat)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -18350,13 +18347,13 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
int *arg6 ;
int *arg7 ;
- npy_clongdouble *arg8 ;
+ npy_cdouble *arg8 ;
std::vector<int > *arg9 = (std::vector<int > *) 0 ;
std::vector<int > *arg10 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg11 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg11 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -18375,7 +18372,7 @@
int is_new_object8 ;
std::vector<int > *tmp9 ;
std::vector<int > *tmp10 ;
- std::vector<npy_clongdouble > *tmp11 ;
+ std::vector<npy_cdouble > *tmp11 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -18394,7 +18391,7 @@
arg10 = tmp10;
}
{
- tmp11 = new std::vector<npy_clongdouble>();
+ tmp11 = new std::vector<npy_cdouble>();
arg11 = tmp11;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cscelmulcsc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
@@ -18428,9 +18425,9 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
{
npy_intp size[1] = {
@@ -18452,11 +18449,11 @@
npy_intp size[1] = {
-1
};
- array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CLONGDOUBLE, &is_new_object8);
+ array8 = obj_to_array_contiguous_allow_conversion(obj7, PyArray_CDOUBLE, &is_new_object8);
if (!array8 || !require_dimensions(array8,1) || !require_size(array8,size,1)) SWIG_fail;
- arg8 = (npy_clongdouble*) array8->data;
+ arg8 = (npy_cdouble*) array8->data;
}
- cscelmulcsc<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_clongdouble const (*))arg8,arg9,arg10,arg11);
+ cscelmulcsc<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,(int const (*))arg6,(int const (*))arg7,(npy_cdouble const (*))arg8,arg9,arg10,arg11);
resultobj = SWIG_Py_Void();
{
int length = (arg9)->size();
@@ -18474,8 +18471,8 @@
}
{
int length = (arg11)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg11))[0]),sizeof(npy_cdouble)*length);
delete arg11;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -18552,7 +18549,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
@@ -18564,7 +18561,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_1(self, args);
@@ -18598,7 +18595,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
@@ -18610,7 +18607,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_2(self, args);
@@ -18644,7 +18641,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -18656,7 +18653,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_3(self, args);
@@ -18690,7 +18687,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -18702,7 +18699,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_4(self, args);
@@ -18736,7 +18733,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
@@ -18748,7 +18745,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_5(self, args);
@@ -18782,7 +18779,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
@@ -18794,7 +18791,7 @@
}
if (_v) {
{
- _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[7]) && PyArray_CanCastSafely(PyArray_TYPE(argv[7]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_cscelmulcsc__SWIG_6(self, args);
@@ -18809,7 +18806,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscelmulcsc'.\n Possible C/C++ prototypes are:\n cscelmulcsc<(float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscelmulcsc<(double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscelmulcsc<(long double)>(int const,int const,int const [],int const [],long double const [],int const [],int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n cscelmulcsc<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscelmulcsc<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n cscelmulcsc<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],int const [],int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cscelmulcsc'.\n Possible C/C++ prototypes are:\n cscelmulcsc<(int,int)>(int const,int const,int const [],int const [],int const [],int const [],int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n cscelmulcsc<(int,long)>(int const,int const,int const [],int const [],long const [],int const [],int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n cscelmulcsc<(int,float)>(int const,int const,int const [],int const [],float const [],int const [],int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n cscelmulcsc<(int,double)>(int const,int const,int const [],int const [],double const [],int const [],int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n cscelmulcsc<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],int const [],int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n cscelmulcsc<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],int const [],int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -18820,10 +18817,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- float *arg5 ;
+ int *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<float > *arg8 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg8 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -18836,7 +18833,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<float > *tmp8 ;
+ std::vector<int > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -18852,7 +18849,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<float>();
+ tmp8 = new std::vector<int>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -18883,11 +18880,11 @@
npy_intp size[2] = {
-1,-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
- spdiags<float >(arg1,arg2,arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
+ spdiags<int,int >(arg1,arg2,arg3,(int const (*))arg4,(int const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -18905,8 +18902,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(int)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -18934,10 +18931,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- double *arg5 ;
+ long *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<double > *arg8 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg8 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -18950,7 +18947,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<double > *tmp8 ;
+ std::vector<long > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -18966,7 +18963,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<double>();
+ tmp8 = new std::vector<long>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -18997,11 +18994,11 @@
npy_intp size[2] = {
-1,-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
- spdiags<double >(arg1,arg2,arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
+ spdiags<int,long >(arg1,arg2,arg3,(int const (*))arg4,(long const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -19019,8 +19016,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -19048,10 +19045,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- long double *arg5 ;
+ float *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg8 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg8 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19064,7 +19061,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<long double > *tmp8 ;
+ std::vector<float > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -19080,7 +19077,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<long double>();
+ tmp8 = new std::vector<float>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -19111,11 +19108,11 @@
npy_intp size[2] = {
-1,-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
- spdiags<long double >(arg1,arg2,arg3,(int const (*))arg4,(long double const (*))arg5,arg6,arg7,arg8);
+ spdiags<int,float >(arg1,arg2,arg3,(int const (*))arg4,(float const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -19133,8 +19130,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(float)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -19162,10 +19159,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
+ double *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg8 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19178,7 +19175,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cfloat > *tmp8 ;
+ std::vector<double > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -19194,7 +19191,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cfloat>();
+ tmp8 = new std::vector<double>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -19225,11 +19222,11 @@
npy_intp size[2] = {
-1,-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
- spdiags<npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
+ spdiags<int,double >(arg1,arg2,arg3,(int const (*))arg4,(double const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -19247,8 +19244,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(double)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -19276,10 +19273,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
+ npy_cfloat *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg8 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19292,7 +19289,7 @@
int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_cdouble > *tmp8 ;
+ std::vector<npy_cfloat > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -19308,7 +19305,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_cdouble>();
+ tmp8 = new std::vector<npy_cfloat>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -19339,11 +19336,11 @@
npy_intp size[2] = {
-1,-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
- spdiags<npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
+ spdiags<int,npy_cfloat >(arg1,arg2,arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -19361,8 +19358,8 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cfloat)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -19390,10 +19387,10 @@
int arg2 ;
int arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
+ npy_cdouble *arg5 ;
std::vector<int > *arg6 = (std::vector<int > *) 0 ;
std::vector<int > *arg7 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg8 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg8 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19402,11 +19399,11 @@
int ecode3 = 0 ;
PyArrayObject *array4 = NULL ;
int is_new_object4 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
+ PyArrayObject *array5 = NULL ;
+ int is_new_object5 ;
std::vector<int > *tmp6 ;
std::vector<int > *tmp7 ;
- std::vector<npy_clongdouble > *tmp8 ;
+ std::vector<npy_cdouble > *tmp8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -19422,7 +19419,7 @@
arg7 = tmp7;
}
{
- tmp8 = new std::vector<npy_clongdouble>();
+ tmp8 = new std::vector<npy_cdouble>();
arg8 = tmp8;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOO:spdiags",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
@@ -19449,12 +19446,15 @@
if (!array4 || !require_dimensions(array4,1) || !require_size(array4,size,1)) SWIG_fail;
arg4 = (int*) array4->data;
}
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_npy_clongdouble, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "spdiags" "', argument " "5"" of type '" "npy_clongdouble const []""'");
- }
- arg5 = reinterpret_cast< npy_clongdouble * >(argp5);
- spdiags<npy_clongdouble >(arg1,arg2,arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6,arg7,arg8);
+ {
+ npy_intp size[2] = {
+ -1,-1
+ };
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ if (!array5 || !require_dimensions(array5,2) || !require_size(array5,size,1)) SWIG_fail;
+ arg5 = (npy_cdouble*) array5->data;
+ }
+ spdiags<int,npy_cdouble >(arg1,arg2,arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6,arg7,arg8);
resultobj = SWIG_Py_Void();
{
int length = (arg6)->size();
@@ -19472,19 +19472,25 @@
}
{
int length = (arg8)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg8))[0]),sizeof(npy_cdouble)*length);
delete arg8;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
{
if (is_new_object4 && array4) Py_DECREF(array4);
}
+ {
+ if (is_new_object5 && array5) Py_DECREF(array5);
+ }
return resultobj;
fail:
{
if (is_new_object4 && array4) Py_DECREF(array4);
}
+ {
+ if (is_new_object5 && array5) Py_DECREF(array5);
+ }
return NULL;
}
@@ -19521,7 +19527,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_1(self, args);
@@ -19553,7 +19559,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_2(self, args);
@@ -19585,7 +19591,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_3(self, args);
@@ -19617,7 +19623,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_4(self, args);
@@ -19649,7 +19655,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_5(self, args);
@@ -19681,7 +19687,7 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_spdiags__SWIG_6(self, args);
@@ -19693,7 +19699,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'spdiags'.\n Possible C/C++ prototypes are:\n spdiags<(float)>(int const,int const,int const,int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n spdiags<(double)>(int const,int const,int const,int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n spdiags<(long double)>(int const,int const,int const,int const [],long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n spdiags<(npy_cfloat)>(int const,int const,int const,int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n spdiags<(npy_cdouble)>(int const,int const,int const,int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n spdiags<(npy_clongdouble)>(int const,int const,int const,int const [],npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'spdiags'.\n Possible C/C++ prototypes are:\n spdiags<(int,int)>(int const,int const,int const,int const [],int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n spdiags<(int,long)>(int const,int const,int const,int const [],long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n spdiags<(int,float)>(int const,int const,int const,int const [],float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n spdiags<(int,double)>(int const,int const,int const,int const [],double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n spdiags<(int,npy_cfloat)>(int const,int const,int const,int const [],npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n spdiags<(int,npy_cdouble)>(int const,int const,int const,int const [],npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -19704,8 +19710,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- float *arg5 ;
- float *arg6 ;
+ int *arg5 ;
+ int *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19755,16 +19761,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_INT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (float*) array5->data;
+ arg5 = (int*) array5->data;
}
{
- temp6 = obj_to_array_no_conversion(obj5,PyArray_FLOAT);
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_INT);
if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
- arg6 = (float*) temp6->data;
+ arg6 = (int*) temp6->data;
}
- csrtodense<float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6);
+ csrtodense<int,int >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(int const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -19796,8 +19802,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- double *arg5 ;
- double *arg6 ;
+ long *arg5 ;
+ long *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19847,16 +19853,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONG, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (double*) array5->data;
+ arg5 = (long*) array5->data;
}
{
- temp6 = obj_to_array_no_conversion(obj5,PyArray_DOUBLE);
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_LONG);
if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
- arg6 = (double*) temp6->data;
+ arg6 = (long*) temp6->data;
}
- csrtodense<double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6);
+ csrtodense<int,long >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -19888,8 +19894,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- long double *arg5 ;
- long double *arg6 ;
+ float *arg5 ;
+ float *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -19939,16 +19945,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_LONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_FLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (long double*) array5->data;
+ arg5 = (float*) array5->data;
}
{
- temp6 = obj_to_array_no_conversion(obj5,PyArray_LONGDOUBLE);
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_FLOAT);
if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
- arg6 = (long double*) temp6->data;
+ arg6 = (float*) temp6->data;
}
- csrtodense<long double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(long double const (*))arg5,arg6);
+ csrtodense<int,float >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(float const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -19980,8 +19986,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cfloat *arg5 ;
- npy_cfloat *arg6 ;
+ double *arg5 ;
+ double *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20031,16 +20037,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_DOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cfloat*) array5->data;
+ arg5 = (double*) array5->data;
}
{
- temp6 = obj_to_array_no_conversion(obj5,PyArray_CFLOAT);
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_DOUBLE);
if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
- arg6 = (npy_cfloat*) temp6->data;
+ arg6 = (double*) temp6->data;
}
- csrtodense<npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6);
+ csrtodense<int,double >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(double const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -20072,8 +20078,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_cdouble *arg5 ;
- npy_cdouble *arg6 ;
+ npy_cfloat *arg5 ;
+ npy_cfloat *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20123,16 +20129,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CFLOAT, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_cdouble*) array5->data;
+ arg5 = (npy_cfloat*) array5->data;
}
{
- temp6 = obj_to_array_no_conversion(obj5,PyArray_CDOUBLE);
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_CFLOAT);
if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
- arg6 = (npy_cdouble*) temp6->data;
+ arg6 = (npy_cfloat*) temp6->data;
}
- csrtodense<npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6);
+ csrtodense<int,npy_cfloat >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cfloat const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -20164,8 +20170,8 @@
int arg2 ;
int *arg3 ;
int *arg4 ;
- npy_clongdouble *arg5 ;
- npy_clongdouble *arg6 ;
+ npy_cdouble *arg5 ;
+ npy_cdouble *arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20176,8 +20182,7 @@
int is_new_object4 ;
PyArrayObject *array5 = NULL ;
int is_new_object5 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
+ PyArrayObject *temp6 = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20216,16 +20221,16 @@
npy_intp size[1] = {
-1
};
- array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CLONGDOUBLE, &is_new_object5);
+ array5 = obj_to_array_contiguous_allow_conversion(obj4, PyArray_CDOUBLE, &is_new_object5);
if (!array5 || !require_dimensions(array5,1) || !require_size(array5,size,1)) SWIG_fail;
- arg5 = (npy_clongdouble*) array5->data;
+ arg5 = (npy_cdouble*) array5->data;
}
- res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_npy_clongdouble, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "csrtodense" "', argument " "6"" of type '" "npy_clongdouble []""'");
- }
- arg6 = reinterpret_cast< npy_clongdouble * >(argp6);
- csrtodense<npy_clongdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_clongdouble const (*))arg5,arg6);
+ {
+ temp6 = obj_to_array_no_conversion(obj5,PyArray_CDOUBLE);
+ if (!temp6 || !require_contiguous(temp6)) SWIG_fail;
+ arg6 = (npy_cdouble*) temp6->data;
+ }
+ csrtodense<int,npy_cdouble >(arg1,arg2,(int const (*))arg3,(int const (*))arg4,(npy_cdouble const (*))arg5,arg6);
resultobj = SWIG_Py_Void();
{
if (is_new_object3 && array3) Py_DECREF(array3);
@@ -20282,11 +20287,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_1(self, args);
@@ -20318,11 +20323,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_2(self, args);
@@ -20354,11 +20359,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_3(self, args);
@@ -20390,11 +20395,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_4(self, args);
@@ -20426,11 +20431,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_5(self, args);
@@ -20462,11 +20467,11 @@
}
if (_v) {
{
- _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[4]) && PyArray_CanCastSafely(PyArray_TYPE(argv[4]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
{
- _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[5]) && PyArray_CanCastSafely(PyArray_TYPE(argv[5]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_csrtodense__SWIG_6(self, args);
@@ -20479,7 +20484,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtodense'.\n Possible C/C++ prototypes are:\n csrtodense<(float)>(int const,int const,int const [],int const [],float const [],float [])\n csrtodense<(double)>(int const,int const,int const [],int const [],double const [],double [])\n csrtodense<(long double)>(int const,int const,int const [],int const [],long double const [],long double [])\n csrtodense<(npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat [])\n csrtodense<(npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble [])\n csrtodense<(npy_clongdouble)>(int const,int const,int const [],int const [],npy_clongdouble const [],npy_clongdouble [])\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'csrtodense'.\n Possible C/C++ prototypes are:\n csrtodense<(int,int)>(int const,int const,int const [],int const [],int const [],int [])\n csrtodense<(int,long)>(int const,int const,int const [],int const [],long const [],long [])\n csrtodense<(int,float)>(int const,int const,int const [],int const [],float const [],float [])\n csrtodense<(int,double)>(int const,int const,int const [],int const [],double const [],double [])\n csrtodense<(int,npy_cfloat)>(int const,int const,int const [],int const [],npy_cfloat const [],npy_cfloat [])\n csrtodense<(int,npy_cdouble)>(int const,int const,int const [],int const [],npy_cdouble const [],npy_cdouble [])\n");
return NULL;
}
@@ -20488,10 +20493,10 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- float *arg3 ;
+ int *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<float > *arg6 = (std::vector<float > *) 0 ;
+ std::vector<int > *arg6 = (std::vector<int > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20500,7 +20505,7 @@
int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<float > *tmp6 ;
+ std::vector<int > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20514,7 +20519,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<float>();
+ tmp6 = new std::vector<int>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20532,11 +20537,11 @@
npy_intp size[2] = {
-1,-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_FLOAT, &is_new_object3);
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (float*) array3->data;
+ arg3 = (int*) array3->data;
}
- densetocsr<float >(arg1,arg2,(float const (*))arg3,arg4,arg5,arg6);
+ densetocsr<int,int >(arg1,arg2,(int const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20554,8 +20559,8 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(float)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_INT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(int)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -20575,10 +20580,10 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- double *arg3 ;
+ long *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<double > *arg6 = (std::vector<double > *) 0 ;
+ std::vector<long > *arg6 = (std::vector<long > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20587,7 +20592,7 @@
int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<double > *tmp6 ;
+ std::vector<long > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20601,7 +20606,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<double>();
+ tmp6 = new std::vector<long>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20619,11 +20624,11 @@
npy_intp size[2] = {
-1,-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_DOUBLE, &is_new_object3);
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_LONG, &is_new_object3);
if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (double*) array3->data;
+ arg3 = (long*) array3->data;
}
- densetocsr<double >(arg1,arg2,(double const (*))arg3,arg4,arg5,arg6);
+ densetocsr<int,long >(arg1,arg2,(long const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20641,8 +20646,8 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONG);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(long)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -20662,10 +20667,10 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- long double *arg3 ;
+ float *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<long double > *arg6 = (std::vector<long double > *) 0 ;
+ std::vector<float > *arg6 = (std::vector<float > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20674,7 +20679,7 @@
int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<long double > *tmp6 ;
+ std::vector<float > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20688,7 +20693,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<long double>();
+ tmp6 = new std::vector<float>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20706,11 +20711,11 @@
npy_intp size[2] = {
-1,-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_LONGDOUBLE, &is_new_object3);
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_FLOAT, &is_new_object3);
if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (long double*) array3->data;
+ arg3 = (float*) array3->data;
}
- densetocsr<long double >(arg1,arg2,(long double const (*))arg3,arg4,arg5,arg6);
+ densetocsr<int,float >(arg1,arg2,(float const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20728,8 +20733,8 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_LONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(long double)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_FLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(float)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -20749,10 +20754,10 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- npy_cfloat *arg3 ;
+ double *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<npy_cfloat > *arg6 = (std::vector<npy_cfloat > *) 0 ;
+ std::vector<double > *arg6 = (std::vector<double > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20761,7 +20766,7 @@
int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<npy_cfloat > *tmp6 ;
+ std::vector<double > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20775,7 +20780,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<npy_cfloat>();
+ tmp6 = new std::vector<double>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20793,11 +20798,11 @@
npy_intp size[2] = {
-1,-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_CFLOAT, &is_new_object3);
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_DOUBLE, &is_new_object3);
if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (npy_cfloat*) array3->data;
+ arg3 = (double*) array3->data;
}
- densetocsr<npy_cfloat >(arg1,arg2,(npy_cfloat const (*))arg3,arg4,arg5,arg6);
+ densetocsr<int,double >(arg1,arg2,(double const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20815,8 +20820,8 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(npy_cfloat)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_DOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(double)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -20836,10 +20841,10 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- npy_cdouble *arg3 ;
+ npy_cfloat *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<npy_cdouble > *arg6 = (std::vector<npy_cdouble > *) 0 ;
+ std::vector<npy_cfloat > *arg6 = (std::vector<npy_cfloat > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -20848,7 +20853,7 @@
int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<npy_cdouble > *tmp6 ;
+ std::vector<npy_cfloat > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20862,7 +20867,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<npy_cdouble>();
+ tmp6 = new std::vector<npy_cfloat>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20880,11 +20885,11 @@
npy_intp size[2] = {
-1,-1
};
- array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_CDOUBLE, &is_new_object3);
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_CFLOAT, &is_new_object3);
if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
- arg3 = (npy_cdouble*) array3->data;
+ arg3 = (npy_cfloat*) array3->data;
}
- densetocsr<npy_cdouble >(arg1,arg2,(npy_cdouble const (*))arg3,arg4,arg5,arg6);
+ densetocsr<int,npy_cfloat >(arg1,arg2,(npy_cfloat const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20902,8 +20907,8 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(npy_cdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CFLOAT);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(npy_cfloat)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
@@ -20923,19 +20928,19 @@
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- npy_clongdouble *arg3 ;
+ npy_cdouble *arg3 ;
std::vector<int > *arg4 = (std::vector<int > *) 0 ;
std::vector<int > *arg5 = (std::vector<int > *) 0 ;
- std::vector<npy_clongdouble > *arg6 = (std::vector<npy_clongdouble > *) 0 ;
+ std::vector<npy_cdouble > *arg6 = (std::vector<npy_cdouble > *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ PyArrayObject *array3 = NULL ;
+ int is_new_object3 ;
std::vector<int > *tmp4 ;
std::vector<int > *tmp5 ;
- std::vector<npy_clongdouble > *tmp6 ;
+ std::vector<npy_cdouble > *tmp6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
@@ -20949,7 +20954,7 @@
arg5 = tmp5;
}
{
- tmp6 = new std::vector<npy_clongdouble>();
+ tmp6 = new std::vector<npy_cdouble>();
arg6 = tmp6;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:densetocsr",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -20963,12 +20968,15 @@
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "densetocsr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npy_clongdouble, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "densetocsr" "', argument " "3"" of type '" "npy_clongdouble const []""'");
- }
- arg3 = reinterpret_cast< npy_clongdouble * >(argp3);
- densetocsr<npy_clongdouble >(arg1,arg2,(npy_clongdouble const (*))arg3,arg4,arg5,arg6);
+ {
+ npy_intp size[2] = {
+ -1,-1
+ };
+ array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_CDOUBLE, &is_new_object3);
+ if (!array3 || !require_dimensions(array3,2) || !require_size(array3,size,1)) SWIG_fail;
+ arg3 = (npy_cdouble*) array3->data;
+ }
+ densetocsr<int,npy_cdouble >(arg1,arg2,(npy_cdouble const (*))arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
int length = (arg4)->size();
@@ -20986,13 +20994,19 @@
}
{
int length = (arg6)->size();
- PyObject *obj = PyArray_FromDims(1, &length, PyArray_CLONGDOUBLE);
- memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(npy_clongdouble)*length);
+ PyObject *obj = PyArray_FromDims(1, &length, PyArray_CDOUBLE);
+ memcpy(PyArray_DATA(obj),&((*(arg6))[0]),sizeof(npy_cdouble)*length);
delete arg6;
resultobj = helper_appendToTuple( resultobj, (PyObject *)obj );
}
+ {
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
return resultobj;
fail:
+ {
+ if (is_new_object3 && array3) Py_DECREF(array3);
+ }
return NULL;
}
@@ -21020,7 +21034,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_FLOAT)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_INT)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_1(self, args);
@@ -21041,7 +21055,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_DOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_LONG)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_2(self, args);
@@ -21062,7 +21076,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_LONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_FLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_3(self, args);
@@ -21083,7 +21097,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_CFLOAT)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_DOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_4(self, args);
@@ -21104,7 +21118,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_CDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_CFLOAT)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_5(self, args);
@@ -21125,7 +21139,7 @@
}
if (_v) {
{
- _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_CLONGDOUBLE)) ? 1 : 0;
+ _v = (is_array(argv[2]) && PyArray_CanCastSafely(PyArray_TYPE(argv[2]),PyArray_CDOUBLE)) ? 1 : 0;
}
if (_v) {
return _wrap_densetocsr__SWIG_6(self, args);
@@ -21135,7 +21149,7 @@
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'densetocsr'.\n Possible C/C++ prototypes are:\n densetocsr<(float)>(int const,int const,float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n densetocsr<(double)>(int const,int const,double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n densetocsr<(long double)>(int const,int const,long double const [],std::vector<int > *,std::vector<int > *,std::vector<long double > *)\n densetocsr<(npy_cfloat)>(int const,int const,npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n densetocsr<(npy_cdouble)>(int const,int const,npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n densetocsr<(npy_clongdouble)>(int const,int const,npy_clongdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_clongdouble > *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'densetocsr'.\n Possible C/C++ prototypes are:\n densetocsr<(int,int)>(int const,int const,int const [],std::vector<int > *,std::vector<int > *,std::vector<int > *)\n densetocsr<(int,long)>(int const,int const,long const [],std::vector<int > *,std::vector<int > *,std::vector<long > *)\n densetocsr<(int,float)>(int const,int const,float const [],std::vector<int > *,std::vector<int > *,std::vector<float > *)\n densetocsr<(int,double)>(int const,int const,double const [],std::vector<int > *,std::vector<int > *,std::vector<double > *)\n densetocsr<(int,npy_cfloat)>(int const,int const,npy_cfloat const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cfloat > *)\n densetocsr<(int,npy_cdouble)>(int const,int const,npy_cdouble const [],std::vector<int > *,std::vector<int > *,std::vector<npy_cdouble > *)\n");
return NULL;
}
@@ -21144,8 +21158,8 @@
{ (char *)"csrtocsc", _wrap_csrtocsc, METH_VARARGS, NULL},
{ (char *)"csctocsr", _wrap_csctocsr, METH_VARARGS, NULL},
{ (char *)"csrtocoo", _wrap_csrtocoo, METH_VARARGS, NULL},
+ { (char *)"csctocoo", _wrap_csctocoo, METH_VARARGS, NULL},
{ (char *)"cootocsr", _wrap_cootocsr, METH_VARARGS, NULL},
- { (char *)"csctocoo", _wrap_csctocoo, METH_VARARGS, NULL},
{ (char *)"cootocsc", _wrap_cootocsc, METH_VARARGS, NULL},
{ (char *)"csrplcsr", _wrap_csrplcsr, METH_VARARGS, NULL},
{ (char *)"cscplcsc", _wrap_cscplcsc, METH_VARARGS, NULL},
@@ -21165,47 +21179,39 @@
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_npy_clongdouble = {"_p_npy_clongdouble", "npy_clongdouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTdouble_t = {"_p_std__vectorTdouble_t", "std::vector<double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTfloat_t = {"_p_std__vectorTfloat_t", "std::vector<float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTint_t = {"_p_std__vectorTint_t", "std::vector<int > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTlong_double_t = {"_p_std__vectorTlong_double_t", "std::vector<long double > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTlong_t = {"_p_std__vectorTlong_t", "std::vector<long > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTnpy_cdouble_t = {"_p_std__vectorTnpy_cdouble_t", "std::vector<npy_cdouble > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTnpy_cfloat_t = {"_p_std__vectorTnpy_cfloat_t", "std::vector<npy_cfloat > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTnpy_clongdouble_t = {"_p_std__vectorTnpy_clongdouble_t", "std::vector<npy_clongdouble > *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_char,
- &_swigt__p_npy_clongdouble,
&_swigt__p_std__vectorTdouble_t,
&_swigt__p_std__vectorTfloat_t,
&_swigt__p_std__vectorTint_t,
- &_swigt__p_std__vectorTlong_double_t,
+ &_swigt__p_std__vectorTlong_t,
&_swigt__p_std__vectorTnpy_cdouble_t,
&_swigt__p_std__vectorTnpy_cfloat_t,
- &_swigt__p_std__vectorTnpy_clongdouble_t,
};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_npy_clongdouble[] = { {&_swigt__p_npy_clongdouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTdouble_t[] = { {&_swigt__p_std__vectorTdouble_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTfloat_t[] = { {&_swigt__p_std__vectorTfloat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTint_t[] = { {&_swigt__p_std__vectorTint_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTlong_double_t[] = { {&_swigt__p_std__vectorTlong_double_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTlong_t[] = { {&_swigt__p_std__vectorTlong_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTnpy_cdouble_t[] = { {&_swigt__p_std__vectorTnpy_cdouble_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTnpy_cfloat_t[] = { {&_swigt__p_std__vectorTnpy_cfloat_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTnpy_clongdouble_t[] = { {&_swigt__p_std__vectorTnpy_clongdouble_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_char,
- _swigc__p_npy_clongdouble,
_swigc__p_std__vectorTdouble_t,
_swigc__p_std__vectorTfloat_t,
_swigc__p_std__vectorTint_t,
- _swigc__p_std__vectorTlong_double_t,
+ _swigc__p_std__vectorTlong_t,
_swigc__p_std__vectorTnpy_cdouble_t,
_swigc__p_std__vectorTnpy_cfloat_t,
- _swigc__p_std__vectorTnpy_clongdouble_t,
};
More information about the Scipy-svn
mailing list