adding CT_ prefix to numeric types to avoid name conflicts with other…

… libraries

examples/dmrg/basic_dmrg_fermi_hubbard.c

@@ -96,7 +96,7 @@ int main()
 		assert(hmat.dim[0] == 1 && hmat.dim[3] == 1);
 		assert(hmat.dim[1] == ipow(hamiltonian.d, hamiltonian.nsites));
 		assert(hmat.dim[1] == hmat.dim[2]);
-		assert(hmat.dtype == DOUBLE_REAL);
+		assert(hmat.dtype == CT_DOUBLE_REAL);
 	}
 
 	// reference eigenvalues (based on exact diagonalization of matrix representation)

pymodule/pymodule.c

@@ -12,19 +12,19 @@ static inline enum NPY_TYPES numeric_to_numpy_type(const enum numeric_type dtype
 {
 	switch (dtype)
 	{
-		case SINGLE_REAL:
+		case CT_SINGLE_REAL:
 		{
 			return NPY_FLOAT;
 		}
-		case DOUBLE_REAL:
+		case CT_DOUBLE_REAL:
 		{
 			return NPY_DOUBLE;
 		}
-		case SINGLE_COMPLEX:
+		case CT_SINGLE_COMPLEX:
 		{
 			return NPY_CFLOAT;
 		}
-		case DOUBLE_COMPLEX:
+		case CT_DOUBLE_COMPLEX:
 		{
 			return NPY_CDOUBLE;
 		}
@@ -543,7 +543,7 @@ static int PyMPO_set_coeffmap(PyMPOObject* self, PyObject* arg, void* Py_UNUSED(
 	// first two entries must always be 0 and 1
 	switch (self->assembly.dtype)
 	{
-		case SINGLE_REAL:
+		case CT_SINGLE_REAL:
 		{
 			const float* data = (float*)PyArray_DATA(py_coeffmap);
 			if ((data[0] != 0) || (data[1] != 1)) {
@@ -555,7 +555,7 @@ static int PyMPO_set_coeffmap(PyMPOObject* self, PyObject* arg, void* Py_UNUSED(
 			}
 			break;
 		}
-		case DOUBLE_REAL:
+		case CT_DOUBLE_REAL:
 		{
 			const double* data = (double*)PyArray_DATA(py_coeffmap);
 			if ((data[0] != 0) || (data[1] != 1)) {
@@ -567,7 +567,7 @@ static int PyMPO_set_coeffmap(PyMPOObject* self, PyObject* arg, void* Py_UNUSED(
 			}
 			break;
 		}
-		case SINGLE_COMPLEX:
+		case CT_SINGLE_COMPLEX:
 		{
 			const scomplex* data = (scomplex*)PyArray_DATA(py_coeffmap);
 			if ((data[0] != 0) || (data[1] != 1)) {
@@ -579,7 +579,7 @@ static int PyMPO_set_coeffmap(PyMPOObject* self, PyObject* arg, void* Py_UNUSED(
 			}
 			break;
 		}
-		case DOUBLE_COMPLEX:
+		case CT_DOUBLE_COMPLEX:
 		{
 			const dcomplex* data = (dcomplex*)PyArray_DATA(py_coeffmap);
 			if ((data[0] != 0) || (data[1] != 1)) {
@@ -706,19 +706,19 @@ static PyObject* Py_construct_random_mps(PyObject* Py_UNUSED(self), PyObject* ar
 	enum numeric_type dtype;
 	if ((strcmp(dtype_string, "float32") == 0)
 	 || (strcmp(dtype_string, "float") == 0)) {
-		dtype = SINGLE_REAL;
+		dtype = CT_SINGLE_REAL;
 	}
 	else if ((strcmp(dtype_string, "float64") == 0)
 	      || (strcmp(dtype_string, "double") == 0)) {
-		dtype = DOUBLE_REAL;
+		dtype = CT_DOUBLE_REAL;
 	}
 	else if ((strcmp(dtype_string, "complex64") == 0) ||
 	         (strcmp(dtype_string, "float complex") == 0)) {
-		dtype = SINGLE_COMPLEX;
+		dtype = CT_SINGLE_COMPLEX;
 	}
 	else if ((strcmp(dtype_string, "complex128") == 0)
 	      || (strcmp(dtype_string, "double complex") == 0)) {
-		dtype = DOUBLE_COMPLEX;
+		dtype = CT_DOUBLE_COMPLEX;
 	}
 	else {
 		PyErr_SetString(PyExc_ValueError, "unrecognized 'dtype' argument; use \"float32\", \"float64\", \"complex64\" or \"complex128\"");
@@ -1041,14 +1041,14 @@ static PyObject* Py_construct_molecular_hamiltonian_mpo(PyObject* Py_UNUSED(self
 	struct dense_tensor tkin = {
 		.data  = PyArray_DATA(py_tkin),
 		.dim   = dim_tkin,
-		.dtype = DOUBLE_REAL,
+		.dtype = CT_DOUBLE_REAL,
 		.ndim  = 2,
 	};
 	long dim_vint[4] = { nsites, nsites, nsites, nsites };
 	struct dense_tensor vint = {
 		.data  = PyArray_DATA(py_vint),
 		.dim   = dim_vint,
-		.dtype = DOUBLE_REAL,
+		.dtype = CT_DOUBLE_REAL,
 		.ndim  = 4,
 	};
 

src/algorithm/bond_ops.c

@@ -185,7 +185,7 @@ void retained_bond_indices(const double* sigma, const long n, const double tol,
 	{
 		retained[i] = sigma[list->ind[i]];
 	}
-	info->norm_sigma = norm2(DOUBLE_REAL, list->num, retained);
+	info->norm_sigma = norm2(CT_DOUBLE_REAL, list->num, retained);
 
 	// normalized retained singular values
 	for (long i = 0; i < list->num; i++)
@@ -219,13 +219,13 @@ int split_block_sparse_matrix_svd(const struct block_sparse_tensor* restrict a,
 
 	// determine retained bond indices
 	struct index_list retained;
-	if (s.dtype == DOUBLE_REAL)
+	if (s.dtype == CT_DOUBLE_REAL)
 	{
 		retained_bond_indices(s.data, s.dim[0], tol, max_vdim, &retained, info);
 	}
 	else
 	{
-		assert(s.dtype == SINGLE_REAL);
+		assert(s.dtype == CT_SINGLE_REAL);
 
 		// temporarily convert singular values to double format
 		const float* sdata = s.data;
@@ -293,14 +293,14 @@ int split_block_sparse_matrix_svd(const struct block_sparse_tensor* restrict a,
 		// rescale retained singular values
 		assert(info->norm_sigma > 0);
 		const double scale = norm_sigma_all / info->norm_sigma;
-		if (s_ret.dtype == SINGLE_REAL)
+		if (s_ret.dtype == CT_SINGLE_REAL)
 		{
 			const float scalef = (float)scale;
 			scale_dense_tensor(&scalef, &s_ret);
 		}
 		else
 		{
-			assert(s_ret.dtype == DOUBLE_REAL);
+			assert(s_ret.dtype == CT_DOUBLE_REAL);
 			scale_dense_tensor(&scale, &s_ret);
 		}
 	}

src/algorithm/dmrg.c

@@ -29,14 +29,14 @@ static void apply_local_hamiltonian_wrapper_d(const long n, const void* restrict
 	struct local_hamiltonian_data* hdata = (struct local_hamiltonian_data*)data;
 
 	// interpret input vector as MPS tensor entries
-	assert(hdata->a->dtype == DOUBLE_REAL);
+	assert(hdata->a->dtype == CT_DOUBLE_REAL);
 	assert(n == block_sparse_tensor_num_elements_blocks(hdata->a));
 	block_sparse_tensor_deserialize_entries(hdata->a, v);
 
 	struct block_sparse_tensor ha;
 	apply_local_hamiltonian(hdata->a, hdata->w, hdata->l, hdata->r, &ha);
 
-	assert(ha.dtype == DOUBLE_REAL);
+	assert(ha.dtype == CT_DOUBLE_REAL);
 	assert(n == block_sparse_tensor_num_elements_blocks(&ha));
 	block_sparse_tensor_serialize_entries(&ha, ret);
 
@@ -53,14 +53,14 @@ static void apply_local_hamiltonian_wrapper_z(const long n, const void* restrict
 	struct local_hamiltonian_data* hdata = (struct local_hamiltonian_data*)data;
 
 	// interpret input vector as MPS tensor entries
-	assert(hdata->a->dtype == DOUBLE_COMPLEX);
+	assert(hdata->a->dtype == CT_DOUBLE_COMPLEX);
 	assert(n == block_sparse_tensor_num_elements_blocks(hdata->a));
 	block_sparse_tensor_deserialize_entries(hdata->a, v);
 
 	struct block_sparse_tensor ha;
 	apply_local_hamiltonian(hdata->a, hdata->w, hdata->l, hdata->r, &ha);
 
-	assert(ha.dtype == DOUBLE_COMPLEX);
+	assert(ha.dtype == CT_DOUBLE_COMPLEX);
 	assert(n == block_sparse_tensor_num_elements_blocks(&ha));
 	block_sparse_tensor_serialize_entries(&ha, ret);
 
@@ -92,27 +92,27 @@ static int minimize_local_energy(const struct block_sparse_tensor* restrict w, c
 
 	switch (a_start->dtype)
 	{
-		case SINGLE_REAL:
+		case CT_SINGLE_REAL:
 		{
 			// not implemented yet
 			assert(false);
 			break;
 		}
-		case DOUBLE_REAL:
+		case CT_DOUBLE_REAL:
 		{
 			int ret = eigensystem_krylov_symmetric(n, apply_local_hamiltonian_wrapper_d, &hdata, vstart, maxiter, 1, en_min, u_opt);
 			if (ret < 0) {
 				return ret;
 			}
 			break;
 		}
-		case SINGLE_COMPLEX:
+		case CT_SINGLE_COMPLEX:
 		{
 			// not implemented yet
 			assert(false);
 			break;
 		}
-		case DOUBLE_COMPLEX:
+		case CT_DOUBLE_COMPLEX:
 		{
 			int ret = eigensystem_krylov_hermitian(n, apply_local_hamiltonian_wrapper_z, &hdata, vstart, maxiter, 1, en_min, u_opt);
 			if (ret < 0) {
@@ -149,7 +149,7 @@ int dmrg_singlesite(const struct mpo* hamiltonian, const int num_sweeps, const i
 	assert(nsites >= 1);
 
 	// currently only double precision supported
-	assert(numeric_real_type(hamiltonian->a[0].dtype) == DOUBLE_REAL);
+	assert(numeric_real_type(hamiltonian->a[0].dtype) == CT_DOUBLE_REAL);
 
 	// right-normalize input matrix product state
 	double nrm = mps_orthonormalize_qr(psi, MPS_ORTHONORMAL_RIGHT);
@@ -257,7 +257,7 @@ int dmrg_twosite(const struct mpo* hamiltonian, const int num_sweeps, const int
 	assert(nsites >= 2);
 
 	// currently only double precision supported
-	assert(numeric_real_type(hamiltonian->a[0].dtype) == DOUBLE_REAL);
+	assert(numeric_real_type(hamiltonian->a[0].dtype) == CT_DOUBLE_REAL);
 
 	// right-normalize input matrix product state
 	double nrm = mps_orthonormalize_qr(psi, MPS_ORTHONORMAL_RIGHT);

src/algorithm/gradient.c

@@ -120,7 +120,7 @@ void operator_average_coefficient_gradient(const struct mpo_assembly* assembly,
 				// explicitly contract physical axes
 				switch (assembly->dtype)
 				{
-					case SINGLE_REAL:
+					case CT_SINGLE_REAL:
 					{
 						float* dc = dcoeff;
 						const float* opdata = op->data;
@@ -141,7 +141,7 @@ void operator_average_coefficient_gradient(const struct mpo_assembly* assembly,
 						}
 						break;
 					}
-					case DOUBLE_REAL:
+					case CT_DOUBLE_REAL:
 					{
 						double* dc = dcoeff;
 						const double* opdata = op->data;
@@ -162,7 +162,7 @@ void operator_average_coefficient_gradient(const struct mpo_assembly* assembly,
 						}
 						break;
 					}
-					case SINGLE_COMPLEX:
+					case CT_SINGLE_COMPLEX:
 					{
 						scomplex* dc = dcoeff;
 						const scomplex* opdata = op->data;
@@ -183,7 +183,7 @@ void operator_average_coefficient_gradient(const struct mpo_assembly* assembly,
 						}
 						break;
 					}
-					case DOUBLE_COMPLEX:
+					case CT_DOUBLE_COMPLEX:
 					{
 						dcomplex* dc = dcoeff;
 						const dcomplex* opdata = op->data;

src/mps/mps.c

@@ -320,29 +320,29 @@ double mps_norm(const struct mps* psi)
 
 	switch (psi->a[0].dtype)
 	{
-		case SINGLE_REAL:
+		case CT_SINGLE_REAL:
 		{
 			float nrm2;
 			mps_vdot(psi, psi, &nrm2);
 			assert(nrm2 >= 0);
 			return sqrt(nrm2);
 		}
-		case DOUBLE_REAL:
+		case CT_DOUBLE_REAL:
 		{
 			double nrm2;
 			mps_vdot(psi, psi, &nrm2);
 			assert(nrm2 >= 0);
 			return sqrt(nrm2);
 		}
-		case SINGLE_COMPLEX:
+		case CT_SINGLE_COMPLEX:
 		{
 			scomplex vdot;
 			mps_vdot(psi, psi, &vdot);
 			float nrm2 = crealf(vdot);
 			assert(nrm2 >= 0);
 			return sqrt(nrm2);
 		}
-		case DOUBLE_COMPLEX:
+		case CT_DOUBLE_COMPLEX:
 		{
 			dcomplex vdot;
 			mps_vdot(psi, psi, &vdot);
@@ -497,22 +497,22 @@ double mps_orthonormalize_qr(struct mps* mps, const enum mps_orthonormalization_
 		{
 			switch (a_tail.blocks[0]->dtype)
 			{
-				case SINGLE_REAL:
+				case CT_SINGLE_REAL:
 				{
 					nrm = *((float*)a_tail.blocks[0]->data);
 					break;
 				}
-				case DOUBLE_REAL:
+				case CT_DOUBLE_REAL:
 				{
 					nrm = *((double*)a_tail.blocks[0]->data);
 					break;
 				}
-				case SINGLE_COMPLEX:
+				case CT_SINGLE_COMPLEX:
 				{
 					nrm = crealf(*((scomplex*)a_tail.blocks[0]->data));
 					break;
 				}
-				case DOUBLE_COMPLEX:
+				case CT_DOUBLE_COMPLEX:
 				{
 					nrm = creal(*((dcomplex*)a_tail.blocks[0]->data));
 					break;
@@ -570,22 +570,22 @@ double mps_orthonormalize_qr(struct mps* mps, const enum mps_orthonormalization_
 		{
 			switch (a_head.blocks[0]->dtype)
 			{
-				case SINGLE_REAL:
+				case CT_SINGLE_REAL:
 				{
 					nrm = *((float*)a_head.blocks[0]->data);
 					break;
 				}
-				case DOUBLE_REAL:
+				case CT_DOUBLE_REAL:
 				{
 					nrm = *((double*)a_head.blocks[0]->data);
 					break;
 				}
-				case SINGLE_COMPLEX:
+				case CT_SINGLE_COMPLEX:
 				{
 					nrm = crealf(*((scomplex*)a_head.blocks[0]->data));
 					break;
 				}
-				case DOUBLE_COMPLEX:
+				case CT_DOUBLE_COMPLEX:
 				{
 					nrm = creal(*((dcomplex*)a_head.blocks[0]->data));
 					break;