From 1d8efb7980ff3695fc4a2fa1b06737eac7a3a30a Mon Sep 17 00:00:00 2001 From: stevencwilliams Date: Thu, 29 Dec 2011 22:05:27 +0000 Subject: [PATCH] Allow float- and long double-precision compilation. --- Makefile | 34 +- Makefile.vars-template | 22 +- assortativity.cpp | 90 ++-- bct.h | 265 +++++------ bct_double.h | 4 + bct_float.h | 4 + bct_gsl.i | 83 ++-- bct_long_double.h | 4 + bct_py.i | 83 ++-- betweenness_bin.cpp | 126 +++-- betweenness_wei.cpp | 145 +++--- breadth.cpp | 65 ++- breadthdist.cpp | 25 +- cat.cpp | 21 +- charpath.cpp | 58 +-- clustering_coef_bd.cpp | 55 ++- clustering_coef_bu.cpp | 64 +-- clustering_coef_wd.cpp | 75 ++- clustering_coef_wu.cpp | 41 +- connectivity_length.cpp | 18 +- convert.cpp | 57 ++- cycprob.cpp | 39 +- debug.cpp | 15 +- degrees_dir.cpp | 26 +- degrees_und.cpp | 31 +- density_dir.cpp | 5 +- density_und.cpp | 24 +- distance_bin.cpp | 47 +- distance_wei.cpp | 97 ++-- efficiency.cpp | 225 ++------- eigenvector_centrality.cpp | 169 +++---- erange.cpp | 65 ++- find_motif34.cpp | 68 ++- findpaths.cpp | 242 +++++----- findwalks.cpp | 33 +- fve.cpp | 21 +- jdegree.cpp | 54 ++- latmio_dir.cpp | 109 +++-- latmio_dir_connected.cpp | 227 +++++---- latmio_und.cpp | 129 +++--- latmio_und_connected.cpp | 225 +++++---- macaque.cpp | 21 +- make_motif34lib.cpp | 229 +++++----- makeevenCIJ.cpp | 92 ++-- makefractalCIJ.cpp | 85 ++-- makelatticeCIJ.cpp | 57 ++- makerandCIJ_bd.cpp | 26 +- makerandCIJ_bu.cpp | 38 +- makerandCIJ_wd.cpp | 55 +-- makerandCIJ_wu.cpp | 69 ++- makerandCIJdegreesfixed.cpp | 99 ++-- makeringlatticeCIJ.cpp | 81 ++-- maketoeplitzCIJ.cpp | 44 +- matching_ind.cpp | 76 ++-- matlab/compare.cpp | 79 ++-- matlab/convert.cpp | 134 +++--- matlab/functions.cpp | 430 ++++++++++-------- matlab/index.cpp | 127 +++--- matlab/macros.h | 33 -- matlab/matlab.cpp | 125 ----- matlab/matlab.h | 337 +++++++------- matlab/matlab_double.cpp | 10 - matlab/matlab_double.h | 10 - matlab/matlab_float.cpp | 10 - matlab/matlab_float.h | 10 - matlab/matlab_long_double.cpp | 10 - matlab/matlab_long_double.h | 10 - matlab/operators.cpp | 203 +++++---- matlab/utility.cpp | 48 +- modularity_louvain.cpp | 185 ++++---- modularity_newman.cpp | 327 ++++++------- module_degree_zscore.cpp | 31 +- motif3funct_bin.cpp | 144 +++--- motif3funct_wei.cpp | 246 +++++----- motif3struct_bin.cpp | 80 ++-- motif3struct_wei.cpp | 137 +++--- motif4funct_bin.cpp | 180 ++++---- motif4funct_wei.cpp | 282 ++++++------ motif4struct_bin.cpp | 116 +++-- motif4struct_wei.cpp | 173 ++++--- normalized_path_length.cpp | 44 +- participation_coef.cpp | 51 +-- precision.h | 39 ++ randmio_dir.cpp | 40 +- randmio_dir_connected.cpp | 158 ++++--- randmio_und.cpp | 60 ++- randmio_und_connected.cpp | 156 ++++--- reachdist.cpp | 93 ++-- status.cpp | 161 +------ strengths_dir.cpp | 16 +- strengths_und.cpp | 4 +- test/Makefile | 2 +- test/assortativity_dir_cpp.cpp | 1 - test/assortativity_und_cpp.cpp | 1 - test/bct_test.cpp | 6 - test/bct_test.h | 1 + test/bct_test_modularity.m | 10 +- test/betweenness_bin_cpp.cpp | 1 - test/betweenness_wei_cpp.cpp | 1 - test/breadth_cpp.cpp | 6 +- test/breadthdist_cpp.cpp | 3 - test/charpath_ecc_cpp.cpp | 4 - test/charpath_lambda_cpp.cpp | 1 - test/clustering_coef_bd_cpp.cpp | 1 - test/clustering_coef_bu_cpp.cpp | 1 - test/clustering_coef_wd_cpp.cpp | 1 - test/clustering_coef_wu_cpp.cpp | 1 - test/cycprob_fcyc_cpp.cpp | 4 - test/cycprob_pcyc_cpp.cpp | 4 - test/degrees_dir_cpp.cpp | 1 - test/degrees_und_cpp.cpp | 1 - test/density_dir_cpp.cpp | 1 - test/density_und_cpp.cpp | 1 - test/distance_bin_cpp.cpp | 1 - test/distance_wei_cpp.cpp | 1 - test/edge_betweenness_bin_cpp.cpp | 1 - test/edge_betweenness_wei_cpp.cpp | 1 - test/efficiency_global_cpp.cpp | 1 - test/efficiency_local_cpp.cpp | 1 - test/erange_cpp.cpp | 3 - test/find_motif34_cpp.cpp | 4 - test/findpaths_cpp.cpp | 5 - test/findwalks_cpp.cpp | 5 - test/jdegree_bl_cpp.cpp | 1 - test/jdegree_cpp.cpp | 1 - test/jdegree_id_cpp.cpp | 1 - test/jdegree_od_cpp.cpp | 1 - test/latmio_dir_connected_cpp.cpp | 3 - test/latmio_dir_cpp.cpp | 3 - test/latmio_und_connected_cpp.cpp | 3 - test/latmio_und_cpp.cpp | 3 - test/makeevenCIJ_cpp.cpp | 3 - test/makefractalCIJ_cpp.cpp | 3 - test/makelatticeCIJ_cpp.cpp | 3 - test/makerandCIJ_bd_cpp.cpp | 3 - test/makerandCIJ_bu_cpp.cpp | 3 - test/makerandCIJdegreesfixed_cpp.cpp | 4 - test/makeringlatticeCIJ_cpp.cpp | 3 - test/maketoeplitzCIJ_cpp.cpp | 3 - test/matching_ind_cpp.cpp | 1 - test/matching_ind_in_cpp.cpp | 1 - test/matching_ind_out_cpp.cpp | 1 - test/modularity_dir_cpp.cpp | 4 - ...cpp.cpp => modularity_louvain_und_cpp.cpp} | 8 +- test/modularity_und_cpp.cpp | 4 - test/module_degree_zscore_cpp.cpp | 4 - test/motif3funct_bin_cpp.cpp | 4 - test/motif3funct_wei_cpp.cpp | 3 - test/motif3generate_cpp.cpp | 4 - test/motif3struct_bin_cpp.cpp | 4 - test/motif3struct_wei_cpp.cpp | 3 - test/motif4funct_bin_cpp.cpp | 4 - test/motif4funct_wei_cpp.cpp | 3 - test/motif4generate_cpp.cpp | 4 - test/motif4struct_bin_cpp.cpp | 4 - test/motif4struct_wei_cpp.cpp | 3 - test/participation_coef_cpp.cpp | 4 - test/randmio_dir_connected_cpp.cpp | 3 - test/randmio_dir_cpp.cpp | 3 - test/randmio_und_connected_cpp.cpp | 3 - test/randmio_und_cpp.cpp | 3 - test/reachdist_cpp.cpp | 3 - test/strengths_dir_cpp.cpp | 1 - test/strengths_und_cpp.cpp | 1 - test/threshold_absolute_cpp.cpp | 3 - test/threshold_proportional_dir_cpp.cpp | 3 - test/threshold_proportional_und_cpp.cpp | 3 - threshold_absolute.cpp | 11 +- threshold_proportional.cpp | 55 ++- utility.cpp | 26 +- 170 files changed, 3961 insertions(+), 4798 deletions(-) create mode 100644 bct_double.h create mode 100644 bct_float.h create mode 100644 bct_long_double.h delete mode 100644 matlab/macros.h delete mode 100644 matlab/matlab.cpp delete mode 100644 matlab/matlab_double.cpp delete mode 100644 matlab/matlab_double.h delete mode 100644 matlab/matlab_float.cpp delete mode 100644 matlab/matlab_float.h delete mode 100644 matlab/matlab_long_double.cpp delete mode 100644 matlab/matlab_long_double.h create mode 100644 precision.h rename test/{modularity_und_louvain_cpp.cpp => modularity_louvain_und_cpp.cpp} (65%) diff --git a/Makefile b/Makefile index c67f22d..efd5e62 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,4 @@ CXXFLAGS = -Wall -#To enable parallel algorithms, use following (assuming gcc) -#CXXFLAGS = -Wall -fopenmp - # OUTPUT_OPTION = -o .obj/$@ swig_flags = -Wall -c++ -python -outputtuple objects = assortativity.o \ @@ -26,7 +23,7 @@ objects = assortativity.o \ distance_bin.o \ distance_wei.o \ efficiency.o \ - eigenvector_centrality.o \ + eigenvector_centrality.o \ erange.o \ find_motif34.o \ findpaths.o \ @@ -50,10 +47,12 @@ objects = assortativity.o \ makeringlatticeCIJ.o \ maketoeplitzCIJ.o \ matching_ind.o \ - matlab/matlab.o \ - matlab/matlab_double.o \ - matlab/matlab_float.o \ - matlab/matlab_long_double.o \ + matlab/compare.o \ + matlab/convert.o \ + matlab/functions.o \ + matlab/index.o \ + matlab/operators.o \ + matlab/utility.o \ modularity_louvain.o \ modularity_newman.o \ module_degree_zscore.o \ @@ -82,9 +81,8 @@ objects = assortativity.o \ include Makefile.vars # To make a multi-architecture library: -# Compile once for each architecture -# Add -arch to CXXFLAGS and LDFLAGS during compilation -# lipo -create -output +# Compile once for each architecture by adding -arch to CXXFLAGS and LDFLAGS during compilation +# Then execute "lipo -create -output " .PHONY: all clean install swig uninstall @@ -108,13 +106,17 @@ install: libbct.a mkdir $(install_dir)/include/bct; \ mkdir $(install_dir)/include/bct/matlab; \ fi - cp matlab/macros.h $(install_dir)/include/bct/matlab + if [[ "$(CXXFLAGS)" == *GSL_FLOAT* ]]; then \ + cat bct_float.h bct.h > _bct.h; \ + elif [[ "$(CXXFLAGS)" == *GSL_DOUBLE* ]]; then \ + cat bct_double.h bct.h > _bct.h; \ + elif [[ "$(CXXFLAGS)" == *GSL_LONG_DOUBLE* ]]; then \ + cat bct_long_double.h bct.h > _bct.h; \ + fi + mv _bct.h $(install_dir)/include/bct/bct.h cp matlab/matlab.h $(install_dir)/include/bct/matlab - cp matlab/matlab_double.h $(install_dir)/include/bct/matlab - cp matlab/matlab_float.h $(install_dir)/include/bct/matlab - cp matlab/matlab_long_double.h $(install_dir)/include/bct/matlab cp matlab/sort.h $(install_dir)/include/bct/matlab - cp bct.h $(install_dir)/include/bct + cp precision.h $(install_dir)/include/bct cp libbct.a $(install_dir)/lib uninstall: diff --git a/Makefile.vars-template b/Makefile.vars-template index f81ffdd..5eb41aa 100644 --- a/Makefile.vars-template +++ b/Makefile.vars-template @@ -1,9 +1,12 @@ # Arguments to be sent to the C++ compiler # Some arguments may already be specified in Makefile -# To enable parallel processing with OpenMP add "-fopenmp" (assuming gcc) -# To build for a particular architecture add "-arch ", -# where is the specific architecture; e.g., "-arch i386" -CXXFLAGS += +# To compile with float precision, replace "-DGSL_DOUBLE" with "-DGSL_FLOAT" +# To compile with long double precision, replace "-DGSL_DOUBLE" with "-DGSL_LONG_DOUBLE" +# WARNING: SWIG wrappers are only set up to work with double precision +# To enable parallel processing with OpenMP, add "-fopenmp" +# To build for a particular architecture, add "-arch " (e.g., "-arch i386") +# On Linux, "-fPIC" may be required? +CXXFLAGS += -DGSL_DOUBLE # Installation directory install_dir = /usr/local @@ -11,21 +14,22 @@ install_dir = /usr/local # The following variables are only needed for SWIG # If you aren't generating Python bindings, you don't need to worry about them -# A typical value for the Python header file directory is -python_dir_apple = /Library/Frameworks/Python.framework/Versions/Current/include/python2.6 +# Typical values for python_dir in different environments +python_dir_apple = /Library/Frameworks/Python.framework/Versions/2.6/include/python2.6 +python_dir_linux = /usr/include/python2.6 # Python header file directory -# This points to the C header files required to compile the SWIG bindings +# This is the location of the C++ header files required to build Python bindings # You may be able to use one of the previously defined variables # E.g., python_dir = $(python_dir_apple) python_dir = # Typical values for swig_lib_flags in different environments -# You probably don't need to change these swig_lib_flags_apple = -bundle -flat_namespace -undefined suppress swig_lib_flags_linux = -shared # Arguments for generating a shared library from SWIG wrappers -# You can probably use one of the previously defined variables +# You may be able to use one of the previously defined variables # E.g., swig_lib_flags = $(swig_lib_flags_apple) +# On Linux, "-lpython2.6" may be required? swig_lib_flags = diff --git a/assortativity.cpp b/assortativity.cpp index 18cb680..32bc768 100644 --- a/assortativity.cpp +++ b/assortativity.cpp @@ -1,26 +1,24 @@ #include "bct.h" -#include -#include -double assortativity(const gsl_vector*, const gsl_matrix*); +FP_T assortativity(const VECTOR_T*, const MATRIX_T*); /* * Computes assortativity for a directed graph. Connection weights are ignored. */ -double bct::assortativity_dir(const gsl_matrix* CIJ) { +FP_T bct::assortativity_dir(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | DIRECTED, "assortativity_dir"); // [id,od,deg] = degrees_dir(CIJ); - gsl_vector* deg = degrees_dir(CIJ); + VECTOR_T* deg = degrees_dir(CIJ); // [i,j] = find(CIJ>0); - gsl_matrix* CIJ_gt_0 = compare_elements(CIJ, fp_greater, 0.0); - gsl_matrix* CIJ_gt_0_ij = find_ij(CIJ_gt_0); - gsl_matrix_free(CIJ_gt_0); + MATRIX_T* CIJ_gt_0 = compare_elements(CIJ, fp_greater, 0.0); + MATRIX_T* CIJ_gt_0_ij = find_ij(CIJ_gt_0); + MATRIX_ID(free)(CIJ_gt_0); - double ret = assortativity(deg, CIJ_gt_0_ij); - gsl_vector_free(deg); - gsl_matrix_free(CIJ_gt_0_ij); + FP_T ret = assortativity(deg, CIJ_gt_0_ij); + VECTOR_ID(free)(deg); + MATRIX_ID(free)(CIJ_gt_0_ij); return ret; } @@ -28,32 +26,32 @@ double bct::assortativity_dir(const gsl_matrix* CIJ) { * Computes assortativity for an undirected graph. Connection weights are * ignored. */ -double bct::assortativity_und(const gsl_matrix* CIJ) { +FP_T bct::assortativity_und(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "assortativity_und"); // [deg] = degrees_und(m); - gsl_vector* deg = degrees_und(CIJ); + VECTOR_T* deg = degrees_und(CIJ); // [i,j] = find(triu(CIJ,1)>0); - gsl_matrix* triu_CIJ = triu(CIJ, 1); - gsl_matrix* triu_CIJ_gt_0 = compare_elements(triu_CIJ, fp_greater, 0.0); - gsl_matrix_free(triu_CIJ); - gsl_matrix* triu_CIJ_gt_0_ij = find_ij(triu_CIJ_gt_0); - gsl_matrix_free(triu_CIJ_gt_0); + MATRIX_T* triu_CIJ = triu(CIJ, 1); + MATRIX_T* triu_CIJ_gt_0 = compare_elements(triu_CIJ, fp_greater, 0.0); + MATRIX_ID(free)(triu_CIJ); + MATRIX_T* triu_CIJ_gt_0_ij = find_ij(triu_CIJ_gt_0); + MATRIX_ID(free)(triu_CIJ_gt_0); - double ret = assortativity(deg, triu_CIJ_gt_0_ij); - gsl_vector_free(deg); - gsl_matrix_free(triu_CIJ_gt_0_ij); + FP_T ret = assortativity(deg, triu_CIJ_gt_0_ij); + VECTOR_ID(free)(deg); + MATRIX_ID(free)(triu_CIJ_gt_0_ij); return ret; } -double assortativity(const gsl_vector* deg, const gsl_matrix* ij) { +FP_T assortativity(const VECTOR_T* deg, const MATRIX_T* ij) { using namespace bct; - gsl_vector_const_view i = gsl_matrix_const_column(ij, 0); - gsl_vector_const_view j = gsl_matrix_const_column(ij, 1); - gsl_vector* degi = gsl_vector_alloc(ij->size1); - gsl_vector* degj = gsl_vector_alloc(ij->size1); + VECTOR_ID(const_view) i = MATRIX_ID(const_column)(ij, 0); + VECTOR_ID(const_view) j = MATRIX_ID(const_column)(ij, 1); + VECTOR_T* degi = VECTOR_ID(alloc)(ij->size1); + VECTOR_T* degj = VECTOR_ID(alloc)(ij->size1); // K = length(i); int K = length(&i.vector); @@ -62,36 +60,36 @@ double assortativity(const gsl_vector* deg, const gsl_matrix* ij) { for (int k = 0; k < K; k++) { // degi(k) = deg(i(k)); - int i_k = (int)gsl_vector_get(&i.vector, k); - gsl_vector_set(degi, k, gsl_vector_get(deg, i_k)); + int i_k = (int)VECTOR_ID(get)(&i.vector, k); + VECTOR_ID(set)(degi, k, VECTOR_ID(get)(deg, i_k)); // degj(k) = deg(j(k)); - int j_k = (int)gsl_vector_get(&j.vector, k); - gsl_vector_set(degj, k, gsl_vector_get(deg, j_k)); + int j_k = (int)VECTOR_ID(get)(&j.vector, k); + VECTOR_ID(set)(degj, k, VECTOR_ID(get)(deg, j_k)); } // r = (sum(degi.*degj)/K - (sum(0.5*(degi+degj))/K)^2)/(sum(0.5*(degi.^2+degj.^2))/K - (sum(0.5*(degi+degj))/K)^2); - gsl_vector* degi_mul_degj = copy(degi); - gsl_vector_mul(degi_mul_degj, degj); - double r1 = sum(degi_mul_degj) / (double)K; - gsl_vector_free(degi_mul_degj); + VECTOR_T* degi_mul_degj = copy(degi); + VECTOR_ID(mul)(degi_mul_degj, degj); + FP_T r1 = sum(degi_mul_degj) / (FP_T)K; + VECTOR_ID(free)(degi_mul_degj); - gsl_vector* degi_add_degj = copy(degi); - gsl_vector_add(degi_add_degj, degj); - double r2 = 0.5 * sum(degi_add_degj) / (double)K; - gsl_vector_free(degi_add_degj); + VECTOR_T* degi_add_degj = copy(degi); + VECTOR_ID(add)(degi_add_degj, degj); + FP_T r2 = 0.5 * sum(degi_add_degj) / (FP_T)K; + VECTOR_ID(free)(degi_add_degj); r2 *= r2; - gsl_vector* degi_pow_2_add_degj_pow_2 = pow_elements(degi, 2); - gsl_vector* degj_pow_2 = pow_elements(degj, 2); - gsl_vector_add(degi_pow_2_add_degj_pow_2, degj_pow_2); - gsl_vector_free(degj_pow_2); - double r3 = 0.5 * sum(degi_pow_2_add_degj_pow_2) / (double)K; - gsl_vector_free(degi_pow_2_add_degj_pow_2); + VECTOR_T* degi_pow_2_add_degj_pow_2 = pow_elements(degi, 2); + VECTOR_T* degj_pow_2 = pow_elements(degj, 2); + VECTOR_ID(add)(degi_pow_2_add_degj_pow_2, degj_pow_2); + VECTOR_ID(free)(degj_pow_2); + FP_T r3 = 0.5 * sum(degi_pow_2_add_degj_pow_2) / (FP_T)K; + VECTOR_ID(free)(degi_pow_2_add_degj_pow_2); - gsl_vector_free(degi); - gsl_vector_free(degj); + VECTOR_ID(free)(degi); + VECTOR_ID(free)(degj); return (r1 - r2) / (r3 - r2); } diff --git a/bct.h b/bct.h index 0ba79eb..a0313f0 100644 --- a/bct.h +++ b/bct.h @@ -1,16 +1,13 @@ #ifndef BCT_H #define BCT_H -#include -#include -#include -#include "matlab/matlab_double.h" -#include "matlab/matlab_float.h" -#include "matlab/matlab_long_double.h" +#include "precision.h" + #include -#include #include +#include "matlab/matlab.h" + namespace bct { using namespace matlab; @@ -20,122 +17,116 @@ namespace bct { }; // Density, degree, and assortativity - double assortativity_dir(const gsl_matrix* CIJ); - double assortativity_und(const gsl_matrix* CIJ); - gsl_vector* degrees_dir(const gsl_matrix* CIJ, gsl_vector** id = NULL, gsl_vector** od = NULL); - gsl_vector* degrees_und(const gsl_matrix* CIJ); - gsl_vector_float* degrees_und(const gsl_matrix_float* CIJ); - double density_dir(const gsl_matrix* CIJ); - double density_und(const gsl_matrix* CIJ); - float density_und(const gsl_matrix_float* CIJ); - gsl_matrix* jdegree(const gsl_matrix* CIJ); - int jdegree_bl(const gsl_matrix* J); - int jdegree_id(const gsl_matrix* J); - int jdegree_od(const gsl_matrix* J); - gsl_matrix* matching_ind(const gsl_matrix* CIJ); - gsl_matrix* matching_ind_in(const gsl_matrix* CIJ); - gsl_matrix* matching_ind_out(const gsl_matrix* CIJ); - gsl_vector* strengths_dir(const gsl_matrix* CIJ, gsl_vector** is = NULL, gsl_vector** os = NULL); - gsl_vector* strengths_und(const gsl_matrix* CIJ); + FP_T assortativity_dir(const MATRIX_T* CIJ); + FP_T assortativity_und(const MATRIX_T* CIJ); + VECTOR_T* degrees_dir(const MATRIX_T* CIJ, VECTOR_T** id = NULL, VECTOR_T** od = NULL); + VECTOR_T* degrees_und(const MATRIX_T* CIJ); + FP_T density_dir(const MATRIX_T* CIJ); + FP_T density_und(const MATRIX_T* CIJ); + MATRIX_T* jdegree(const MATRIX_T* CIJ); + int jdegree_bl(const MATRIX_T* J); + int jdegree_id(const MATRIX_T* J); + int jdegree_od(const MATRIX_T* J); + MATRIX_T* matching_ind(const MATRIX_T* CIJ); + MATRIX_T* matching_ind_in(const MATRIX_T* CIJ); + MATRIX_T* matching_ind_out(const MATRIX_T* CIJ); + VECTOR_T* strengths_dir(const MATRIX_T* CIJ, VECTOR_T** is = NULL, VECTOR_T** os = NULL); + VECTOR_T* strengths_und(const MATRIX_T* CIJ); // Clustering - gsl_vector* clustering_coef_bd(const gsl_matrix* A); - gsl_vector* clustering_coef_bu(const gsl_matrix* G); - gsl_vector_float* clustering_coef_bu(const gsl_matrix_float* G); - gsl_vector* clustering_coef_wd(const gsl_matrix* W); - gsl_vector* clustering_coef_wu(const gsl_matrix* W); - gsl_vector* efficiency_local(const gsl_matrix* G); - gsl_vector_float* efficiency_local(const gsl_matrix_float* G); + VECTOR_T* clustering_coef_bd(const MATRIX_T* A); + VECTOR_T* clustering_coef_bu(const MATRIX_T* G); + VECTOR_T* clustering_coef_wd(const MATRIX_T* W); + VECTOR_T* clustering_coef_wu(const MATRIX_T* W); + VECTOR_T* efficiency_local(const MATRIX_T* G); // Paths, distances, and cycles - gsl_vector* breadth(const gsl_matrix* CIJ, int source, gsl_vector** branch = NULL); - gsl_matrix* breadthdist(const gsl_matrix* CIJ, gsl_matrix** D = NULL); - gsl_vector* charpath_ecc(const gsl_matrix* D, double* radius = NULL, double* diameter = NULL); - double charpath_lambda(const gsl_matrix* D); - double capped_charpath_lambda(const gsl_matrix* G); - double connectivity_length(const gsl_matrix* D); - gsl_vector* cycprob_fcyc(const std::vector& Pq); - gsl_vector* cycprob_pcyc(const std::vector& Pq); - gsl_matrix* distance_bin(const gsl_matrix* G); - gsl_matrix* distance_wei(const gsl_matrix* G); - double efficiency_global(const gsl_matrix* G); - float efficiency_global(const gsl_matrix_float* G); - std::vector findpaths(const gsl_matrix* CIJ, const gsl_vector* sources, int qmax, gsl_vector** plq = NULL, int* qstop = NULL, gsl_matrix** allpths = NULL, gsl_matrix** util = NULL); - std::vector findwalks(const gsl_matrix* CIJ, gsl_vector** wlq = NULL); - double normalized_path_length(const gsl_matrix* D, double wmax = 1.0); - double normalized_path_length_m(const gsl_matrix* G, double wmax = 1.0); - gsl_matrix* reachdist(const gsl_matrix* CIJ, gsl_matrix** D = NULL); + VECTOR_T* breadth(const MATRIX_T* CIJ, int source, VECTOR_T** branch = NULL); + MATRIX_T* breadthdist(const MATRIX_T* CIJ, MATRIX_T** D = NULL); + VECTOR_T* charpath_ecc(const MATRIX_T* D, FP_T* radius = NULL, FP_T* diameter = NULL); + FP_T charpath_lambda(const MATRIX_T* D); + FP_T capped_charpath_lambda(const MATRIX_T* G); + FP_T connectivity_length(const MATRIX_T* D); + VECTOR_T* cycprob_fcyc(const std::vector& Pq); + VECTOR_T* cycprob_pcyc(const std::vector& Pq); + MATRIX_T* distance_bin(const MATRIX_T* G); + MATRIX_T* distance_wei(const MATRIX_T* G); + FP_T efficiency_global(const MATRIX_T* G); + std::vector findpaths(const MATRIX_T* CIJ, const VECTOR_T* sources, int qmax, VECTOR_T** plq = NULL, int* qstop = NULL, MATRIX_T** allpths = NULL, MATRIX_T** util = NULL); + std::vector findwalks(const MATRIX_T* CIJ, VECTOR_T** wlq = NULL); + FP_T normalized_path_length(const MATRIX_T* D, FP_T wmax = 1.0); + FP_T normalized_path_length_m(const MATRIX_T* G, FP_T wmax = 1.0); + MATRIX_T* reachdist(const MATRIX_T* CIJ, MATRIX_T** D = NULL); // Centrality - gsl_vector* betweenness_bin(const gsl_matrix* G); - gsl_vector* betweenness_wei(const gsl_matrix* G); - gsl_matrix* edge_betweenness_bin(const gsl_matrix* G, gsl_vector** BC = NULL); - gsl_matrix* edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC = NULL); - gsl_matrix* erange(const gsl_matrix* CIJ, double* eta = NULL, gsl_matrix** Eshort = NULL, double* fs = NULL); - gsl_vector* eigenvector_centrality(const gsl_matrix* G); - gsl_vector_float* eigenvector_centrality(const gsl_matrix_float* G); + VECTOR_T* betweenness_bin(const MATRIX_T* G); + VECTOR_T* betweenness_wei(const MATRIX_T* G); + MATRIX_T* edge_betweenness_bin(const MATRIX_T* G, VECTOR_T** BC = NULL); + MATRIX_T* edge_betweenness_wei(const MATRIX_T* G, VECTOR_T** BC = NULL); + MATRIX_T* erange(const MATRIX_T* CIJ, FP_T* eta = NULL, MATRIX_T** Eshort = NULL, FP_T* fs = NULL); + VECTOR_T* eigenvector_centrality(const MATRIX_T* G); // Motifs enum motif_mode_enum { MILO, SPORNS }; extern motif_mode_enum motif_mode; motif_mode_enum get_motif_mode(); void set_motif_mode(motif_mode_enum motif_mode); - std::vector find_motif34(int m, int n); - int find_motif34(const gsl_matrix* m); - gsl_vector* motif3funct_bin(const gsl_matrix* W, gsl_matrix** F = NULL); - gsl_matrix* motif3funct_wei(const gsl_matrix* W, gsl_matrix** Q = NULL, gsl_matrix** F = NULL); - gsl_vector* motif3funct_wei_v(const gsl_matrix* W, gsl_vector** Q = NULL, gsl_vector** F = NULL); - gsl_matrix* motif3generate(gsl_vector** ID = NULL, gsl_vector** N = NULL); - gsl_vector* motif3struct_bin(const gsl_matrix* A, gsl_matrix** F = NULL); - gsl_matrix* motif3struct_wei(const gsl_matrix* W, gsl_matrix** Q = NULL, gsl_matrix** F = NULL); - gsl_vector* motif3struct_wei_v(const gsl_matrix* W, gsl_vector** Q = NULL, gsl_vector** F = NULL); - gsl_matrix* motif4generate(gsl_vector** ID = NULL, gsl_vector** N = NULL); - gsl_vector* motif4funct_bin(const gsl_matrix* W, gsl_matrix** F = NULL); - gsl_matrix* motif4funct_wei(const gsl_matrix* W, gsl_matrix** Q = NULL, gsl_matrix** F = NULL); - gsl_vector* motif4funct_wei_v(const gsl_matrix* W, gsl_vector** Q = NULL, gsl_vector** F = NULL); - gsl_vector* motif4struct_bin(const gsl_matrix* A, gsl_matrix** F = NULL); - gsl_matrix* motif4struct_wei(const gsl_matrix* W, gsl_matrix** Q = NULL, gsl_matrix** F = NULL); - gsl_vector* motif4struct_wei_v(const gsl_matrix* W, gsl_vector** Q = NULL, gsl_vector** F = NULL); + std::vector find_motif34(int m, int n); + int find_motif34(const MATRIX_T* m); + VECTOR_T* motif3funct_bin(const MATRIX_T* W, MATRIX_T** F = NULL); + MATRIX_T* motif3funct_wei(const MATRIX_T* W, MATRIX_T** Q = NULL, MATRIX_T** F = NULL); + VECTOR_T* motif3funct_wei_v(const MATRIX_T* W, VECTOR_T** Q = NULL, VECTOR_T** F = NULL); + MATRIX_T* motif3generate(VECTOR_T** ID = NULL, VECTOR_T** N = NULL); + VECTOR_T* motif3struct_bin(const MATRIX_T* A, MATRIX_T** F = NULL); + MATRIX_T* motif3struct_wei(const MATRIX_T* W, MATRIX_T** Q = NULL, MATRIX_T** F = NULL); + VECTOR_T* motif3struct_wei_v(const MATRIX_T* W, VECTOR_T** Q = NULL, VECTOR_T** F = NULL); + MATRIX_T* motif4generate(VECTOR_T** ID = NULL, VECTOR_T** N = NULL); + VECTOR_T* motif4funct_bin(const MATRIX_T* W, MATRIX_T** F = NULL); + MATRIX_T* motif4funct_wei(const MATRIX_T* W, MATRIX_T** Q = NULL, MATRIX_T** F = NULL); + VECTOR_T* motif4funct_wei_v(const MATRIX_T* W, VECTOR_T** Q = NULL, VECTOR_T** F = NULL); + VECTOR_T* motif4struct_bin(const MATRIX_T* A, MATRIX_T** F = NULL); + MATRIX_T* motif4struct_wei(const MATRIX_T* W, MATRIX_T** Q = NULL, MATRIX_T** F = NULL); + VECTOR_T* motif4struct_wei_v(const MATRIX_T* W, VECTOR_T** Q = NULL, VECTOR_T** F = NULL); // Modularity and community structure - double modularity_dir(const gsl_matrix* A, gsl_vector** Ci = NULL); - double modularity_und(const gsl_matrix* A, gsl_vector** Ci = NULL); - double modularity_und_louvain(const gsl_matrix* W, gsl_vector** Ci = NULL, int N = 100); - gsl_vector* module_degree_zscore(const gsl_matrix* A, const gsl_vector* Ci); - gsl_vector* participation_coef(const gsl_matrix* A, const gsl_vector* Ci); + FP_T modularity_dir(const MATRIX_T* A, VECTOR_T** Ci = NULL); + FP_T modularity_und(const MATRIX_T* A, VECTOR_T** Ci = NULL); + FP_T modularity_louvain_und(const MATRIX_T* W, VECTOR_T** Ci = NULL, int N = 100); + VECTOR_T* module_degree_zscore(const MATRIX_T* A, const VECTOR_T* Ci); + VECTOR_T* participation_coef(const MATRIX_T* A, const VECTOR_T* Ci); // Synthetic connection networks - gsl_matrix* makeevenCIJ(int N, int K, int sz_cl); - gsl_matrix* makefractalCIJ(int mx_lvl, double E, int sz_cl, int* K = NULL); - gsl_matrix* makelatticeCIJ(int N, int K); - gsl_matrix* makerandCIJ_bd(int N, int K); - gsl_matrix* makerandCIJ_bu(int N, int K); - gsl_matrix* makerandCIJ_wd(int N, int K, double wmin, double wmax); - gsl_matrix* makerandCIJ_wd_wp(const gsl_matrix* m); - gsl_matrix* makerandCIJ_wu(int N, int K, double wmin, double wmax); - gsl_matrix* makerandCIJ_wu_wp(const gsl_matrix* m); - gsl_matrix* makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* out); - gsl_matrix* makerandCIJdegreesfixed(const gsl_matrix* m); - gsl_matrix* makeringlatticeCIJ(int N, int K); - gsl_matrix* maketoeplitzCIJ(int N, int K, double s); + MATRIX_T* makeevenCIJ(int N, int K, int sz_cl); + MATRIX_T* makefractalCIJ(int mx_lvl, FP_T E, int sz_cl, int* K = NULL); + MATRIX_T* makelatticeCIJ(int N, int K); + MATRIX_T* makerandCIJ_bd(int N, int K); + MATRIX_T* makerandCIJ_bu(int N, int K); + MATRIX_T* makerandCIJ_wd(int N, int K, FP_T wmin, FP_T wmax); + MATRIX_T* makerandCIJ_wd_wp(const MATRIX_T* m); + MATRIX_T* makerandCIJ_wu(int N, int K, FP_T wmin, FP_T wmax); + MATRIX_T* makerandCIJ_wu_wp(const MATRIX_T* m); + MATRIX_T* makerandCIJdegreesfixed(const VECTOR_T* in, const VECTOR_T* out); + MATRIX_T* makerandCIJdegreesfixed(const MATRIX_T* m); + MATRIX_T* makeringlatticeCIJ(int N, int K); + MATRIX_T* maketoeplitzCIJ(int N, int K, FP_T s); // Graph randomization - gsl_matrix* latmio_dir(const gsl_matrix* R, int ITER); - gsl_matrix* latmio_dir_connected(const gsl_matrix* R, int ITER); - gsl_matrix* latmio_und(const gsl_matrix* R, int ITER); - gsl_matrix* latmio_und_connected(const gsl_matrix* R, int ITER); - gsl_matrix* randmio_dir(const gsl_matrix* R, int ITER); - gsl_matrix* randmio_dir_connected(const gsl_matrix* R, int ITER); - gsl_matrix* randmio_und(const gsl_matrix* R, int ITER); - gsl_matrix* randmio_und_connected(const gsl_matrix* R, int ITER); + MATRIX_T* latmio_dir(const MATRIX_T* R, int ITER); + MATRIX_T* latmio_dir_connected(const MATRIX_T* R, int ITER); + MATRIX_T* latmio_und(const MATRIX_T* R, int ITER); + MATRIX_T* latmio_und_connected(const MATRIX_T* R, int ITER); + MATRIX_T* randmio_dir(const MATRIX_T* R, int ITER); + MATRIX_T* randmio_dir_connected(const MATRIX_T* R, int ITER); + MATRIX_T* randmio_und(const MATRIX_T* R, int ITER); + MATRIX_T* randmio_und_connected(const MATRIX_T* R, int ITER); // Data sets - gsl_matrix* get_cat_all(); - gsl_matrix* get_cat_ctx(); - gsl_matrix* get_fve30(); - gsl_matrix* get_fve32(); - gsl_matrix* get_macaque47(); - gsl_matrix* get_macaque71(); + MATRIX_T* get_cat_all(); + MATRIX_T* get_cat_ctx(); + MATRIX_T* get_fve30(); + MATRIX_T* get_fve32(); + MATRIX_T* get_macaque47(); + MATRIX_T* get_macaque71(); // Matrix status checking enum status { @@ -148,55 +139,43 @@ namespace bct { extern bool safe_mode; bool get_safe_mode(); void set_safe_mode(bool safe_mode); - - bool check_status(const gsl_matrix* m, int flags, const std::string& text); - bool check_status(const gsl_matrix_float* m, int flags, const std::string& text); - bool is_square(const gsl_matrix* m); - bool is_square(const gsl_matrix_float* m); - bool is_rectangular(const gsl_matrix* m); - bool is_rectangular(const gsl_matrix_float* m); - bool is_undirected(const gsl_matrix* m); - bool is_undirected(const gsl_matrix_float* m); - bool is_directed(const gsl_matrix* m); - bool is_directed(const gsl_matrix_float* m); - bool is_binary(const gsl_matrix* m); - bool is_binary(const gsl_matrix_float* m); - bool is_weighted(const gsl_matrix* m); - bool is_weighted(const gsl_matrix_float* m); - bool is_positive(const gsl_matrix* m); - bool is_positive(const gsl_matrix_float* m); - bool is_signed(const gsl_matrix* m); - bool is_signed(const gsl_matrix_float* m); - bool has_loops(const gsl_matrix* m); - bool has_loops(const gsl_matrix_float* m); - bool has_no_loops(const gsl_matrix* m); - bool has_no_loops(const gsl_matrix_float* m); + bool check_status(const MATRIX_T* m, int flags, const std::string& text); + bool is_square(const MATRIX_T* m); + bool is_rectangular(const MATRIX_T* m); + bool is_undirected(const MATRIX_T* m); + bool is_directed(const MATRIX_T* m); + bool is_binary(const MATRIX_T* m); + bool is_weighted(const MATRIX_T* m); + bool is_positive(const MATRIX_T* m); + bool is_signed(const MATRIX_T* m); + bool has_loops(const MATRIX_T* m); + bool has_no_loops(const MATRIX_T* m); // Matrix conversion - gsl_matrix* invert_elements(const gsl_matrix* m); - gsl_matrix* remove_loops(const gsl_matrix* m); - gsl_matrix* to_binary(const gsl_matrix* m); - gsl_matrix* to_positive(const gsl_matrix* m); - gsl_matrix* to_undirected_bin(const gsl_matrix* m); - gsl_matrix* to_undirected_wei(const gsl_matrix* m); + MATRIX_T* invert_elements(const MATRIX_T* m); + MATRIX_T* remove_loops(const MATRIX_T* m); + MATRIX_T* to_binary(const MATRIX_T* m); + MATRIX_T* to_positive(const MATRIX_T* m); + MATRIX_T* to_undirected_bin(const MATRIX_T* m); + MATRIX_T* to_undirected_wei(const MATRIX_T* m); // Utility void gsl_error_handler(const char* reason, const char* file, int line, int gsl_errno); - void gsl_free(gsl_vector* v); - void gsl_free(gsl_matrix* m); - void gsl_free(std::vector& m); + void gsl_free(VECTOR_T* v); + void gsl_free(MATRIX_T* m); + void gsl_free(std::vector& m); void gsl_free(gsl_permutation* p); void init(); - int number_of_edges_dir(const gsl_matrix* m); - int number_of_edges_und(const gsl_matrix* m); - int number_of_nodes(const gsl_matrix* m); - gsl_matrix* threshold_absolute(const gsl_matrix* W, double thr); - gsl_matrix* threshold_proportional_dir(const gsl_matrix* W, double p); - gsl_matrix* threshold_proportional_und(const gsl_matrix* W, double p); + int number_of_edges_dir(const MATRIX_T* m); + int number_of_edges_und(const MATRIX_T* m); + int number_of_nodes(const MATRIX_T* m); + MATRIX_T* threshold_absolute(const MATRIX_T* W, FP_T thr); + MATRIX_T* threshold_proportional_dir(const MATRIX_T* W, FP_T p); + MATRIX_T* threshold_proportional_und(const MATRIX_T* W, FP_T p); // Debugging - void printf(const gsl_vector* v, const std::string& format); - void printf(const gsl_matrix* m, const std::string& format); + void printf(const VECTOR_T* v, const std::string& format); + void printf(const MATRIX_T* m, const std::string& format); void printf(const gsl_permutation* p, const std::string& format); } diff --git a/bct_double.h b/bct_double.h new file mode 100644 index 0000000..aab8133 --- /dev/null +++ b/bct_double.h @@ -0,0 +1,4 @@ +#undef GSL_FLOAT +#undef GSL_DOUBLE +#undef GSL_LONG_DOUBLE +#define GSL_DOUBLE diff --git a/bct_float.h b/bct_float.h new file mode 100644 index 0000000..1849f4a --- /dev/null +++ b/bct_float.h @@ -0,0 +1,4 @@ +#undef GSL_FLOAT +#undef GSL_DOUBLE +#undef GSL_LONG_DOUBLE +#define GSL_FLOAT diff --git a/bct_gsl.i b/bct_gsl.i index b297d86..11a9730 100644 --- a/bct_gsl.i +++ b/bct_gsl.i @@ -5,6 +5,10 @@ %feature("autodoc", "1"); %{ + #undef GSL_FLOAT + #undef GSL_DOUBLE + #undef GSL_LONG_DOUBLE + #define GSL_DOUBLE #include "bct.h" %} @@ -67,6 +71,7 @@ namespace bct { gsl_matrix* edge_betweenness_bin(const gsl_matrix* G, gsl_vector** BC); gsl_matrix* edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC); gsl_matrix* erange(const gsl_matrix* CIJ, double* eta, gsl_matrix** Eshort, double* fs); + gsl_vector* eigenvector_centrality(const gsl_matrix* G); // Motifs enum motif_mode_enum { MILO, SPORNS }; @@ -93,7 +98,7 @@ namespace bct { // Modularity and community structure double modularity_dir(const gsl_matrix* A, gsl_vector** Ci); double modularity_und(const gsl_matrix* A, gsl_vector** Ci); - double modularity_und_louvain(const gsl_matrix* W, gsl_vector** Ci, int N = 100); + double modularity_louvain_und(const gsl_matrix* W, gsl_vector** Ci, int N = 100); gsl_vector* module_degree_zscore(const gsl_matrix* A, const gsl_vector* Ci); gsl_vector* participation_coef(const gsl_matrix* A, const gsl_vector* Ci); @@ -183,28 +188,6 @@ namespace bct { namespace matlab { - // --------------------------------- - // Precision-independent definitions - // --------------------------------- - - // Functions - std::string dec2bin(int n); - std::string dec2bin(int n, int len); - gsl_matrix* inv(const gsl_matrix* m); - gsl_permutation* randperm(int size); - - // Operators - gsl_matrix* div_left(const gsl_matrix* m1, const gsl_matrix* m2); - gsl_matrix* div_right(const gsl_matrix* m1, const gsl_matrix* m2); - - // Utility - gsl_rng* get_gsl_rng(); - void seed_rng(const gsl_rng* rng, unsigned long seed); - - // ------------------------------- - // Precision-dependent definitions - // ------------------------------- - // Functions gsl_vector* abs(const gsl_vector* v); gsl_matrix* abs(const gsl_matrix* m); @@ -212,15 +195,18 @@ namespace matlab { gsl_vector* all(const gsl_matrix* m, int dim = 1); int any(const gsl_vector* v); gsl_vector* any(const gsl_matrix* m, int dim = 1); + std::string dec2bin(int n); + std::string dec2bin(int n, int len); gsl_matrix* diag(const gsl_vector* v, int k = 0); gsl_vector* diag(const gsl_matrix* m, int k = 0); - gsl_matrix* eye_double(int size); - gsl_matrix* eye_double(int size1, int size2); + gsl_matrix* eye(int size); + gsl_matrix* eye(int size1, int size2); gsl_vector* find(const gsl_vector* v, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_vector* find(const gsl_matrix* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_matrix* find_ij(const gsl_matrix* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_vector* hist(const gsl_vector* v, int n = 10); gsl_vector* hist(const gsl_vector* v, const gsl_vector* centers); + gsl_matrix* inv(const gsl_matrix* m); int length(const gsl_vector* v); int length(const gsl_matrix* m); double max(double x, double y); @@ -235,14 +221,15 @@ namespace matlab { int nnz(const gsl_matrix* m); gsl_vector* nonzeros(const gsl_matrix* m); gsl_vector* normpdf(const gsl_vector* v, double mean, double stdev); - gsl_matrix* ones_double(int size); - gsl_matrix* ones_double(int size1, int size2); - gsl_vector* ones_vector_double(int size); + gsl_matrix* ones(int size); + gsl_matrix* ones(int size1, int size2); + gsl_vector* ones_vector(int size); double prod(const gsl_vector* v); gsl_vector* prod(const gsl_matrix* m, int dim = 1); - gsl_matrix* rand_double(int size); - gsl_matrix* rand_double(int size1, int size2); - gsl_vector* rand_vector_double(int size); + gsl_matrix* rand(int size); + gsl_matrix* rand(int size1, int size2); + gsl_vector* rand_vector(int size); + gsl_permutation* randperm(int size); gsl_vector* reverse(const gsl_vector* v); gsl_vector* setxor(const gsl_vector* v1, const gsl_vector* v2); gsl_vector* sort(const gsl_vector* v, const std::string& mode, gsl_vector** ind); @@ -259,9 +246,9 @@ namespace matlab { gsl_vector* unique(const gsl_vector* v, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); gsl_vector* unique(const gsl_matrix* m, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); gsl_matrix* unique_rows(const gsl_matrix* m, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); - gsl_matrix* zeros_double(int size); - gsl_matrix* zeros_double(int size1, int size2); - gsl_vector* zeros_vector_double(int size); + gsl_matrix* zeros(int size); + gsl_matrix* zeros(int size1, int size2); + gsl_vector* zeros_vector(int size); // Operators gsl_vector* concatenate(const gsl_vector* v, double x); @@ -277,6 +264,8 @@ namespace matlab { gsl_matrix* concatenate_rows(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* copy(const gsl_vector* v); gsl_matrix* copy(const gsl_matrix* m); + gsl_matrix* div_left(const gsl_matrix* m1, const gsl_matrix* m2); + gsl_matrix* div_right(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* logical_and(const gsl_vector* v1, const gsl_vector* v2); gsl_matrix* logical_and(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* logical_not(const gsl_vector* v); @@ -289,13 +278,12 @@ namespace matlab { gsl_vector* pow_elements(const gsl_vector* v, const gsl_vector* powers); gsl_matrix* pow_elements(const gsl_matrix* m, double power); gsl_matrix* pow_elements(const gsl_matrix* m, const gsl_matrix* powers); - gsl_vector* sequence_double(int start, int end); - gsl_vector* sequence_double(int start, int step, int end); + gsl_vector* sequence(int start, int end); + gsl_vector* sequence(int start, int step, int end); // Floating-point comparison - extern double epsilon_double; + extern double epsilon; int fp_compare(double x, double y); - typedef bool (*fp_cmp_fn_double)(double, double); bool fp_zero(double x); bool fp_nonzero(double x); bool fp_equal(double x, double y); @@ -306,14 +294,15 @@ namespace matlab { bool fp_greater_or_equal(double x, double y); // Vector/matrix comparison + typedef bool (*comparator)(double, double); int compare_vectors(const gsl_vector* v1, const gsl_vector* v2); bool vector_less(gsl_vector* v1, gsl_vector* v2); int compare_matrices(const gsl_matrix* m1, const gsl_matrix* m2); bool matrix_less(gsl_matrix* m1, gsl_matrix* m2); - gsl_vector* compare_elements(const gsl_vector* v, fp_cmp_fn_double compare, double x); - gsl_vector* compare_elements(const gsl_vector* v1, fp_cmp_fn_double compare, const gsl_vector* v2); - gsl_matrix* compare_elements(const gsl_matrix* m, fp_cmp_fn_double compare, double x); - gsl_matrix* compare_elements(const gsl_matrix* m1, fp_cmp_fn_double compare, const gsl_matrix* m2); + gsl_vector* compare_elements(const gsl_vector* v, comparator compare, double x); + gsl_vector* compare_elements(const gsl_vector* v1, comparator compare, const gsl_vector* v2); + gsl_matrix* compare_elements(const gsl_matrix* m, comparator compare, double x); + gsl_matrix* compare_elements(const gsl_matrix* m1, comparator compare, const gsl_matrix* m2); // Vector-by-vector indexing gsl_vector* ordinal_index(const gsl_vector* v, const gsl_vector* indices); @@ -363,19 +352,15 @@ namespace matlab { void to_array(const gsl_vector* v, double* array); bool to_bool(const gsl_vector* v); bool to_bool(const gsl_matrix* m); - gsl_vector_float* to_vector_float(const gsl_vector* v); - gsl_vector* to_vector_double(const gsl_vector* v); - gsl_vector_long_double* to_vector_long_double(const gsl_vector* v); gsl_vector* to_vector(const gsl_matrix* m); - gsl_matrix_float* to_matrix_float(const gsl_matrix* m); - gsl_matrix* to_matrix_double(const gsl_matrix* m); - gsl_matrix_long_double* to_matrix_long_double(const gsl_matrix* m); gsl_matrix* to_column_matrix(const gsl_vector* v); gsl_matrix* to_row_matrix(const gsl_vector* v); - gsl_vector* to_vector_double(const gsl_permutation* p); + gsl_vector* to_vector(const gsl_permutation* p); gsl_permutation* to_permutation(const gsl_vector* v); // Utility + gsl_rng* get_rng(); + void seed_rng(const gsl_rng* rng, unsigned long seed); gsl_matrix* permute_columns(const gsl_permutation* p, const gsl_matrix* m); gsl_matrix* permute_rows(const gsl_permutation* p, const gsl_matrix* m); } diff --git a/bct_long_double.h b/bct_long_double.h new file mode 100644 index 0000000..5e3762c --- /dev/null +++ b/bct_long_double.h @@ -0,0 +1,4 @@ +#undef GSL_FLOAT +#undef GSL_DOUBLE +#undef GSL_LONG_DOUBLE +#define GSL_LONG_DOUBLE diff --git a/bct_py.i b/bct_py.i index dd204d4..dc25171 100644 --- a/bct_py.i +++ b/bct_py.i @@ -5,6 +5,10 @@ %feature("autodoc", "1"); %{ + #undef GSL_FLOAT + #undef GSL_DOUBLE + #undef GSL_LONG_DOUBLE + #define GSL_DOUBLE #include "bct.h" %} @@ -87,6 +91,7 @@ namespace bct { gsl_matrix* edge_betweenness_bin(const gsl_matrix* G, gsl_vector** BC); gsl_matrix* edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC); gsl_matrix* erange(const gsl_matrix* CIJ, double* eta, gsl_matrix** Eshort, double* fs); + gsl_vector* eigenvector_centrality(const gsl_matrix* G); // Motifs enum motif_mode_enum { MILO, SPORNS }; @@ -113,7 +118,7 @@ namespace bct { // Modularity and community structure double modularity_dir(const gsl_matrix* A, gsl_vector** Ci); double modularity_und(const gsl_matrix* A, gsl_vector** Ci); - double modularity_und_louvain(const gsl_matrix* W, gsl_vector** Ci, int N = 100); + double modularity_louvain_und(const gsl_matrix* W, gsl_vector** Ci, int N = 100); gsl_vector* module_degree_zscore(const gsl_matrix* A, const gsl_vector* Ci); gsl_vector* participation_coef(const gsl_matrix* A, const gsl_vector* Ci); @@ -199,28 +204,6 @@ namespace bct { namespace matlab { - // --------------------------------- - // Precision-independent definitions - // --------------------------------- - - // Functions - std::string dec2bin(int n); - std::string dec2bin(int n, int len); - gsl_matrix* inv(const gsl_matrix* m); - gsl_permutation* randperm(int size); - - // Operators - gsl_matrix* div_left(const gsl_matrix* m1, const gsl_matrix* m2); - gsl_matrix* div_right(const gsl_matrix* m1, const gsl_matrix* m2); - - // Utility - gsl_rng* get_gsl_rng(); - void seed_rng(const gsl_rng* rng, unsigned long seed); - - // ------------------------------- - // Precision-dependent definitions - // ------------------------------- - // Functions gsl_vector* abs(const gsl_vector* v); gsl_matrix* abs(const gsl_matrix* m); @@ -228,15 +211,18 @@ namespace matlab { gsl_vector* all(const gsl_matrix* m, int dim = 1); int any(const gsl_vector* v); gsl_vector* any(const gsl_matrix* m, int dim = 1); + std::string dec2bin(int n); + std::string dec2bin(int n, int len); gsl_matrix* diag(const gsl_vector* v, int k = 0); gsl_vector* diag(const gsl_matrix* m, int k = 0); - gsl_matrix* eye_double(int size); - gsl_matrix* eye_double(int size1, int size2); + gsl_matrix* eye(int size); + gsl_matrix* eye(int size1, int size2); gsl_vector* find(const gsl_vector* v, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_vector* find(const gsl_matrix* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_matrix* find_ij(const gsl_matrix* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); gsl_vector* hist(const gsl_vector* v, int n = 10); gsl_vector* hist(const gsl_vector* v, const gsl_vector* centers); + gsl_matrix* inv(const gsl_matrix* m); int length(const gsl_vector* v); int length(const gsl_matrix* m); double max(double x, double y); @@ -251,14 +237,15 @@ namespace matlab { int nnz(const gsl_matrix* m); gsl_vector* nonzeros(const gsl_matrix* m); gsl_vector* normpdf(const gsl_vector* v, double mean, double stdev); - gsl_matrix* ones_double(int size); - gsl_matrix* ones_double(int size1, int size2); - gsl_vector* ones_vector_double(int size); + gsl_matrix* ones(int size); + gsl_matrix* ones(int size1, int size2); + gsl_vector* ones_vector(int size); double prod(const gsl_vector* v); gsl_vector* prod(const gsl_matrix* m, int dim = 1); - gsl_matrix* rand_double(int size); - gsl_matrix* rand_double(int size1, int size2); - gsl_vector* rand_vector_double(int size); + gsl_matrix* rand(int size); + gsl_matrix* rand(int size1, int size2); + gsl_vector* rand_vector(int size); + gsl_permutation* randperm(int size); gsl_vector* reverse(const gsl_vector* v); gsl_vector* setxor(const gsl_vector* v1, const gsl_vector* v2); gsl_vector* sort(const gsl_vector* v, const std::string& mode, gsl_vector** ind); @@ -275,9 +262,9 @@ namespace matlab { gsl_vector* unique(const gsl_vector* v, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); gsl_vector* unique(const gsl_matrix* m, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); gsl_matrix* unique_rows(const gsl_matrix* m, const std::string& first_or_last, gsl_vector** i, gsl_vector** j); - gsl_matrix* zeros_double(int size); - gsl_matrix* zeros_double(int size1, int size2); - gsl_vector* zeros_vector_double(int size); + gsl_matrix* zeros(int size); + gsl_matrix* zeros(int size1, int size2); + gsl_vector* zeros_vector(int size); // Operators gsl_vector* concatenate(const gsl_vector* v, double x); @@ -293,6 +280,8 @@ namespace matlab { gsl_matrix* concatenate_rows(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* copy(const gsl_vector* v); gsl_matrix* copy(const gsl_matrix* m); + gsl_matrix* div_left(const gsl_matrix* m1, const gsl_matrix* m2); + gsl_matrix* div_right(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* logical_and(const gsl_vector* v1, const gsl_vector* v2); gsl_matrix* logical_and(const gsl_matrix* m1, const gsl_matrix* m2); gsl_vector* logical_not(const gsl_vector* v); @@ -305,13 +294,12 @@ namespace matlab { gsl_vector* pow_elements(const gsl_vector* v, const gsl_vector* powers); gsl_matrix* pow_elements(const gsl_matrix* m, double power); gsl_matrix* pow_elements(const gsl_matrix* m, const gsl_matrix* powers); - gsl_vector* sequence_double(int start, int end); - gsl_vector* sequence_double(int start, int step, int end); + gsl_vector* sequence(int start, int end); + gsl_vector* sequence(int start, int step, int end); // Floating-point comparison - extern double epsilon_double; + extern double epsilon; int fp_compare(double x, double y); - typedef bool (*fp_cmp_fn_double)(double, double); bool fp_zero(double x); bool fp_nonzero(double x); bool fp_equal(double x, double y); @@ -322,14 +310,15 @@ namespace matlab { bool fp_greater_or_equal(double x, double y); // Vector/matrix comparison + typedef bool (*comparator)(double, double); int compare_vectors(const gsl_vector* v1, const gsl_vector* v2); bool vector_less(gsl_vector* v1, gsl_vector* v2); int compare_matrices(const gsl_matrix* m1, const gsl_matrix* m2); bool matrix_less(gsl_matrix* m1, gsl_matrix* m2); - gsl_vector* compare_elements(const gsl_vector* v, fp_cmp_fn_double compare, double x); - gsl_vector* compare_elements(const gsl_vector* v1, fp_cmp_fn_double compare, const gsl_vector* v2); - gsl_matrix* compare_elements(const gsl_matrix* m, fp_cmp_fn_double compare, double x); - gsl_matrix* compare_elements(const gsl_matrix* m1, fp_cmp_fn_double compare, const gsl_matrix* m2); + gsl_vector* compare_elements(const gsl_vector* v, comparator compare, double x); + gsl_vector* compare_elements(const gsl_vector* v1, comparator compare, const gsl_vector* v2); + gsl_matrix* compare_elements(const gsl_matrix* m, comparator compare, double x); + gsl_matrix* compare_elements(const gsl_matrix* m1, comparator compare, const gsl_matrix* m2); // Vector-by-vector indexing gsl_vector* ordinal_index(const gsl_vector* v, const gsl_vector* indices); @@ -379,19 +368,15 @@ namespace matlab { void to_array(const gsl_vector* v, double* array); bool to_bool(const gsl_vector* v); bool to_bool(const gsl_matrix* m); - gsl_vector_float* to_vector_float(const gsl_vector* v); - gsl_vector* to_vector_double(const gsl_vector* v); - gsl_vector_long_double* to_vector_long_double(const gsl_vector* v); gsl_vector* to_vector(const gsl_matrix* m); - gsl_matrix_float* to_matrix_float(const gsl_matrix* m); - gsl_matrix* to_matrix_double(const gsl_matrix* m); - gsl_matrix_long_double* to_matrix_long_double(const gsl_matrix* m); gsl_matrix* to_column_matrix(const gsl_vector* v); gsl_matrix* to_row_matrix(const gsl_vector* v); - gsl_vector* to_vector_double(const gsl_permutation* p); + gsl_vector* to_vector(const gsl_permutation* p); gsl_permutation* to_permutation(const gsl_vector* v); // Utility + gsl_rng* get_rng(); + void seed_rng(const gsl_rng* rng, unsigned long seed); gsl_matrix* permute_columns(const gsl_permutation* p, const gsl_matrix* m); gsl_matrix* permute_rows(const gsl_permutation* p, const gsl_matrix* m); } diff --git a/betweenness_bin.cpp b/betweenness_bin.cpp index 8c702b8..0cea75a 100644 --- a/betweenness_bin.cpp +++ b/betweenness_bin.cpp @@ -1,21 +1,19 @@ #include "bct.h" -#include -#include /* * Computes node betweenness for a binary graph. */ -gsl_vector* bct::betweenness_bin(const gsl_matrix* G) { - gsl_vector* BC; - gsl_matrix* EBC = edge_betweenness_bin(G, &BC); - gsl_matrix_free(EBC); +VECTOR_T* bct::betweenness_bin(const MATRIX_T* G) { + VECTOR_T* BC; + MATRIX_T* EBC = edge_betweenness_bin(G, &BC); + MATRIX_ID(free)(EBC); return BC; } /* * Computes node and edge betweenness for a binary graph. */ -gsl_matrix* bct::edge_betweenness_bin(const gsl_matrix* G, gsl_vector** BC) { +MATRIX_T* bct::edge_betweenness_bin(const MATRIX_T* G, VECTOR_T** BC) { if (safe_mode) check_status(G, SQUARE | BINARY, "edge_betweenness_bin"); // n=length(G); @@ -23,153 +21,153 @@ gsl_matrix* bct::edge_betweenness_bin(const gsl_matrix* G, gsl_vector** BC) { // BC=zeros(n,1); if (BC != NULL) { - *BC = zeros_vector_double(n); + *BC = zeros_vector(n); } // EBC=zeros(n); - gsl_matrix* EBC = zeros_double(n); + MATRIX_T* EBC = zeros(n); // for u=1:n for (int u = 0; u < n; u++) { // D=false(1,n); D(u) = 1; - gsl_vector* D = gsl_vector_calloc(n); - gsl_vector_set(D, u, 1.0); + VECTOR_T* D = VECTOR_ID(calloc)(n); + VECTOR_ID(set)(D, u, 1.0); // NP=zeros(1,n); NP(u)=1; - gsl_vector* NP = zeros_vector_double(n); - gsl_vector_set(NP, u, 1.0); + VECTOR_T* NP = zeros_vector(n); + VECTOR_ID(set)(NP, u, 1.0); // P=false(n); - gsl_matrix* P = gsl_matrix_calloc(n, n); + MATRIX_T* P = MATRIX_ID(calloc)(n, n); // Q=zeros(1,n); q=n; - gsl_vector* Q = zeros_vector_double(n); + VECTOR_T* Q = zeros_vector(n); int q = n - 1; // Gu=G; - gsl_matrix* Gu = copy(G); + MATRIX_T* Gu = copy(G); // V=u; - gsl_vector* V = gsl_vector_alloc(1); - gsl_vector_set(V, 0, (double)u); + VECTOR_T* V = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(V, 0, (FP_T)u); // while V while (V != NULL) { // Gu(:,V)=0; - gsl_vector* Gu_rows = sequence_double(0, Gu->size1 - 1); + VECTOR_T* Gu_rows = sequence(0, Gu->size1 - 1); ordinal_index_assign(Gu, Gu_rows, V, 0.0); - gsl_vector_free(Gu_rows); + VECTOR_ID(free)(Gu_rows); // for v=V for (int i_V = 0; i_V < (int)V->size; i_V++) { - int v = (int)gsl_vector_get(V, i_V); + int v = (int)VECTOR_ID(get)(V, i_V); // Q(q)=v; q=q-1; - gsl_vector_set(Q, q--, (double)v); + VECTOR_ID(set)(Q, q--, (FP_T)v); // W=find(Gu(v,:)); - gsl_vector_view Gu_row_v = gsl_matrix_row(Gu, v); - gsl_vector* W = find(&Gu_row_v.vector); + VECTOR_ID(view) Gu_row_v = MATRIX_ID(row)(Gu, v); + VECTOR_T* W = find(&Gu_row_v.vector); if (W != NULL) { // for w=W for (int i_W = 0; i_W < (int)W->size; i_W++) { - int w = (int)gsl_vector_get(W, i_W); + int w = (int)VECTOR_ID(get)(W, i_W); // if D(w) - if (fp_nonzero(gsl_vector_get(D, w))) { + if (fp_nonzero(VECTOR_ID(get)(D, w))) { // NP(w)=NP(w)+NP(v); - gsl_vector_set(NP, w, gsl_vector_get(NP, w) + gsl_vector_get(NP, v)); + VECTOR_ID(set)(NP, w, VECTOR_ID(get)(NP, w) + VECTOR_ID(get)(NP, v)); // P(w,v)=1; - gsl_matrix_set(P, w, v, 1.0); + MATRIX_ID(set)(P, w, v, 1.0); // else } else { // D(w)=1; - gsl_vector_set(D, w, 1.0); + VECTOR_ID(set)(D, w, 1.0); // NP(w)=NP(v); - gsl_vector_set(NP, w, gsl_vector_get(NP, v)); + VECTOR_ID(set)(NP, w, VECTOR_ID(get)(NP, v)); // P(w,v)=1; - gsl_matrix_set(P, w, v, 1.0); + MATRIX_ID(set)(P, w, v, 1.0); } } - gsl_vector_free(W); + VECTOR_ID(free)(W); } } // V=find(any(Gu(V,:),1)); - gsl_vector* Gu_cols = sequence_double(0, G->size2 - 1); - gsl_matrix* Gu_idx = ordinal_index(Gu, V, Gu_cols); - gsl_vector_free(Gu_cols); - gsl_vector* any_Gu_idx = any(Gu_idx); - gsl_matrix_free(Gu_idx); - gsl_vector_free(V); + VECTOR_T* Gu_cols = sequence(0, G->size2 - 1); + MATRIX_T* Gu_idx = ordinal_index(Gu, V, Gu_cols); + VECTOR_ID(free)(Gu_cols); + VECTOR_T* any_Gu_idx = any(Gu_idx); + MATRIX_ID(free)(Gu_idx); + VECTOR_ID(free)(V); V = find(any_Gu_idx); - gsl_vector_free(any_Gu_idx); + VECTOR_ID(free)(any_Gu_idx); } - gsl_matrix_free(Gu); + MATRIX_ID(free)(Gu); // if ~all(D) if (all(D) == 0) { // Q(1:q)=find(~D); - gsl_vector* not_D = logical_not(D); - gsl_vector* find_not_D = find(not_D); - gsl_vector_free(not_D); - gsl_vector_view Q_subv = gsl_vector_subvector(Q, 0, q + 1); - gsl_vector_memcpy(&Q_subv.vector, find_not_D); - gsl_vector_free(find_not_D); + VECTOR_T* not_D = logical_not(D); + VECTOR_T* find_not_D = find(not_D); + VECTOR_ID(free)(not_D); + VECTOR_ID(view) Q_subv = VECTOR_ID(subvector)(Q, 0, q + 1); + VECTOR_ID(memcpy)(&Q_subv.vector, find_not_D); + VECTOR_ID(free)(find_not_D); } - gsl_vector_free(D); + VECTOR_ID(free)(D); // DP=zeros(n,1); - gsl_vector* DP = zeros_vector_double(n); + VECTOR_T* DP = zeros_vector(n); // for w=Q(1:n-1); for (int i_Q = 0; i_Q < n - 1; i_Q++) { - int w = (int)gsl_vector_get(Q, i_Q); + int w = (int)VECTOR_ID(get)(Q, i_Q); // BC(w)=BC(w)+DP(w) if (BC != NULL) { - gsl_vector_set(*BC, w, gsl_vector_get(*BC, w) + gsl_vector_get(DP, w)); + VECTOR_ID(set)(*BC, w, VECTOR_ID(get)(*BC, w) + VECTOR_ID(get)(DP, w)); } // for v=find(P(w,:)) - gsl_vector_view P_row_w = gsl_matrix_row(P, w); - gsl_vector* find_P_row_w = find(&P_row_w.vector); + VECTOR_ID(view) P_row_w = MATRIX_ID(row)(P, w); + VECTOR_T* find_P_row_w = find(&P_row_w.vector); if (find_P_row_w != NULL) { for (int i_find_P_row_w = 0; i_find_P_row_w < (int)find_P_row_w->size; i_find_P_row_w++) { - int v = (int)gsl_vector_get(find_P_row_w, i_find_P_row_w); + int v = (int)VECTOR_ID(get)(find_P_row_w, i_find_P_row_w); // DPvw=(1+DP(w)).*NP(v)./NP(w); - double DP_w = gsl_vector_get(DP, w); - double NP_v = gsl_vector_get(NP, v); - double NP_w = gsl_vector_get(NP, w); - double DPvw = (1 + DP_w) * NP_v / NP_w; + FP_T DP_w = VECTOR_ID(get)(DP, w); + FP_T NP_v = VECTOR_ID(get)(NP, v); + FP_T NP_w = VECTOR_ID(get)(NP, w); + FP_T DPvw = (1 + DP_w) * NP_v / NP_w; // DP(v)=DP(v)+DPvw; - gsl_vector_set(DP, v, gsl_vector_get(DP, v) + DPvw); + VECTOR_ID(set)(DP, v, VECTOR_ID(get)(DP, v) + DPvw); // EBC(v,w)=EBC(v,w)+DPvw; - gsl_matrix_set(EBC, v, w, gsl_matrix_get(EBC, v, w) + DPvw); + MATRIX_ID(set)(EBC, v, w, MATRIX_ID(get)(EBC, v, w) + DPvw); } - gsl_vector_free(find_P_row_w); + VECTOR_ID(free)(find_P_row_w); } } - gsl_vector_free(NP); - gsl_matrix_free(P); - gsl_vector_free(Q); - gsl_vector_free(DP); + VECTOR_ID(free)(NP); + MATRIX_ID(free)(P); + VECTOR_ID(free)(Q); + VECTOR_ID(free)(DP); } return EBC; diff --git a/betweenness_wei.cpp b/betweenness_wei.cpp index 28dc49a..9d62926 100644 --- a/betweenness_wei.cpp +++ b/betweenness_wei.cpp @@ -1,22 +1,21 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes node betweenness for a weighted graph. */ -gsl_vector* bct::betweenness_wei(const gsl_matrix* G) { - gsl_vector* BC; - gsl_matrix* EBC = edge_betweenness_wei(G, &BC); - gsl_matrix_free(EBC); +VECTOR_T* bct::betweenness_wei(const MATRIX_T* G) { + VECTOR_T* BC; + MATRIX_T* EBC = edge_betweenness_wei(G, &BC); + MATRIX_ID(free)(EBC); return BC; } /* * Computes node and edge betweenness for a weighted graph. */ -gsl_matrix* bct::edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC) { +MATRIX_T* bct::edge_betweenness_wei(const MATRIX_T* G, VECTOR_T** BC) { if (safe_mode) check_status(G, SQUARE | WEIGHTED, "edge_betweenness_wei"); // n=length(G); @@ -24,41 +23,41 @@ gsl_matrix* bct::edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC) { // BC=zeros(n,1); if (BC != NULL) { - *BC = zeros_vector_double(n); + *BC = zeros_vector(n); } // EBC=zeros(n); - gsl_matrix* EBC = zeros_double(n); + MATRIX_T* EBC = zeros(n); // for u=1:n for (int u = 0; u < n; u++) { // D=inf(1,n); D(u) = 0; - gsl_vector* D = gsl_vector_alloc(n); - gsl_vector_set_all(D, GSL_POSINF); - gsl_vector_set(D, u, 0.0); + VECTOR_T* D = VECTOR_ID(alloc)(n); + VECTOR_ID(set_all)(D, GSL_POSINF); + VECTOR_ID(set)(D, u, 0.0); // NP=zeros(1,n); NP(u)=1; - gsl_vector* NP = zeros_vector_double(n); - gsl_vector_set(NP, u, 1.0); + VECTOR_T* NP = zeros_vector(n); + VECTOR_ID(set)(NP, u, 1.0); // S=true(1,n); - gsl_vector* S = gsl_vector_alloc(n); - gsl_vector_set_all(S, 1.0); + VECTOR_T* S = VECTOR_ID(alloc)(n); + VECTOR_ID(set_all)(S, 1.0); // P=false(n); - gsl_matrix* P = gsl_matrix_calloc(n, n); + MATRIX_T* P = MATRIX_ID(calloc)(n, n); // Q=zeros(1,n); q=n; - gsl_vector* Q = zeros_vector_double(n); + VECTOR_T* Q = zeros_vector(n); int q = n - 1; // G1=G; - gsl_matrix* G1 = copy(G); + MATRIX_T* G1 = copy(G); // V=u; - gsl_vector* V = gsl_vector_alloc(1); - gsl_vector_set(V, 0, (double)u); + VECTOR_T* V = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(V, 0, (FP_T)u); // while 1 while (true) { @@ -67,56 +66,56 @@ gsl_matrix* bct::edge_betweenness_wei(const gsl_matrix* G, gsl_vector** BC) { ordinal_index_assign(S, V, 0.0); // G1(:,V)=0; - gsl_vector* G1_rows = sequence_double(0, G1->size1 - 1); + VECTOR_T* G1_rows = sequence(0, G1->size1 - 1); ordinal_index_assign(G1, G1_rows, V, 0.0); - gsl_vector_free(G1_rows); + VECTOR_ID(free)(G1_rows); // for v=V for (int i_V = 0; i_V < (int)V->size; i_V++) { - int v = (int)gsl_vector_get(V, i_V); + int v = (int)VECTOR_ID(get)(V, i_V); // Q(q)=v; q=q-1; - gsl_vector_set(Q, q--, (double)v); + VECTOR_ID(set)(Q, q--, (FP_T)v); // W=find(G1(v,:)); - gsl_vector_view G1_row_v = gsl_matrix_row(G1, v); - gsl_vector* W = find(&G1_row_v.vector); + VECTOR_ID(view) G1_row_v = MATRIX_ID(row)(G1, v); + VECTOR_T* W = find(&G1_row_v.vector); if (W != NULL) { // for w=W for (int i_W = 0; i_W < (int)W->size; i_W++) { - int w = (int)gsl_vector_get(W, i_W); + int w = (int)VECTOR_ID(get)(W, i_W); // Duw=D(v)+G1(v,w); - double Duw = gsl_vector_get(D, v) + gsl_matrix_get(G1, v, w); + FP_T Duw = VECTOR_ID(get)(D, v) + MATRIX_ID(get)(G1, v, w); // if Duwsize; i_find_P_row_w++) { - int v = (int)gsl_vector_get(find_P_row_w, i_find_P_row_w); + int v = (int)VECTOR_ID(get)(find_P_row_w, i_find_P_row_w); // DPvw=(1+DP(w)).*NP(v)./NP(w); - double DP_w = gsl_vector_get(DP, w); - double NP_v = gsl_vector_get(NP, v); - double NP_w = gsl_vector_get(NP, w); - double DPvw = (1 + DP_w) * NP_v / NP_w; + FP_T DP_w = VECTOR_ID(get)(DP, w); + FP_T NP_v = VECTOR_ID(get)(NP, v); + FP_T NP_w = VECTOR_ID(get)(NP, w); + FP_T DPvw = (1 + DP_w) * NP_v / NP_w; // DP(v)=DP(v)+DPvw; - gsl_vector_set(DP, v, gsl_vector_get(DP, v) + DPvw); + VECTOR_ID(set)(DP, v, VECTOR_ID(get)(DP, v) + DPvw); // EBC(v,w)=EBC(v,w)+DPvw; - gsl_matrix_set(EBC, v, w, gsl_matrix_get(EBC, v, w) + DPvw); + MATRIX_ID(set)(EBC, v, w, MATRIX_ID(get)(EBC, v, w) + DPvw); } - gsl_vector_free(find_P_row_w); + VECTOR_ID(free)(find_P_row_w); } } - gsl_vector_free(NP); - gsl_matrix_free(P); - gsl_vector_free(Q); - gsl_vector_free(DP); + VECTOR_ID(free)(NP); + MATRIX_ID(free)(P); + VECTOR_ID(free)(Q); + VECTOR_ID(free)(DP); } return EBC; diff --git a/breadth.cpp b/breadth.cpp index b62fbe4..d46f70b 100644 --- a/breadth.cpp +++ b/breadth.cpp @@ -1,7 +1,6 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Performs a breadth-first search starting at the source node. Because C++ @@ -9,7 +8,7 @@ * 0 precedes node i or that node i is unreachable. Check distance(i) for * GSL_POSINF to differentiate between these two cases. */ -gsl_vector* bct::breadth(const gsl_matrix* CIJ, int source, gsl_vector** branch) { +VECTOR_T* bct::breadth(const MATRIX_T* CIJ, int source, VECTOR_T** branch) { if (safe_mode) check_status(CIJ, SQUARE, "breadth"); // N = size(CIJ,1); @@ -21,94 +20,94 @@ gsl_vector* bct::breadth(const gsl_matrix* CIJ, int source, gsl_vector** branch) int black = 2; // color = zeros(1,N); - gsl_vector* color = zeros_vector_double(N); + VECTOR_T* color = zeros_vector(N); // distance = inf*ones(1,N); - gsl_vector* distance = gsl_vector_alloc(N); - gsl_vector_set_all(distance, GSL_POSINF); + VECTOR_T* distance = VECTOR_ID(alloc)(N); + VECTOR_ID(set_all)(distance, GSL_POSINF); // branch = zeros(1,N); if (branch != NULL) { - *branch = zeros_vector_double(N); + *branch = zeros_vector(N); } // color(source) = gray; - gsl_vector_set(color, source, (double)gray); + VECTOR_ID(set)(color, source, (FP_T)gray); // distance(source) = 0; - gsl_vector_set(distance, source, 0.0); + VECTOR_ID(set)(distance, source, 0.0); // branch(source) = -1; if (branch != NULL) { - gsl_vector_set(*branch, source, -1.0); + VECTOR_ID(set)(*branch, source, -1.0); } // Q = source; - gsl_vector* Q = gsl_vector_alloc(1); - gsl_vector_set(Q, 0, (double)source); + VECTOR_T* Q = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(Q, 0, (FP_T)source); // while ~isempty(Q) while (Q != NULL) { // u = Q(1); - int u = (int)gsl_vector_get(Q, 0); + int u = (int)VECTOR_ID(get)(Q, 0); // ns = find(CIJ(u,:)); - gsl_vector_const_view CIJ_row_u = gsl_matrix_const_row(CIJ, u); - gsl_vector* ns = find(&CIJ_row_u.vector); + VECTOR_ID(const_view) CIJ_row_u = MATRIX_ID(const_row)(CIJ, u); + VECTOR_T* ns = find(&CIJ_row_u.vector); // for v=ns if (ns != NULL) { for (int i_ns = 0; i_ns < (int)ns->size; i_ns++) { - int v = (int)gsl_vector_get(ns, i_ns); + int v = (int)VECTOR_ID(get)(ns, i_ns); // if (distance(v)==0) - if ((int)gsl_vector_get(distance, v) == 0) { + if ((int)VECTOR_ID(get)(distance, v) == 0) { // distance(v) = distance(u)+1; - gsl_vector_set(distance, v, gsl_vector_get(distance, u) + 1.0); + VECTOR_ID(set)(distance, v, VECTOR_ID(get)(distance, u) + 1.0); } // if (color(v)==white) - if ((int)gsl_vector_get(color, v) == white) { + if ((int)VECTOR_ID(get)(color, v) == white) { // color(v) = gray; - gsl_vector_set(color, v, (double)gray); + VECTOR_ID(set)(color, v, (FP_T)gray); // distance(v) = distance(u)+1; - gsl_vector_set(distance, v, gsl_vector_get(distance, u) + 1.0); + VECTOR_ID(set)(distance, v, VECTOR_ID(get)(distance, u) + 1.0); // branch(v) = u; if (branch != NULL) { - gsl_vector_set(*branch, v, (double)u); + VECTOR_ID(set)(*branch, v, (FP_T)u); } // Q = [Q v]; - gsl_vector* temp = concatenate(Q, (double)v); - gsl_vector_free(Q); + VECTOR_T* temp = concatenate(Q, (FP_T)v); + VECTOR_ID(free)(Q); Q = temp; } } - gsl_vector_free(ns); + VECTOR_ID(free)(ns); } // Q = Q(2:length(Q)); - gsl_vector* Q_cols = sequence_double(1, length(Q) - 1); + VECTOR_T* Q_cols = sequence(1, length(Q) - 1); if (Q_cols != NULL) { - gsl_vector* temp = ordinal_index(Q, Q_cols); - gsl_vector_free(Q); - gsl_vector_free(Q_cols); + VECTOR_T* temp = ordinal_index(Q, Q_cols); + VECTOR_ID(free)(Q); + VECTOR_ID(free)(Q_cols); Q = temp; } else { - gsl_vector_free(Q); + VECTOR_ID(free)(Q); Q = NULL; } // color(u) = black; - gsl_vector_set(color, u, (double)black); + VECTOR_ID(set)(color, u, (FP_T)black); } - gsl_vector_free(color); + VECTOR_ID(free)(color); return distance; } diff --git a/breadthdist.cpp b/breadthdist.cpp index 3fd7746..9237880 100644 --- a/breadthdist.cpp +++ b/breadthdist.cpp @@ -1,37 +1,36 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes reachability and distance matrices using breadth-first search. */ -gsl_matrix* bct::breadthdist(const gsl_matrix* CIJ, gsl_matrix** D) { +MATRIX_T* bct::breadthdist(const MATRIX_T* CIJ, MATRIX_T** D) { if (safe_mode) check_status(CIJ, SQUARE, "breadthdist"); // N = size(CIJ,1); int N = CIJ->size1; // D = zeros(N); - gsl_matrix* _D = zeros_double(N); + MATRIX_T* _D = zeros(N); // for i=1:N for (int i = 0; i < N; i++) { // D(i,:) = breadth(CIJ,i); - gsl_vector* distance = breadth(CIJ, i); - gsl_matrix_set_row(_D, i, distance); - gsl_vector_free(distance); + VECTOR_T* distance = breadth(CIJ, i); + MATRIX_ID(set_row)(_D, i, distance); + VECTOR_ID(free)(distance); } // D(D==0) = Inf; - gsl_matrix* D_eq_0 = compare_elements(_D, fp_equal, 0.0); + MATRIX_T* D_eq_0 = compare_elements(_D, fp_equal, 0.0); logical_index_assign(_D, D_eq_0, GSL_POSINF); - gsl_matrix_free(D_eq_0); + MATRIX_ID(free)(D_eq_0); - // R = double(D~=Inf); - gsl_matrix* R = compare_elements(_D, fp_not_equal, GSL_POSINF); + // R = FP_T(D~=Inf); + MATRIX_T* R = compare_elements(_D, fp_not_equal, GSL_POSINF); - if (D != NULL) *D = _D; else gsl_matrix_free(_D); + if (D != NULL) *D = _D; else MATRIX_ID(free)(_D); return R; } diff --git a/cat.cpp b/cat.cpp index 489f04d..906804b 100644 --- a/cat.cpp +++ b/cat.cpp @@ -1,7 +1,6 @@ #include "bct.h" -#include -const double cat_all[95 * 95] = { +const FP_T cat_all[95 * 95] = { 0, 3, 3, 1, 3, 3, 0, 0, 0, 3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 2, 1, 2, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 2, 2, 3, 0, 1, 0, 3, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 2, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 1, 3, 2, 1, 1, 0, 3, 1, 3, 1, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -99,7 +98,7 @@ const double cat_all[95 * 95] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 2, 3, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; -const double cat_ctx[52 * 52] = { +const FP_T cat_ctx[52 * 52] = { 0, 3, 3, 1, 3, 3, 0, 0, 0, 3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 2, 2, 3, 0, 1, 0, 3, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 1, 3, 2, 1, 1, 0, 3, 1, 3, 1, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -154,16 +153,16 @@ const double cat_ctx[52 * 52] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 1, 0, 1, 2, 3, 2, 3, 2, 0 }; -gsl_matrix* bct::get_cat_all() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(cat_all, 95, 95); - gsl_matrix* m = gsl_matrix_alloc(95, 95); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_cat_all() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(cat_all, 95, 95); + MATRIX_T* m = MATRIX_ID(alloc)(95, 95); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } -gsl_matrix* bct::get_cat_ctx() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(cat_ctx, 52, 52); - gsl_matrix* m = gsl_matrix_alloc(52, 52); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_cat_ctx() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(cat_ctx, 52, 52); + MATRIX_T* m = MATRIX_ID(alloc)(52, 52); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } diff --git a/charpath.cpp b/charpath.cpp index 6a19c84..84cf5f2 100644 --- a/charpath.cpp +++ b/charpath.cpp @@ -1,42 +1,43 @@ +#include + #include "bct.h" -#include -#include /* - * IMPORTANT WARNING: charpath_lambda() takes a distance matrix, - * but capped_charpath_lambda() takes a connection matrix. Both should - * be lengths, not weights (called distances in CalcMetric). + * WARNING: bct::charpath_lambda takes a distance matrix, but + * bct::capped_charpath_lambda takes a connection matrix. Both should be + * lengths, not weights (called distances in CalcMetric). */ /* * Given a distance matrix, computes characteristic path length. */ -double bct::charpath_lambda(const gsl_matrix* D) { +FP_T bct::charpath_lambda(const MATRIX_T* D) { + if (safe_mode) check_status(D, SQUARE, "charpath_lambda"); // lambda = sum(sum(D(D~=Inf)))/length(nonzeros(D~=Inf)); - gsl_matrix* D_neq_inf = compare_elements(D, fp_not_equal, GSL_POSINF); - gsl_vector* D_idx = logical_index(D, D_neq_inf); - double sum_D_idx = sum(D_idx); - gsl_vector_free(D_idx); - double ret = sum_D_idx / (double)nnz(D_neq_inf); - gsl_matrix_free(D_neq_inf); + MATRIX_T* D_neq_inf = compare_elements(D, fp_not_equal, GSL_POSINF); + VECTOR_T* D_idx = logical_index(D, D_neq_inf); + FP_T sum_D_idx = sum(D_idx); + VECTOR_ID(free)(D_idx); + FP_T ret = sum_D_idx / (FP_T)nnz(D_neq_inf); + MATRIX_ID(free)(D_neq_inf); return ret; } /* - * Given a connection matrix (of distances, not weights), - * computes capped characteristic path length. + * Given a connection matrix, computes capped characteristic path length. */ -double bct::capped_charpath_lambda(const gsl_matrix* L) { +FP_T bct::capped_charpath_lambda(const MATRIX_T* L) { + if (safe_mode) check_status(L, SQUARE, "capped_charpath_lambda"); int N = L->size1; int nonzeros = 0; - double lmean = 0.0; + FP_T lmean = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double l = gsl_matrix_get(L, i, j); + FP_T l = MATRIX_ID(get)(L, i, j); if (fp_nonzero(l)) { nonzeros++; lmean += l; @@ -44,35 +45,36 @@ double bct::capped_charpath_lambda(const gsl_matrix* L) { } } lmean /= nonzeros; - gsl_matrix* D = distance_wei(L); - double dmax = (double)N * lmean; - double dmean = 0.0; + MATRIX_T* D = distance_wei(L); + FP_T dmax = (FP_T)N * lmean; + FP_T dmean = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double d = gsl_matrix_get(D, i, j); + FP_T d = MATRIX_ID(get)(D, i, j); dmean += (d < dmax) ? d : dmax; } } dmean /= N * (N - 1); - gsl_matrix_free(D); + MATRIX_ID(free)(D); return dmean; } /* * Given a distance matrix, computes eccentricity, radius, and diameter. */ -gsl_vector* bct::charpath_ecc(const gsl_matrix* D, double* radius, double* diameter) { +VECTOR_T* bct::charpath_ecc(const MATRIX_T* D, FP_T* radius, FP_T* diameter) { + if (safe_mode) check_status(D, SQUARE, "charpath_ecc"); // ecc = max(D.*(D~=Inf),[],2); - gsl_matrix* D_finite = copy(D); - gsl_matrix* D_eq_inf = compare_elements(D, fp_equal, GSL_POSINF); + MATRIX_T* D_finite = copy(D); + MATRIX_T* D_eq_inf = compare_elements(D, fp_equal, GSL_POSINF); logical_index_assign(D_finite, D_eq_inf, 0.0); - gsl_matrix_free(D_eq_inf); - gsl_vector* ecc = max(D_finite, 2); - gsl_matrix_free(D_finite); + MATRIX_ID(free)(D_eq_inf); + VECTOR_T* ecc = max(D_finite, 2); + MATRIX_ID(free)(D_finite); // radius = min(ecc); if (radius != NULL) { diff --git a/clustering_coef_bd.cpp b/clustering_coef_bd.cpp index 23b4cd3..36bd831 100644 --- a/clustering_coef_bd.cpp +++ b/clustering_coef_bd.cpp @@ -1,50 +1,49 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes clustering coefficient for a binary directed graph. */ -gsl_vector* bct::clustering_coef_bd(const gsl_matrix* A) { +VECTOR_T* bct::clustering_coef_bd(const MATRIX_T* A) { if (safe_mode) check_status(A, SQUARE | BINARY | DIRECTED, "clustering_coef_bd"); // S=A+A.'; - gsl_matrix* S = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(S, A); - gsl_matrix_add(S, A); + MATRIX_T* S = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(S, A); + MATRIX_ID(add)(S, A); // K=sum(S,2); - gsl_vector* K = sum(S, 2); + VECTOR_T* K = sum(S, 2); // cyc3=diag(S^3)/2; - gsl_matrix* S_pow_3_div_2 = pow(S, 3); - gsl_matrix_free(S); - gsl_matrix_scale(S_pow_3_div_2, 0.5); - gsl_vector_view cyc3 = gsl_matrix_diagonal(S_pow_3_div_2); + MATRIX_T* S_pow_3_div_2 = pow(S, 3); + MATRIX_ID(free)(S); + MATRIX_ID(scale)(S_pow_3_div_2, 0.5); + VECTOR_ID(view) cyc3 = MATRIX_ID(diagonal)(S_pow_3_div_2); // K(cyc3==0)=inf; - gsl_vector* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); + VECTOR_T* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); logical_index_assign(K, cyc3_eq_0, GSL_POSINF); - gsl_vector_free(cyc3_eq_0); + VECTOR_ID(free)(cyc3_eq_0); // CYC3=K.*(K-1)-2*diag(A^2); - gsl_vector* K_sub_1 = copy(K); - gsl_vector_add_constant(K_sub_1, -1.0); - gsl_matrix* A_pow_2_mul_2 = pow(A, 2); - gsl_matrix_scale(A_pow_2_mul_2, 2.0); - gsl_vector_view diag_A_pow_2_mul_2 = gsl_matrix_diagonal(A_pow_2_mul_2); - gsl_vector* CYC3 = K; - gsl_vector_mul(CYC3, K_sub_1); - gsl_vector_free(K_sub_1); - gsl_vector_sub(CYC3, &diag_A_pow_2_mul_2.vector); - gsl_matrix_free(A_pow_2_mul_2); + VECTOR_T* K_sub_1 = copy(K); + VECTOR_ID(add_constant)(K_sub_1, -1.0); + MATRIX_T* A_pow_2_mul_2 = pow(A, 2); + MATRIX_ID(scale)(A_pow_2_mul_2, 2.0); + VECTOR_ID(view) diag_A_pow_2_mul_2 = MATRIX_ID(diagonal)(A_pow_2_mul_2); + VECTOR_T* CYC3 = K; + VECTOR_ID(mul)(CYC3, K_sub_1); + VECTOR_ID(free)(K_sub_1); + VECTOR_ID(sub)(CYC3, &diag_A_pow_2_mul_2.vector); + MATRIX_ID(free)(A_pow_2_mul_2); // C=cyc3./CYC3 - gsl_vector* C = copy(&cyc3.vector); - gsl_matrix_free(S_pow_3_div_2); - gsl_vector_div(C, CYC3); - gsl_vector_free(CYC3); + VECTOR_T* C = copy(&cyc3.vector); + MATRIX_ID(free)(S_pow_3_div_2); + VECTOR_ID(div)(C, CYC3); + VECTOR_ID(free)(CYC3); return C; } diff --git a/clustering_coef_bu.cpp b/clustering_coef_bu.cpp index 7be88dc..5a8dbad 100644 --- a/clustering_coef_bu.cpp +++ b/clustering_coef_bu.cpp @@ -1,18 +1,16 @@ #include "bct.h" -#include -#include /* * Computes the clustering coefficient for a binary undirected graph. */ -gsl_vector* bct::clustering_coef_bu(const gsl_matrix* G) { +VECTOR_T* bct::clustering_coef_bu(const MATRIX_T* G) { if (safe_mode) check_status(G, SQUARE | BINARY | UNDIRECTED, "clustering_coef_bu"); // n=length(G); int n = length(G); // C=zeros(n,1); - gsl_vector* C = zeros_vector_double(n); + VECTOR_T* C = zeros_vector(n); // for u=1:n #ifdef _OPENMP @@ -23,65 +21,23 @@ gsl_vector* bct::clustering_coef_bu(const gsl_matrix* G) { // V=find(G(u,:)); // k=length(V); // if k>=2; - gsl_vector_const_view G_row_u = gsl_matrix_const_row(G, u); - gsl_vector* V = find(&G_row_u.vector); + VECTOR_ID(const_view) G_row_u = MATRIX_ID(const_row)(G, u); + VECTOR_T* V = find(&G_row_u.vector); if (V != NULL) { int k = length(V); if (k >= 2) { // S=G(V,V); - gsl_matrix* S = ordinal_index(G, V, V); + MATRIX_T* S = ordinal_index(G, V, V); // C(u)=sum(S(:))/(k^2-k); - gsl_vector* sum_S = sum(S); - gsl_matrix_free(S); - gsl_vector_set(C, u, sum(sum_S) / (double)(k * (k - 1))); - gsl_vector_free(sum_S); + VECTOR_T* sum_S = sum(S); + MATRIX_ID(free)(S); + VECTOR_ID(set)(C, u, sum(sum_S) / (FP_T)(k * (k - 1))); + VECTOR_ID(free)(sum_S); } - gsl_vector_free(V); - } - } - - return C; -} - - -gsl_vector_float* bct::clustering_coef_bu(const gsl_matrix_float* G) { - if (safe_mode) check_status(G, SQUARE | BINARY | UNDIRECTED, "clustering_coef_bu"); - - // n=length(G); - int n = length(G); - - // C=zeros(n,1); - gsl_vector_float* C = zeros_vector_float(n); - - // for u=1:n -#ifdef _OPENMP -#pragma omp parallel for shared(C) -#endif - for (int u = 0; u < n; u++) { - - // V=find(G(u,:)); - // k=length(V); - // if k>=2; - gsl_vector_float_const_view G_row_u = gsl_matrix_float_const_row(G, u); - gsl_vector_float* V = find(&G_row_u.vector); - if (V != NULL) { - int k = length(V); - if (k >= 2) { - - // S=G(V,V); - gsl_matrix_float* S = ordinal_index(G, V, V); - - // C(u)=sum(S(:))/(k^2-k); - gsl_vector_float* sum_S = sum(S); - gsl_matrix_float_free(S); - gsl_vector_float_set(C, u, sum(sum_S) / (double)(k * (k - 1))); - gsl_vector_float_free(sum_S); - } - - gsl_vector_float_free(V); + VECTOR_ID(free)(V); } } diff --git a/clustering_coef_wd.cpp b/clustering_coef_wd.cpp index 93efca7..78123a8 100644 --- a/clustering_coef_wd.cpp +++ b/clustering_coef_wd.cpp @@ -1,62 +1,61 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes the clustering coefficient for a weighted directed graph. */ -gsl_vector* bct::clustering_coef_wd(const gsl_matrix* W) { +VECTOR_T* bct::clustering_coef_wd(const MATRIX_T* W) { if (safe_mode) check_status(W, SQUARE | WEIGHTED | DIRECTED, "clustering_coef_wd"); // A=W~=0; - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // S=W.^(1/3)+(W.').^(1/3); - gsl_matrix* S = pow_elements(W, 1.0 / 3.0); - gsl_matrix* W_transpose = gsl_matrix_alloc(W->size2, W->size1); - gsl_matrix_transpose_memcpy(W_transpose, W); - gsl_matrix* W_transpose_pow_1_3 = pow_elements(W_transpose, 1.0 / 3.0); - gsl_matrix_free(W_transpose); - gsl_matrix_add(S, W_transpose_pow_1_3); - gsl_matrix_free(W_transpose_pow_1_3); + MATRIX_T* S = pow_elements(W, 1.0 / 3.0); + MATRIX_T* W_transpose = MATRIX_ID(alloc)(W->size2, W->size1); + MATRIX_ID(transpose_memcpy)(W_transpose, W); + MATRIX_T* W_transpose_pow_1_3 = pow_elements(W_transpose, 1.0 / 3.0); + MATRIX_ID(free)(W_transpose); + MATRIX_ID(add)(S, W_transpose_pow_1_3); + MATRIX_ID(free)(W_transpose_pow_1_3); // K=sum(A+A.',2); - gsl_matrix* A_add_A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_add_A_transpose, A); - gsl_matrix_add(A_add_A_transpose, A); - gsl_vector* K = sum(A_add_A_transpose, 2); - gsl_matrix_free(A_add_A_transpose); + MATRIX_T* A_add_A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_add_A_transpose, A); + MATRIX_ID(add)(A_add_A_transpose, A); + VECTOR_T* K = sum(A_add_A_transpose, 2); + MATRIX_ID(free)(A_add_A_transpose); // cyc3=diag(S^3)/2; - gsl_matrix* S_pow_3_div_2 = pow(S, 3); - gsl_matrix_free(S); - gsl_matrix_scale(S_pow_3_div_2, 0.5); - gsl_vector_view cyc3 = gsl_matrix_diagonal(S_pow_3_div_2); + MATRIX_T* S_pow_3_div_2 = pow(S, 3); + MATRIX_ID(free)(S); + MATRIX_ID(scale)(S_pow_3_div_2, 0.5); + VECTOR_ID(view) cyc3 = MATRIX_ID(diagonal)(S_pow_3_div_2); // K(cyc3==0)=inf; - gsl_vector* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); + VECTOR_T* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); logical_index_assign(K, cyc3_eq_0, GSL_POSINF); - gsl_vector_free(cyc3_eq_0); + VECTOR_ID(free)(cyc3_eq_0); // CYC3=K.*(K-1)-2*diag(A^2); - gsl_vector* K_sub_1 = copy(K); - gsl_vector_add_constant(K_sub_1, -1.0); - gsl_matrix* A_pow_2_mul_2 = pow(A, 2); - gsl_matrix_free(A); - gsl_matrix_scale(A_pow_2_mul_2, 2.0); - gsl_vector_view diag_A_pow_2_mul_2 = gsl_matrix_diagonal(A_pow_2_mul_2); - gsl_vector* CYC3 = K; - gsl_vector_mul(CYC3, K_sub_1); - gsl_vector_free(K_sub_1); - gsl_vector_sub(CYC3, &diag_A_pow_2_mul_2.vector); - gsl_matrix_free(A_pow_2_mul_2); + VECTOR_T* K_sub_1 = copy(K); + VECTOR_ID(add_constant)(K_sub_1, -1.0); + MATRIX_T* A_pow_2_mul_2 = pow(A, 2); + MATRIX_ID(free)(A); + MATRIX_ID(scale)(A_pow_2_mul_2, 2.0); + VECTOR_ID(view) diag_A_pow_2_mul_2 = MATRIX_ID(diagonal)(A_pow_2_mul_2); + VECTOR_T* CYC3 = K; + VECTOR_ID(mul)(CYC3, K_sub_1); + VECTOR_ID(free)(K_sub_1); + VECTOR_ID(sub)(CYC3, &diag_A_pow_2_mul_2.vector); + MATRIX_ID(free)(A_pow_2_mul_2); // C=cyc3./CYC3 - gsl_vector* C = copy(&cyc3.vector); - gsl_matrix_free(S_pow_3_div_2); - gsl_vector_div(C, CYC3); - gsl_vector_free(CYC3); + VECTOR_T* C = copy(&cyc3.vector); + MATRIX_ID(free)(S_pow_3_div_2); + VECTOR_ID(div)(C, CYC3); + VECTOR_ID(free)(CYC3); return C; } diff --git a/clustering_coef_wu.cpp b/clustering_coef_wu.cpp index 1c728c9..3df9294 100644 --- a/clustering_coef_wu.cpp +++ b/clustering_coef_wu.cpp @@ -1,39 +1,38 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes the clustering coefficient for a weighted undirected graph. */ -gsl_vector* bct::clustering_coef_wu(const gsl_matrix* W) { +VECTOR_T* bct::clustering_coef_wu(const MATRIX_T* W) { if (safe_mode) check_status(W, SQUARE | WEIGHTED | UNDIRECTED, "clustering_coef_wu"); // K=sum(W~=0,2); - gsl_matrix* W_neq_0 = compare_elements(W, fp_not_equal, 0.0); - gsl_vector* K = sum(W_neq_0, 2); - gsl_matrix_free(W_neq_0); + MATRIX_T* W_neq_0 = compare_elements(W, fp_not_equal, 0.0); + VECTOR_T* K = sum(W_neq_0, 2); + MATRIX_ID(free)(W_neq_0); // cyc3=diag((W.^(1/3))^3); - gsl_matrix* W_pow_1_3 = pow_elements(W, 1.0 / 3.0); - gsl_matrix* W_pow_1_3_pow_3 = pow(W_pow_1_3, 3); - gsl_matrix_free(W_pow_1_3); - gsl_vector_view cyc3 = gsl_matrix_diagonal(W_pow_1_3_pow_3); + MATRIX_T* W_pow_1_3 = pow_elements(W, 1.0 / 3.0); + MATRIX_T* W_pow_1_3_pow_3 = pow(W_pow_1_3, 3); + MATRIX_ID(free)(W_pow_1_3); + VECTOR_ID(view) cyc3 = MATRIX_ID(diagonal)(W_pow_1_3_pow_3); // K(cyc3==0)=inf; - gsl_vector* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); + VECTOR_T* cyc3_eq_0 = compare_elements(&cyc3.vector, fp_equal, 0.0); logical_index_assign(K, cyc3_eq_0, GSL_POSINF); - gsl_vector_free(cyc3_eq_0); + VECTOR_ID(free)(cyc3_eq_0); // C=cyc3./(K.*(K-1)); - gsl_vector* K_sub_1 = copy(K); - gsl_vector_add_constant(K_sub_1, -1.0); - gsl_vector_mul(K, K_sub_1); - gsl_vector_free(K_sub_1); - gsl_vector* C = copy(&cyc3.vector); - gsl_matrix_free(W_pow_1_3_pow_3); - gsl_vector_div(C, K); - gsl_vector_free(K); + VECTOR_T* K_sub_1 = copy(K); + VECTOR_ID(add_constant)(K_sub_1, -1.0); + VECTOR_ID(mul)(K, K_sub_1); + VECTOR_ID(free)(K_sub_1); + VECTOR_T* C = copy(&cyc3.vector); + MATRIX_ID(free)(W_pow_1_3_pow_3); + VECTOR_ID(div)(C, K); + VECTOR_ID(free)(K); return C; } diff --git a/connectivity_length.cpp b/connectivity_length.cpp index 5c870cf..5dc89a5 100644 --- a/connectivity_length.cpp +++ b/connectivity_length.cpp @@ -1,19 +1,23 @@ -#include "bct.h" #include -#include + +#include "bct.h" /* - * Given a distance matrix, computes Marchiori and Latora's connectivity length. + * Given a distance matrix, computes connectivity length. + * + * Marchiori and Latora (2000). Harmony in the small-world. Physica A 285: + * 539-546. */ -double bct::connectivity_length(const gsl_matrix* D) { +FP_T bct::connectivity_length(const MATRIX_T* D) { + if (safe_mode) check_status(D, SQUARE, "connectivity_length"); int N = D->size1; - double sum = 0.0; + FP_T sum = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double value = gsl_matrix_get(D, i, j); + FP_T value = MATRIX_ID(get)(D, i, j); if (gsl_finite(value) == 1 && fp_nonzero(value)) { sum += 1.0 / value; } @@ -22,6 +26,6 @@ double bct::connectivity_length(const gsl_matrix* D) { if (fp_zero(sum)) { return GSL_POSINF; } else { - return (double)(N * (N - 1)) / sum; + return (FP_T)(N * (N - 1)) / sum; } } diff --git a/convert.cpp b/convert.cpp index 43a9bb1..c6650c6 100644 --- a/convert.cpp +++ b/convert.cpp @@ -1,20 +1,19 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Returns a copy of the given matrix with each nonzero element inverted. */ -gsl_matrix* bct::invert_elements(const gsl_matrix* m) { - gsl_matrix* inv_m = gsl_matrix_alloc(m->size1, m->size2); +MATRIX_T* bct::invert_elements(const MATRIX_T* m) { + MATRIX_T* inv_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - double value = gsl_matrix_get(m, i, j); + FP_T value = MATRIX_ID(get)(m, i, j); if (fp_nonzero(value)) { - gsl_matrix_set(inv_m, i, j, 1.0 / value); + MATRIX_ID(set)(inv_m, i, j, 1.0 / value); } else { - gsl_matrix_set(inv_m, i, j, 0.0); + MATRIX_ID(set)(inv_m, i, j, 0.0); } } } @@ -24,28 +23,28 @@ gsl_matrix* bct::invert_elements(const gsl_matrix* m) { /* * Returns a copy of the given matrix with no loops. */ -gsl_matrix* bct::remove_loops(const gsl_matrix* m) { - gsl_matrix* nl_m = copy(m); - gsl_vector_view diag_nl_m = gsl_matrix_diagonal(nl_m); - gsl_vector_set_zero(&diag_nl_m.vector); +MATRIX_T* bct::remove_loops(const MATRIX_T* m) { + MATRIX_T* nl_m = copy(m); + VECTOR_ID(view) diag_nl_m = MATRIX_ID(diagonal)(nl_m); + VECTOR_ID(set_zero)(&diag_nl_m.vector); return nl_m; } /* * Returns a binary copy of the given matrix. */ -gsl_matrix* bct::to_binary(const gsl_matrix* m) { +MATRIX_T* bct::to_binary(const MATRIX_T* m) { return compare_elements(m, fp_not_equal, 0.0); } /* * Returns a positive copy of the given matrix. */ -gsl_matrix* bct::to_positive(const gsl_matrix* m) { - gsl_matrix* pos_m = gsl_matrix_alloc(m->size1, m->size2); +MATRIX_T* bct::to_positive(const MATRIX_T* m) { + MATRIX_T* pos_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - gsl_matrix_set(pos_m, i, j, std::abs(gsl_matrix_get(m, i, j))); + MATRIX_ID(set)(pos_m, i, j, std::abs(MATRIX_ID(get)(m, i, j))); } } return pos_m; @@ -56,15 +55,15 @@ gsl_matrix* bct::to_positive(const gsl_matrix* m) { * nodes, if either m(i, j) or m(j, i) is nonzero, then both m(i, j) and m(j, i) * are set to one. Otherwise, both are set to zero. */ -gsl_matrix* bct::to_undirected_bin(const gsl_matrix* m) { - gsl_matrix* und_m = gsl_matrix_calloc(m->size1, m->size2); +MATRIX_T* bct::to_undirected_bin(const MATRIX_T* m) { + MATRIX_T* und_m = MATRIX_ID(calloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = i; j < (int)m->size2; j++) { - double value_ij = gsl_matrix_get(m, i, j); - double value_ji = gsl_matrix_get(m, j, i); + FP_T value_ij = MATRIX_ID(get)(m, i, j); + FP_T value_ji = MATRIX_ID(get)(m, j, i); if (fp_nonzero(value_ij) || fp_nonzero(value_ji)) { - gsl_matrix_set(und_m, i, j, 1.0); - gsl_matrix_set(und_m, j, i, 1.0); + MATRIX_ID(set)(und_m, i, j, 1.0); + MATRIX_ID(set)(und_m, j, i, 1.0); } } } @@ -75,16 +74,16 @@ gsl_matrix* bct::to_undirected_bin(const gsl_matrix* m) { * Returns an undirected copy of the given weighted matrix. For every pair of * nodes, m(i, j) and m(j, i) are both set to the average of their two values. */ -gsl_matrix* bct::to_undirected_wei(const gsl_matrix* m) { - gsl_matrix* und_m = gsl_matrix_calloc(m->size1, m->size2); +MATRIX_T* bct::to_undirected_wei(const MATRIX_T* m) { + MATRIX_T* und_m = MATRIX_ID(calloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = i; j < (int)m->size2; j++) { - double value_ij = gsl_matrix_get(m, i, j); - double value_ji = gsl_matrix_get(m, j, i); + FP_T value_ij = MATRIX_ID(get)(m, i, j); + FP_T value_ji = MATRIX_ID(get)(m, j, i); if (fp_nonzero(value_ij) || fp_nonzero(value_ji)) { - double average = (value_ij + value_ji) / 2.0; - gsl_matrix_set(und_m, i, j, average); - gsl_matrix_set(und_m, j, i, average); + FP_T average = (value_ij + value_ji) / 2.0; + MATRIX_ID(set)(und_m, i, j, average); + MATRIX_ID(set)(und_m, j, i, average); } } } diff --git a/cycprob.cpp b/cycprob.cpp index e4fa123..96c1ec1 100644 --- a/cycprob.cpp +++ b/cycprob.cpp @@ -1,29 +1,26 @@ #include "bct.h" -#include -#include -#include /* * Computes the fraction of all paths that are cycles. */ -gsl_vector* bct::cycprob_fcyc(const std::vector& Pq) { +VECTOR_T* bct::cycprob_fcyc(const std::vector& Pq) { // fcyc = zeros(1,size(Pq,3)); - gsl_vector* fcyc = zeros_vector_double(Pq.size()); + VECTOR_T* fcyc = zeros_vector(Pq.size()); // for q=1:size(Pq,3) for (int q = 1; q < (int)Pq.size(); q++) { // if(sum(sum(Pq(:,:,q)))>0) - gsl_vector* sum_Pq_q = sum(Pq[q]); - double sum_sum_Pq_q = sum(sum_Pq_q); - gsl_vector_free(sum_Pq_q); + VECTOR_T* sum_Pq_q = sum(Pq[q]); + FP_T sum_sum_Pq_q = sum(sum_Pq_q); + VECTOR_ID(free)(sum_Pq_q); if (sum_sum_Pq_q > 0.0) { // fcyc(q) = sum(diag(Pq(:,:,q)))/sum(sum(Pq(:,:,q))); - gsl_vector_view diag_Pq_q = gsl_matrix_diagonal(Pq[q]); - double sum_diag_Pq_q = sum(&diag_Pq_q.vector); - gsl_vector_set(fcyc, q, sum_diag_Pq_q / sum_sum_Pq_q); + VECTOR_ID(view) diag_Pq_q = MATRIX_ID(diagonal)(Pq[q]); + FP_T sum_diag_Pq_q = sum(&diag_Pq_q.vector); + VECTOR_ID(set)(fcyc, q, sum_diag_Pq_q / sum_sum_Pq_q); } } @@ -34,26 +31,26 @@ gsl_vector* bct::cycprob_fcyc(const std::vector& Pq) { * Computes the probability that a non-cyclic path of length (q - 1) can be * extended to form a cycle of length q. */ -gsl_vector* bct::cycprob_pcyc(const std::vector& Pq) { +VECTOR_T* bct::cycprob_pcyc(const std::vector& Pq) { // pcyc = zeros(1,size(Pq,3)); - gsl_vector* pcyc = zeros_vector_double(Pq.size()); + VECTOR_T* pcyc = zeros_vector(Pq.size()); // for q=2:size(Pq,3) for (int q = 2; q < (int)Pq.size(); q++) { // if((sum(sum(Pq(:,:,q-1)))-sum(diag(Pq(:,:,q-1))))>0) - gsl_vector* sum_Pq_q_sub_1 = sum(Pq[q - 1]); - double sum_sum_Pq_q_sub_1 = sum(sum_Pq_q_sub_1); - gsl_vector_free(sum_Pq_q_sub_1); - gsl_vector_view diag_Pq_q_sub_1 = gsl_matrix_diagonal(Pq[q - 1]); - double sum_diag_Pq_q_sub_1 = sum(&diag_Pq_q_sub_1.vector); + VECTOR_T* sum_Pq_q_sub_1 = sum(Pq[q - 1]); + FP_T sum_sum_Pq_q_sub_1 = sum(sum_Pq_q_sub_1); + VECTOR_ID(free)(sum_Pq_q_sub_1); + VECTOR_ID(view) diag_Pq_q_sub_1 = MATRIX_ID(diagonal)(Pq[q - 1]); + FP_T sum_diag_Pq_q_sub_1 = sum(&diag_Pq_q_sub_1.vector); if (sum_sum_Pq_q_sub_1 - sum_diag_Pq_q_sub_1 > 0.0) { // pcyc(q) = sum(diag(Pq(:,:,q)))/(sum(sum(Pq(:,:,q-1)))-sum(diag(Pq(:,:,q-1)))); - gsl_vector_view diag_Pq_q = gsl_matrix_diagonal(Pq[q]); - double sum_diag_Pq_q = sum(&diag_Pq_q.vector); - gsl_vector_set(pcyc, q, sum_diag_Pq_q / (sum_sum_Pq_q_sub_1 - sum_diag_Pq_q_sub_1)); + VECTOR_ID(view) diag_Pq_q = MATRIX_ID(diagonal)(Pq[q]); + FP_T sum_diag_Pq_q = sum(&diag_Pq_q.vector); + VECTOR_ID(set)(pcyc, q, sum_diag_Pq_q / (sum_sum_Pq_q_sub_1 - sum_diag_Pq_q_sub_1)); } } diff --git a/debug.cpp b/debug.cpp index dab94e0..5ee299f 100644 --- a/debug.cpp +++ b/debug.cpp @@ -1,17 +1,14 @@ -#include "bct.h" #include -#include -#include -#include -#include + +#include "bct.h" /* * Prints a vector using the given format for each element. This is only * provided for debugging purposes. In other cases, use gsl_vector_fprintf. */ -void bct::printf(const gsl_vector* v, const std::string& format) { +void bct::printf(const VECTOR_T* v, const std::string& format) { for (int i = 0; i < (int)v->size; i++) { - std::printf(format.c_str(), gsl_vector_get(v, i)); + std::printf(format.c_str(), VECTOR_ID(get)(v, i)); std::printf(" "); } std::printf("\n"); @@ -21,10 +18,10 @@ void bct::printf(const gsl_vector* v, const std::string& format) { * Prints a matrix using the given format for each element. This is only * provided for debugging purposes. In other cases, use gsl_matrix_fprintf. */ -void bct::printf(const gsl_matrix* m, const std::string& format) { +void bct::printf(const MATRIX_T* m, const std::string& format) { for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - std::printf(format.c_str(), gsl_matrix_get(m, i, j)); + std::printf(format.c_str(), MATRIX_ID(get)(m, i, j)); std::printf(" "); } std::printf("\n"); diff --git a/degrees_dir.cpp b/degrees_dir.cpp index 0b423d1..21853d8 100644 --- a/degrees_dir.cpp +++ b/degrees_dir.cpp @@ -1,34 +1,32 @@ #include "bct.h" -#include -#include /* * Computes degree, in-degree, and out-degree for a directed graph. Connection * weights are ignored. */ -gsl_vector* bct::degrees_dir(const gsl_matrix* CIJ, gsl_vector** id, gsl_vector** od) { +VECTOR_T* bct::degrees_dir(const MATRIX_T* CIJ, VECTOR_T** id, VECTOR_T** od) { if (safe_mode) check_status(CIJ, SQUARE | DIRECTED, "degrees_dir"); - // CIJ = double(CIJ~=0); + // CIJ = FP_T(CIJ~=0); // id = sum(CIJ,1); - gsl_vector* _id = gsl_vector_alloc(CIJ->size2); + VECTOR_T* _id = VECTOR_ID(alloc)(CIJ->size2); for (int i = 0; i < (int)CIJ->size2; i++) { - gsl_vector_const_view CIJ_col_i = gsl_matrix_const_column(CIJ, i); - gsl_vector_set(_id, i, nnz(&CIJ_col_i.vector)); + VECTOR_ID(const_view) CIJ_col_i = MATRIX_ID(const_column)(CIJ, i); + VECTOR_ID(set)(_id, i, nnz(&CIJ_col_i.vector)); } // od = sum(CIJ,2); - gsl_vector* _od = gsl_vector_alloc(CIJ->size1); + VECTOR_T* _od = VECTOR_ID(alloc)(CIJ->size1); for (int i = 0; i < (int)CIJ->size1; i++) { - gsl_vector_const_view CIJ_col_i = gsl_matrix_const_row(CIJ, i); - gsl_vector_set(_od, i, nnz(&CIJ_col_i.vector)); + VECTOR_ID(const_view) CIJ_col_i = MATRIX_ID(const_row)(CIJ, i); + VECTOR_ID(set)(_od, i, nnz(&CIJ_col_i.vector)); } // deg = id+od; - gsl_vector* deg = copy(_id); - gsl_vector_add(deg, _od); + VECTOR_T* deg = copy(_id); + VECTOR_ID(add)(deg, _od); - if (id != NULL) *id = _id; else gsl_vector_free(_id); - if (od != NULL) *od = _od; else gsl_vector_free(_od); + if (id != NULL) *id = _id; else VECTOR_ID(free)(_id); + if (od != NULL) *od = _od; else VECTOR_ID(free)(_od); return deg; } diff --git a/degrees_und.cpp b/degrees_und.cpp index 0facf94..355f570 100644 --- a/degrees_und.cpp +++ b/degrees_und.cpp @@ -1,42 +1,21 @@ #include "bct.h" -#include -#include /* * Computes degree for an undirected graph. Connection weights are ignored. */ -gsl_vector* bct::degrees_und(const gsl_matrix* CIJ) { +VECTOR_T* bct::degrees_und(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "degrees_und"); - // CIJ = double(CIJ~=0); + // CIJ = FP_T(CIJ~=0); // deg = sum(CIJ); - gsl_vector* deg = gsl_vector_alloc(CIJ->size2); + VECTOR_T* deg = VECTOR_ID(alloc)(CIJ->size2); #ifdef _OPENMP #pragma omp parallel for shared(deg) #endif for (int i = 0; i < (int)CIJ->size2; i++) { - gsl_vector_const_view CIJ_col_i = gsl_matrix_const_column(CIJ, i); - gsl_vector_set(deg, i, nnz(&CIJ_col_i.vector)); - } - return deg; -} - -/*float version*/ -gsl_vector_float* bct::degrees_und(const gsl_matrix_float* CIJ) { - - if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "degrees_und"); - - // CIJ = double(CIJ~=0); - // deg = sum(CIJ); - gsl_vector_float* deg = gsl_vector_float_alloc(CIJ->size2); - -#ifdef _OPENMP -#pragma omp parallel for shared(deg) -#endif - for (int i = 0; i < (int)CIJ->size2; i++) { - gsl_vector_float_const_view CIJ_col_i = gsl_matrix_float_const_column(CIJ, i); - gsl_vector_float_set(deg, i, nnz(&CIJ_col_i.vector)); + VECTOR_ID(const_view) CIJ_col_i = MATRIX_ID(const_column)(CIJ, i); + VECTOR_ID(set)(deg, i, nnz(&CIJ_col_i.vector)); } return deg; } diff --git a/density_dir.cpp b/density_dir.cpp index 27bddbc..7304607 100755 --- a/density_dir.cpp +++ b/density_dir.cpp @@ -1,10 +1,9 @@ #include "bct.h" -#include /* * Computes density for a directed graph. Connection weights are ignored. */ -double bct::density_dir(const gsl_matrix* CIJ) { +FP_T bct::density_dir(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | DIRECTED, "density_dir"); // N = size(CIJ,1); @@ -14,5 +13,5 @@ double bct::density_dir(const gsl_matrix* CIJ) { int K = nnz(CIJ); // kden = K/(N^2-N); - return (double)K / (double)(N * (N - 1)); + return (FP_T)K / (FP_T)(N * (N - 1)); } diff --git a/density_und.cpp b/density_und.cpp index e9d8965..402a099 100755 --- a/density_und.cpp +++ b/density_und.cpp @@ -1,35 +1,19 @@ #include "bct.h" -#include /* * Computes density for an undirected graph. Connection weights are ignored. */ -double bct::density_und(const gsl_matrix* CIJ) { +FP_T bct::density_und(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "density_und"); // N = size(CIJ,1); int N = CIJ->size1; // K = nnz(triu(CIJ)); - gsl_matrix* triu_CIJ = triu(CIJ); + MATRIX_T* triu_CIJ = triu(CIJ); int K = nnz(triu_CIJ); - gsl_matrix_free(triu_CIJ); + MATRIX_ID(free)(triu_CIJ); // kden = K/((N^2-N)/2); - return (double)K / ((double)(N * (N - 1)) / 2.0); -} - -float bct::density_und(const gsl_matrix_float* CIJ) { - if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "density_und"); - - // N = size(CIJ,1); - int N = CIJ->size1; - - // K = nnz(triu(CIJ)); - gsl_matrix_float* triu_CIJ = triu(CIJ); - int K = nnz(triu_CIJ); - gsl_matrix_float_free(triu_CIJ); - - // kden = K/((N^2-N)/2); - return (float)K / ((float)(N * (N - 1)) / 2.0); + return (FP_T)K / ((FP_T)(N * (N - 1)) / 2.0); } diff --git a/distance_bin.cpp b/distance_bin.cpp index 6bc6058..03634c3 100644 --- a/distance_bin.cpp +++ b/distance_bin.cpp @@ -1,65 +1,64 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes the distance matrix for a binary graph. */ -gsl_matrix* bct::distance_bin(const gsl_matrix* G) { +MATRIX_T* bct::distance_bin(const MATRIX_T* G) { if (safe_mode) check_status(G, SQUARE | BINARY, "distance_bin"); // D=eye(length(G)); - gsl_matrix* D = eye_double(length(G)); + MATRIX_T* D = eye(length(G)); // n=1; int n = 1; // nPATH=G; - gsl_matrix* nPATH = copy(G); + MATRIX_T* nPATH = copy(G); // L=(nPATH~=0); - gsl_matrix* L = compare_elements(nPATH, fp_not_equal, 0.0); + MATRIX_T* L = compare_elements(nPATH, fp_not_equal, 0.0); // while find(L,1); - gsl_vector* find_L = find(L, 1); + VECTOR_T* find_L = find(L, 1); while (find_L != NULL) { - gsl_vector_free(find_L); + VECTOR_ID(free)(find_L); // D=D+n.*L; - gsl_matrix_scale(L, (double)n); - gsl_matrix_add(D, L); + MATRIX_ID(scale)(L, (FP_T)n); + MATRIX_ID(add)(D, L); // n=n+1; n++; // nPATH=nPATH*G; - gsl_matrix* temp = mul(nPATH, G); - gsl_matrix_free(nPATH); + MATRIX_T* temp = mul(nPATH, G); + MATRIX_ID(free)(nPATH); nPATH = temp; // L=(nPATH~=0).*(D==0); - gsl_matrix_free(L); + MATRIX_ID(free)(L); L = compare_elements(nPATH, fp_not_equal, 0.0); - gsl_matrix* D_eq_0 = compare_elements(D, fp_equal, 0.0); - gsl_matrix_mul_elements(L, D_eq_0); - gsl_matrix_free(D_eq_0); + MATRIX_T* D_eq_0 = compare_elements(D, fp_equal, 0.0); + MATRIX_ID(mul_elements)(L, D_eq_0); + MATRIX_ID(free)(D_eq_0); find_L = find(L, 1); } - gsl_matrix_free(nPATH); - gsl_matrix_free(L); + MATRIX_ID(free)(nPATH); + MATRIX_ID(free)(L); // D(~D)=inf; - gsl_matrix* not_D = logical_not(D); + MATRIX_T* not_D = logical_not(D); logical_index_assign(D, not_D, GSL_POSINF); - gsl_matrix_free(not_D); + MATRIX_ID(free)(not_D); // D=D-eye(length(G)); - gsl_matrix* eye_length_G = eye_double(length(G)); - gsl_matrix_sub(D, eye_length_G); - gsl_matrix_free(eye_length_G); + MATRIX_T* eye_length_G = eye(length(G)); + MATRIX_ID(sub)(D, eye_length_G); + MATRIX_ID(free)(eye_length_G); return D; } diff --git a/distance_wei.cpp b/distance_wei.cpp index 5c261f1..635dfc5 100644 --- a/distance_wei.cpp +++ b/distance_wei.cpp @@ -1,36 +1,35 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes the distance matrix for a weighted graph. */ -gsl_matrix* bct::distance_wei(const gsl_matrix* G) { +MATRIX_T* bct::distance_wei(const MATRIX_T* G) { if (safe_mode) check_status(G, SQUARE | WEIGHTED, "distance_wei"); // n=length(G); int n = length(G); // D=zeros(n); D(~eye(n))=inf; - gsl_matrix* D = gsl_matrix_alloc(n, n); - gsl_matrix_set_all(D, GSL_POSINF); - gsl_vector_view diag_D = gsl_matrix_diagonal(D); - gsl_vector_set_all(&diag_D.vector, 0.0); + MATRIX_T* D = MATRIX_ID(alloc)(n, n); + MATRIX_ID(set_all)(D, GSL_POSINF); + VECTOR_ID(view) diag_D = MATRIX_ID(diagonal)(D); + VECTOR_ID(set_all)(&diag_D.vector, 0.0); // for u=1:n for (int u = 0; u < n; u++) { // S=true(1,n); - gsl_vector* S = gsl_vector_alloc(n); - gsl_vector_set_all(S, 1.0); + VECTOR_T* S = VECTOR_ID(alloc)(n); + VECTOR_ID(set_all)(S, 1.0); // G1=G; - gsl_matrix* G1 = copy(G); + MATRIX_T* G1 = copy(G); // V=u; - gsl_vector* V = gsl_vector_alloc(1); - gsl_vector_set(V, 0, (double)u); + VECTOR_T* V = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(V, 0, (FP_T)u); // while 1 while (true) { @@ -39,69 +38,69 @@ gsl_matrix* bct::distance_wei(const gsl_matrix* G) { ordinal_index_assign(S, V, 0.0); // G1(:,V)=0; - gsl_vector* G1_rows = sequence_double(0, G1->size1 - 1); + VECTOR_T* G1_rows = sequence(0, G1->size1 - 1); ordinal_index_assign(G1, G1_rows, V, 0.0); - gsl_vector_free(G1_rows); + VECTOR_ID(free)(G1_rows); // for v=V for (int i_V = 0; i_V < (int)V->size; i_V++) { - int v = (int)gsl_vector_get(V, i_V); + int v = (int)VECTOR_ID(get)(V, i_V); // W=find(G1(v,:)); - gsl_vector_view G1_row_v = gsl_matrix_row(G1, v); - gsl_vector* W = find(&G1_row_v.vector); + VECTOR_ID(view) G1_row_v = MATRIX_ID(row)(G1, v); + VECTOR_T* W = find(&G1_row_v.vector); if (W != NULL) { // D(u,W)=min([D(u,W);D(u,v)+G1(v,W)]); - gsl_vector* DG1_row = gsl_vector_alloc(1); - gsl_vector_set(DG1_row, 0, (double)u); - gsl_matrix* D_u_W = ordinal_index(D, DG1_row, W); - double D_u_v = gsl_matrix_get(D, u, v); - gsl_vector_set(DG1_row, 0, (double)v); - gsl_matrix* G1_v_W = ordinal_index(G1, DG1_row, W); - gsl_matrix_add_constant(G1_v_W, D_u_v); - gsl_matrix* cat = concatenate_columns(D_u_W, G1_v_W); - gsl_matrix_free(D_u_W); - gsl_matrix_free(G1_v_W); - gsl_vector* min_cat_v = min(cat); - gsl_matrix_free(cat); - gsl_matrix* min_cat = to_row_matrix(min_cat_v); - gsl_vector_free(min_cat_v); - gsl_vector_set(DG1_row, 0, (double)u); + VECTOR_T* DG1_row = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(DG1_row, 0, (FP_T)u); + MATRIX_T* D_u_W = ordinal_index(D, DG1_row, W); + FP_T D_u_v = MATRIX_ID(get)(D, u, v); + VECTOR_ID(set)(DG1_row, 0, (FP_T)v); + MATRIX_T* G1_v_W = ordinal_index(G1, DG1_row, W); + MATRIX_ID(add_constant)(G1_v_W, D_u_v); + MATRIX_T* cat = concatenate_columns(D_u_W, G1_v_W); + MATRIX_ID(free)(D_u_W); + MATRIX_ID(free)(G1_v_W); + VECTOR_T* min_cat_v = min(cat); + MATRIX_ID(free)(cat); + MATRIX_T* min_cat = to_row_matrix(min_cat_v); + VECTOR_ID(free)(min_cat_v); + VECTOR_ID(set)(DG1_row, 0, (FP_T)u); ordinal_index_assign(D, DG1_row, W, min_cat); - gsl_vector_free(W); - gsl_vector_free(DG1_row); - gsl_matrix_free(min_cat); + VECTOR_ID(free)(W); + VECTOR_ID(free)(DG1_row); + MATRIX_ID(free)(min_cat); } } // minD=min(D(u,S)); // if isempty(minD)||isinf(minD), break, end; - gsl_vector* D_row = gsl_vector_alloc(1); - gsl_vector_set(D_row, 0, (double)u); - gsl_matrix* D_u_S = ord_log_index(D, D_row, S); - gsl_vector_free(D_row); + VECTOR_T* D_row = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(D_row, 0, (FP_T)u); + MATRIX_T* D_u_S = ord_log_index(D, D_row, S); + VECTOR_ID(free)(D_row); if (D_u_S == NULL) { break; } else { - double minD = gsl_matrix_min(D_u_S); - gsl_matrix_free(D_u_S); + FP_T minD = MATRIX_ID(min)(D_u_S); + MATRIX_ID(free)(D_u_S); if (gsl_isinf(minD) == 1) { break; } // V=find(D(u,:)==minD); - gsl_vector_free(V); - gsl_vector_view D_row_u = gsl_matrix_row(D, u); - gsl_vector* D_row_u_eq_minD = compare_elements(&D_row_u.vector, fp_equal, minD); + VECTOR_ID(free)(V); + VECTOR_ID(view) D_row_u = MATRIX_ID(row)(D, u); + VECTOR_T* D_row_u_eq_minD = compare_elements(&D_row_u.vector, fp_equal, minD); V = find(D_row_u_eq_minD); - gsl_vector_free(D_row_u_eq_minD); + VECTOR_ID(free)(D_row_u_eq_minD); } } - gsl_vector_free(S); - gsl_matrix_free(G1); - gsl_vector_free(V); + VECTOR_ID(free)(S); + MATRIX_ID(free)(G1); + VECTOR_ID(free)(V); } return D; diff --git a/efficiency.cpp b/efficiency.cpp index 201258d..8878840 100644 --- a/efficiency.cpp +++ b/efficiency.cpp @@ -1,109 +1,40 @@ -#include "bct.h" #include -#include -#include -gsl_matrix* distance_inv(const gsl_matrix*); -gsl_matrix_float* distance_inv(const gsl_matrix_float*); +#include "bct.h" + +MATRIX_T* distance_inv(const MATRIX_T*); /* * Computes global efficiency. */ -double bct::efficiency_global(const gsl_matrix* G) { - if (safe_mode) check_status(G, SQUARE, "efficiency_global"); - - // N=length(G); - int N = length(G); - - // e=distance_inv(G); - gsl_matrix* e = distance_inv(G); - - // E=sum(e(:))./(N^2-N); - gsl_vector* e_v = to_vector(e); - gsl_matrix_free(e); - double sum_e = sum(e_v); - gsl_vector_free(e_v); - return sum_e / (double)(N * (N - 1)); -} - -/*float version*/ -float bct::efficiency_global(const gsl_matrix_float* G) { +FP_T bct::efficiency_global(const MATRIX_T* G) { if (safe_mode) check_status(G, SQUARE, "efficiency_global"); // N=length(G); int N = length(G); // e=distance_inv(G); - gsl_matrix_float* e = distance_inv(G); + MATRIX_T* e = distance_inv(G); // E=sum(e(:))./(N^2-N); - gsl_vector_float* e_v = to_vector(e); - gsl_matrix_float_free(e); - float sum_e = sum(e_v); - gsl_vector_float_free(e_v); - return sum_e / (float)(N * (N - 1)); + VECTOR_T* e_v = to_vector(e); + MATRIX_ID(free)(e); + FP_T sum_e = sum(e_v); + VECTOR_ID(free)(e_v); + return sum_e / (FP_T)(N * (N - 1)); } - /* * Computes local efficiency. */ -gsl_vector* bct::efficiency_local(const gsl_matrix* G) { - if (safe_mode) check_status(G, SQUARE, "efficiency_local"); - - // N=length(G); - int N = length(G); - - // E=zeros(N,1); - gsl_vector* E = zeros_vector_double(N); - - // for u=1:N -#ifdef _OPENMP -#pragma omp parallel for shared(E) -#endif - for (int u = 0; u < N; u++) { - - // V=find(G(u,:)); - gsl_vector_const_view G_row_u = gsl_matrix_const_row(G, u); - gsl_vector* V = find(&G_row_u.vector); - if (V != NULL) { - - // k=length(V); - int k = length(V); - - // if k>=2; - if (k >= 2) { - - // e=distance_inv(G(V,V)); - gsl_matrix* G_idx = ordinal_index(G, V, V); - gsl_matrix* e = distance_inv(G_idx); - gsl_matrix_free(G_idx); - - // E(u)=sum(e(:))./(k.^2-k); - gsl_vector* e_v = to_vector(e); - gsl_matrix_free(e); - double sum_e = sum(e_v); - gsl_vector_free(e_v); - gsl_vector_set(E, u, sum_e / (double)(k * (k - 1))); - } - - gsl_vector_free(V); - } - } - - return E; -} - - -/*float version*/ -gsl_vector_float* bct::efficiency_local(const gsl_matrix_float* G) { +VECTOR_T* bct::efficiency_local(const MATRIX_T* G) { if (safe_mode) check_status(G, SQUARE, "efficiency_local"); // N=length(G); int N = length(G); // E=zeros(N,1); - gsl_vector_float* E = zeros_vector_float(N); + VECTOR_T* E = zeros_vector(N); // for u=1:N #ifdef _OPENMP @@ -112,8 +43,8 @@ gsl_vector_float* bct::efficiency_local(const gsl_matrix_float* G) { for (int u = 0; u < N; u++) { // V=find(G(u,:)); - gsl_vector_float_const_view G_row_u = gsl_matrix_float_const_row(G, u); - gsl_vector_float* V = find(&G_row_u.vector); + VECTOR_ID(const_view) G_row_u = MATRIX_ID(const_row)(G, u); + VECTOR_T* V = find(&G_row_u.vector); if (V != NULL) { // k=length(V); @@ -123,148 +54,84 @@ gsl_vector_float* bct::efficiency_local(const gsl_matrix_float* G) { if (k >= 2) { // e=distance_inv(G(V,V)); - gsl_matrix_float* G_idx = ordinal_index(G, V, V); - gsl_matrix_float* e = distance_inv(G_idx); - gsl_matrix_float_free(G_idx); + MATRIX_T* G_idx = ordinal_index(G, V, V); + MATRIX_T* e = distance_inv(G_idx); + MATRIX_ID(free)(G_idx); // E(u)=sum(e(:))./(k.^2-k); - gsl_vector_float* e_v = to_vector(e); - gsl_matrix_float_free(e); - double sum_e = sum(e_v); - gsl_vector_float_free(e_v); - gsl_vector_float_set(E, u, sum_e / (double)(k * (k - 1))); + VECTOR_T* e_v = to_vector(e); + MATRIX_ID(free)(e); + FP_T sum_e = sum(e_v); + VECTOR_ID(free)(e_v); + VECTOR_ID(set)(E, u, sum_e / (FP_T)(k * (k - 1))); } - gsl_vector_float_free(V); + VECTOR_ID(free)(V); } } return E; } -gsl_matrix* distance_inv(const gsl_matrix* g) { - using namespace bct; - - // D=eye(length(g)); - gsl_matrix* D = eye_double(length(g)); - - // n=1; - int n = 1; - - // nPATH=g; - gsl_matrix* nPATH = copy(g); - - // L=(nPATH~=0); - gsl_matrix* L = compare_elements(nPATH, fp_not_equal, 0.0); - - // while find(L,1); - gsl_vector* find_L = find(L, 1); - while (find_L != NULL) { - gsl_vector_free(find_L); - - // D=D+n.*L; - gsl_matrix_scale(L, (double)n); - gsl_matrix_add(D, L); - - // n=n+1; - n++; - - // nPATH=nPATH*g; - gsl_matrix* temp = mul(nPATH, g); - gsl_matrix_free(nPATH); - nPATH = temp; - - // L=(nPATH~=0).*(D==0); - gsl_matrix_free(L); - L = compare_elements(nPATH, fp_not_equal, 0.0); - gsl_matrix* D_eq_0 = compare_elements(D, fp_equal, 0.0); - gsl_matrix_mul_elements(L, D_eq_0); - gsl_matrix_free(D_eq_0); - - find_L = find(L, 1); - } - - gsl_matrix_free(nPATH); - gsl_matrix_free(L); - - // D(~D)=inf; - gsl_matrix* not_D = logical_not(D); - logical_index_assign(D, not_D, GSL_POSINF); - gsl_matrix_free(not_D); - - // D=1./D; - gsl_matrix* temp = pow_elements(D, -1.0); - gsl_matrix_free(D); - D = temp; - - // D=D-eye(length(g)); - gsl_matrix* eye_length_g = eye_double(length(g)); - gsl_matrix_sub(D, eye_length_g); - gsl_matrix_free(eye_length_g); - - return D; -} - -/*float version*/ -gsl_matrix_float* distance_inv(const gsl_matrix_float* g) { +MATRIX_T* distance_inv(const MATRIX_T* g) { using namespace bct; // D=eye(length(g)); - gsl_matrix_float* D = eye_float(length(g)); + MATRIX_T* D = eye(length(g)); // n=1; int n = 1; // nPATH=g; - gsl_matrix_float* nPATH = copy(g); + MATRIX_T* nPATH = copy(g); // L=(nPATH~=0); - gsl_matrix_float* L = compare_elements(nPATH, fp_not_equal, 0.0); + MATRIX_T* L = compare_elements(nPATH, fp_not_equal, 0.0); // while find(L,1); - gsl_vector_float* find_L = find(L, 1); + VECTOR_T* find_L = find(L, 1); while (find_L != NULL) { - gsl_vector_float_free(find_L); + VECTOR_ID(free)(find_L); // D=D+n.*L; - gsl_matrix_float_scale(L, (float)n); - gsl_matrix_float_add(D, L); + MATRIX_ID(scale)(L, (FP_T)n); + MATRIX_ID(add)(D, L); // n=n+1; n++; // nPATH=nPATH*g; - gsl_matrix_float* temp = mul(nPATH, g); - gsl_matrix_float_free(nPATH); + MATRIX_T* temp = mul(nPATH, g); + MATRIX_ID(free)(nPATH); nPATH = temp; // L=(nPATH~=0).*(D==0); - gsl_matrix_float_free(L); + MATRIX_ID(free)(L); L = compare_elements(nPATH, fp_not_equal, 0.0); - gsl_matrix_float* D_eq_0 = compare_elements(D, fp_equal, 0.0); - gsl_matrix_float_mul_elements(L, D_eq_0); - gsl_matrix_float_free(D_eq_0); + MATRIX_T* D_eq_0 = compare_elements(D, fp_equal, 0.0); + MATRIX_ID(mul_elements)(L, D_eq_0); + MATRIX_ID(free)(D_eq_0); find_L = find(L, 1); } - gsl_matrix_float_free(nPATH); - gsl_matrix_float_free(L); + MATRIX_ID(free)(nPATH); + MATRIX_ID(free)(L); // D(~D)=inf; - gsl_matrix_float* not_D = logical_not(D); + MATRIX_T* not_D = logical_not(D); logical_index_assign(D, not_D, GSL_POSINF); - gsl_matrix_float_free(not_D); + MATRIX_ID(free)(not_D); // D=1./D; - gsl_matrix_float* temp = pow_elements(D, -1.0); - gsl_matrix_float_free(D); + MATRIX_T* temp = pow_elements(D, -1.0); + MATRIX_ID(free)(D); D = temp; // D=D-eye(length(g)); - gsl_matrix_float* eye_length_g = eye_float(length(g)); - gsl_matrix_float_sub(D, eye_length_g); - gsl_matrix_float_free(eye_length_g); + MATRIX_T* eye_length_g = eye(length(g)); + MATRIX_ID(sub)(D, eye_length_g); + MATRIX_ID(free)(eye_length_g); return D; } diff --git a/eigenvector_centrality.cpp b/eigenvector_centrality.cpp index 140899b..5d437f6 100644 --- a/eigenvector_centrality.cpp +++ b/eigenvector_centrality.cpp @@ -1,123 +1,58 @@ -#include -#include -#include -#include #include -#include "bct.h" - -gsl_vector* bct::eigenvector_centrality(const gsl_matrix* G) { - //uses power iteration to find dominant eigenvector - //adapted from NetworkX 1.4 eigenvector_centrality function - //see also: http://www.mathworks.de/matlabcentral/fx_files/7978/1/mPowerEig.c - //see also: http://en.wikipedia.org/wiki/Power_iteration - - if (safe_mode) check_status(G, SQUARE, "eigenvector_centrality"); - - double tol = .000001; //ensures that the average value is stable at 1e-6 - int maxiter=1000; - int N = G->size1; - gsl_vector* x = gsl_vector_alloc(N); - gsl_vector* xlast=gsl_vector_alloc(N); - - //note that this starting vector is already normalized (elements sum to 1) - double startval = 1.0/double(N); - gsl_vector_set_all(x, startval); - - double evec_norm; - double err; - double newval; - - for (int iter=0; iter < maxiter; iter++) { - err = 0.0; - gsl_vector_memcpy(xlast, x); - gsl_vector_set_zero(x); - -#ifdef _OPENMP -#pragma omp parallel for private(newval) shared(x,xlast) -#endif - for (int i = 0; i < N; i++) { - for (int j = 0; j < N; j++) { - newval = gsl_vector_get(x, i) + gsl_vector_get(xlast, j) * gsl_matrix_get(G, i, j); - gsl_vector_set(x, i, newval); - } - } - - //normalize vector - evec_norm = gsl_blas_dnrm2(x); // -- calculate vector norm - gsl_vector_scale(x, 1.0/evec_norm); - - //check convergence - for (int i = 0; i < (int)x->size; i++) { - err += abs(gsl_vector_get(x, i) - gsl_vector_get(xlast, i)); - } - - if (err < double(N) * tol) { - break; //end power iteration - } - - } - - //deallocate xlast vector - gsl_vector_free(xlast); - return(x); //x contains best estimate of eigenvector centrality -} - -/*float version*/ -gsl_vector_float* bct::eigenvector_centrality(const gsl_matrix_float* G) { - //uses power iteration to find dominant eigenvector - //adapted from NetworkX 1.4 eigenvector_centrality function - //see also: http://www.mathworks.de/matlabcentral/fx_files/7978/1/mPowerEig.c - //see also: http://en.wikipedia.org/wiki/Power_iteration - - if (safe_mode) check_status(G, SQUARE, "eigenvector_centrality"); - - double tol = .000001; //ensures that the average value is stable at 1e-6 - int maxiter=1000; - int N = G->size1; - gsl_vector_float* x = gsl_vector_float_alloc(N); - gsl_vector_float* xlast=gsl_vector_float_alloc(N); - - //note that this starting vector is already normalized (elements sum to 1) - double startval = 1.0/double(N); - gsl_vector_float_set_all(x, (float)startval); - - float evec_norm; - double err; - double newval; - - for (int iter=0; iter < maxiter; iter++) { - err = 0.0; - gsl_vector_float_memcpy(xlast, x); - gsl_vector_float_set_zero(x); +#include "bct.h" +/* + * Finds the dominant eigenvector using power iteration. Adapted from + * NetworkX v1.4 eigenvector_centrality. + * + * http://www.mathworks.de/matlabcentral/fx_files/7978/1/mPowerEig.c + * http://en.wikipedia.org/wiki/Power_iteration + */ +VECTOR_T* bct::eigenvector_centrality(const MATRIX_T* G) { + if (safe_mode) check_status(G, SQUARE, "eigenvector_centrality"); + + FP_T tol = 1e-6; // Ensures that the average value is stable at 1e-6 + int maxiter = 1000; + int N = G->size1; + VECTOR_T* x = VECTOR_ID(alloc)(N); + VECTOR_T* xlast = VECTOR_ID(alloc)(N); + + // Note that this starting vector is already normalized (elements sum to 1) + FP_T startval = 1.0 / (FP_T)N; + VECTOR_ID(set_all)(x, startval); + + FP_T evec_norm; + FP_T err; + FP_T newval; + for (int iter = 0; iter < maxiter; iter++) { + err = 0.0; + VECTOR_ID(memcpy)(xlast, x); + VECTOR_ID(set_zero)(x); + #ifdef _OPENMP -#pragma omp parallel for private(newval) shared(x,xlast) +#pragma omp parallel for private(newval) shared(x, xlast) #endif - for (int i = 0; i < N; i++) { - for (int j = 0; j < N; j++) { - newval = gsl_vector_float_get(x, i) + gsl_vector_float_get(xlast, j) * gsl_matrix_float_get(G, i, j); - gsl_vector_float_set(x, i, newval); - } - } - - //normalize vector - evec_norm = gsl_blas_snrm2(x); // -- calculate vector norm (use snrm because x is float) - gsl_vector_float_scale(x, 1.0/evec_norm); - - //check convergence - for (int i = 0; i < (int)x->size; i++) { - err += abs(gsl_vector_float_get(x, i) - gsl_vector_float_get(xlast, i)); - } - - if (err < double(N) * tol) { - break; //end power iteration - } - - } - - //deallocate xlast vector - gsl_vector_float_free(xlast); - - return(x); //x contains best estimate of eigenvector centrality + for (int i = 0; i < N; i++) { + for (int j = 0; j < N; j++) { + newval = VECTOR_ID(get)(x, i) + VECTOR_ID(get)(xlast, j) * MATRIX_ID(get)(G, i, j); + VECTOR_ID(set)(x, i, newval); + } + } + + // Normalize vector + evec_norm = norm(x, 2); + VECTOR_ID(scale)(x, 1.0 / evec_norm); + + // Check convergence + for (int i = 0; i < (int)x->size; i++) { + err += std::abs(VECTOR_ID(get)(x, i) - VECTOR_ID(get)(xlast, i)); + } + if (err < (FP_T)N * tol) { + break; // End power iteration + } + + } + VECTOR_ID(free)(xlast); + return x; } diff --git a/erange.cpp b/erange.cpp index 4df35fb..bbe8cae 100644 --- a/erange.cpp +++ b/erange.cpp @@ -1,13 +1,12 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes the range for each edge (i.e., the shortest path length between the * nodes it connects after the edge has been removed from the graph) */ -gsl_matrix* bct::erange(const gsl_matrix* CIJ, double* eta, gsl_matrix** Eshort, double* fs) { +MATRIX_T* bct::erange(const MATRIX_T* CIJ, FP_T* eta, MATRIX_T** Eshort, FP_T* fs) { if (safe_mode) check_status(CIJ, SQUARE, "erange"); // N = size(CIJ,1); @@ -17,60 +16,60 @@ gsl_matrix* bct::erange(const gsl_matrix* CIJ, double* eta, gsl_matrix** Eshort, int k = nnz(CIJ); // Erange = zeros(N,N); - gsl_matrix* Erange = zeros_double(N, N); + MATRIX_T* Erange = zeros(N, N); // [i,j] = find(CIJ==1); - gsl_matrix* CIJ_eq_1 = compare_elements(CIJ, fp_equal, 1.0); - gsl_matrix* find_CIJ_eq_1 = find_ij(CIJ_eq_1); - gsl_matrix_free(CIJ_eq_1); - gsl_vector_view i = gsl_matrix_column(find_CIJ_eq_1, 0); - gsl_vector_view j = gsl_matrix_column(find_CIJ_eq_1, 1); + MATRIX_T* CIJ_eq_1 = compare_elements(CIJ, fp_equal, 1.0); + MATRIX_T* find_CIJ_eq_1 = find_ij(CIJ_eq_1); + MATRIX_ID(free)(CIJ_eq_1); + VECTOR_ID(view) i = MATRIX_ID(column)(find_CIJ_eq_1, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_CIJ_eq_1, 1); // for c=1:length(i) for (int c = 0; c < length(&i.vector); c++) { // CIJcut = CIJ; - gsl_matrix* CIJcut = copy(CIJ); + MATRIX_T* CIJcut = copy(CIJ); // CIJcut(i(c),j(c)) = 0; - int i_c = (int)gsl_vector_get(&i.vector, c); - int j_c = (int)gsl_vector_get(&j.vector, c); - gsl_matrix_set(CIJcut, i_c, j_c, 0.0); + int i_c = (int)VECTOR_ID(get)(&i.vector, c); + int j_c = (int)VECTOR_ID(get)(&j.vector, c); + MATRIX_ID(set)(CIJcut, i_c, j_c, 0.0); // [R,D] = reachdist(CIJcut); - gsl_matrix* D; - gsl_matrix* R = reachdist(CIJcut, &D); - gsl_matrix_free(CIJcut); - gsl_matrix_free(R); + MATRIX_T* D; + MATRIX_T* R = reachdist(CIJcut, &D); + MATRIX_ID(free)(CIJcut); + MATRIX_ID(free)(R); // Erange(i(c),j(c)) = D(i(c),j(c)) - gsl_matrix_set(Erange, i_c, j_c, gsl_matrix_get(D, i_c, j_c)); - gsl_matrix_free(D); + MATRIX_ID(set)(Erange, i_c, j_c, MATRIX_ID(get)(D, i_c, j_c)); + MATRIX_ID(free)(D); } - gsl_matrix_free(find_CIJ_eq_1); + MATRIX_ID(free)(find_CIJ_eq_1); // eta = sum(Erange((Erange>0)&(Erange0)&(Erange2; - gsl_matrix* _Eshort = compare_elements(Erange, fp_greater, 2.0); + MATRIX_T* _Eshort = compare_elements(Erange, fp_greater, 2.0); // fs = length(nonzeros(Eshort))/K; if (fs != NULL) { - *fs = (double)nnz(_Eshort) / (double)k; + *fs = (FP_T)nnz(_Eshort) / (FP_T)k; } - if (Eshort != NULL) *Eshort = _Eshort; else gsl_matrix_free(_Eshort); + if (Eshort != NULL) *Eshort = _Eshort; else MATRIX_ID(free)(_Eshort); return Erange; } diff --git a/find_motif34.cpp b/find_motif34.cpp index 3f32cf5..b4757c7 100644 --- a/find_motif34.cpp +++ b/find_motif34.cpp @@ -1,28 +1,25 @@ #include "bct.h" -#include -#include -#include /* * Returns all motif isomorphs for a given motif ID and size. */ -std::vector bct::find_motif34(int m, int n) { +std::vector bct::find_motif34(int m, int n) { // if n==3 if (n == 3) { // load motif34lib M3 ID3 - gsl_vector* ID3; - gsl_matrix* M3 = motif3generate(&ID3); + VECTOR_T* ID3; + MATRIX_T* M3 = motif3generate(&ID3); // ind=find(ID3==m).'; - gsl_vector* ID3_eq_m = compare_elements(ID3, fp_equal, (double)m); - gsl_vector_free(ID3); - gsl_vector* ind = find(ID3_eq_m); - gsl_vector_free(ID3_eq_m); + VECTOR_T* ID3_eq_m = compare_elements(ID3, fp_equal, (FP_T)m); + VECTOR_ID(free)(ID3); + VECTOR_T* ind = find(ID3_eq_m); + VECTOR_ID(free)(ID3_eq_m); // M=zeros(3,3,length(ind)); - std::vector M(length(ind)); + std::vector M(length(ind)); int i_nondiag[] = { 1, 2, 3, 5, 6, 7 }; @@ -30,32 +27,32 @@ std::vector bct::find_motif34(int m, int n) { for (int i = 0; i < length(ind); i++) { // M(:,:,i)=reshape([0 M3(ind(i),1:3) 0 M3(ind(i),4:6) 0],3,3); - M[i] = gsl_matrix_calloc(3, 3); - int ind_i = (int)gsl_vector_get(ind, i); + M[i] = MATRIX_ID(calloc)(3, 3); + int ind_i = (int)VECTOR_ID(get)(ind, i); for (int j = 0; j < 6; j++) { - ordinal_index_assign(M[i], i_nondiag[j], gsl_matrix_get(M3, ind_i, j)); + ordinal_index_assign(M[i], i_nondiag[j], MATRIX_ID(get)(M3, ind_i, j)); } } - gsl_matrix_free(M3); - gsl_vector_free(ind); + MATRIX_ID(free)(M3); + VECTOR_ID(free)(ind); return M; // elseif n==4 } else if (n == 4) { // load motif34lib M4 ID4; - gsl_vector* ID4; - gsl_matrix* M4 = motif4generate(&ID4); + VECTOR_T* ID4; + MATRIX_T* M4 = motif4generate(&ID4); // ind=find(ID4==m).'; - gsl_vector* ID4_eq_m = compare_elements(ID4, fp_equal, (double)m); - gsl_vector_free(ID4); - gsl_vector* ind = find(ID4_eq_m); - gsl_vector_free(ID4_eq_m); + VECTOR_T* ID4_eq_m = compare_elements(ID4, fp_equal, (FP_T)m); + VECTOR_ID(free)(ID4); + VECTOR_T* ind = find(ID4_eq_m); + VECTOR_ID(free)(ID4_eq_m); // M=zeros(4,4,length(ind)); - std::vector M(length(ind)); + std::vector M(length(ind)); int i_nondiag[] = { 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14 }; @@ -63,31 +60,32 @@ std::vector bct::find_motif34(int m, int n) { for (int i = 0; i < length(ind); i++) { // M(:,:,i)=reshape([0 M4(ind(i),1:4) 0 M4(ind(i),5:8) 0 M4(ind(i),9:12) 0],4,4); - M[i] = gsl_matrix_calloc(4, 4); - int ind_i = (int)gsl_vector_get(ind, i); + M[i] = MATRIX_ID(calloc)(4, 4); + int ind_i = (int)VECTOR_ID(get)(ind, i); for (int j = 0; j < 12; j++) { - ordinal_index_assign(M[i], i_nondiag[j], gsl_matrix_get(M4, ind_i, j)); + ordinal_index_assign(M[i], i_nondiag[j], MATRIX_ID(get)(M4, ind_i, j)); } } - gsl_matrix_free(M4); - gsl_vector_free(ind); + MATRIX_ID(free)(M4); + VECTOR_ID(free)(ind); return M; } else { - return std::vector(); + return std::vector(); } } /* * Returns the motif ID for a given matrix. */ -int bct::find_motif34(const gsl_matrix* m) { +int bct::find_motif34(const MATRIX_T* m) { + if (safe_mode) check_status(m, SQUARE, "find_motif34"); // n=size(m,1); int n = m->size1; // M=eval(['find(motif' int2str(n) 'struct_bin(m))']); - gsl_vector* f; + VECTOR_T* f; if (n == 3) { f = motif3struct_bin(m); } else if (n == 4) { @@ -95,11 +93,11 @@ int bct::find_motif34(const gsl_matrix* m) { } else { return 0; } - gsl_vector* M_v = find(f); - gsl_vector_free(f); + VECTOR_T* M_v = find(f); + VECTOR_ID(free)(f); if (M_v != NULL) { - int M = (int)gsl_vector_get(M_v, 0); - gsl_vector_free(M_v); + int M = (int)VECTOR_ID(get)(M_v, 0); + VECTOR_ID(free)(M_v); return M + 1; } else { return 0; diff --git a/findpaths.cpp b/findpaths.cpp index d192afc..35486ff 100644 --- a/findpaths.cpp +++ b/findpaths.cpp @@ -1,8 +1,6 @@ -#include "bct.h" #include -#include -#include -#include + +#include "bct.h" /* * Finds paths from a set of source nodes up to a given length. Note that there @@ -13,67 +11,67 @@ * plq, and util are indexed by path length. They therefore have (qmax + 1) * elements and contain no valid data at index 0. */ -std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* sources, int qmax, gsl_vector** plq, int* qstop, gsl_matrix** allpths, gsl_matrix** util) { +std::vector bct::findpaths(const MATRIX_T* CIJ, const VECTOR_T* sources, int qmax, VECTOR_T** plq, int* qstop, MATRIX_T** allpths, MATRIX_T** util) { if (safe_mode) check_status(CIJ, SQUARE, "findpaths"); - // CIJ = double(CIJ~=0); - gsl_matrix* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); + // CIJ = FP_T(CIJ~=0); + MATRIX_T* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); // N = size(CIJ,1); int N = CIJ->size1; // pths = []; - gsl_matrix* pths = NULL; + MATRIX_T* pths = NULL; // Pq = zeros(N,N,qmax); - std::vector Pq(qmax + 1); + std::vector Pq(qmax + 1); Pq[0] = NULL; for (int i = 1; i <= qmax; i++) { - Pq[i] = zeros_double(N, N); + Pq[i] = zeros(N, N); } // util = zeros(N,qmax); if (util != NULL) { - *util = zeros_double(N, qmax + 1); + *util = zeros(N, qmax + 1); } // q = 1; int q = 1; - gsl_vector* _CIJ_cols = sequence_double(0, N - 1); - gsl_matrix* _CIJ_idx = ordinal_index(_CIJ, sources, _CIJ_cols); - gsl_vector_free(_CIJ_cols); - gsl_matrix* _CIJ_idx_ij = find_ij(_CIJ_idx); - gsl_matrix_free(_CIJ_idx); - pths = gsl_matrix_alloc(2, _CIJ_idx_ij->size1); + VECTOR_T* _CIJ_cols = sequence(0, N - 1); + MATRIX_T* _CIJ_idx = ordinal_index(_CIJ, sources, _CIJ_cols); + VECTOR_ID(free)(_CIJ_cols); + MATRIX_T* _CIJ_idx_ij = find_ij(_CIJ_idx); + MATRIX_ID(free)(_CIJ_idx); + pths = MATRIX_ID(alloc)(2, _CIJ_idx_ij->size1); for (int i = 0; i < (int)_CIJ_idx_ij->size1; i++) { - int i_row = (int)gsl_matrix_get(_CIJ_idx_ij, i, 0); - int i_start = (int)gsl_vector_get(sources, i_row); - int i_end = (int)gsl_matrix_get(_CIJ_idx_ij, i, 1); - gsl_matrix_set(pths, 0, i, (double)i_start); - gsl_matrix_set(pths, 1, i, (double)i_end); + int i_row = (int)MATRIX_ID(get)(_CIJ_idx_ij, i, 0); + int i_start = (int)VECTOR_ID(get)(sources, i_row); + int i_end = (int)MATRIX_ID(get)(_CIJ_idx_ij, i, 1); + MATRIX_ID(set)(pths, 0, i, (FP_T)i_start); + MATRIX_ID(set)(pths, 1, i, (FP_T)i_end); } - gsl_matrix_free(_CIJ_idx_ij); + MATRIX_ID(free)(_CIJ_idx_ij); // util(1:N,q) = util(1:N,q)+hist(reshape(pths,1,size(pths,1)*size(pths,2)),1:N)'; if (util != NULL) { - gsl_vector* reshape_pths = to_vector(pths); - gsl_vector* centers = sequence_double(0, N - 1); - gsl_vector* hist_reshape_pths = hist(reshape_pths, centers); - gsl_vector_free(reshape_pths); - gsl_vector_free(centers); - gsl_vector_view util_col_q = gsl_matrix_column(*util, q); - gsl_vector_add(&util_col_q.vector, hist_reshape_pths); - gsl_vector_free(hist_reshape_pths); + VECTOR_T* reshape_pths = to_vector(pths); + VECTOR_T* centers = sequence(0, N - 1); + VECTOR_T* hist_reshape_pths = hist(reshape_pths, centers); + VECTOR_ID(free)(reshape_pths); + VECTOR_ID(free)(centers); + VECTOR_ID(view) util_col_q = MATRIX_ID(column)(*util, q); + VECTOR_ID(add)(&util_col_q.vector, hist_reshape_pths); + VECTOR_ID(free)(hist_reshape_pths); } // for np=1:size(pths,2) for (int np = 0; np < (int)pths->size2; np++) { // Pq(pths(1,np),pths(q+1,np),q) = Pq(pths(1,np),pths(q+1,np),q) + 1; - int i = (int)gsl_matrix_get(pths, 0, np); - int j = (int)gsl_matrix_get(pths, q, np); - gsl_matrix_set(Pq[q], i, j, gsl_matrix_get(Pq[q], i, j) + 1.0); + int i = (int)MATRIX_ID(get)(pths, 0, np); + int j = (int)MATRIX_ID(get)(pths, q, np); + MATRIX_ID(set)(Pq[q], i, j, MATRIX_ID(get)(Pq[q], i, j) + 1.0); } // if (savepths==1) @@ -87,12 +85,12 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* for (q = 2; q <= qmax; q++) { // npths = zeros(q+1,len_npths); - // Handle as a std::vector rather than preallocating a gsl_matrix* - std::vector npths_v; + // Handle as a std::vector rather than preallocating a MATRIX_T* + std::vector npths_v; // endp = unique(pths(q,:)); - gsl_vector_view pths_row_q_sub_1 = gsl_matrix_row(pths, q - 1); - gsl_vector* endp = unique(&pths_row_q_sub_1.vector); + VECTOR_ID(view) pths_row_q_sub_1 = MATRIX_ID(row)(pths, q - 1); + VECTOR_T* endp = unique(&pths_row_q_sub_1.vector); // npthscnt = 0; int npthscnt = 0; @@ -101,19 +99,19 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* for (int ii = 0; ii < length(endp); ii++) { // i = endp(ii); - int i = (int)gsl_vector_get(endp, ii); + int i = (int)VECTOR_ID(get)(endp, ii); // [pa,pb] = find(pths(q,:) == i); - gsl_vector* pths_row_q_sub_1_eq_i = compare_elements(&pths_row_q_sub_1.vector, fp_equal, (double)i); - gsl_vector* pb = find(pths_row_q_sub_1_eq_i); - gsl_vector_free(pths_row_q_sub_1_eq_i); + VECTOR_T* pths_row_q_sub_1_eq_i = compare_elements(&pths_row_q_sub_1.vector, fp_equal, (FP_T)i); + VECTOR_T* pb = find(pths_row_q_sub_1_eq_i); + VECTOR_ID(free)(pths_row_q_sub_1_eq_i); if (pb != NULL) { // nendp = find(CIJ(i,:)==1); - gsl_vector_const_view _CIJ_row_i = gsl_matrix_const_row(_CIJ, i); - gsl_vector* _CIJ_row_i_eq_1 = compare_elements(&_CIJ_row_i.vector, fp_equal, 1.0); - gsl_vector* nendp = find(_CIJ_row_i_eq_1); - gsl_vector_free(_CIJ_row_i_eq_1); + VECTOR_ID(const_view) _CIJ_row_i = MATRIX_ID(const_row)(_CIJ, i); + VECTOR_T* _CIJ_row_i_eq_1 = compare_elements(&_CIJ_row_i.vector, fp_equal, 1.0); + VECTOR_T* nendp = find(_CIJ_row_i_eq_1); + VECTOR_ID(free)(_CIJ_row_i_eq_1); // if (~isempty(nendp)) if (nendp != NULL) { @@ -122,72 +120,72 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* for (int jj = 0; jj < length(nendp); jj++) { // j = nendp(jj); - int j = (int)gsl_vector_get(nendp, jj); + int j = (int)VECTOR_ID(get)(nendp, jj); // pb_temp = pb(sum(j==pths(2:q,pb),1)==0); - gsl_vector* pths_rows = sequence_double(1, q - 1); - gsl_matrix* pths_idx = ordinal_index(pths, pths_rows, pb); - gsl_vector_free(pths_rows); - gsl_matrix* pths_idx_eq_j = compare_elements(pths_idx, fp_equal, (double)j); - gsl_matrix_free(pths_idx); - gsl_vector* sum_pths_idx_eq_j = sum(pths_idx_eq_j, 1); - gsl_matrix_free(pths_idx_eq_j); - gsl_vector* sum_pths_idx_eq_j_eq_0 = compare_elements(sum_pths_idx_eq_j, fp_equal, 0.0); - gsl_vector_free(sum_pths_idx_eq_j); - gsl_vector* pb_temp = logical_index(pb, sum_pths_idx_eq_j_eq_0); - gsl_vector_free(sum_pths_idx_eq_j_eq_0); + VECTOR_T* pths_rows = sequence(1, q - 1); + MATRIX_T* pths_idx = ordinal_index(pths, pths_rows, pb); + VECTOR_ID(free)(pths_rows); + MATRIX_T* pths_idx_eq_j = compare_elements(pths_idx, fp_equal, (FP_T)j); + MATRIX_ID(free)(pths_idx); + VECTOR_T* sum_pths_idx_eq_j = sum(pths_idx_eq_j, 1); + MATRIX_ID(free)(pths_idx_eq_j); + VECTOR_T* sum_pths_idx_eq_j_eq_0 = compare_elements(sum_pths_idx_eq_j, fp_equal, 0.0); + VECTOR_ID(free)(sum_pths_idx_eq_j); + VECTOR_T* pb_temp = logical_index(pb, sum_pths_idx_eq_j_eq_0); + VECTOR_ID(free)(sum_pths_idx_eq_j_eq_0); if (pb_temp != NULL) { // npths(:,npthscnt+1:npthscnt+length(pb_temp)) = [pths(:,pb_temp)' ones(length(pb_temp),1)*j]'; - pths_rows = sequence_double(0, pths->size1 - 1); + pths_rows = sequence(0, pths->size1 - 1); pths_idx = ordinal_index(pths, pths_rows, pb_temp); - gsl_vector_free(pths_rows); - gsl_matrix* temp = gsl_matrix_alloc(pths_idx->size1 + 1, pths_idx->size2); - gsl_matrix_view temp_subm = gsl_matrix_submatrix(temp, 0, 0, pths_idx->size1, pths_idx->size2); - gsl_matrix_memcpy(&temp_subm.matrix, pths_idx); - gsl_matrix_free(pths_idx); + VECTOR_ID(free)(pths_rows); + MATRIX_T* temp = MATRIX_ID(alloc)(pths_idx->size1 + 1, pths_idx->size2); + MATRIX_ID(view) temp_subm = MATRIX_ID(submatrix)(temp, 0, 0, pths_idx->size1, pths_idx->size2); + MATRIX_ID(memcpy)(&temp_subm.matrix, pths_idx); + MATRIX_ID(free)(pths_idx); pths_idx = temp; - gsl_vector* last_row = gsl_vector_alloc(length(pb_temp)); - gsl_vector_set_all(last_row, (double)j); - gsl_matrix_set_row(pths_idx, pths_idx->size1 - 1, last_row); - gsl_vector_free(last_row); + VECTOR_T* last_row = VECTOR_ID(alloc)(length(pb_temp)); + VECTOR_ID(set_all)(last_row, (FP_T)j); + MATRIX_ID(set_row)(pths_idx, pths_idx->size1 - 1, last_row); + VECTOR_ID(free)(last_row); for (int i = 0; i < length(pb_temp); i++) { - npths_v.push_back(zeros_vector_double(q + 1)); - gsl_vector_view pths_idx_col_i = gsl_matrix_column(pths_idx, i); - gsl_vector_view npths_v_i_subv = gsl_vector_subvector(npths_v[npthscnt + i], 0, pths_idx->size1); - gsl_vector_memcpy(&npths_v_i_subv.vector, &pths_idx_col_i.vector); + npths_v.push_back(zeros_vector(q + 1)); + VECTOR_ID(view) pths_idx_col_i = MATRIX_ID(column)(pths_idx, i); + VECTOR_ID(view) npths_v_i_subv = VECTOR_ID(subvector)(npths_v[npthscnt + i], 0, pths_idx->size1); + VECTOR_ID(memcpy)(&npths_v_i_subv.vector, &pths_idx_col_i.vector); } - gsl_matrix_free(pths_idx); + MATRIX_ID(free)(pths_idx); // npthscnt = npthscnt+length(pb_temp); npthscnt += length(pb_temp); // Pq(1:N,j,q) = Pq(1:N,j,q)+(hist(pths(1,pb_temp),1:N))'; - gsl_vector_view pths_row_0 = gsl_matrix_row(pths, 0); - gsl_vector* pths_row_0_idx = ordinal_index(&pths_row_0.vector, pb_temp); - gsl_vector_free(pb_temp); - gsl_vector* centers = sequence_double(0, N - 1); - gsl_vector* hist_pths_idx = hist(pths_row_0_idx, centers); - gsl_vector_free(pths_row_0_idx); - gsl_vector_free(centers); - gsl_vector_view Pq_q_col_j = gsl_matrix_column(Pq[q], j); - gsl_vector_add(&Pq_q_col_j.vector, hist_pths_idx); - gsl_vector_free(hist_pths_idx); + VECTOR_ID(view) pths_row_0 = MATRIX_ID(row)(pths, 0); + VECTOR_T* pths_row_0_idx = ordinal_index(&pths_row_0.vector, pb_temp); + VECTOR_ID(free)(pb_temp); + VECTOR_T* centers = sequence(0, N - 1); + VECTOR_T* hist_pths_idx = hist(pths_row_0_idx, centers); + VECTOR_ID(free)(pths_row_0_idx); + VECTOR_ID(free)(centers); + VECTOR_ID(view) Pq_q_col_j = MATRIX_ID(column)(Pq[q], j); + VECTOR_ID(add)(&Pq_q_col_j.vector, hist_pths_idx); + VECTOR_ID(free)(hist_pths_idx); } } - gsl_vector_free(nendp); + VECTOR_ID(free)(nendp); } - gsl_vector_free(pb); + VECTOR_ID(free)(pb); } } - gsl_vector_free(endp); - gsl_matrix* npths = gsl_matrix_alloc(q + 1, npthscnt); + VECTOR_ID(free)(endp); + MATRIX_T* npths = MATRIX_ID(alloc)(q + 1, npthscnt); for (int i = 0; i < npthscnt; i++) { - gsl_matrix_set_col(npths, i, npths_v[i]); - gsl_vector_free(npths_v[i]); + MATRIX_ID(set_col)(npths, i, npths_v[i]); + VECTOR_ID(free)(npths_v[i]); } // if (savepths==1) @@ -195,41 +193,41 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* // allpths = [allpths; zeros(1,size(allpths,2))]; // allpths = [allpths npths(:,1:npthscnt)]; - gsl_matrix* temp = gsl_matrix_alloc((*allpths)->size1 + 1, (*allpths)->size2 + npthscnt); - gsl_matrix_set_all(temp, -1.0); - gsl_matrix_view temp_subm = gsl_matrix_submatrix(temp, 0, 0, (*allpths)->size1, (*allpths)->size2); - gsl_matrix_memcpy(&temp_subm.matrix, *allpths); - temp_subm = gsl_matrix_submatrix(temp, 0, (*allpths)->size2, (*allpths)->size1 + 1, npthscnt); - gsl_matrix_view npths_subm = gsl_matrix_submatrix(npths, 0, 0, npths->size1, npthscnt); - gsl_matrix_memcpy(&temp_subm.matrix, &npths_subm.matrix); - gsl_matrix_free(*allpths); + MATRIX_T* temp = MATRIX_ID(alloc)((*allpths)->size1 + 1, (*allpths)->size2 + npthscnt); + MATRIX_ID(set_all)(temp, -1.0); + MATRIX_ID(view) temp_subm = MATRIX_ID(submatrix)(temp, 0, 0, (*allpths)->size1, (*allpths)->size2); + MATRIX_ID(memcpy)(&temp_subm.matrix, *allpths); + temp_subm = MATRIX_ID(submatrix)(temp, 0, (*allpths)->size2, (*allpths)->size1 + 1, npthscnt); + MATRIX_ID(view) npths_subm = MATRIX_ID(submatrix)(npths, 0, 0, npths->size1, npthscnt); + MATRIX_ID(memcpy)(&temp_subm.matrix, &npths_subm.matrix); + MATRIX_ID(free)(*allpths); *allpths = temp; } // util(1:N,q) = util(1:N,q) + hist(reshape(npths,1,size(npths,1)*size(npths,2)),1:N)' - diag(Pq(:,:,q)); if (util != NULL) { - gsl_vector* reshape_npths = to_vector(npths); - gsl_vector* centers = sequence_double(0, N - 1); - gsl_vector* hist_reshape_npths = hist(reshape_npths, centers); - gsl_vector_free(reshape_npths); - gsl_vector_free(centers); - gsl_vector_view util_col_q = gsl_matrix_column(*util, q); - gsl_vector_add(&util_col_q.vector, hist_reshape_npths); - gsl_vector_free(hist_reshape_npths); - gsl_vector_view diag_Pq_q = gsl_matrix_diagonal(Pq[q]); - gsl_vector_sub(&util_col_q.vector, &diag_Pq_q.vector); + VECTOR_T* reshape_npths = to_vector(npths); + VECTOR_T* centers = sequence(0, N - 1); + VECTOR_T* hist_reshape_npths = hist(reshape_npths, centers); + VECTOR_ID(free)(reshape_npths); + VECTOR_ID(free)(centers); + VECTOR_ID(view) util_col_q = MATRIX_ID(column)(*util, q); + VECTOR_ID(add)(&util_col_q.vector, hist_reshape_npths); + VECTOR_ID(free)(hist_reshape_npths); + VECTOR_ID(view) diag_Pq_q = MATRIX_ID(diagonal)(Pq[q]); + VECTOR_ID(sub)(&util_col_q.vector, &diag_Pq_q.vector); } // pths = npths(:,npths(1,:)~=npths(q+1,:)); - gsl_vector* npths_rows = sequence_double(0, npths->size1 - 1); - gsl_vector_view npths_row_0 = gsl_matrix_row(npths, 0); - gsl_vector_view npths_row_q = gsl_matrix_row(npths, q); - gsl_vector* npths_cols = compare_elements(&npths_row_0.vector, fp_not_equal, &npths_row_q.vector); - gsl_matrix_free(pths); + VECTOR_T* npths_rows = sequence(0, npths->size1 - 1); + VECTOR_ID(view) npths_row_0 = MATRIX_ID(row)(npths, 0); + VECTOR_ID(view) npths_row_q = MATRIX_ID(row)(npths, q); + VECTOR_T* npths_cols = compare_elements(&npths_row_0.vector, fp_not_equal, &npths_row_q.vector); + MATRIX_ID(free)(pths); pths = ord_log_index(npths, npths_rows, npths_cols); - gsl_matrix_free(npths); - gsl_vector_free(npths_rows); - gsl_vector_free(npths_cols); + MATRIX_ID(free)(npths); + VECTOR_ID(free)(npths_rows); + VECTOR_ID(free)(npths_cols); // if (isempty(pths)) // ... @@ -238,9 +236,9 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* } } - gsl_matrix_free(_CIJ); + MATRIX_ID(free)(_CIJ); if (pths != NULL) { - gsl_matrix_free(pths); + MATRIX_ID(free)(pths); } // qstop = q; @@ -251,12 +249,12 @@ std::vector bct::findpaths(const gsl_matrix* CIJ, const gsl_vector* // tpath = sum(sum(sum(Pq))); // plq = reshape(sum(sum(Pq)),1,qmax) if (plq != NULL) { - *plq = gsl_vector_alloc(qmax + 1); - gsl_vector_set(*plq, 0, 0.0); + *plq = VECTOR_ID(alloc)(qmax + 1); + VECTOR_ID(set)(*plq, 0, 0.0); for (int i = 1; i <= qmax; i++) { - gsl_vector* sum_Pq_i = sum(Pq[i]); - gsl_vector_set(*plq, i, sum(sum_Pq_i)); - gsl_vector_free(sum_Pq_i); + VECTOR_T* sum_Pq_i = sum(Pq[i]); + VECTOR_ID(set)(*plq, i, sum(sum_Pq_i)); + VECTOR_ID(free)(sum_Pq_i); } } diff --git a/findwalks.cpp b/findwalks.cpp index fdf5a98..c038f60 100644 --- a/findwalks.cpp +++ b/findwalks.cpp @@ -1,31 +1,28 @@ #include "bct.h" -#include -#include -#include /* * Finds walks. Note that there is no twalk argument as its value may overflow * a C++ long. Wq (the main return) and wlq are indexed by path length. They * therefore contain no valid data at index 0. */ -std::vector bct::findwalks(const gsl_matrix* CIJ, gsl_vector** wlq) { +std::vector bct::findwalks(const MATRIX_T* CIJ, VECTOR_T** wlq) { if (safe_mode) check_status(CIJ, SQUARE, "findwalks"); - // CIJ = double(CIJ~=0); - gsl_matrix* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); + // CIJ = FP_T(CIJ~=0); + MATRIX_T* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); // N = size(CIJ,1); int N = CIJ->size1; // Wq = zeros(N,N,N); - std::vector Wq(N + 1); + std::vector Wq(N + 1); Wq[0] = NULL; for (int i = 1; i <= N; i++) { - Wq[i] = zeros_double(N, N); + Wq[i] = zeros(N, N); } // CIJpwr = CIJ; - gsl_matrix* _CIJpwr = copy(_CIJ); + MATRIX_T* _CIJpwr = copy(_CIJ); // Wq(:,:,1) = CIJ; Wq[1] = copy(_CIJ); @@ -34,26 +31,26 @@ std::vector bct::findwalks(const gsl_matrix* CIJ, gsl_vector** wlq) for (int q = 2; q <= N; q++) { // CIJpwr = CIJpwr*CIJ; - gsl_matrix* temp = mul(_CIJpwr, _CIJ); - gsl_matrix_free(_CIJpwr); + MATRIX_T* temp = mul(_CIJpwr, _CIJ); + MATRIX_ID(free)(_CIJpwr); _CIJpwr = temp; // Wq(:,:,q) = CIJpwr; Wq[q] = copy(_CIJpwr); } - gsl_matrix_free(_CIJ); - gsl_matrix_free(_CIJpwr); + MATRIX_ID(free)(_CIJ); + MATRIX_ID(free)(_CIJpwr); // twalk = sum(sum(sum(Wq))); // wlq = reshape(sum(sum(Wq)),1,N); if (wlq != NULL) { - *wlq = gsl_vector_alloc(N + 1); - gsl_vector_set(*wlq, 0, 0.0); + *wlq = VECTOR_ID(alloc)(N + 1); + VECTOR_ID(set)(*wlq, 0, 0.0); for (int i = 1; i <= N; i++) { - gsl_vector* sum_Wq_i = sum(Wq[i]); - gsl_vector_set(*wlq, i, sum(sum_Wq_i)); - gsl_vector_free(sum_Wq_i); + VECTOR_T* sum_Wq_i = sum(Wq[i]); + VECTOR_ID(set)(*wlq, i, sum(sum_Wq_i)); + VECTOR_ID(free)(sum_Wq_i); } } diff --git a/fve.cpp b/fve.cpp index 0fc40d4..59cc316 100644 --- a/fve.cpp +++ b/fve.cpp @@ -1,7 +1,6 @@ #include "bct.h" -#include -const double fve30[30 * 30] = { +const FP_T fve30[30 * 30] = { 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, @@ -34,7 +33,7 @@ const double fve30[30 * 30] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0 }; -const double fve32[32 * 32] = { +const FP_T fve32[32 * 32] = { 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, @@ -69,16 +68,16 @@ const double fve32[32 * 32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0 }; -gsl_matrix* bct::get_fve30() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(fve30, 30, 30); - gsl_matrix* m = gsl_matrix_alloc(30, 30); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_fve30() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(fve30, 30, 30); + MATRIX_T* m = MATRIX_ID(alloc)(30, 30); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } -gsl_matrix* bct::get_fve32() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(fve32, 32, 32); - gsl_matrix* m = gsl_matrix_alloc(32, 32); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_fve32() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(fve32, 32, 32); + MATRIX_T* m = MATRIX_ID(alloc)(32, 32); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } diff --git a/jdegree.cpp b/jdegree.cpp index 3a4f835..e63e3df 100644 --- a/jdegree.cpp +++ b/jdegree.cpp @@ -1,47 +1,45 @@ #include "bct.h" -#include -#include /* * Computes the joint degree distribution, a matrix in which the value of each * element (u, v) is the number of nodes with u outgoing connections and v * incoming connections. */ -gsl_matrix* bct::jdegree(const gsl_matrix* CIJ) { +MATRIX_T* bct::jdegree(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE, "jdegree"); - // CIJ = double(CIJ~=0); - gsl_matrix* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); + // CIJ = FP_T(CIJ~=0); + MATRIX_T* _CIJ = compare_elements(CIJ, fp_not_equal, 0.0); // N = size(CIJ,1); int N = _CIJ->size1; // id = sum(CIJ,1); - gsl_vector* id = sum(_CIJ, 1); + VECTOR_T* id = sum(_CIJ, 1); // od = sum(CIJ,2)'; - gsl_vector* od = sum(_CIJ, 2); - gsl_matrix_free(_CIJ); + VECTOR_T* od = sum(_CIJ, 2); + MATRIX_ID(free)(_CIJ); // szJ = max(max(id,od))+1; - double max_id = gsl_vector_max(id); - double max_od = gsl_vector_max(od); + FP_T max_id = VECTOR_ID(max)(id); + FP_T max_od = VECTOR_ID(max)(od); int szJ = (int)max(max_id, max_od) + 1; // J = zeros(szJ); - gsl_matrix* J = zeros_double(szJ); + MATRIX_T* J = zeros(szJ); // for i=1:N for (int i = 0; i < N; i++) { // J(id(i)+1,od(i)+1) = J(id(i)+1,od(i)+1) + 1; - int id_i = (int)gsl_vector_get(id, i); - int od_i = (int)gsl_vector_get(od, i); - gsl_matrix_set(J, id_i, od_i, gsl_matrix_get(J, id_i, od_i) + 1.0); + int id_i = (int)VECTOR_ID(get)(id, i); + int od_i = (int)VECTOR_ID(get)(od, i); + MATRIX_ID(set)(J, id_i, od_i, MATRIX_ID(get)(J, id_i, od_i) + 1.0); } - gsl_vector_free(id); - gsl_vector_free(od); + VECTOR_ID(free)(id); + VECTOR_ID(free)(od); return J; } @@ -49,10 +47,10 @@ gsl_matrix* bct::jdegree(const gsl_matrix* CIJ) { * Given a joint degree distribution matrix, returns the number of nodes with * in-degree = out-degree. */ -int bct::jdegree_bl(const gsl_matrix* J) { +int bct::jdegree_bl(const MATRIX_T* J) { // J_bl = sum(diag(J)); - gsl_vector_const_view diag_J = gsl_matrix_const_diagonal(J); + VECTOR_ID(const_view) diag_J = MATRIX_ID(const_diagonal)(J); return (int)sum(&diag_J.vector); } @@ -60,14 +58,14 @@ int bct::jdegree_bl(const gsl_matrix* J) { * Given a joint degree distribution matrix, returns the number of nodes with * in-degree > out-degree. */ -int bct::jdegree_id(const gsl_matrix* J) { +int bct::jdegree_id(const MATRIX_T* J) { // J_id = sum(sum(tril(J,-1))); - gsl_matrix* tril_J = tril(J, -1); - gsl_vector* sum_tril_J = sum(tril_J); + MATRIX_T* tril_J = tril(J, -1); + VECTOR_T* sum_tril_J = sum(tril_J); int J_id = (int)sum(sum_tril_J); - gsl_matrix_free(tril_J); - gsl_vector_free(sum_tril_J); + MATRIX_ID(free)(tril_J); + VECTOR_ID(free)(sum_tril_J); return J_id; } @@ -75,13 +73,13 @@ int bct::jdegree_id(const gsl_matrix* J) { * Given a joint degree distribution matrix, returns the number of nodes with * out-degree > in-degree. */ -int bct::jdegree_od(const gsl_matrix* J) { +int bct::jdegree_od(const MATRIX_T* J) { // J_od = sum(sum(triu(J,1))); - gsl_matrix* triu_J = triu(J, 1); - gsl_vector* sum_triu_J = sum(triu_J); + MATRIX_T* triu_J = triu(J, 1); + VECTOR_T* sum_triu_J = sum(triu_J); int J_od = (int)sum(sum_triu_J); - gsl_matrix_free(triu_J); - gsl_vector_free(sum_triu_J); + MATRIX_ID(free)(triu_J); + VECTOR_ID(free)(sum_triu_J); return J_od; } diff --git a/latmio_dir.cpp b/latmio_dir.cpp index 2c672ff..f3a3cb6 100644 --- a/latmio_dir.cpp +++ b/latmio_dir.cpp @@ -1,68 +1,65 @@ -#include "bct.h" #include -#include -#include -#include -#include + +#include "bct.h" /* * Returns a latticized graph with equivalent degree sequence to the original * weighted directed graph. On average, each edge is rewired ITER times. Out- * strength is preserved for weighted graphs, while in-strength is not. */ -gsl_matrix* bct::latmio_dir(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::latmio_dir(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | DIRECTED, "latmio_dir"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // n=length(R); int n = length(R); // D=zeros(n); - gsl_matrix* D = zeros_double(n); + MATRIX_T* D = zeros(n); // u=[0 min([mod(1:n-1,n);mod(n-1:-1:1,n)])]; - gsl_vector* seq1 = sequence_double(1, n - 1); - gsl_vector* seq2 = sequence_double(n - 1, -1, 1); - gsl_matrix* seq1_seq2 = concatenate_columns(seq1, seq2); - gsl_vector_free(seq1); - gsl_vector_free(seq2); - gsl_vector* min_seq1_seq2 = min(seq1_seq2); - gsl_matrix_free(seq1_seq2); - gsl_vector* u = concatenate(0.0, min_seq1_seq2); - gsl_vector_free(min_seq1_seq2); + VECTOR_T* seq1 = sequence(1, n - 1); + VECTOR_T* seq2 = sequence(n - 1, -1, 1); + MATRIX_T* seq1_seq2 = concatenate_columns(seq1, seq2); + VECTOR_ID(free)(seq1); + VECTOR_ID(free)(seq2); + VECTOR_T* min_seq1_seq2 = min(seq1_seq2); + MATRIX_ID(free)(seq1_seq2); + VECTOR_T* u = concatenate(0.0, min_seq1_seq2); + VECTOR_ID(free)(min_seq1_seq2); // for v=1:ceil(n/2) - for (int v = 1; v <= (int)std::ceil((double)n / 2.0); v++) { + for (int v = 1; v <= (int)std::ceil((FP_T)n / 2.0); v++) { // D(n-v+1,:)=u([v+1:n 1:v]); - gsl_vector* u_indices1 = sequence_double(v, n - 1); - gsl_vector* u_indices2 = sequence_double(0, v - 1); - gsl_vector* u_indices = concatenate(u_indices1, u_indices2); - gsl_vector_free(u_indices1); - gsl_vector_free(u_indices2); - gsl_vector* u_idx = ordinal_index(u, u_indices); - gsl_vector_free(u_indices); - gsl_matrix_set_row(D, n - v, u_idx); - gsl_vector_free(u_idx); + VECTOR_T* u_indices1 = sequence(v, n - 1); + VECTOR_T* u_indices2 = sequence(0, v - 1); + VECTOR_T* u_indices = concatenate(u_indices1, u_indices2); + VECTOR_ID(free)(u_indices1); + VECTOR_ID(free)(u_indices2); + VECTOR_T* u_idx = ordinal_index(u, u_indices); + VECTOR_ID(free)(u_indices); + MATRIX_ID(set_row)(D, n - v, u_idx); + VECTOR_ID(free)(u_idx); // D(v,:)=D(n-v+1,n:-1:1); - gsl_vector* D_rows = gsl_vector_alloc(1); - gsl_vector_set(D_rows, 0, (double)(n - v)); - gsl_vector* D_cols = sequence_double(n - 1, -1, 0); - gsl_matrix* D_idx = ordinal_index(D, D_rows, D_cols); - gsl_vector_free(D_rows); - gsl_vector_free(D_cols); - gsl_vector* D_idx_v = to_vector(D_idx); - gsl_matrix_free(D_idx); - gsl_matrix_set_row(D, v - 1, D_idx_v); - gsl_vector_free(D_idx_v); + VECTOR_T* D_rows = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(D_rows, 0, (FP_T)(n - v)); + VECTOR_T* D_cols = sequence(n - 1, -1, 0); + MATRIX_T* D_idx = ordinal_index(D, D_rows, D_cols); + VECTOR_ID(free)(D_rows); + VECTOR_ID(free)(D_cols); + VECTOR_T* D_idx_v = to_vector(D_idx); + MATRIX_ID(free)(D_idx); + MATRIX_ID(set_row)(D, v - 1, D_idx_v); + VECTOR_ID(free)(D_idx_v); } // [i j]=find(R); - gsl_matrix* find_R = find_ij(R); - gsl_vector_view i = gsl_matrix_column(find_R, 0); - gsl_vector_view j = gsl_matrix_column(find_R, 1); + MATRIX_T* find_R = find_ij(R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_R, 1); // K=length(i); int K = length(&i.vector); @@ -70,7 +67,7 @@ gsl_matrix* bct::latmio_dir(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -98,12 +95,12 @@ gsl_matrix* bct::latmio_dir(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -114,25 +111,25 @@ gsl_matrix* bct::latmio_dir(const gsl_matrix* R, int ITER) { } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if (D(a,b)+D(c,d))>=(D(a,d)+D(c,b)) - if (fp_greater_or_equal(gsl_matrix_get(D, a, b) + gsl_matrix_get(D, c, d), - gsl_matrix_get(D, a, d) + gsl_matrix_get(D, c, b))) { + if (fp_greater_or_equal(MATRIX_ID(get)(D, a, b) + MATRIX_ID(get)(D, c, d), + MATRIX_ID(get)(D, a, d) + MATRIX_ID(get)(D, c, b))) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -141,7 +138,7 @@ gsl_matrix* bct::latmio_dir(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(D); - gsl_matrix_free(find_R); + MATRIX_ID(free)(D); + MATRIX_ID(free)(find_R); return _R; } diff --git a/latmio_dir_connected.cpp b/latmio_dir_connected.cpp index 7bf36df..b208368 100644 --- a/latmio_dir_connected.cpp +++ b/latmio_dir_connected.cpp @@ -1,9 +1,6 @@ -#include "bct.h" #include -#include -#include -#include -#include + +#include "bct.h" /* * Returns a latticized graph with equivalent degree sequence to the original @@ -11,59 +8,59 @@ * edge is rewired ITER times. Out-strength is preserved for weighted graphs, * while in-strength is not. */ -gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::latmio_dir_connected(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | DIRECTED, "latmio_dir_connected"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // n=length(R); int n = length(R); // D=zeros(n); - gsl_matrix* D = zeros_double(n); + MATRIX_T* D = zeros(n); // u=[0 min([mod(1:n-1,n);mod(n-1:-1:1,n)])]; - gsl_vector* seq1 = sequence_double(1, n - 1); - gsl_vector* seq2 = sequence_double(n - 1, -1, 1); - gsl_matrix* seq1_seq2 = concatenate_columns(seq1, seq2); - gsl_vector_free(seq1); - gsl_vector_free(seq2); - gsl_vector* min_seq1_seq2 = min(seq1_seq2); - gsl_matrix_free(seq1_seq2); - gsl_vector* u = concatenate(0.0, min_seq1_seq2); - gsl_vector_free(min_seq1_seq2); + VECTOR_T* seq1 = sequence(1, n - 1); + VECTOR_T* seq2 = sequence(n - 1, -1, 1); + MATRIX_T* seq1_seq2 = concatenate_columns(seq1, seq2); + VECTOR_ID(free)(seq1); + VECTOR_ID(free)(seq2); + VECTOR_T* min_seq1_seq2 = min(seq1_seq2); + MATRIX_ID(free)(seq1_seq2); + VECTOR_T* u = concatenate(0.0, min_seq1_seq2); + VECTOR_ID(free)(min_seq1_seq2); // for v=1:ceil(n/2) - for (int v = 1; v <= (int)std::ceil((double)n / 2.0); v++) { + for (int v = 1; v <= (int)std::ceil((FP_T)n / 2.0); v++) { // D(n-v+1,:)=u([v+1:n 1:v]); - gsl_vector* u_indices1 = sequence_double(v, n - 1); - gsl_vector* u_indices2 = sequence_double(0, v - 1); - gsl_vector* u_indices = concatenate(u_indices1, u_indices2); - gsl_vector_free(u_indices1); - gsl_vector_free(u_indices2); - gsl_vector* u_idx = ordinal_index(u, u_indices); - gsl_vector_free(u_indices); - gsl_matrix_set_row(D, n - v, u_idx); - gsl_vector_free(u_idx); + VECTOR_T* u_indices1 = sequence(v, n - 1); + VECTOR_T* u_indices2 = sequence(0, v - 1); + VECTOR_T* u_indices = concatenate(u_indices1, u_indices2); + VECTOR_ID(free)(u_indices1); + VECTOR_ID(free)(u_indices2); + VECTOR_T* u_idx = ordinal_index(u, u_indices); + VECTOR_ID(free)(u_indices); + MATRIX_ID(set_row)(D, n - v, u_idx); + VECTOR_ID(free)(u_idx); // D(v,:)=D(n-v+1,n:-1:1); - gsl_vector* D_rows = gsl_vector_alloc(1); - gsl_vector_set(D_rows, 0, (double)(n - v)); - gsl_vector* D_cols = sequence_double(n - 1, -1, 0); - gsl_matrix* D_idx = ordinal_index(D, D_rows, D_cols); - gsl_vector_free(D_rows); - gsl_vector_free(D_cols); - gsl_vector* D_idx_v = to_vector(D_idx); - gsl_matrix_free(D_idx); - gsl_matrix_set_row(D, v - 1, D_idx_v); - gsl_vector_free(D_idx_v); + VECTOR_T* D_rows = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(D_rows, 0, (FP_T)(n - v)); + VECTOR_T* D_cols = sequence(n - 1, -1, 0); + MATRIX_T* D_idx = ordinal_index(D, D_rows, D_cols); + VECTOR_ID(free)(D_rows); + VECTOR_ID(free)(D_cols); + VECTOR_T* D_idx_v = to_vector(D_idx); + MATRIX_ID(free)(D_idx); + MATRIX_ID(set_row)(D, v - 1, D_idx_v); + VECTOR_ID(free)(D_idx_v); } // [i j]=find(R); - gsl_matrix* find_R = find_ij(R); - gsl_vector_view i = gsl_matrix_column(find_R, 0); - gsl_vector_view j = gsl_matrix_column(find_R, 1); + MATRIX_T* find_R = find_ij(R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_R, 1); // K=length(i); int K = length(&i.vector); @@ -71,7 +68,7 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -102,12 +99,12 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -118,95 +115,95 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if (D(a,b)+D(c,d))>=(D(a,d)+D(c,b)) - if (fp_greater_or_equal(gsl_matrix_get(D, a, b) + gsl_matrix_get(D, c, d), - gsl_matrix_get(D, a, d) + gsl_matrix_get(D, c, b))) { + if (fp_greater_or_equal(MATRIX_ID(get)(D, a, b) + MATRIX_ID(get)(D, c, d), + MATRIX_ID(get)(D, a, d) + MATRIX_ID(get)(D, c, b))) { // if ~(any([R(a,c) R(d,b) R(d,c)]) && any([R(c,a) R(b,d) R(b,a)])) - gsl_vector* _R_idx_1 = gsl_vector_alloc(3); - gsl_vector_set(_R_idx_1, 0, gsl_matrix_get(_R, a, c)); - gsl_vector_set(_R_idx_1, 1, gsl_matrix_get(_R, d, b)); - gsl_vector_set(_R_idx_1, 2, gsl_matrix_get(_R, d, c)); - gsl_vector* _R_idx_2 = gsl_vector_alloc(3); - gsl_vector_set(_R_idx_2, 0, gsl_matrix_get(_R, c, a)); - gsl_vector_set(_R_idx_2, 1, gsl_matrix_get(_R, b, d)); - gsl_vector_set(_R_idx_2, 2, gsl_matrix_get(_R, b, a)); + VECTOR_T* _R_idx_1 = VECTOR_ID(alloc)(3); + VECTOR_ID(set)(_R_idx_1, 0, MATRIX_ID(get)(_R, a, c)); + VECTOR_ID(set)(_R_idx_1, 1, MATRIX_ID(get)(_R, d, b)); + VECTOR_ID(set)(_R_idx_1, 2, MATRIX_ID(get)(_R, d, c)); + VECTOR_T* _R_idx_2 = VECTOR_ID(alloc)(3); + VECTOR_ID(set)(_R_idx_2, 0, MATRIX_ID(get)(_R, c, a)); + VECTOR_ID(set)(_R_idx_2, 1, MATRIX_ID(get)(_R, b, d)); + VECTOR_ID(set)(_R_idx_2, 2, MATRIX_ID(get)(_R, b, a)); bool any_R_idx_1_and_any_R_idx_2 = any(_R_idx_1) && any(_R_idx_2); - gsl_vector_free(_R_idx_1); - gsl_vector_free(_R_idx_2); + VECTOR_ID(free)(_R_idx_1); + VECTOR_ID(free)(_R_idx_2); if (!any_R_idx_1_and_any_R_idx_2) { // P=R([a c],:); - gsl_vector* _R_rows = gsl_vector_alloc(2); - gsl_vector_set(_R_rows, 0, (double)a); - gsl_vector_set(_R_rows, 1, (double)c); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* P = ordinal_index(_R, _R_rows, _R_cols); - gsl_vector_free(_R_rows); - gsl_vector_free(_R_cols); + VECTOR_T* _R_rows = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(_R_rows, 0, (FP_T)a); + VECTOR_ID(set)(_R_rows, 1, (FP_T)c); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* P = ordinal_index(_R, _R_rows, _R_cols); + VECTOR_ID(free)(_R_rows); + VECTOR_ID(free)(_R_cols); // P(1,b)=0; P(1,d)=1; - gsl_matrix_set(P, 0, b, 0.0); - gsl_matrix_set(P, 0, d, 1.0); + MATRIX_ID(set)(P, 0, b, 0.0); + MATRIX_ID(set)(P, 0, d, 1.0); // P(2,d)=0; P(2,b)=1; - gsl_matrix_set(P, 1, d, 0.0); - gsl_matrix_set(P, 1, b, 1.0); + MATRIX_ID(set)(P, 1, d, 0.0); + MATRIX_ID(set)(P, 1, b, 1.0); // PN=P; - gsl_matrix* PN = copy(P); + MATRIX_T* PN = copy(P); // PN(1,a)=1; PN(2,c)=1; - gsl_matrix_set(PN, 0, a, 1.0); - gsl_matrix_set(PN, 1, c, 1.0); + MATRIX_ID(set)(PN, 0, a, 1.0); + MATRIX_ID(set)(PN, 1, c, 1.0); // while 1 while (true) { // P(1,:)=any(R(P(1,:)~=0,:),1); - gsl_vector_view P_row_0 = gsl_matrix_row(P, 0); - gsl_vector* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); - gsl_vector_free(P_row_0_neq_0); + VECTOR_ID(view) P_row_0 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); + VECTOR_ID(free)(P_row_0_neq_0); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 0, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 0, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_0.vector); + VECTOR_ID(set_zero)(&P_row_0.vector); } // P(2,:)=any(R(P(2,:)~=0,:),1); - gsl_vector_view P_row_1 = gsl_matrix_row(P, 0); - gsl_vector* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); + VECTOR_ID(view) P_row_1 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); _R_idx = log_ord_index(_R, P_row_1_neq_0, _R_cols); - gsl_vector_free(P_row_1_neq_0); - gsl_vector_free(_R_cols); + VECTOR_ID(free)(P_row_1_neq_0); + VECTOR_ID(free)(_R_cols); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 1, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 1, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_1.vector); + VECTOR_ID(set_zero)(&P_row_1.vector); } // P=P.*(~PN); - gsl_matrix* not_PN = logical_not(PN); - gsl_matrix_mul_elements(P, not_PN); - gsl_matrix_free(not_PN); + MATRIX_T* not_PN = logical_not(PN); + MATRIX_ID(mul_elements)(P, not_PN); + MATRIX_ID(free)(not_PN); // PN=PN+P - gsl_matrix_add(PN, P); + MATRIX_ID(add)(PN, P); // if ~all(any(P,2)) - gsl_vector* any_P = any(P, 2); + VECTOR_T* any_P = any(P, 2); bool all_any_P = all(any_P); - gsl_vector_free(any_P); + VECTOR_ID(free)(any_P); if (!all_any_P) { // rewire=0; @@ -217,15 +214,15 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { } // elseif any(PN(1,[b c])) && any(PN(2,[d a])) - gsl_vector* PN_idx_1 = gsl_vector_alloc(2); - gsl_vector_set(PN_idx_1, 0, gsl_matrix_get(PN, 0, b)); - gsl_vector_set(PN_idx_1, 1, gsl_matrix_get(PN, 0, c)); - gsl_vector* PN_idx_2 = gsl_vector_alloc(2); - gsl_vector_set(PN_idx_2, 0, gsl_matrix_get(PN, 1, d)); - gsl_vector_set(PN_idx_2, 1, gsl_matrix_get(PN, 1, a)); + VECTOR_T* PN_idx_1 = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(PN_idx_1, 0, MATRIX_ID(get)(PN, 0, b)); + VECTOR_ID(set)(PN_idx_1, 1, MATRIX_ID(get)(PN, 0, c)); + VECTOR_T* PN_idx_2 = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(PN_idx_2, 0, MATRIX_ID(get)(PN, 1, d)); + VECTOR_ID(set)(PN_idx_2, 1, MATRIX_ID(get)(PN, 1, a)); bool any_PN_idx_1_and_any_PN_idx_2 = any(PN_idx_1) && any(PN_idx_2); - gsl_vector_free(PN_idx_1); - gsl_vector_free(PN_idx_2); + VECTOR_ID(free)(PN_idx_1); + VECTOR_ID(free)(PN_idx_2); if (any_PN_idx_1_and_any_PN_idx_2) { // break @@ -233,26 +230,26 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(P); - gsl_matrix_free(PN); + MATRIX_ID(free)(P); + MATRIX_ID(free)(PN); } // if rewire if (rewire) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -262,7 +259,7 @@ gsl_matrix* bct::latmio_dir_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(D); - gsl_matrix_free(find_R); + MATRIX_ID(free)(D); + MATRIX_ID(free)(find_R); return _R; } diff --git a/latmio_und.cpp b/latmio_und.cpp index d4ffa7a..193dafb 100644 --- a/latmio_und.cpp +++ b/latmio_und.cpp @@ -1,70 +1,67 @@ -#include "bct.h" #include -#include -#include -#include -#include + +#include "bct.h" /* * Returns a latticized graph with equivalent degree sequence to the original * weighted undirected graph. On average, each edge is rewired ITER time. * Strength distributions are not preserved for weighted graphs. */ -gsl_matrix* bct::latmio_und(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::latmio_und(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | UNDIRECTED, "latmio_und"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // n=length(R); int n = length(R); // D=zeros(n); - gsl_matrix* D = zeros_double(n); + MATRIX_T* D = zeros(n); // u=[0 min([mod(1:n-1,n);mod(n-1:-1:1,n)])]; - gsl_vector* seq1 = sequence_double(1, n - 1); - gsl_vector* seq2 = sequence_double(n - 1, -1, 1); - gsl_matrix* seq1_seq2 = concatenate_columns(seq1, seq2); - gsl_vector_free(seq1); - gsl_vector_free(seq2); - gsl_vector* min_seq1_seq2 = min(seq1_seq2); - gsl_matrix_free(seq1_seq2); - gsl_vector* u = concatenate(0.0, min_seq1_seq2); - gsl_vector_free(min_seq1_seq2); + VECTOR_T* seq1 = sequence(1, n - 1); + VECTOR_T* seq2 = sequence(n - 1, -1, 1); + MATRIX_T* seq1_seq2 = concatenate_columns(seq1, seq2); + VECTOR_ID(free)(seq1); + VECTOR_ID(free)(seq2); + VECTOR_T* min_seq1_seq2 = min(seq1_seq2); + MATRIX_ID(free)(seq1_seq2); + VECTOR_T* u = concatenate(0.0, min_seq1_seq2); + VECTOR_ID(free)(min_seq1_seq2); // for v=1:ceil(n/2) - for (int v = 1; v <= (int)std::ceil((double)n / 2.0); v++) { + for (int v = 1; v <= (int)std::ceil((FP_T)n / 2.0); v++) { // D(n-v+1,:)=u([v+1:n 1:v]); - gsl_vector* u_indices1 = sequence_double(v, n - 1); - gsl_vector* u_indices2 = sequence_double(0, v - 1); - gsl_vector* u_indices = concatenate(u_indices1, u_indices2); - gsl_vector_free(u_indices1); - gsl_vector_free(u_indices2); - gsl_vector* u_idx = ordinal_index(u, u_indices); - gsl_vector_free(u_indices); - gsl_matrix_set_row(D, n - v, u_idx); - gsl_vector_free(u_idx); + VECTOR_T* u_indices1 = sequence(v, n - 1); + VECTOR_T* u_indices2 = sequence(0, v - 1); + VECTOR_T* u_indices = concatenate(u_indices1, u_indices2); + VECTOR_ID(free)(u_indices1); + VECTOR_ID(free)(u_indices2); + VECTOR_T* u_idx = ordinal_index(u, u_indices); + VECTOR_ID(free)(u_indices); + MATRIX_ID(set_row)(D, n - v, u_idx); + VECTOR_ID(free)(u_idx); // D(v,:)=D(n-v+1,n:-1:1); - gsl_vector* D_rows = gsl_vector_alloc(1); - gsl_vector_set(D_rows, 0, (double)(n - v)); - gsl_vector* D_cols = sequence_double(n - 1, -1, 0); - gsl_matrix* D_idx = ordinal_index(D, D_rows, D_cols); - gsl_vector_free(D_rows); - gsl_vector_free(D_cols); - gsl_vector* D_idx_v = to_vector(D_idx); - gsl_matrix_free(D_idx); - gsl_matrix_set_row(D, v - 1, D_idx_v); - gsl_vector_free(D_idx_v); + VECTOR_T* D_rows = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(D_rows, 0, (FP_T)(n - v)); + VECTOR_T* D_cols = sequence(n - 1, -1, 0); + MATRIX_T* D_idx = ordinal_index(D, D_rows, D_cols); + VECTOR_ID(free)(D_rows); + VECTOR_ID(free)(D_cols); + VECTOR_T* D_idx_v = to_vector(D_idx); + MATRIX_ID(free)(D_idx); + MATRIX_ID(set_row)(D, v - 1, D_idx_v); + VECTOR_ID(free)(D_idx_v); } // [i j]=find(tril(R)); - gsl_matrix* tril_R = tril(R); - gsl_matrix* find_tril_R = find_ij(tril_R); - gsl_matrix_free(tril_R); - gsl_vector_view i = gsl_matrix_column(find_tril_R, 0); - gsl_vector_view j = gsl_matrix_column(find_tril_R, 1); + MATRIX_T* tril_R = tril(R); + MATRIX_T* find_tril_R = find_ij(tril_R); + MATRIX_ID(free)(tril_R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_tril_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_tril_R, 1); // K=length(i); int K = length(&i.vector); @@ -72,7 +69,7 @@ gsl_matrix* bct::latmio_und(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -100,12 +97,12 @@ gsl_matrix* bct::latmio_und(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -119,42 +116,42 @@ gsl_matrix* bct::latmio_und(const gsl_matrix* R, int ITER) { if (gsl_rng_uniform(rng) > 0.5) { // i(e2)=d; j(e2)=c; - gsl_vector_set(&i.vector, e2, (double)d); - gsl_vector_set(&j.vector, e2, (double)c); + VECTOR_ID(set)(&i.vector, e2, (FP_T)d); + VECTOR_ID(set)(&j.vector, e2, (FP_T)c); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if (D(a,b)+D(c,d))>=(D(a,d)+D(c,b)) - if (fp_greater_or_equal(gsl_matrix_get(D, a, b) + gsl_matrix_get(D, c, d), - gsl_matrix_get(D, a, d) + gsl_matrix_get(D, c, b))) { + if (fp_greater_or_equal(MATRIX_ID(get)(D, a, b) + MATRIX_ID(get)(D, c, d), + MATRIX_ID(get)(D, a, d) + MATRIX_ID(get)(D, c, b))) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(d,a)=R(b,a); R(b,a)=0; - gsl_matrix_set(_R, d, a, gsl_matrix_get(_R, b, a)); - gsl_matrix_set(_R, b, a, 0.0); + MATRIX_ID(set)(_R, d, a, MATRIX_ID(get)(_R, b, a)); + MATRIX_ID(set)(_R, b, a, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // R(b,c)=R(d,c); R(d,c)=0; - gsl_matrix_set(_R, b, c, gsl_matrix_get(_R, d, c)); - gsl_matrix_set(_R, d, c, 0.0); + MATRIX_ID(set)(_R, b, c, MATRIX_ID(get)(_R, d, c)); + MATRIX_ID(set)(_R, d, c, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -163,7 +160,7 @@ gsl_matrix* bct::latmio_und(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(D); - gsl_matrix_free(find_tril_R); + MATRIX_ID(free)(D); + MATRIX_ID(free)(find_tril_R); return _R; } diff --git a/latmio_und_connected.cpp b/latmio_und_connected.cpp index 62a590a..77d6fc5 100644 --- a/latmio_und_connected.cpp +++ b/latmio_und_connected.cpp @@ -1,9 +1,6 @@ -#include "bct.h" #include -#include -#include -#include -#include + +#include "bct.h" /* * Returns a latticized graph with equivalent degree sequence to the original @@ -11,61 +8,61 @@ * each edge is rewired ITER times. Strength distributions are not preserved * for weighted graphs. */ -gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::latmio_und_connected(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | UNDIRECTED, "latmio_und_connected"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // n=length(R); int n = length(R); // D=zeros(n); - gsl_matrix* D = zeros_double(n); + MATRIX_T* D = zeros(n); // u=[0 min([mod(1:n-1,n);mod(n-1:-1:1,n)])]; - gsl_vector* seq1 = sequence_double(1, n - 1); - gsl_vector* seq2 = sequence_double(n - 1, -1, 1); - gsl_matrix* seq1_seq2 = concatenate_columns(seq1, seq2); - gsl_vector_free(seq1); - gsl_vector_free(seq2); - gsl_vector* min_seq1_seq2 = min(seq1_seq2); - gsl_matrix_free(seq1_seq2); - gsl_vector* u = concatenate(0.0, min_seq1_seq2); - gsl_vector_free(min_seq1_seq2); + VECTOR_T* seq1 = sequence(1, n - 1); + VECTOR_T* seq2 = sequence(n - 1, -1, 1); + MATRIX_T* seq1_seq2 = concatenate_columns(seq1, seq2); + VECTOR_ID(free)(seq1); + VECTOR_ID(free)(seq2); + VECTOR_T* min_seq1_seq2 = min(seq1_seq2); + MATRIX_ID(free)(seq1_seq2); + VECTOR_T* u = concatenate(0.0, min_seq1_seq2); + VECTOR_ID(free)(min_seq1_seq2); // for v=1:ceil(n/2) - for (int v = 1; v <= (int)std::ceil((double)n / 2.0); v++) { + for (int v = 1; v <= (int)std::ceil((FP_T)n / 2.0); v++) { // D(n-v+1,:)=u([v+1:n 1:v]); - gsl_vector* u_indices1 = sequence_double(v, n - 1); - gsl_vector* u_indices2 = sequence_double(0, v - 1); - gsl_vector* u_indices = concatenate(u_indices1, u_indices2); - gsl_vector_free(u_indices1); - gsl_vector_free(u_indices2); - gsl_vector* u_idx = ordinal_index(u, u_indices); - gsl_vector_free(u_indices); - gsl_matrix_set_row(D, n - v, u_idx); - gsl_vector_free(u_idx); + VECTOR_T* u_indices1 = sequence(v, n - 1); + VECTOR_T* u_indices2 = sequence(0, v - 1); + VECTOR_T* u_indices = concatenate(u_indices1, u_indices2); + VECTOR_ID(free)(u_indices1); + VECTOR_ID(free)(u_indices2); + VECTOR_T* u_idx = ordinal_index(u, u_indices); + VECTOR_ID(free)(u_indices); + MATRIX_ID(set_row)(D, n - v, u_idx); + VECTOR_ID(free)(u_idx); // D(v,:)=D(n-v+1,n:-1:1); - gsl_vector* D_rows = gsl_vector_alloc(1); - gsl_vector_set(D_rows, 0, (double)(n - v)); - gsl_vector* D_cols = sequence_double(n - 1, -1, 0); - gsl_matrix* D_idx = ordinal_index(D, D_rows, D_cols); - gsl_vector_free(D_rows); - gsl_vector_free(D_cols); - gsl_vector* D_idx_v = to_vector(D_idx); - gsl_matrix_free(D_idx); - gsl_matrix_set_row(D, v - 1, D_idx_v); - gsl_vector_free(D_idx_v); + VECTOR_T* D_rows = VECTOR_ID(alloc)(1); + VECTOR_ID(set)(D_rows, 0, (FP_T)(n - v)); + VECTOR_T* D_cols = sequence(n - 1, -1, 0); + MATRIX_T* D_idx = ordinal_index(D, D_rows, D_cols); + VECTOR_ID(free)(D_rows); + VECTOR_ID(free)(D_cols); + VECTOR_T* D_idx_v = to_vector(D_idx); + MATRIX_ID(free)(D_idx); + MATRIX_ID(set_row)(D, v - 1, D_idx_v); + VECTOR_ID(free)(D_idx_v); } // [i j]=find(tril(R)); - gsl_matrix* tril_R = tril(R); - gsl_matrix* find_tril_R = find_ij(tril_R); - gsl_matrix_free(tril_R); - gsl_vector_view i = gsl_matrix_column(find_tril_R, 0); - gsl_vector_view j = gsl_matrix_column(find_tril_R, 1); + MATRIX_T* tril_R = tril(R); + MATRIX_T* find_tril_R = find_ij(tril_R); + MATRIX_ID(free)(tril_R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_tril_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_tril_R, 1); // K=length(i); int K = length(&i.vector); @@ -73,7 +70,7 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -104,12 +101,12 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -123,88 +120,88 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { if (gsl_rng_uniform(rng) > 0.5) { // i(e2)=d; j(e2)=c; - gsl_vector_set(&i.vector, e2, (double)d); - gsl_vector_set(&j.vector, e2, (double)c); + VECTOR_ID(set)(&i.vector, e2, (FP_T)d); + VECTOR_ID(set)(&j.vector, e2, (FP_T)c); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if (D(a,b)+D(c,d))>=(D(a,d)+D(c,b)) - if (fp_greater_or_equal(gsl_matrix_get(D, a, b) + gsl_matrix_get(D, c, d), - gsl_matrix_get(D, a, d) + gsl_matrix_get(D, c, b))) { + if (fp_greater_or_equal(MATRIX_ID(get)(D, a, b) + MATRIX_ID(get)(D, c, d), + MATRIX_ID(get)(D, a, d) + MATRIX_ID(get)(D, c, b))) { // if ~(R(a,c) || R(b,d)) - if (fp_zero(gsl_matrix_get(_R, a, c)) && fp_zero(gsl_matrix_get(_R, b, d))) { + if (fp_zero(MATRIX_ID(get)(_R, a, c)) && fp_zero(MATRIX_ID(get)(_R, b, d))) { // P=R([a d],:); - gsl_vector* _R_rows = gsl_vector_alloc(2); - gsl_vector_set(_R_rows, 0, (double)a); - gsl_vector_set(_R_rows, 1, (double)d); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* P = ordinal_index(_R, _R_rows, _R_cols); - gsl_vector_free(_R_rows); - gsl_vector_free(_R_cols); + VECTOR_T* _R_rows = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(_R_rows, 0, (FP_T)a); + VECTOR_ID(set)(_R_rows, 1, (FP_T)d); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* P = ordinal_index(_R, _R_rows, _R_cols); + VECTOR_ID(free)(_R_rows); + VECTOR_ID(free)(_R_cols); // P(1,b)=0; P(2,c)=0; - gsl_matrix_set(P, 0, b, 0.0); - gsl_matrix_set(P, 1, c, 0.0); + MATRIX_ID(set)(P, 0, b, 0.0); + MATRIX_ID(set)(P, 1, c, 0.0); // PN=P; - gsl_matrix* PN = copy(P); + MATRIX_T* PN = copy(P); // PN(:,d)=1; PN(:,a)=1; - gsl_vector_view PN_col_d = gsl_matrix_column(PN, d); - gsl_vector_set_all(&PN_col_d.vector, 1.0); - gsl_vector_view PN_col_a = gsl_matrix_column(PN, a); - gsl_vector_set_all(&PN_col_a.vector, 1.0); + VECTOR_ID(view) PN_col_d = MATRIX_ID(column)(PN, d); + VECTOR_ID(set_all)(&PN_col_d.vector, 1.0); + VECTOR_ID(view) PN_col_a = MATRIX_ID(column)(PN, a); + VECTOR_ID(set_all)(&PN_col_a.vector, 1.0); // while 1 while (true) { // P(1,:)=any(R(P(1,:)~=0,:),1); - gsl_vector_view P_row_0 = gsl_matrix_row(P, 0); - gsl_vector* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); - gsl_vector_free(P_row_0_neq_0); + VECTOR_ID(view) P_row_0 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); + VECTOR_ID(free)(P_row_0_neq_0); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 0, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 0, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_0.vector); + VECTOR_ID(set_zero)(&P_row_0.vector); } // P(2,:)=any(R(P(2,:)~=0,:),1); - gsl_vector_view P_row_1 = gsl_matrix_row(P, 0); - gsl_vector* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); + VECTOR_ID(view) P_row_1 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); _R_idx = log_ord_index(_R, P_row_1_neq_0, _R_cols); - gsl_vector_free(P_row_1_neq_0); - gsl_vector_free(_R_cols); + VECTOR_ID(free)(P_row_1_neq_0); + VECTOR_ID(free)(_R_cols); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 1, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 1, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_1.vector); + VECTOR_ID(set_zero)(&P_row_1.vector); } // P=P.*(~PN); - gsl_matrix* not_PN = logical_not(PN); - gsl_matrix_mul_elements(P, not_PN); - gsl_matrix_free(not_PN); + MATRIX_T* not_PN = logical_not(PN); + MATRIX_ID(mul_elements)(P, not_PN); + MATRIX_ID(free)(not_PN); // if ~all(any(P,2)) - gsl_vector* any_P = any(P, 2); + VECTOR_T* any_P = any(P, 2); bool all_any_P = all(any_P); - gsl_vector_free(any_P); + VECTOR_ID(free)(any_P); if (!all_any_P) { // rewire=0; @@ -215,13 +212,13 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { } // elseif any(any(P(:,[b c]))) - gsl_vector_view P_col_b = gsl_matrix_column(P, b); - gsl_vector_view P_col_c = gsl_matrix_column(P, c); - gsl_matrix* P_idx = concatenate_rows(&P_col_b.vector, &P_col_c.vector); - gsl_vector* any_P_idx = any(P_idx); - gsl_matrix_free(P_idx); + VECTOR_ID(view) P_col_b = MATRIX_ID(column)(P, b); + VECTOR_ID(view) P_col_c = MATRIX_ID(column)(P, c); + MATRIX_T* P_idx = concatenate_rows(&P_col_b.vector, &P_col_c.vector); + VECTOR_T* any_P_idx = any(P_idx); + MATRIX_ID(free)(P_idx); bool any_any_P_idx = any(any_P_idx); - gsl_vector_free(any_P_idx); + VECTOR_ID(free)(any_P_idx); if (any_any_P_idx) { // break @@ -229,37 +226,37 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { } // PN=PN+P; - gsl_matrix_add(PN, P); + MATRIX_ID(add)(PN, P); } - gsl_matrix_free(P); - gsl_matrix_free(PN); + MATRIX_ID(free)(P); + MATRIX_ID(free)(PN); } // if rewire if (rewire) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(d,a)=R(b,a); R(b,a)=0; - gsl_matrix_set(_R, d, a, gsl_matrix_get(_R, b, a)); - gsl_matrix_set(_R, b, a, 0.0); + MATRIX_ID(set)(_R, d, a, MATRIX_ID(get)(_R, b, a)); + MATRIX_ID(set)(_R, b, a, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // R(b,c)=R(d,c); R(d,c)=0; - gsl_matrix_set(_R, b, c, gsl_matrix_get(_R, d, c)); - gsl_matrix_set(_R, d, c, 0.0); + MATRIX_ID(set)(_R, b, c, MATRIX_ID(get)(_R, d, c)); + MATRIX_ID(set)(_R, d, c, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -269,7 +266,7 @@ gsl_matrix* bct::latmio_und_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(D); - gsl_matrix_free(find_tril_R); + MATRIX_ID(free)(D); + MATRIX_ID(free)(find_tril_R); return _R; } diff --git a/macaque.cpp b/macaque.cpp index 2357c4e..6abf03c 100644 --- a/macaque.cpp +++ b/macaque.cpp @@ -1,7 +1,6 @@ #include "bct.h" -#include -const double macaque47[47 * 47] = { +const FP_T macaque47[47 * 47] = { 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, @@ -51,7 +50,7 @@ const double macaque47[47 * 47] = { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0 }; -const double macaque71[71 * 71] = { +const FP_T macaque71[71 * 71] = { 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -125,16 +124,16 @@ const double macaque71[71 * 71] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0 }; -gsl_matrix* bct::get_macaque47() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(macaque47, 47, 47); - gsl_matrix* m = gsl_matrix_alloc(47, 47); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_macaque47() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(macaque47, 47, 47); + MATRIX_T* m = MATRIX_ID(alloc)(47, 47); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } -gsl_matrix* bct::get_macaque71() { - gsl_matrix_const_view mv = gsl_matrix_const_view_array(macaque71, 71, 71); - gsl_matrix* m = gsl_matrix_alloc(71, 71); - gsl_matrix_memcpy(m, &mv.matrix); +MATRIX_T* bct::get_macaque71() { + MATRIX_ID(const_view) mv = MATRIX_ID(const_view_array)(macaque71, 71, 71); + MATRIX_T* m = MATRIX_ID(alloc)(71, 71); + MATRIX_ID(memcpy)(m, &mv.matrix); return m; } diff --git a/make_motif34lib.cpp b/make_motif34lib.cpp index 96edb8a..5c629dc 100644 --- a/make_motif34lib.cpp +++ b/make_motif34lib.cpp @@ -1,9 +1,4 @@ #include "bct.h" -#include -#include -#include -#include -#include /* * Our implementation of the BCT motif library does not include Mn ("M as a @@ -19,26 +14,26 @@ void bct::set_motif_mode(motif_mode_enum motif_mode) { bct::motif_mode = motif_m /* * Constructs the three-node motif library. */ -gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { - static gsl_matrix* M = NULL; - static gsl_vector* _ID = NULL; - static gsl_vector* _N = NULL; +MATRIX_T* bct::motif3generate(VECTOR_T** ID, VECTOR_T** N) { + static MATRIX_T* M = NULL; + static VECTOR_T* _ID = NULL; + static VECTOR_T* _N = NULL; if (M == NULL) { // n=0; int n = -1; // M=false(54,6); - M = gsl_matrix_calloc(54, 6); + M = MATRIX_ID(calloc)(54, 6); // CL=zeros(54,6,'uint8'); - gsl_matrix* CL = zeros_double(54, 6); + MATRIX_T* CL = zeros(54, 6); // cl=zeros(1,6,'uint8'); - gsl_vector* cl = zeros_vector_double(6); + VECTOR_T* cl = zeros_vector(6); - double i_nondiag[] = { 1, 2, 3, 5, 6, 7 }; - gsl_vector_view i_nondiag_vv = gsl_vector_view_array(i_nondiag, 6); + FP_T i_nondiag[] = { 1, 2, 3, 5, 6, 7 }; + VECTOR_ID(view) i_nondiag_vv = VECTOR_ID(view_array)(i_nondiag, 6); // for i=0:2^6-1 for (int i = 0; i < 64; i++) { @@ -51,7 +46,7 @@ gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { // '0' ' ' m(3) ' ' m(5) ; // m(1) ' ' '0' ' ' m(6) ; // m(2) ' ' m(4) ' ' '0' ]); - gsl_matrix* G = gsl_matrix_calloc(3, 3); + MATRIX_T* G = MATRIX_ID(calloc)(3, 3); for (int i = 0; i < 6; i++) { int index = (int)i_nondiag[i]; if (m[i] == '1') { @@ -60,53 +55,53 @@ gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { } // Ko=sum(G,2); - gsl_vector* Ko = sum(G, 2); + VECTOR_T* Ko = sum(G, 2); // Ki=sum(G,1).'; - gsl_vector* Ki = sum(G, 1); + VECTOR_T* Ki = sum(G, 1); // if Ko+Ki, - gsl_vector* Ko_add_Ki = copy(Ko); - gsl_vector_add(Ko_add_Ki, Ki); + VECTOR_T* Ko_add_Ki = copy(Ko); + VECTOR_ID(add)(Ko_add_Ki, Ki); bool Ko_add_Ki_bool = to_bool(Ko_add_Ki); - gsl_vector_free(Ko_add_Ki); + VECTOR_ID(free)(Ko_add_Ki); if (Ko_add_Ki_bool) { // n=n+1; n++; // cl(:)=sortrows([Ko Ki]).'; - gsl_matrix* Ko_Ki = concatenate_rows(Ko, Ki); - gsl_matrix* Ko_Ki_sorted = sortrows(Ko_Ki); - gsl_matrix_free(Ko_Ki); - gsl_matrix* Ko_Ki_transpose = gsl_matrix_alloc(2, G->size1); - gsl_matrix_transpose_memcpy(Ko_Ki_transpose, Ko_Ki_sorted); - gsl_matrix_free(Ko_Ki_sorted); - gsl_vector_free(cl); + MATRIX_T* Ko_Ki = concatenate_rows(Ko, Ki); + MATRIX_T* Ko_Ki_sorted = sortrows(Ko_Ki); + MATRIX_ID(free)(Ko_Ki); + MATRIX_T* Ko_Ki_transpose = MATRIX_ID(alloc)(2, G->size1); + MATRIX_ID(transpose_memcpy)(Ko_Ki_transpose, Ko_Ki_sorted); + MATRIX_ID(free)(Ko_Ki_sorted); + VECTOR_ID(free)(cl); cl = to_vector(Ko_Ki_transpose); - gsl_matrix_free(Ko_Ki_transpose); + MATRIX_ID(free)(Ko_Ki_transpose); // CL(n,:)=cl; - gsl_matrix_set_row(CL, n, cl); + MATRIX_ID(set_row)(CL, n, cl); // M(n,:)=G([2:4 6:8]); - gsl_vector* G_nondiag = ordinal_index(G, &i_nondiag_vv.vector); - gsl_matrix_set_row(M, n, G_nondiag); - gsl_vector_free(G_nondiag); + VECTOR_T* G_nondiag = ordinal_index(G, &i_nondiag_vv.vector); + MATRIX_ID(set_row)(M, n, G_nondiag); + VECTOR_ID(free)(G_nondiag); } - gsl_matrix_free(G); - gsl_vector_free(Ko); - gsl_vector_free(Ki); + MATRIX_ID(free)(G); + VECTOR_ID(free)(Ko); + VECTOR_ID(free)(Ki); } - gsl_vector_free(cl); + VECTOR_ID(free)(cl); // [u1 u2 ID]=unique(CL,'rows'); - gsl_matrix* u1 = unique_rows(CL, "last", NULL, &_ID); - gsl_matrix_free(CL); - gsl_matrix_free(u1); - gsl_vector_add_constant(_ID, 1.0); + MATRIX_T* u1 = unique_rows(CL, "last", NULL, &_ID); + MATRIX_ID(free)(CL); + MATRIX_ID(free)(u1); + VECTOR_ID(add_constant)(_ID, 1.0); // id_mika= [1 3 4 6 7 8 11]; int id_mika[] = { 1, 3, 4, 6, 7, 8, 11 }; @@ -118,8 +113,8 @@ gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { if (motif_mode == SPORNS) { for (int i = 0; i < (int)_ID->size; i++) { for (int j = 0; j < 7; j++) { - if ((int)gsl_vector_get(_ID, i) == id_mika[j]) { - gsl_vector_set(_ID, i, id_olaf[j]); + if ((int)VECTOR_ID(get)(_ID, i) == id_mika[j]) { + VECTOR_ID(set)(_ID, i, id_olaf[j]); break; } } @@ -127,18 +122,20 @@ gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { } // [X ind]=sortrows(ID); - gsl_vector* ind_v; - gsl_vector* X = sortrows(_ID, &ind_v); - gsl_vector_free(X); + VECTOR_T* ind_v; + VECTOR_T* X = sortrows(_ID, &ind_v); + VECTOR_ID(free)(X); gsl_permutation* ind = to_permutation(ind_v); - gsl_vector_free(ind_v); + VECTOR_ID(free)(ind_v); // ID=ID(ind,:); - gsl_permute_vector(ind, _ID); + VECTOR_T* _ID_permuted = permute(ind, _ID); + VECTOR_ID(free)(_ID); + _ID = _ID_permuted; // M=M(ind,:); - gsl_matrix* M_permuted = permute_rows(ind, M); - gsl_matrix_free(M); + MATRIX_T* M_permuted = permute_rows(ind, M); + MATRIX_ID(free)(M); M = M_permuted; gsl_permutation_free(ind); @@ -158,26 +155,26 @@ gsl_matrix* bct::motif3generate(gsl_vector** ID, gsl_vector** N) { /* * Constructs the four-node motif library. */ -gsl_matrix* bct::motif4generate(gsl_vector** ID, gsl_vector** N) { - static gsl_matrix* M = NULL; - static gsl_vector* _ID = NULL; - static gsl_vector* _N = NULL; +MATRIX_T* bct::motif4generate(VECTOR_T** ID, VECTOR_T** N) { + static MATRIX_T* M = NULL; + static VECTOR_T* _ID = NULL; + static VECTOR_T* _N = NULL; if (M == NULL) { // n=0; int n = -1; // M=false(3834,12); - M = gsl_matrix_calloc(3834, 12); + M = MATRIX_ID(calloc)(3834, 12); // CL=zeros(3834,16,'uint8'); - gsl_matrix* CL = zeros_double(3834, 16); + MATRIX_T* CL = zeros(3834, 16); // cl=zeros(1,16,'uint8'); - gsl_vector* cl = zeros_vector_double(16); + VECTOR_T* cl = zeros_vector(16); - double i_nondiag[] = { 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14 }; - gsl_vector_view i_nondiag_vv = gsl_vector_view_array(i_nondiag, 12); + FP_T i_nondiag[] = { 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14 }; + VECTOR_ID(view) i_nondiag_vv = VECTOR_ID(view_array)(i_nondiag, 12); // for i=0:2^12-1 for (int i = 0; i < 4096; i++) { @@ -191,7 +188,7 @@ gsl_matrix* bct::motif4generate(gsl_vector** ID, gsl_vector** N) { // m(1) ' ' '0' ' ' m(8) ' ' m(11) ; // m(2) ' ' m(5) ' ' '0' ' ' m(12) ; // m(3) ' ' m(6) ' ' m(9) ' ' '0' ]); - gsl_matrix* G = gsl_matrix_calloc(4, 4); + MATRIX_T* G = MATRIX_ID(calloc)(4, 4); for (int i = 0; i < 12; i++) { int index = (int)i_nondiag[i]; if (m[i] == '1') { @@ -200,110 +197,112 @@ gsl_matrix* bct::motif4generate(gsl_vector** ID, gsl_vector** N) { } // Gs=G+G.'; - gsl_matrix* Gs = gsl_matrix_alloc(4, 4); - gsl_matrix_transpose_memcpy(Gs, G); - gsl_matrix_add(Gs, G); + MATRIX_T* Gs = MATRIX_ID(alloc)(4, 4); + MATRIX_ID(transpose_memcpy)(Gs, G); + MATRIX_ID(add)(Gs, G); // v=Gs(1,:); - gsl_vector* v = gsl_vector_alloc(4); - gsl_matrix_get_row(v, Gs, 0); + VECTOR_T* v = VECTOR_ID(alloc)(4); + MATRIX_ID(get_row)(v, Gs, 0); // for j=1:2, for (int j = 1; j <= 2; j++) { // v=any(Gs(v~=0,:),1)+v; - gsl_vector* v_neq_0 = compare_elements(v, fp_not_equal, 0.0); - gsl_vector* Gs_cols = sequence_double(0, Gs->size2 - 1); - gsl_matrix* Gs_idx = log_ord_index(Gs, v_neq_0, Gs_cols); - gsl_vector_free(v_neq_0); - gsl_vector_free(Gs_cols); + VECTOR_T* v_neq_0 = compare_elements(v, fp_not_equal, 0.0); + VECTOR_T* Gs_cols = sequence(0, Gs->size2 - 1); + MATRIX_T* Gs_idx = log_ord_index(Gs, v_neq_0, Gs_cols); + VECTOR_ID(free)(v_neq_0); + VECTOR_ID(free)(Gs_cols); if (Gs_idx != NULL) { - gsl_vector* any_Gs_idx = any(Gs_idx, 1); - gsl_vector_add(v, any_Gs_idx); - gsl_matrix_free(Gs_idx); - gsl_vector_free(any_Gs_idx); + VECTOR_T* any_Gs_idx = any(Gs_idx, 1); + VECTOR_ID(add)(v, any_Gs_idx); + MATRIX_ID(free)(Gs_idx); + VECTOR_ID(free)(any_Gs_idx); } } - gsl_matrix_free(Gs); + MATRIX_ID(free)(Gs); // if v bool v_bool = to_bool(v); - gsl_vector_free(v); + VECTOR_ID(free)(v); if (v_bool) { // n=n+1; n++; // G2=(G*G)~=0; - gsl_matrix* G_mul_G = mul(G, G); - gsl_matrix* G2 = compare_elements(G_mul_G, fp_not_equal, 0.0); - gsl_matrix_free(G_mul_G); + MATRIX_T* G_mul_G = mul(G, G); + MATRIX_T* G2 = compare_elements(G_mul_G, fp_not_equal, 0.0); + MATRIX_ID(free)(G_mul_G); // Ko=sum(G,2); - gsl_vector* Ko = sum(G, 2); + VECTOR_T* Ko = sum(G, 2); // Ki=sum(G,1).'; - gsl_vector* Ki = sum(G, 1); + VECTOR_T* Ki = sum(G, 1); // Ko2=sum(G2,2); - gsl_vector* Ko2 = sum(G2, 2); + VECTOR_T* Ko2 = sum(G2, 2); // Ki2=sum(G2,1).'; - gsl_vector* Ki2 = sum(G2, 1); + VECTOR_T* Ki2 = sum(G2, 1); // cl(:)=sortrows([Ki Ko Ki2 Ko2]).'; - gsl_matrix* Ki_Ko = concatenate_rows(Ki, Ko); - gsl_vector_free(Ki); - gsl_vector_free(Ko); - gsl_matrix* Ki_Ko_Ki2 = concatenate_rows(Ki_Ko, Ki2); - gsl_vector_free(Ki2); - gsl_matrix_free(Ki_Ko); - gsl_matrix* Ki_Ko_Ki2_Ko2 = concatenate_rows(Ki_Ko_Ki2, Ko2); - gsl_vector_free(Ko2); - gsl_matrix_free(Ki_Ko_Ki2); - gsl_matrix* Ks_sorted = sortrows(Ki_Ko_Ki2_Ko2); - gsl_matrix_free(Ki_Ko_Ki2_Ko2); - gsl_matrix* Ks_transpose = gsl_matrix_alloc(4, G->size1); - gsl_matrix_transpose_memcpy(Ks_transpose, Ks_sorted); - gsl_matrix_free(Ks_sorted); - gsl_vector_free(cl); + MATRIX_T* Ki_Ko = concatenate_rows(Ki, Ko); + VECTOR_ID(free)(Ki); + VECTOR_ID(free)(Ko); + MATRIX_T* Ki_Ko_Ki2 = concatenate_rows(Ki_Ko, Ki2); + VECTOR_ID(free)(Ki2); + MATRIX_ID(free)(Ki_Ko); + MATRIX_T* Ki_Ko_Ki2_Ko2 = concatenate_rows(Ki_Ko_Ki2, Ko2); + VECTOR_ID(free)(Ko2); + MATRIX_ID(free)(Ki_Ko_Ki2); + MATRIX_T* Ks_sorted = sortrows(Ki_Ko_Ki2_Ko2); + MATRIX_ID(free)(Ki_Ko_Ki2_Ko2); + MATRIX_T* Ks_transpose = MATRIX_ID(alloc)(4, G->size1); + MATRIX_ID(transpose_memcpy)(Ks_transpose, Ks_sorted); + MATRIX_ID(free)(Ks_sorted); + VECTOR_ID(free)(cl); cl = to_vector(Ks_transpose); - gsl_matrix_free(Ks_transpose); + MATRIX_ID(free)(Ks_transpose); // CL(n,:)=cl; - gsl_matrix_set_row(CL, n, cl); + MATRIX_ID(set_row)(CL, n, cl); // M(n,:)=G([2:5 7:10 12:15]); - gsl_vector* G_nondiag = ordinal_index(G, &i_nondiag_vv.vector); - gsl_matrix_set_row(M, n, G_nondiag); - gsl_vector_free(G_nondiag); + VECTOR_T* G_nondiag = ordinal_index(G, &i_nondiag_vv.vector); + MATRIX_ID(set_row)(M, n, G_nondiag); + VECTOR_ID(free)(G_nondiag); } - gsl_matrix_free(G); + MATRIX_ID(free)(G); } - gsl_vector_free(cl); + VECTOR_ID(free)(cl); // [u1 u2 ID]=unique(CL,'rows'); - gsl_matrix* u1 = unique_rows(CL, "last", NULL, &_ID); - gsl_matrix_free(CL); - gsl_matrix_free(u1); - gsl_vector_add_constant(_ID, 1.0); + MATRIX_T* u1 = unique_rows(CL, "last", NULL, &_ID); + MATRIX_ID(free)(CL); + MATRIX_ID(free)(u1); + VECTOR_ID(add_constant)(_ID, 1.0); // [X ind]=sortrows(ID); - gsl_vector* ind_v; - gsl_vector* X = sortrows(_ID, &ind_v); - gsl_vector_free(X); + VECTOR_T* ind_v; + VECTOR_T* X = sortrows(_ID, &ind_v); + VECTOR_ID(free)(X); gsl_permutation* ind = to_permutation(ind_v); - gsl_vector_free(ind_v); + VECTOR_ID(free)(ind_v); // ID=ID(ind,:); - gsl_permute_vector(ind, _ID); + VECTOR_T* _ID_permuted = permute(ind, _ID); + VECTOR_ID(free)(_ID); + _ID = _ID_permuted; // M=M(ind,:); - gsl_matrix* M_permuted = permute_rows(ind, M); - gsl_matrix_free(M); + MATRIX_T* M_permuted = permute_rows(ind, M); + MATRIX_ID(free)(M); M = M_permuted; gsl_permutation_free(ind); diff --git a/makeevenCIJ.cpp b/makeevenCIJ.cpp index f479886..6e4405b 100644 --- a/makeevenCIJ.cpp +++ b/makeevenCIJ.cpp @@ -1,60 +1,58 @@ -#include "bct.h" #include -#include -#include -#include + +#include "bct.h" /* * Generates a random directed binary graph with equal-sized clusters placed on * the diagonal and the remaining connections distributed randomly among them. * N must be a power of 2, and the cluster size is given by (2 ^ sz_cl). */ -gsl_matrix* bct::makeevenCIJ(int N, int K, int sz_cl) { +MATRIX_T* bct::makeevenCIJ(int N, int K, int sz_cl) { // mx_lvl = floor(log2(N)); - int mx_lvl = (int)std::floor(std::log((double)N) / std::log(2.0)); + int mx_lvl = (int)std::floor(std::log((FP_T)N) / std::log(2.0)); // sz_cl = sz_cl-1; sz_cl--; // t = ones(2).*2; - gsl_matrix* t = gsl_matrix_alloc(2, 2); - gsl_matrix_set_all(t, 2.0); + MATRIX_T* t = MATRIX_ID(alloc)(2, 2); + MATRIX_ID(set_all)(t, 2.0); // Nlvl = 2^mx_lvl; - double Nlvl = std::pow(2.0, mx_lvl); + FP_T Nlvl = std::pow(2.0, mx_lvl); // N = Nlvl; N = (int)Nlvl; - gsl_matrix* CIJ = NULL; + MATRIX_T* CIJ = NULL; // for lvl=1:mx_lvl-1 for (int lvl = 1; lvl <= mx_lvl - 1; lvl++) { // CIJ = ones(2^(lvl+1),2^(lvl+1)); int n = (int)std::pow(2.0, lvl + 1); - CIJ = ones_double(n, n); + CIJ = ones(n, n); // group1 = [1:size(CIJ,1)/2]; - gsl_vector* group1 = sequence_double(0, n / 2 - 1); + VECTOR_T* group1 = sequence(0, n / 2 - 1); // group2 = [size(CIJ,1)/2+1:size(CIJ,1)]; - gsl_vector* group2 = sequence_double(n / 2, n - 1); + VECTOR_T* group2 = sequence(n / 2, n - 1); // CIJ(group1,group1) = t; ordinal_index_assign(CIJ, group1, group1, t); - gsl_vector_free(group1); + VECTOR_ID(free)(group1); // CIJ(group2,group2) = t; ordinal_index_assign(CIJ, group2, group2, t); - gsl_vector_free(group2); + VECTOR_ID(free)(group2); // CIJ = CIJ+ones(size(CIJ,1),size(CIJ,1)); - gsl_matrix_add_constant(CIJ, 1.0); + MATRIX_ID(add_constant)(CIJ, 1.0); // t = CIJ; - gsl_matrix_free(t); + MATRIX_ID(free)(t); t = CIJ; } @@ -62,19 +60,19 @@ gsl_matrix* bct::makeevenCIJ(int N, int K, int sz_cl) { int s = CIJ->size1; // CIJ = CIJ-ones(s,s)-mx_lvl.*eye(s); - gsl_matrix_add_constant(CIJ, -1.0); - gsl_matrix* mx_lvl_mul_eye_s = eye_double(s); - gsl_matrix_scale(mx_lvl_mul_eye_s, (double)mx_lvl); - gsl_matrix_sub(CIJ, mx_lvl_mul_eye_s); - gsl_matrix_free(mx_lvl_mul_eye_s); + MATRIX_ID(add_constant)(CIJ, -1.0); + MATRIX_T* mx_lvl_mul_eye_s = eye(s); + MATRIX_ID(scale)(mx_lvl_mul_eye_s, (FP_T)mx_lvl); + MATRIX_ID(sub)(CIJ, mx_lvl_mul_eye_s); + MATRIX_ID(free)(mx_lvl_mul_eye_s); // CIJp = (CIJ>=(mx_lvl-sz_cl)); - gsl_matrix* CIJp = compare_elements(CIJ, fp_greater_or_equal, (double)(mx_lvl - sz_cl)); - gsl_matrix_free(CIJ); + MATRIX_T* CIJp = compare_elements(CIJ, fp_greater_or_equal, (FP_T)(mx_lvl - sz_cl)); + MATRIX_ID(free)(CIJ); // CIJc = (CIJp==1); - gsl_matrix* CIJc = compare_elements(CIJp, fp_equal, 1.0); - gsl_matrix_free(CIJp); + MATRIX_T* CIJc = compare_elements(CIJp, fp_equal, 1.0); + MATRIX_ID(free)(CIJp); // remK = K-nnz(CIJc); int remK = K - nnz(CIJc); @@ -82,44 +80,44 @@ gsl_matrix* bct::makeevenCIJ(int N, int K, int sz_cl) { if (remK > 0) { // [a,b] = find(~(CIJc+eye(N))); - gsl_matrix* CIJc_add_eye_N = copy(CIJc); - gsl_matrix* eye_N = eye_double(N); - gsl_matrix_add(CIJc_add_eye_N, eye_N); - gsl_matrix_free(eye_N); - gsl_matrix* not_CIJc_add_eye_N = logical_not(CIJc_add_eye_N); - gsl_matrix_free(CIJc_add_eye_N); - gsl_matrix* find_not_CIJc_add_eye_N = find_ij(not_CIJc_add_eye_N); - gsl_matrix_free(not_CIJc_add_eye_N); - gsl_vector_view a = gsl_matrix_column(find_not_CIJc_add_eye_N, 0); - gsl_vector_view b = gsl_matrix_column(find_not_CIJc_add_eye_N, 1); + MATRIX_T* CIJc_add_eye_N = copy(CIJc); + MATRIX_T* eye_N = eye(N); + MATRIX_ID(add)(CIJc_add_eye_N, eye_N); + MATRIX_ID(free)(eye_N); + MATRIX_T* not_CIJc_add_eye_N = logical_not(CIJc_add_eye_N); + MATRIX_ID(free)(CIJc_add_eye_N); + MATRIX_T* find_not_CIJc_add_eye_N = find_ij(not_CIJc_add_eye_N); + MATRIX_ID(free)(not_CIJc_add_eye_N); + VECTOR_ID(view) a = MATRIX_ID(column)(find_not_CIJc_add_eye_N, 0); + VECTOR_ID(view) b = MATRIX_ID(column)(find_not_CIJc_add_eye_N, 1); // rp = randperm(length(a)); gsl_permutation* rp = randperm(length(&a.vector)); - gsl_vector* rp_v = to_vector_double(rp); + VECTOR_T* rp_v = to_vector(rp); gsl_permutation_free(rp); - gsl_vector_view rp_subv = gsl_vector_subvector(rp_v, 0, remK); + VECTOR_ID(view) rp_subv = VECTOR_ID(subvector)(rp_v, 0, remK); // a = a(rp(1:remK)); - gsl_vector* a_rp_subv = ordinal_index(&a.vector, &rp_subv.vector); - gsl_vector* ab_indices = sequence_double(0, remK - 1); + VECTOR_T* a_rp_subv = ordinal_index(&a.vector, &rp_subv.vector); + VECTOR_T* ab_indices = sequence(0, remK - 1); ordinal_index_assign(&a.vector, ab_indices, a_rp_subv); - gsl_vector_free(a_rp_subv); + VECTOR_ID(free)(a_rp_subv); // b = b(rp(1:remK)); - gsl_vector* b_rp_subv = ordinal_index(&b.vector, &rp_subv.vector); - gsl_vector_free(rp_v); + VECTOR_T* b_rp_subv = ordinal_index(&b.vector, &rp_subv.vector); + VECTOR_ID(free)(rp_v); ordinal_index_assign(&b.vector, ab_indices, b_rp_subv); - gsl_vector_free(ab_indices); - gsl_vector_free(b_rp_subv); + VECTOR_ID(free)(ab_indices); + VECTOR_ID(free)(b_rp_subv); // for i=1:remK for (int i = 0; i < remK; i++) { // CIJc(a(i),b(i)) = 1; - gsl_matrix_set(CIJc, (int)gsl_vector_get(&a.vector, i), (int)gsl_vector_get(&b.vector, i), 1.0); + MATRIX_ID(set)(CIJc, (int)VECTOR_ID(get)(&a.vector, i), (int)VECTOR_ID(get)(&b.vector, i), 1.0); } - gsl_matrix_free(find_not_CIJc_add_eye_N); + MATRIX_ID(free)(find_not_CIJc_add_eye_N); } // CIJ = CIJc; diff --git a/makefractalCIJ.cpp b/makefractalCIJ.cpp index f56453a..8cbe174 100644 --- a/makefractalCIJ.cpp +++ b/makefractalCIJ.cpp @@ -1,7 +1,6 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Generates a random directed binary graph with a hierarchical (fractal) @@ -9,11 +8,11 @@ * (1 / (E ^ n)), where n is the hierarchical level index. Cluster size is * given by (2 ^ sz_cl). */ -gsl_matrix* bct::makefractalCIJ(int mx_lvl, double E, int sz_cl, int* K) { +MATRIX_T* bct::makefractalCIJ(int mx_lvl, FP_T E, int sz_cl, int* K) { // t = ones(2).*2; - gsl_matrix* t = gsl_matrix_alloc(2, 2); - gsl_matrix_set_all(t, 2.0); + MATRIX_T* t = MATRIX_ID(alloc)(2, 2); + MATRIX_ID(set_all)(t, 2.0); // N = 2^mx_lvl; int N = (int)std::pow(2.0, mx_lvl); @@ -21,34 +20,34 @@ gsl_matrix* bct::makefractalCIJ(int mx_lvl, double E, int sz_cl, int* K) { // sz_cl = sz_cl-1; sz_cl--; - gsl_matrix* CIJ = NULL; + MATRIX_T* CIJ = NULL; // for lvl=1:mx_lvl-1 for (int lvl = 1; lvl <= mx_lvl - 1; lvl++) { // CIJ = ones(2^(lvl+1),2^(lvl+1)); int n = (int)std::pow(2.0, lvl + 1); - CIJ = ones_double(n, n); + CIJ = ones(n, n); // group1 = [1:size(CIJ,1)/2]; - gsl_vector* group1 = sequence_double(0, n / 2 - 1); + VECTOR_T* group1 = sequence(0, n / 2 - 1); // group2 = [size(CIJ,1)/2+1:size(CIJ,1)]; - gsl_vector* group2 = sequence_double(n / 2, n - 1); + VECTOR_T* group2 = sequence(n / 2, n - 1); // CIJ(group1,group1) = t; ordinal_index_assign(CIJ, group1, group1, t); - gsl_vector_free(group1); + VECTOR_ID(free)(group1); // CIJ(group2,group2) = t; ordinal_index_assign(CIJ, group2, group2, t); - gsl_vector_free(group2); + VECTOR_ID(free)(group2); // CIJ = CIJ+ones(size(CIJ,1),size(CIJ,1)); - gsl_matrix_add_constant(CIJ, 1.0); + MATRIX_ID(add_constant)(CIJ, 1.0); // t = CIJ; - gsl_matrix_free(t); + MATRIX_ID(free)(t); t = CIJ; } @@ -56,49 +55,49 @@ gsl_matrix* bct::makefractalCIJ(int mx_lvl, double E, int sz_cl, int* K) { int s = CIJ->size1; // CIJ = CIJ-ones(s,s)-mx_lvl.*eye(s); - gsl_matrix_add_constant(CIJ, -1.0); - gsl_matrix* mx_lvl_mul_eye_s = eye_double(s); - gsl_matrix_scale(mx_lvl_mul_eye_s, (double)mx_lvl); - gsl_matrix_sub(CIJ, mx_lvl_mul_eye_s); - gsl_matrix_free(mx_lvl_mul_eye_s); + MATRIX_ID(add_constant)(CIJ, -1.0); + MATRIX_T* mx_lvl_mul_eye_s = eye(s); + MATRIX_ID(scale)(mx_lvl_mul_eye_s, (FP_T)mx_lvl); + MATRIX_ID(sub)(CIJ, mx_lvl_mul_eye_s); + MATRIX_ID(free)(mx_lvl_mul_eye_s); // ee = mx_lvl-CIJ-sz_cl; - gsl_matrix* ee = copy(CIJ); - gsl_matrix_scale(ee, -1.0); - gsl_matrix_add_constant(ee, (double)(mx_lvl - sz_cl)); + MATRIX_T* ee = copy(CIJ); + MATRIX_ID(scale)(ee, -1.0); + MATRIX_ID(add_constant)(ee, (FP_T)(mx_lvl - sz_cl)); // ee = (ee>0).*ee; - gsl_matrix* temp = compare_elements(ee, fp_greater, 0.0); - gsl_matrix_mul_elements(temp, ee); - gsl_matrix_free(ee); + MATRIX_T* temp = compare_elements(ee, fp_greater, 0.0); + MATRIX_ID(mul_elements)(temp, ee); + MATRIX_ID(free)(ee); ee = temp; // prob = (1./(E.^ee)).*(ones(s,s)-eye(s)); - gsl_matrix* E_m = gsl_matrix_alloc(s, s); - gsl_matrix_set_all(E_m, E); - gsl_matrix* neg_ee = copy(ee); - gsl_matrix_scale(neg_ee, -1.0); - gsl_matrix* prob = pow_elements(E_m, neg_ee); - gsl_matrix_free(E_m); - gsl_matrix_free(neg_ee); - gsl_matrix* ones_s_sub_eye_s = ones_double(s, s); - gsl_matrix* eye_s = eye_double(s); - gsl_matrix_sub(ones_s_sub_eye_s, eye_s); - gsl_matrix_free(eye_s); - gsl_matrix_mul_elements(prob, ones_s_sub_eye_s); - gsl_matrix_free(ones_s_sub_eye_s); + MATRIX_T* E_m = MATRIX_ID(alloc)(s, s); + MATRIX_ID(set_all)(E_m, E); + MATRIX_T* neg_ee = copy(ee); + MATRIX_ID(scale)(neg_ee, -1.0); + MATRIX_T* prob = pow_elements(E_m, neg_ee); + MATRIX_ID(free)(E_m); + MATRIX_ID(free)(neg_ee); + MATRIX_T* ones_s_sub_eye_s = ones(s, s); + MATRIX_T* eye_s = eye(s); + MATRIX_ID(sub)(ones_s_sub_eye_s, eye_s); + MATRIX_ID(free)(eye_s); + MATRIX_ID(mul_elements)(prob, ones_s_sub_eye_s); + MATRIX_ID(free)(ones_s_sub_eye_s); // CIJ = (prob>rand(N)); - gsl_matrix* rand_N = rand_double(N); - gsl_matrix_free(CIJ); + MATRIX_T* rand_N = rand(N); + MATRIX_ID(free)(CIJ); CIJ = compare_elements(prob, fp_greater, rand_N); - gsl_matrix_free(rand_N); + MATRIX_ID(free)(rand_N); // K = sum(sum(CIJ)); if (K != NULL) { - gsl_vector* sum_CIJ = sum(CIJ); + VECTOR_T* sum_CIJ = sum(CIJ); *K = sum(sum_CIJ); - gsl_vector_free(sum_CIJ); + VECTOR_ID(free)(sum_CIJ); } return CIJ; diff --git a/makelatticeCIJ.cpp b/makelatticeCIJ.cpp index f5c4008..68f6a87 100644 --- a/makelatticeCIJ.cpp +++ b/makelatticeCIJ.cpp @@ -1,18 +1,15 @@ #include "bct.h" -#include -#include -#include /* * Generates a random directed binary graph with a lattice organization. */ -gsl_matrix* bct::makelatticeCIJ(int N, int K) { +MATRIX_T* bct::makelatticeCIJ(int N, int K) { // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ1 = ones(N); - gsl_matrix* CIJ1 = ones_double(N); + MATRIX_T* CIJ1 = ones(N); // KK = 0; int KK = 0; @@ -21,9 +18,9 @@ gsl_matrix* bct::makelatticeCIJ(int N, int K) { int cnt = -1; // seq = 1:N-1; - gsl_vector* seq = sequence_double(1, N - 1); + VECTOR_T* seq = sequence(1, N - 1); - gsl_matrix* dCIJ = NULL; + MATRIX_T* dCIJ = NULL; // while (KKsize2, dCIJ->size1); - gsl_matrix_transpose_memcpy(dCIJ_transpose, dCIJ); - gsl_matrix_add(dCIJ, dCIJ_transpose); - gsl_matrix_free(dCIJ_transpose); + MATRIX_T* dCIJ_transpose = MATRIX_ID(alloc)(dCIJ->size2, dCIJ->size1); + MATRIX_ID(transpose_memcpy)(dCIJ_transpose, dCIJ); + MATRIX_ID(add)(dCIJ, dCIJ_transpose); + MATRIX_ID(free)(dCIJ_transpose); // CIJ = CIJ + dCIJ; - gsl_matrix_add(CIJ, dCIJ); + MATRIX_ID(add)(CIJ, dCIJ); // KK = sum(sum(CIJ)); - gsl_vector* sum_CIJ = sum(CIJ); + VECTOR_T* sum_CIJ = sum(CIJ); KK = (int)sum(sum_CIJ); - gsl_vector_free(sum_CIJ); + VECTOR_ID(free)(sum_CIJ); } - gsl_matrix_free(CIJ1); - gsl_vector_free(seq); + MATRIX_ID(free)(CIJ1); + VECTOR_ID(free)(seq); // overby = KK-K; int overby = KK - K; @@ -65,9 +62,9 @@ gsl_matrix* bct::makelatticeCIJ(int N, int K) { if (overby > 0) { // [i j] = find(dCIJ); - gsl_matrix* find_dCIJ = find_ij(dCIJ); - gsl_vector_view i = gsl_matrix_column(find_dCIJ, 0); - gsl_vector_view j = gsl_matrix_column(find_dCIJ, 1); + MATRIX_T* find_dCIJ = find_ij(dCIJ); + VECTOR_ID(view) i = MATRIX_ID(column)(find_dCIJ, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_dCIJ, 1); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(&i.vector)); @@ -76,15 +73,15 @@ gsl_matrix* bct::makelatticeCIJ(int N, int K) { for (int ii = 0; ii < overby; ii++) { // CIJ(i(rp(ii)),j(rp(ii))) = 0; - int i_rp_ii = gsl_vector_get(&i.vector, gsl_permutation_get(rp, ii)); - int j_rp_ii = gsl_vector_get(&j.vector, gsl_permutation_get(rp, ii)); - gsl_matrix_set(CIJ, i_rp_ii, j_rp_ii, 0.0); + int i_rp_ii = VECTOR_ID(get)(&i.vector, gsl_permutation_get(rp, ii)); + int j_rp_ii = VECTOR_ID(get)(&j.vector, gsl_permutation_get(rp, ii)); + MATRIX_ID(set)(CIJ, i_rp_ii, j_rp_ii, 0.0); } - gsl_matrix_free(find_dCIJ); + MATRIX_ID(free)(find_dCIJ); gsl_permutation_free(rp); } - gsl_matrix_free(dCIJ); + MATRIX_ID(free)(dCIJ); return CIJ; } diff --git a/makerandCIJ_bd.cpp b/makerandCIJ_bd.cpp index 5e6085e..75ba365 100644 --- a/makerandCIJ_bd.cpp +++ b/makerandCIJ_bd.cpp @@ -1,39 +1,35 @@ #include "bct.h" -#include -#include -#include -#include /* * Generates a random directed binary graph with N nodes and K edges. No edges * are placed on the main diagonal. */ -gsl_matrix* bct::makerandCIJ_bd(int N, int K) { +MATRIX_T* bct::makerandCIJ_bd(int N, int K) { // ind = ~eye(N); - gsl_matrix* eye_N = eye_double(N); - gsl_matrix* ind = logical_not(eye_N); - gsl_matrix_free(eye_N); + MATRIX_T* eye_N = eye(N); + MATRIX_T* ind = logical_not(eye_N); + MATRIX_ID(free)(eye_N); // i = find(ind); - gsl_vector* i = find(ind); - gsl_matrix_free(ind); + VECTOR_T* i = find(ind); + MATRIX_ID(free)(ind); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(i)); // irp = i(rp); - gsl_permute_vector(rp, i); + VECTOR_T* irp = permute(rp, i); gsl_permutation_free(rp); - gsl_vector* irp = i; + VECTOR_ID(free)(i); // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ(irp(1:K)) = 1; - gsl_vector_view irp_subv = gsl_vector_subvector(irp, 0, K); + VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K); ordinal_index_assign(CIJ, &irp_subv.vector, 1.0); - gsl_vector_free(irp); + VECTOR_ID(free)(irp); return CIJ; } diff --git a/makerandCIJ_bu.cpp b/makerandCIJ_bu.cpp index 8962474..9fcf736 100644 --- a/makerandCIJ_bu.cpp +++ b/makerandCIJ_bu.cpp @@ -1,47 +1,43 @@ #include "bct.h" -#include -#include -#include -#include /* * Generates a random undirected binary graph with N nodes and K edges. No * edges are placed on the main diagonal. */ -gsl_matrix* bct::makerandCIJ_bu(int N, int K) { +MATRIX_T* bct::makerandCIJ_bu(int N, int K) { // ind = triu(~eye(N)); - gsl_matrix* eye_N = eye_double(N); - gsl_matrix* not_eye_N = logical_not(eye_N); - gsl_matrix_free(eye_N); - gsl_matrix* ind = triu(not_eye_N); - gsl_matrix_free(not_eye_N); + MATRIX_T* eye_N = eye(N); + MATRIX_T* not_eye_N = logical_not(eye_N); + MATRIX_ID(free)(eye_N); + MATRIX_T* ind = triu(not_eye_N); + MATRIX_ID(free)(not_eye_N); // i = find(ind); - gsl_vector* i = find(ind); - gsl_matrix_free(ind); + VECTOR_T* i = find(ind); + MATRIX_ID(free)(ind); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(i)); // irp = i(rp); - gsl_permute_vector(rp, i); + VECTOR_T* irp = permute(rp, i); gsl_permutation_free(rp); - gsl_vector* irp = i; + VECTOR_ID(free)(i); // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ(irp(1:K)) = 1; - gsl_vector_view irp_subv = gsl_vector_subvector(irp, 0, K); + VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K); ordinal_index_assign(CIJ, &irp_subv.vector, 1.0); - gsl_vector_free(irp); + VECTOR_ID(free)(irp); // CIJ = CIJ+CIJ'; - gsl_matrix* CIJ_transpose = gsl_matrix_alloc(CIJ->size2, CIJ->size1); - gsl_matrix_transpose_memcpy(CIJ_transpose, CIJ); - gsl_matrix_add(CIJ, CIJ_transpose); - gsl_matrix_free(CIJ_transpose); + MATRIX_T* CIJ_transpose = MATRIX_ID(alloc)(CIJ->size2, CIJ->size1); + MATRIX_ID(transpose_memcpy)(CIJ_transpose, CIJ); + MATRIX_ID(add)(CIJ, CIJ_transpose); + MATRIX_ID(free)(CIJ_transpose); return CIJ; } diff --git a/makerandCIJ_wd.cpp b/makerandCIJ_wd.cpp index a669007..c3262cf 100644 --- a/makerandCIJ_wd.cpp +++ b/makerandCIJ_wd.cpp @@ -1,49 +1,44 @@ -#include "bct.h" -#include -#include -#include -#include #include -#include -#include + +#include "bct.h" /* * Generates a random directed weighted graph with N nodes and K edges. Weights * are chosen uniformly between wmin and wmax. No edges are placed on the main * diagonal. */ -gsl_matrix* bct::makerandCIJ_wd(int N, int K, double wmin, double wmax) { - gsl_rng* rng = get_gsl_rng(); - gsl_vector* w = gsl_vector_alloc(K); +MATRIX_T* bct::makerandCIJ_wd(int N, int K, FP_T wmin, FP_T wmax) { + gsl_rng* rng = get_rng(); + VECTOR_T* w = VECTOR_ID(alloc)(K); for (int i = 0; i < K; i++) { - gsl_vector_set(w, i, gsl_rng_uniform(rng) * (wmax - wmin) + wmin); + VECTOR_ID(set)(w, i, gsl_rng_uniform(rng) * (wmax - wmin) + wmin); } // ind = ~eye(N); - gsl_matrix* eye_N = eye_double(N); - gsl_matrix* ind = logical_not(eye_N); - gsl_matrix_free(eye_N); + MATRIX_T* eye_N = eye(N); + MATRIX_T* ind = logical_not(eye_N); + MATRIX_ID(free)(eye_N); // i = find(ind); - gsl_vector* i = find(ind); - gsl_matrix_free(ind); + VECTOR_T* i = find(ind); + MATRIX_ID(free)(ind); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(i)); // irp = i(rp); - gsl_permute_vector(rp, i); + VECTOR_T* irp = permute(rp, i); gsl_permutation_free(rp); - gsl_vector* irp = i; + VECTOR_ID(free)(i); // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ(irp(1:K)) = w; - gsl_vector_view irp_subv = gsl_vector_subvector(irp, 0, K); + VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K); ordinal_index_assign(CIJ, &irp_subv.vector, w); - gsl_vector_free(w); - gsl_vector_free(irp); + VECTOR_ID(free)(w); + VECTOR_ID(free)(irp); return CIJ; } @@ -54,27 +49,27 @@ gsl_matrix* bct::makerandCIJ_wd(int N, int K, double wmin, double wmax) { * placed on the main diagonal. The given matrix should therefore not contain * nonzero entries on the main diagonal. */ -gsl_matrix* bct::makerandCIJ_wd_wp(const gsl_matrix* m) { +MATRIX_T* bct::makerandCIJ_wd_wp(const MATRIX_T* m) { if (safe_mode) check_status(m, SQUARE | NO_LOOPS, "makerandCIJ_wd_wp"); int N = m->size1; int K = N * (N - 1); - double* w = new double[K]; + FP_T* w = new FP_T[K]; for (int i = 0, k = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { if (i != j) { - w[k++] = gsl_matrix_get(m, i, j); + w[k++] = MATRIX_ID(get)(m, i, j); } } } - gsl_rng* rng = get_gsl_rng(); - gsl_ran_shuffle(rng, w, K, sizeof(double)); - gsl_matrix* rand_m = gsl_matrix_alloc(m->size1, m->size2); + gsl_rng* rng = get_rng(); + gsl_ran_shuffle(rng, w, K, sizeof(FP_T)); + MATRIX_T* rand_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0, k = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { if (i == j) { - gsl_matrix_set(rand_m, i, j, 0.0); + MATRIX_ID(set)(rand_m, i, j, 0.0); } else { - gsl_matrix_set(rand_m, i, j, w[k++]); + MATRIX_ID(set)(rand_m, i, j, w[k++]); } } } diff --git a/makerandCIJ_wu.cpp b/makerandCIJ_wu.cpp index 0dc4fa7..60a736b 100644 --- a/makerandCIJ_wu.cpp +++ b/makerandCIJ_wu.cpp @@ -1,57 +1,52 @@ -#include "bct.h" -#include -#include -#include -#include #include -#include -#include + +#include "bct.h" /* * Generates a random undirected weighted graph with N nodes and K edges. * Weights are chosen uniformly between wmin and wmax. No edges are placed on * the main diagonal. */ -gsl_matrix* bct::makerandCIJ_wu(int N, int K, double wmin, double wmax) { - gsl_rng* rng = get_gsl_rng(); - gsl_vector* w = gsl_vector_alloc(K); +MATRIX_T* bct::makerandCIJ_wu(int N, int K, FP_T wmin, FP_T wmax) { + gsl_rng* rng = get_rng(); + VECTOR_T* w = VECTOR_ID(alloc)(K); for (int i = 0; i < K; i++) { - gsl_vector_set(w, i, gsl_rng_uniform(rng) * (wmax - wmin) + wmin); + VECTOR_ID(set)(w, i, gsl_rng_uniform(rng) * (wmax - wmin) + wmin); } // ind = triu(~eye(N)); - gsl_matrix* eye_N = eye_double(N); - gsl_matrix* not_eye_N = logical_not(eye_N); - gsl_matrix_free(eye_N); - gsl_matrix* ind = triu(not_eye_N); - gsl_matrix_free(not_eye_N); + MATRIX_T* eye_N = eye(N); + MATRIX_T* not_eye_N = logical_not(eye_N); + MATRIX_ID(free)(eye_N); + MATRIX_T* ind = triu(not_eye_N); + MATRIX_ID(free)(not_eye_N); // i = find(ind); - gsl_vector* i = find(ind); - gsl_matrix_free(ind); + VECTOR_T* i = find(ind); + MATRIX_ID(free)(ind); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(i)); // irp = i(rp); - gsl_permute_vector(rp, i); + VECTOR_T* irp = permute(rp, i); gsl_permutation_free(rp); - gsl_vector* irp = i; + VECTOR_ID(free)(i); // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ(irp(1:K)) = w; - gsl_vector_view irp_subv = gsl_vector_subvector(irp, 0, K); + VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K); ordinal_index_assign(CIJ, &irp_subv.vector, w); - gsl_vector_free(w); - gsl_vector_free(irp); + VECTOR_ID(free)(w); + VECTOR_ID(free)(irp); // CIJ = CIJ+CIJ'; - gsl_matrix* CIJ_transpose = gsl_matrix_alloc(CIJ->size2, CIJ->size1); - gsl_matrix_transpose_memcpy(CIJ_transpose, CIJ); - gsl_matrix_add(CIJ, CIJ_transpose); - gsl_matrix_free(CIJ_transpose); + MATRIX_T* CIJ_transpose = MATRIX_ID(alloc)(CIJ->size2, CIJ->size1); + MATRIX_ID(transpose_memcpy)(CIJ_transpose, CIJ); + MATRIX_ID(add)(CIJ, CIJ_transpose); + MATRIX_ID(free)(CIJ_transpose); return CIJ; } @@ -62,26 +57,26 @@ gsl_matrix* bct::makerandCIJ_wu(int N, int K, double wmin, double wmax) { * placed on the main diagonal. The given matrix should therefore not contain * nonzero entries on the main diagonal. */ -gsl_matrix* bct::makerandCIJ_wu_wp(const gsl_matrix* m) { +MATRIX_T* bct::makerandCIJ_wu_wp(const MATRIX_T* m) { if (safe_mode) check_status(m, SQUARE | NO_LOOPS, "makerandCIJ_wu_wp"); int N = m->size1; int K = (N * (N - 1)) / 2; - double* w = new double[K]; + FP_T* w = new FP_T[K]; for (int i = 0, k = 0; i < (int)m->size1; i++) { for (int j = i + 1; j < (int)m->size2; j++) { - w[k++] = gsl_matrix_get(m, i, j); + w[k++] = MATRIX_ID(get)(m, i, j); } } - gsl_rng* rng = get_gsl_rng(); - gsl_ran_shuffle(rng, w, K, sizeof(double)); - gsl_matrix* rand_m = gsl_matrix_alloc(m->size1, m->size2); + gsl_rng* rng = get_rng(); + gsl_ran_shuffle(rng, w, K, sizeof(FP_T)); + MATRIX_T* rand_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0, k = 0; i < (int)m->size1; i++) { for (int j = i; j < (int)m->size2; j++) { if (i == j) { - gsl_matrix_set(rand_m, i, j, 0.0); + MATRIX_ID(set)(rand_m, i, j, 0.0); } else { - gsl_matrix_set(rand_m, i, j, w[k]); - gsl_matrix_set(rand_m, j, i, w[k]); + MATRIX_ID(set)(rand_m, i, j, w[k]); + MATRIX_ID(set)(rand_m, j, i, w[k]); k++; } } diff --git a/makerandCIJdegreesfixed.cpp b/makerandCIJdegreesfixed.cpp index 8cf4d3f..f91f2b6 100644 --- a/makerandCIJdegreesfixed.cpp +++ b/makerandCIJdegreesfixed.cpp @@ -1,19 +1,14 @@ -#include "bct.h" #include -#include -#include -#include -#include -#include -#include + +#include "bct.h" /* * Generates a random directed binary graph with the given in-degree and out- * degree sequences. Returns NULL if the algorithm failed to generate a graph * satisfying the given degree sequences. */ -gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* out) { - gsl_rng* rng = get_gsl_rng(); +MATRIX_T* bct::makerandCIJdegreesfixed(const VECTOR_T* in, const VECTOR_T* out) { + gsl_rng* rng = get_rng(); // n = length(in); int n = length(in); @@ -22,10 +17,10 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* int k = sum(in); // inInv = zeros(k,1); - gsl_vector* inInv = zeros_vector_double(k); + VECTOR_T* inInv = zeros_vector(k); // outInv = inInv; - gsl_vector* outInv = copy(inInv); + VECTOR_T* outInv = copy(inInv); // iIn = 1; iOut = 1; int iIn = 0; @@ -35,41 +30,41 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* for (int i = 0; i < n; i++) { // inInv(iIn:iIn+in(i) - 1) = i; - gsl_vector* inInv_ind = sequence_double(iIn, iIn + (int)gsl_vector_get(in, i) - 1); + VECTOR_T* inInv_ind = sequence(iIn, iIn + (int)VECTOR_ID(get)(in, i) - 1); if (inInv_ind != NULL) { - ordinal_index_assign(inInv, inInv_ind, (double)i); - gsl_vector_free(inInv_ind); + ordinal_index_assign(inInv, inInv_ind, (FP_T)i); + VECTOR_ID(free)(inInv_ind); } // outInv(iOut:iOut+out(i) - 1) = i; - gsl_vector* outInv_ind = sequence_double(iOut, iOut + (int)gsl_vector_get(out, i) - 1); + VECTOR_T* outInv_ind = sequence(iOut, iOut + (int)VECTOR_ID(get)(out, i) - 1); if (outInv_ind != NULL) { - ordinal_index_assign(outInv, outInv_ind, (double)i); - gsl_vector_free(outInv_ind); + ordinal_index_assign(outInv, outInv_ind, (FP_T)i); + VECTOR_ID(free)(outInv_ind); } // iIn = iIn+in(i); - iIn += (int)gsl_vector_get(in, i); + iIn += (int)VECTOR_ID(get)(in, i); // iOut = iOut+out(i); - iOut += (int)gsl_vector_get(out, i); + iOut += (int)VECTOR_ID(get)(out, i); } // cij = eye(n); - gsl_matrix* cij = eye_double(n); + MATRIX_T* cij = eye(n); // edges = [outInv(1:k)'; inInv(randperm(k))']; - gsl_vector* outInv_ind = sequence_double(0, k - 1); - gsl_vector* edges_row_0 = ordinal_index(outInv, outInv_ind); - gsl_vector_free(outInv); - gsl_vector_free(outInv_ind); + VECTOR_T* outInv_ind = sequence(0, k - 1); + VECTOR_T* edges_row_0 = ordinal_index(outInv, outInv_ind); + VECTOR_ID(free)(outInv); + VECTOR_ID(free)(outInv_ind); gsl_permutation* inInv_ind = randperm(k); - gsl_permute_vector(inInv_ind, inInv); + VECTOR_T* edges_row_1 = permute(inInv_ind, inInv); gsl_permutation_free(inInv_ind); - gsl_vector* edges_row_1 = inInv; - gsl_matrix* edges = concatenate_columns(edges_row_0, edges_row_1); - gsl_vector_free(edges_row_0); - gsl_vector_free(edges_row_1); + VECTOR_ID(free)(inInv); + MATRIX_T* edges = concatenate_columns(edges_row_0, edges_row_1); + VECTOR_ID(free)(edges_row_0); + VECTOR_ID(free)(edges_row_1); bool flag = true; @@ -77,7 +72,7 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* for (int i = 0; i < k && flag; i++) { // if cij(edges(1,i),edges(2,i)), - if (fp_nonzero(gsl_matrix_get(cij, (int)gsl_matrix_get(edges, 0, i), (int)gsl_matrix_get(edges, 1, i)))) { + if (fp_nonzero(MATRIX_ID(get)(cij, (int)MATRIX_ID(get)(edges, 0, i), (int)MATRIX_ID(get)(edges, 1, i)))) { // warningCounter = 1; int warningCounter = 1; @@ -89,30 +84,30 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* int switchTo = (int)std::ceil((k - 1) * gsl_rng_uniform(rng)); // if ~(cij(edges(1,i),edges(2,switchTo)) || cij(edges(1,switchTo),edges(2,i))), - if (!(fp_nonzero(gsl_matrix_get(cij, (int)gsl_matrix_get(edges, 0, i), (int)gsl_matrix_get(edges, 1, switchTo))) || - fp_nonzero(gsl_matrix_get(cij, (int)gsl_matrix_get(edges, 0, switchTo), (int)gsl_matrix_get(edges, 1, i))))) { + if (!(fp_nonzero(MATRIX_ID(get)(cij, (int)MATRIX_ID(get)(edges, 0, i), (int)MATRIX_ID(get)(edges, 1, switchTo))) || + fp_nonzero(MATRIX_ID(get)(cij, (int)MATRIX_ID(get)(edges, 0, switchTo), (int)MATRIX_ID(get)(edges, 1, i))))) { // cij(edges(1,i),edges(2,switchTo)) = 1; - gsl_matrix_set(cij, (int)gsl_matrix_get(edges, 0, i), (int)gsl_matrix_get(edges, 1, switchTo), 1.0); + MATRIX_ID(set)(cij, (int)MATRIX_ID(get)(edges, 0, i), (int)MATRIX_ID(get)(edges, 1, switchTo), 1.0); // if switchTo < i, if (switchTo < i) { // cij(edges(1,switchTo),edges(2,switchTo)) = 0; - gsl_matrix_set(cij, (int)gsl_matrix_get(edges, 0, switchTo), (int)gsl_matrix_get(edges, 1, switchTo), 0.0); + MATRIX_ID(set)(cij, (int)MATRIX_ID(get)(edges, 0, switchTo), (int)MATRIX_ID(get)(edges, 1, switchTo), 0.0); // cij(edges(1,switchTo),edges(2,i)) = 1; - gsl_matrix_set(cij, (int)gsl_matrix_get(edges, 0, switchTo), (int)gsl_matrix_get(edges, 1, i), 1.0); + MATRIX_ID(set)(cij, (int)MATRIX_ID(get)(edges, 0, switchTo), (int)MATRIX_ID(get)(edges, 1, i), 1.0); } // temp = edges(2,i); - double temp = gsl_matrix_get(edges, 1, i); + FP_T temp = MATRIX_ID(get)(edges, 1, i); // edges(2,i) = edges(2,switchTo); - gsl_matrix_set(edges, 1, i, gsl_matrix_get(edges, 1, switchTo)); + MATRIX_ID(set)(edges, 1, i, MATRIX_ID(get)(edges, 1, switchTo)); // edges(2,switchTo) = temp; - gsl_matrix_set(edges, 1, switchTo, temp); + MATRIX_ID(set)(edges, 1, switchTo, temp); // break break; @@ -134,22 +129,22 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* } else { // cij(edges(1,i),edges(2,i)) = 1; - gsl_matrix_set(cij, (int)gsl_matrix_get(edges, 0, i), (int)gsl_matrix_get(edges, 1, i), 1.0); + MATRIX_ID(set)(cij, (int)MATRIX_ID(get)(edges, 0, i), (int)MATRIX_ID(get)(edges, 1, i), 1.0); } } - gsl_matrix_free(edges); + MATRIX_ID(free)(edges); // flag = 1; if (!flag) { - gsl_matrix_free(cij); + MATRIX_ID(free)(cij); return NULL; } // cij = cij - eye(n); - gsl_matrix* eye_n = eye_double(n); - gsl_matrix_sub(cij, eye_n); - gsl_matrix_free(eye_n); + MATRIX_T* eye_n = eye(n); + MATRIX_ID(sub)(cij, eye_n); + MATRIX_ID(free)(eye_n); return cij; } @@ -160,17 +155,17 @@ gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_vector* in, const gsl_vector* * necessarily valid, this function should not return NULL unless the given * matrix contains nonzero entries on the main diagonal. */ -gsl_matrix* bct::makerandCIJdegreesfixed(const gsl_matrix* m) { +MATRIX_T* bct::makerandCIJdegreesfixed(const MATRIX_T* m) { if (safe_mode) check_status(m, SQUARE | NO_LOOPS, "makerandCIJdegreesfixed"); - gsl_matrix* ret; + MATRIX_T* ret; do { - gsl_vector* id; - gsl_vector* od; - gsl_vector* deg = degrees_dir(m, &id, &od); - gsl_vector_free(deg); + VECTOR_T* id; + VECTOR_T* od; + VECTOR_T* deg = degrees_dir(m, &id, &od); + VECTOR_ID(free)(deg); ret = makerandCIJdegreesfixed(id, od); - gsl_vector_free(id); - gsl_vector_free(od); + VECTOR_ID(free)(id); + VECTOR_ID(free)(od); } while (ret == NULL && has_no_loops(m)); return ret; } diff --git a/makeringlatticeCIJ.cpp b/makeringlatticeCIJ.cpp index 24e079f..0b19130 100644 --- a/makeringlatticeCIJ.cpp +++ b/makeringlatticeCIJ.cpp @@ -1,18 +1,15 @@ #include "bct.h" -#include -#include -#include /* * Generates a random directed binary graph with a ring lattice organization. */ -gsl_matrix* bct::makeringlatticeCIJ(int N, int K) { +MATRIX_T* bct::makeringlatticeCIJ(int N, int K) { // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // CIJ1 = ones(N); - gsl_matrix* CIJ1 = ones_double(N); + MATRIX_T* CIJ1 = ones(N); // KK = 0; int KK = 0; @@ -21,12 +18,12 @@ gsl_matrix* bct::makeringlatticeCIJ(int N, int K) { int cnt = -1; // seq = 1:N-1; - gsl_vector* seq = sequence_double(1, N - 1); + VECTOR_T* seq = sequence(1, N - 1); // seq2 = N-1:-1:1; - gsl_vector* seq2 = sequence_double(N - 1, -1, 1); + VECTOR_T* seq2 = sequence(N - 1, -1, 1); - gsl_matrix* dCIJ = NULL; + MATRIX_T* dCIJ = NULL; // while (KKsize2, dCIJ->size1); - gsl_matrix_transpose_memcpy(dCIJ_transpose, dCIJ); - gsl_matrix* dCIJ2_transpose = gsl_matrix_alloc(dCIJ2->size2, dCIJ2->size1); - gsl_matrix_transpose_memcpy(dCIJ2_transpose, dCIJ2); - gsl_matrix_add(dCIJ, dCIJ_transpose); - gsl_matrix_free(dCIJ_transpose); - gsl_matrix_add(dCIJ, dCIJ2); - gsl_matrix_free(dCIJ2); - gsl_matrix_add(dCIJ, dCIJ2_transpose); - gsl_matrix_free(dCIJ2_transpose); + MATRIX_T* dCIJ_transpose = MATRIX_ID(alloc)(dCIJ->size2, dCIJ->size1); + MATRIX_ID(transpose_memcpy)(dCIJ_transpose, dCIJ); + MATRIX_T* dCIJ2_transpose = MATRIX_ID(alloc)(dCIJ2->size2, dCIJ2->size1); + MATRIX_ID(transpose_memcpy)(dCIJ2_transpose, dCIJ2); + MATRIX_ID(add)(dCIJ, dCIJ_transpose); + MATRIX_ID(free)(dCIJ_transpose); + MATRIX_ID(add)(dCIJ, dCIJ2); + MATRIX_ID(free)(dCIJ2); + MATRIX_ID(add)(dCIJ, dCIJ2_transpose); + MATRIX_ID(free)(dCIJ2_transpose); // CIJ = CIJ + dCIJ; - gsl_matrix_add(CIJ, dCIJ); + MATRIX_ID(add)(CIJ, dCIJ); // KK = sum(sum(CIJ)); - gsl_vector* sum_CIJ = sum(CIJ); + VECTOR_T* sum_CIJ = sum(CIJ); KK = (int)sum(sum_CIJ); - gsl_vector_free(sum_CIJ); + VECTOR_ID(free)(sum_CIJ); } - gsl_matrix_free(CIJ1); - gsl_vector_free(seq); - gsl_vector_free(seq2); + MATRIX_ID(free)(CIJ1); + VECTOR_ID(free)(seq); + VECTOR_ID(free)(seq2); // overby = KK-K; int overby = KK - K; @@ -81,9 +78,9 @@ gsl_matrix* bct::makeringlatticeCIJ(int N, int K) { if (overby > 0) { // [i j] = find(dCIJ); - gsl_matrix* find_dCIJ = find_ij(dCIJ); - gsl_vector_view i = gsl_matrix_column(find_dCIJ, 0); - gsl_vector_view j = gsl_matrix_column(find_dCIJ, 1); + MATRIX_T* find_dCIJ = find_ij(dCIJ); + VECTOR_ID(view) i = MATRIX_ID(column)(find_dCIJ, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_dCIJ, 1); // rp = randperm(length(i)); gsl_permutation* rp = randperm(length(&i.vector)); @@ -92,15 +89,15 @@ gsl_matrix* bct::makeringlatticeCIJ(int N, int K) { for (int ii = 0; ii < overby; ii++) { // CIJ(i(rp(ii)),j(rp(ii))) = 0; - int i_rp_ii = gsl_vector_get(&i.vector, gsl_permutation_get(rp, ii)); - int j_rp_ii = gsl_vector_get(&j.vector, gsl_permutation_get(rp, ii)); - gsl_matrix_set(CIJ, i_rp_ii, j_rp_ii, 0.0); + int i_rp_ii = VECTOR_ID(get)(&i.vector, gsl_permutation_get(rp, ii)); + int j_rp_ii = VECTOR_ID(get)(&j.vector, gsl_permutation_get(rp, ii)); + MATRIX_ID(set)(CIJ, i_rp_ii, j_rp_ii, 0.0); } - gsl_matrix_free(find_dCIJ); + MATRIX_ID(free)(find_dCIJ); gsl_permutation_free(rp); } - gsl_matrix_free(dCIJ); + MATRIX_ID(free)(dCIJ); return CIJ; } diff --git a/maketoeplitzCIJ.cpp b/maketoeplitzCIJ.cpp index 036e085..aece622 100644 --- a/maketoeplitzCIJ.cpp +++ b/maketoeplitzCIJ.cpp @@ -1,50 +1,48 @@ #include "bct.h" -#include -#include /* * Generates a random directed binary graph with a Toeplitz organization. */ -gsl_matrix* bct::maketoeplitzCIJ(int N, int K, double s) { +MATRIX_T* bct::maketoeplitzCIJ(int N, int K, FP_T s) { // profile = normpdf([1:N-1],0.5,s); - gsl_vector* indices = sequence_double(1, N - 1); - gsl_vector* profile = normpdf(indices, 0.5, s); - gsl_vector_free(indices); + VECTOR_T* indices = sequence(1, N - 1); + VECTOR_T* profile = normpdf(indices, 0.5, s); + VECTOR_ID(free)(indices); // template = toeplitz([0 profile],[0 profile]); - gsl_vector* temp = concatenate(0.0, profile); - gsl_vector_free(profile); + VECTOR_T* temp = concatenate(0.0, profile); + VECTOR_ID(free)(profile); profile = temp; - gsl_matrix* _template = toeplitz(profile, profile); - gsl_vector_free(profile); + MATRIX_T* _template = toeplitz(profile, profile); + VECTOR_ID(free)(profile); // template = template.*(K./sum(sum(template))) - gsl_vector* sum__template = sum(_template); - double sum_sum__template = sum(sum__template); - gsl_vector_free(sum__template); - gsl_matrix_scale(_template, (double)K / sum_sum__template); + VECTOR_T* sum__template = sum(_template); + FP_T sum_sum__template = sum(sum__template); + VECTOR_ID(free)(sum__template); + MATRIX_ID(scale)(_template, (FP_T)K / sum_sum__template); // CIJ = zeros(N); - gsl_matrix* CIJ = zeros_double(N); + MATRIX_T* CIJ = zeros(N); // while ((sum(sum(CIJ)) ~= K)) - gsl_vector* sum_CIJ = sum(CIJ); - double sum_sum_CIJ = sum(sum_CIJ); - gsl_vector_free(sum_CIJ); + VECTOR_T* sum_CIJ = sum(CIJ); + FP_T sum_sum_CIJ = sum(sum_CIJ); + VECTOR_ID(free)(sum_CIJ); while ((int)sum_sum_CIJ != K) { // CIJ = (rand(N) -#include -double matching_ind(const gsl_vector*, const gsl_vector*, int, int, int); +FP_T matching_ind(const VECTOR_T*, const VECTOR_T*, int, int, int); /* * Computes matching index for all connections. */ -gsl_matrix* bct::matching_ind(const gsl_matrix* CIJ) { +MATRIX_T* bct::matching_ind(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE, "matching_ind"); // N = size(CIJ,1); int N = CIJ->size1; // Mall = zeros(N,N); - gsl_matrix* Mall = zeros_double(N, N); + MATRIX_T* Mall = zeros(N, N); // for i=1:N-1 for (int i = 0; i < N - 1; i++) { // c1 = [CIJ(:,i)' CIJ(i,:)]; - gsl_vector_const_view CIJ_col_i = gsl_matrix_const_column(CIJ, i); - gsl_vector_const_view CIJ_row_i = gsl_matrix_const_row(CIJ, i); - gsl_vector* c1 = concatenate(&CIJ_col_i.vector, &CIJ_row_i.vector); + VECTOR_ID(const_view) CIJ_col_i = MATRIX_ID(const_column)(CIJ, i); + VECTOR_ID(const_view) CIJ_row_i = MATRIX_ID(const_row)(CIJ, i); + VECTOR_T* c1 = concatenate(&CIJ_col_i.vector, &CIJ_row_i.vector); // for j=i+1:N for (int j = i + 1; j < N; j++) { // c2 = [CIJ(:,j)' CIJ(j,:)]; - gsl_vector_const_view CIJ_col_j = gsl_matrix_const_column(CIJ, j); - gsl_vector_const_view CIJ_row_j = gsl_matrix_const_row(CIJ, j); - gsl_vector* c2 = concatenate(&CIJ_col_j.vector, &CIJ_row_j.vector); + VECTOR_ID(const_view) CIJ_col_j = MATRIX_ID(const_column)(CIJ, j); + VECTOR_ID(const_view) CIJ_row_j = MATRIX_ID(const_row)(CIJ, j); + VECTOR_T* c2 = concatenate(&CIJ_col_j.vector, &CIJ_row_j.vector); - gsl_matrix_set(Mall, i, j, matching_ind(c1, c2, i, j, N)); - gsl_vector_free(c2); + MATRIX_ID(set)(Mall, i, j, matching_ind(c1, c2, i, j, N)); + VECTOR_ID(free)(c2); } - gsl_vector_free(c1); + VECTOR_ID(free)(c1); } return Mall; @@ -45,28 +43,28 @@ gsl_matrix* bct::matching_ind(const gsl_matrix* CIJ) { /* * Computes matching index for incoming connections. */ -gsl_matrix* bct::matching_ind_in(const gsl_matrix* CIJ) { +MATRIX_T* bct::matching_ind_in(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE, "matching_ind_in"); // N = size(CIJ,1); int N = CIJ->size1; // Min = zeros(N,N); - gsl_matrix* Min = zeros_double(N, N); + MATRIX_T* Min = zeros(N, N); // for i=1:N-1 for (int i = 0; i < N - 1; i++) { // c1 = CIJ(:,i); - gsl_vector_const_view c1 = gsl_matrix_const_column(CIJ, i); + VECTOR_ID(const_view) c1 = MATRIX_ID(const_column)(CIJ, i); // for j=i+1:N for (int j = i + 1; j < N; j++) { // c2 = CIJ(:,j); - gsl_vector_const_view c2 = gsl_matrix_const_column(CIJ, j); + VECTOR_ID(const_view) c2 = MATRIX_ID(const_column)(CIJ, j); - gsl_matrix_set(Min, i, j, matching_ind(&c1.vector, &c2.vector, i, j, 0)); + MATRIX_ID(set)(Min, i, j, matching_ind(&c1.vector, &c2.vector, i, j, 0)); } } @@ -76,53 +74,53 @@ gsl_matrix* bct::matching_ind_in(const gsl_matrix* CIJ) { /* * Computes matching index for outgoing connections. */ -gsl_matrix* bct::matching_ind_out(const gsl_matrix* CIJ) { +MATRIX_T* bct::matching_ind_out(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE, "matching_ind_out"); // N = size(CIJ,1); int N = CIJ->size1; // Mout = zeros(N,N); - gsl_matrix* Mout = zeros_double(N, N); + MATRIX_T* Mout = zeros(N, N); // for i=1:N-1 for (int i = 0; i < N - 1; i++) { // c1 = CIJ(:,i); - gsl_vector_const_view c1 = gsl_matrix_const_row(CIJ, i); + VECTOR_ID(const_view) c1 = MATRIX_ID(const_row)(CIJ, i); // for j=i+1:N for (int j = i + 1; j < N; j++) { // c2 = CIJ(:,j); - gsl_vector_const_view c2 = gsl_matrix_const_row(CIJ, j); + VECTOR_ID(const_view) c2 = MATRIX_ID(const_row)(CIJ, j); - gsl_matrix_set(Mout, i, j, matching_ind(&c1.vector, &c2.vector, i, j, 0)); + MATRIX_ID(set)(Mout, i, j, matching_ind(&c1.vector, &c2.vector, i, j, 0)); } } return Mout; } -double matching_ind(const gsl_vector* c1, const gsl_vector* c2, int i, int j, int N) { +FP_T matching_ind(const VECTOR_T* c1, const VECTOR_T* c2, int i, int j, int N) { using namespace bct; // use = ~(~c1&~c2); - gsl_vector* use = logical_or(c1, c2); + VECTOR_T* use = logical_or(c1, c2); // use(i) = 0; use(i+N) = 0; - gsl_vector_set(use, i, 0.0); - gsl_vector_set(use, i + N, 0.0); + VECTOR_ID(set)(use, i, 0.0); + VECTOR_ID(set)(use, i + N, 0.0); // use(j) = 0; use(j+N) = 0; - gsl_vector_set(use, j, 0.0); - gsl_vector_set(use, j + N, 0.0); + VECTOR_ID(set)(use, j, 0.0); + VECTOR_ID(set)(use, j + N, 0.0); // ncon = sum(c1(use))+sum(c2(use)); - gsl_vector* c1_use = logical_index(c1, use); - gsl_vector* c2_use = logical_index(c2, use); - gsl_vector_free(use); - double ncon = 0.0; + VECTOR_T* c1_use = logical_index(c1, use); + VECTOR_T* c2_use = logical_index(c2, use); + VECTOR_ID(free)(use); + FP_T ncon = 0.0; if (c1_use != NULL) { ncon += sum(c1_use); } @@ -131,7 +129,7 @@ double matching_ind(const gsl_vector* c1, const gsl_vector* c2, int i, int j, in } // if (ncon==0) - double ret; + FP_T ret; if (fp_zero(ncon)) { // Mall(i,j) = 0; @@ -142,13 +140,13 @@ double matching_ind(const gsl_vector* c1, const gsl_vector* c2, int i, int j, in if (c1_use == NULL || c2_use == NULL) { ret = 0.0; } else { - gsl_vector* log_and = logical_and(c1_use, c2_use); + VECTOR_T* log_and = logical_and(c1_use, c2_use); ret = 2.0 * sum(log_and) / ncon; - gsl_vector_free(log_and); + VECTOR_ID(free)(log_and); } } - if (c1_use != NULL) gsl_vector_free(c1_use); - if (c2_use != NULL) gsl_vector_free(c2_use); + if (c1_use != NULL) VECTOR_ID(free)(c1_use); + if (c2_use != NULL) VECTOR_ID(free)(c2_use); return ret; } diff --git a/matlab/compare.cpp b/matlab/compare.cpp index 88e3e7c..128d373 100644 --- a/matlab/compare.cpp +++ b/matlab/compare.cpp @@ -1,22 +1,21 @@ #include -#include -#include -#include -FP_TYPE matlab::FP_ID(epsilon) = std::numeric_limits::epsilon(); +#include "matlab.h" + +FP_T matlab::epsilon = std::numeric_limits::epsilon(); /* * Compares two floating-point numbers. */ -int matlab::fp_compare(FP_TYPE x, FP_TYPE y) { +int matlab::fp_compare(FP_T x, FP_T y) { if (fp_zero(x) && fp_zero(y)) { return 0; } else { int exponent; - FP_TYPE max = (std::abs(x) > std::abs(y)) ? x : y; + FP_T max = (std::abs(x) > std::abs(y)) ? x : y; std::frexp(max, &exponent); - FP_TYPE delta = std::ldexp(FP_ID(epsilon), exponent); - FP_TYPE difference = x - y; + FP_T delta = std::ldexp(epsilon, exponent); + FP_T difference = x - y; if (difference > delta) { return 1; } else if (difference < -delta) { @@ -27,25 +26,25 @@ int matlab::fp_compare(FP_TYPE x, FP_TYPE y) { } } -bool matlab::fp_zero(FP_TYPE x) { return std::abs(x) < FP_ID(epsilon); } -bool matlab::fp_nonzero(FP_TYPE x) { return std::abs(x) > FP_ID(epsilon); } -bool matlab::fp_equal(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) == 0; } -bool matlab::fp_not_equal(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) != 0; } -bool matlab::fp_less(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) == -1; } -bool matlab::fp_less_or_equal(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) <= 0; } -bool matlab::fp_greater(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) == 1; } -bool matlab::fp_greater_or_equal(FP_TYPE x, FP_TYPE y) { return fp_compare(x, y) >= 0; } +bool matlab::fp_zero(FP_T x) { return std::abs(x) < epsilon; } +bool matlab::fp_nonzero(FP_T x) { return std::abs(x) > epsilon; } +bool matlab::fp_equal(FP_T x, FP_T y) { return fp_compare(x, y) == 0; } +bool matlab::fp_not_equal(FP_T x, FP_T y) { return fp_compare(x, y) != 0; } +bool matlab::fp_less(FP_T x, FP_T y) { return fp_compare(x, y) == -1; } +bool matlab::fp_less_or_equal(FP_T x, FP_T y) { return fp_compare(x, y) <= 0; } +bool matlab::fp_greater(FP_T x, FP_T y) { return fp_compare(x, y) == 1; } +bool matlab::fp_greater_or_equal(FP_T x, FP_T y) { return fp_compare(x, y) >= 0; } /* * Compares two vectors lexicographically, returning -1, 0, or 1 if the first * vector is less than, equal to, or greater than the second. */ -int matlab::compare_vectors(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +int matlab::compare_vectors(const VECTOR_T* v1, const VECTOR_T* v2) { for (int i = 0; i < (int)v1->size; i++) { if (i >= (int)v2->size) { return 1; } - int result = fp_compare((FP_TYPE)VECTOR_ID(get)(v1, i), (FP_TYPE)VECTOR_ID(get)(v2, i)); + int result = fp_compare(VECTOR_ID(get)(v1, i), VECTOR_ID(get)(v2, i)); if (result != 0) { return result; } @@ -61,7 +60,7 @@ int matlab::compare_vectors(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { * Returns whether the first vector comes before the second vector in a strict * weak ordering. */ -bool matlab::vector_less(VECTOR_TYPE* v1, VECTOR_TYPE* v2) { +bool matlab::vector_less(VECTOR_T* v1, VECTOR_T* v2) { return compare_vectors(v1, v2) == -1; } @@ -69,14 +68,14 @@ bool matlab::vector_less(VECTOR_TYPE* v1, VECTOR_TYPE* v2) { * Compares two matrices lexicographically, returning -1, 0, or 1 if the first * matrix is less than, equal to, or greater than the second. */ -int matlab::compare_matrices(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { +int matlab::compare_matrices(const MATRIX_T* m1, const MATRIX_T* m2) { int size1 = (int)m1->size1 * (int)m1->size2; int size2 = (int)m2->size1 * (int)m2->size2; for (int i = 0; i < size1; i++) { if (i >= size2) { return 1; } - int result = fp_compare((FP_TYPE)ordinal_index(m1, i), (FP_TYPE)ordinal_index(m2, i)); + int result = fp_compare(ordinal_index(m1, i), ordinal_index(m2, i)); if (result != 0) { return result; } @@ -92,18 +91,18 @@ int matlab::compare_matrices(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { * Returns whether the first matrix comes before the second matrix in a strict * weak ordering. */ -bool matlab::matrix_less(MATRIX_TYPE* m1, MATRIX_TYPE* m2) { +bool matlab::matrix_less(MATRIX_T* m1, MATRIX_T* m2) { return compare_matrices(m1, m2) == -1; } /* * Emulates (v op x), where op is a binary comparison operator. */ -VECTOR_TYPE* matlab::compare_elements(const VECTOR_TYPE* v, FP_ID(fp_cmp_fn) compare, FP_TYPE x) { - VECTOR_TYPE* cmp_v = VECTOR_ID(alloc)(v->size); +VECTOR_T* matlab::compare_elements(const VECTOR_T* v, comparator compare, FP_T x) { + VECTOR_T* cmp_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); - VECTOR_ID(set)(cmp_v, i, (FP_TYPE)compare((FP_TYPE)value, (FP_TYPE)x)); + FP_T value = VECTOR_ID(get)(v, i); + VECTOR_ID(set)(cmp_v, i, (FP_T)compare(value, x)); } return cmp_v; } @@ -111,15 +110,15 @@ VECTOR_TYPE* matlab::compare_elements(const VECTOR_TYPE* v, FP_ID(fp_cmp_fn) com /* * Emulates (v1 op v2), where op is a binary comparison operator. */ -VECTOR_TYPE* matlab::compare_elements(const VECTOR_TYPE* v1, FP_ID(fp_cmp_fn) compare, const VECTOR_TYPE* v2) { +VECTOR_T* matlab::compare_elements(const VECTOR_T* v1, comparator compare, const VECTOR_T* v2) { if (v1->size != v2->size) { return NULL; } - VECTOR_TYPE* cmp_v = VECTOR_ID(alloc)(v1->size); + VECTOR_T* cmp_v = VECTOR_ID(alloc)(v1->size); for (int i = 0; i < (int)v1->size; i++) { - FP_TYPE value1 = VECTOR_ID(get)(v1, i); - FP_TYPE value2 = VECTOR_ID(get)(v2, i); - VECTOR_ID(set)(cmp_v, i, (FP_TYPE)compare((FP_TYPE)value1, (FP_TYPE)value2)); + FP_T value1 = VECTOR_ID(get)(v1, i); + FP_T value2 = VECTOR_ID(get)(v2, i); + VECTOR_ID(set)(cmp_v, i, (FP_T)compare(value1, value2)); } return cmp_v; } @@ -127,12 +126,12 @@ VECTOR_TYPE* matlab::compare_elements(const VECTOR_TYPE* v1, FP_ID(fp_cmp_fn) co /* * Emulates (m op x), where op is a binary comparison operator. */ -MATRIX_TYPE* matlab::compare_elements(const MATRIX_TYPE* m, FP_ID(fp_cmp_fn) compare, FP_TYPE x) { - MATRIX_TYPE* cmp_m = MATRIX_ID(alloc)(m->size1, m->size2); +MATRIX_T* matlab::compare_elements(const MATRIX_T* m, comparator compare, FP_T x) { + MATRIX_T* cmp_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - FP_TYPE value = MATRIX_ID(get)(m, i, j); - MATRIX_ID(set)(cmp_m, i, j, (FP_TYPE)compare((FP_TYPE)value, (FP_TYPE)x)); + FP_T value = MATRIX_ID(get)(m, i, j); + MATRIX_ID(set)(cmp_m, i, j, (FP_T)compare(value, x)); } } return cmp_m; @@ -141,16 +140,16 @@ MATRIX_TYPE* matlab::compare_elements(const MATRIX_TYPE* m, FP_ID(fp_cmp_fn) com /* * Emulates (m1 op m2), where op is a binary comparison operator. */ -MATRIX_TYPE* matlab::compare_elements(const MATRIX_TYPE* m1, FP_ID(fp_cmp_fn) compare, const MATRIX_TYPE* m2) { +MATRIX_T* matlab::compare_elements(const MATRIX_T* m1, comparator compare, const MATRIX_T* m2) { if (m1->size1 != m2->size1 || m1->size2 != m2->size2) { return NULL; } - MATRIX_TYPE* cmp_m = MATRIX_ID(alloc)(m1->size1, m1->size2); + MATRIX_T* cmp_m = MATRIX_ID(alloc)(m1->size1, m1->size2); for (int i = 0; i < (int)m1->size1; i++) { for (int j = 0; j < (int)m1->size2; j++) { - FP_TYPE value1 = MATRIX_ID(get)(m1, i, j); - FP_TYPE value2 = MATRIX_ID(get)(m2, i, j); - MATRIX_ID(set)(cmp_m, i, j, (FP_TYPE)compare((FP_TYPE)value1, (FP_TYPE)value2)); + FP_T value1 = MATRIX_ID(get)(m1, i, j); + FP_T value2 = MATRIX_ID(get)(m2, i, j); + MATRIX_ID(set)(cmp_m, i, j, (FP_T)compare(value1, value2)); } } return cmp_m; diff --git a/matlab/convert.cpp b/matlab/convert.cpp index 51cc9c7..2e6df6f 100644 --- a/matlab/convert.cpp +++ b/matlab/convert.cpp @@ -1,11 +1,9 @@ -#include -#include -#include +#include "matlab.h" /* * Converts a vector to an array. */ -void matlab::to_array(const VECTOR_TYPE* v, FP_TYPE* array) { +void matlab::to_array(const VECTOR_T* v, FP_T* array) { for (int i = 0; i < (int)v->size; i++) { array[i] = VECTOR_ID(get)(v, i); } @@ -15,7 +13,7 @@ void matlab::to_array(const VECTOR_TYPE* v, FP_TYPE* array) { * Converts a vector to a boolean: true if all elements are nonzero, false * otherwise. */ -bool matlab::to_bool(const VECTOR_TYPE* v) { +bool matlab::to_bool(const VECTOR_T* v) { return all(v) == 1; } @@ -23,129 +21,109 @@ bool matlab::to_bool(const VECTOR_TYPE* v) { * Converts a matrix to a boolean: true if all elements are nonzero, false * otherwise. */ -bool matlab::to_bool(const MATRIX_TYPE* m) { - VECTOR_TYPE* all_v = all(m); +bool matlab::to_bool(const MATRIX_T* m) { + VECTOR_T* all_v = all(m); bool ret = all(all_v); VECTOR_ID(free)(all_v); return ret; } /* - * Converts a vector to float precision. + * Converts a matrix to a vector. The vector is constructed by consecutively + * appending columns. */ -gsl_vector_float* matlab::to_vector_float(const VECTOR_TYPE* v) { - gsl_vector_float* v_f = gsl_vector_float_alloc(v->size); - for (int i = 0; i < (int)v->size; i++) { - gsl_vector_float_set(v_f, i, (float)VECTOR_ID(get)(v, i)); +VECTOR_T* matlab::to_vector(const MATRIX_T* m) { + VECTOR_T* v = VECTOR_ID(alloc)(m->size1 * m->size2); + for (int j = 0; j < (int)m->size2; j++) { + for (int i = 0; i < (int)m->size1; i++) { + FP_T value = MATRIX_ID(get)(m, i, j); + VECTOR_ID(set)(v, j * m->size1 + i, value); + } } - return v_f; + return v; +} + +/* + * Converts a double-precision vector to the currently selected precision. + */ +VECTOR_T* matlab::to_vector(const gsl_vector* v_d) { + VECTOR_T* v = VECTOR_ID(alloc)(v_d->size); + for (int i = 0; i < (int)v_d->size; i++) { + FP_T value = (FP_T)gsl_vector_get(v_d, i); + VECTOR_ID(set)(v, i, value); + } + return v; } /* * Converts a vector to double precision. */ -gsl_vector* matlab::to_vector_double(const VECTOR_TYPE* v) { +gsl_vector* matlab::to_vector_double(const VECTOR_T* v) { gsl_vector* v_d = gsl_vector_alloc(v->size); for (int i = 0; i < (int)v->size; i++) { - gsl_vector_set(v_d, i, (double)VECTOR_ID(get)(v, i)); + double value = (double)VECTOR_ID(get)(v, i); + gsl_vector_set(v_d, i, value); } return v_d; } /* - * Converts a vector to long double precision. + * Converts a vector to a single-column matrix. */ -gsl_vector_long_double* matlab::to_vector_long_double(const VECTOR_TYPE* v) { - gsl_vector_long_double* v_ld = gsl_vector_long_double_alloc(v->size); +MATRIX_T* matlab::to_column_matrix(const VECTOR_T* v) { + MATRIX_T* m = MATRIX_ID(alloc)(v->size, 1); for (int i = 0; i < (int)v->size; i++) { - gsl_vector_long_double_set(v_ld, i, (long double)VECTOR_ID(get)(v, i)); + MATRIX_ID(set)(m, i, 0, VECTOR_ID(get)(v, i)); } - return v_ld; + return m; } /* - * Converts a matrix to a vector. The vector is constructed by consecutively - * appending columns. + * Converts a vector to a single-row matrix. */ -VECTOR_TYPE* matlab::to_vector(const MATRIX_TYPE* m) { - VECTOR_TYPE* v = VECTOR_ID(alloc)(m->size1 * m->size2); - for (int j = 0; j < (int)m->size2; j++) { - for (int i = 0; i < (int)m->size1; i++) { - FP_TYPE value = MATRIX_ID(get)(m, i, j); - VECTOR_ID(set)(v, j * m->size1 + i, value); - } +MATRIX_T* matlab::to_row_matrix(const VECTOR_T* v) { + MATRIX_T* m = MATRIX_ID(alloc)(1, v->size); + for (int i = 0; i < (int)v->size; i++) { + MATRIX_ID(set)(m, 0, i, VECTOR_ID(get)(v, i)); } - return v; + return m; } /* - * Converts a matrix to float precision. + * Converts a double-precision matrix to the currently selected precision. */ -gsl_matrix_float* matlab::to_matrix_float(const MATRIX_TYPE* m) { - gsl_matrix_float* m_f = gsl_matrix_float_alloc(m->size1, m->size2); - for (int i = 0; i < (int)m->size1; i++) { - for (int j = 0; j < (int)m->size2; j++) { - gsl_matrix_float_set(m_f, i, j, (float)MATRIX_ID(get)(m, i, j)); +MATRIX_T* matlab::to_matrix(const gsl_matrix* m_d) { + MATRIX_T* m = MATRIX_ID(alloc)(m_d->size1, m_d->size2); + for (int i = 0; i < (int)m_d->size1; i++) { + for (int j = 0; j < (int)m_d->size2; j++) { + FP_T value = (FP_T)gsl_matrix_get(m_d, i, j); + MATRIX_ID(set)(m, i, j, value); } } - return m_f; + return m; } /* * Converts a matrix to double precision. */ -gsl_matrix* matlab::to_matrix_double(const MATRIX_TYPE* m) { +gsl_matrix* matlab::to_matrix_double(const MATRIX_T* m) { gsl_matrix* m_d = gsl_matrix_alloc(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - gsl_matrix_set(m_d, i, j, (double)MATRIX_ID(get)(m, i, j)); + double value = (double)MATRIX_ID(get)(m, i, j); + gsl_matrix_set(m_d, i, j, value); } } return m_d; } -/* - * Converts a matrix to long double precision. - */ -gsl_matrix_long_double* matlab::to_matrix_long_double(const MATRIX_TYPE* m) { - gsl_matrix_long_double* m_ld = gsl_matrix_long_double_alloc(m->size1, m->size2); - for (int i = 0; i < (int)m->size1; i++) { - for (int j = 0; j < (int)m->size2; j++) { - gsl_matrix_long_double_set(m_ld, i, j, (long double)MATRIX_ID(get)(m, i, j)); - } - } - return m_ld; -} - -/* - * Converts a vector to a single-column matrix. - */ -MATRIX_TYPE* matlab::to_column_matrix(const VECTOR_TYPE* v) { - MATRIX_TYPE* m = MATRIX_ID(alloc)(v->size, 1); - for (int i = 0; i < (int)v->size; i++) { - MATRIX_ID(set)(m, i, 0, VECTOR_ID(get)(v, i)); - } - return m; -} - -/* - * Converts a vector to a single-row matrix. - */ -MATRIX_TYPE* matlab::to_row_matrix(const VECTOR_TYPE* v) { - MATRIX_TYPE* m = MATRIX_ID(alloc)(1, v->size); - for (int i = 0; i < (int)v->size; i++) { - MATRIX_ID(set)(m, 0, i, VECTOR_ID(get)(v, i)); - } - return m; -} - /* * Converts a permutation to a vector. */ -VECTOR_TYPE* matlab::FP_ID(to_vector)(const gsl_permutation* p) { - VECTOR_TYPE* v = VECTOR_ID(alloc)(p->size); +VECTOR_T* matlab::to_vector(const gsl_permutation* p) { + VECTOR_T* v = VECTOR_ID(alloc)(p->size); for (int i = 0; i < (int)p->size; i++) { - VECTOR_ID(set)(v, i, (FP_TYPE)gsl_permutation_get(p, i)); + VECTOR_ID(set)(v, i, (FP_T)gsl_permutation_get(p, i)); } return v; } @@ -153,7 +131,7 @@ VECTOR_TYPE* matlab::FP_ID(to_vector)(const gsl_permutation* p) { /* * Converts a vector to a permutation. */ -gsl_permutation* matlab::to_permutation(const VECTOR_TYPE* v) { +gsl_permutation* matlab::to_permutation(const VECTOR_T* v) { gsl_permutation* p = gsl_permutation_alloc(v->size); for (int i = 0; i < (int)v->size; i++) { p->data[i] = (int)VECTOR_ID(get)(v, i); diff --git a/matlab/functions.cpp b/matlab/functions.cpp index e712e83..fe9432c 100644 --- a/matlab/functions.cpp +++ b/matlab/functions.cpp @@ -1,28 +1,27 @@ #include #include -#include +#include #include -#include #include -#include -#include -#include + +#include "matlab.h" +#include "sort.h" /* * See MATLAB documentation for descriptions of these functions. We will * document instances where our version differs from the MATLAB version. */ -VECTOR_TYPE* matlab::abs(const VECTOR_TYPE* v) { - VECTOR_TYPE* abs_v = VECTOR_ID(alloc)(v->size); +VECTOR_T* matlab::abs(const VECTOR_T* v) { + VECTOR_T* abs_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { VECTOR_ID(set)(abs_v, i, std::abs(VECTOR_ID(get)(v, i))); } return abs_v; } -MATRIX_TYPE* matlab::abs(const MATRIX_TYPE* m) { - MATRIX_TYPE* abs_m = MATRIX_ID(alloc)(m->size1, m->size2); +MATRIX_T* matlab::abs(const MATRIX_T* m) { + MATRIX_T* abs_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { MATRIX_ID(set)(abs_m, i, j, std::abs(MATRIX_ID(get)(m, i, j))); @@ -31,7 +30,7 @@ MATRIX_TYPE* matlab::abs(const MATRIX_TYPE* m) { return abs_m; } -int matlab::all(const VECTOR_TYPE* v) { +int matlab::all(const VECTOR_T* v) { for (int i = 0; i < (int)v->size; i++) { if (fp_zero(VECTOR_ID(get)(v, i))) { return 0; @@ -40,16 +39,16 @@ int matlab::all(const VECTOR_TYPE* v) { return 1; } -VECTOR_TYPE* matlab::all(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::all(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* all_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* all_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); VECTOR_ID(set)(all_v, i, all(&m_col_i.vector)); } return all_v; } else if (dim == 2) { - VECTOR_TYPE* all_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* all_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); VECTOR_ID(set)(all_v, i, all(&m_row_i.vector)); @@ -60,7 +59,7 @@ VECTOR_TYPE* matlab::all(const MATRIX_TYPE* m, int dim) { } } -int matlab::any(const VECTOR_TYPE* v) { +int matlab::any(const VECTOR_T* v) { for (int i = 0; i < (int)v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(v, i))) { return 1; @@ -69,16 +68,16 @@ int matlab::any(const VECTOR_TYPE* v) { return 0; } -VECTOR_TYPE* matlab::any(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::any(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* any_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* any_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); VECTOR_ID(set)(any_v, i, any(&m_col_i.vector)); } return any_v; } else if (dim == 2) { - VECTOR_TYPE* any_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* any_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); VECTOR_ID(set)(any_v, i, any(&m_row_i.vector)); @@ -89,20 +88,40 @@ VECTOR_TYPE* matlab::any(const MATRIX_TYPE* m, int dim) { } } -MATRIX_TYPE* matlab::diag(const VECTOR_TYPE* v, int k) { +std::string matlab::dec2bin(int n) { + return dec2bin(n, 0); +} + +std::string matlab::dec2bin(int n, int len) { + if (n < 0) { + return ""; + } + int binlen = (int)(std::floor(1.0 + std::log(n) / std::log(2))); + std::string bin((len > binlen) ? len : binlen, '0'); + for (int i = bin.size() - 1; i >= 0; i--) { + int remainder = n % 2; + if (remainder) { + bin[i] = '1'; + } + n >>= 1; + } + return bin; +} + +MATRIX_T* matlab::diag(const VECTOR_T* v, int k) { int i0; int j0; if (k >= 0) { i0 = 0; j0 = k; } else { i0 = -k; j0 = 0; } int n = (int)v->size + (int)std::abs(k); - MATRIX_TYPE* diag_m = MATRIX_ID(calloc)(n, n); + MATRIX_T* diag_m = MATRIX_ID(calloc)(n, n); for (int i = 0; i < (int)v->size; i++) { MATRIX_ID(set)(diag_m, i0 + i, j0 + i, VECTOR_ID(get)(v, i)); } return diag_m; } -VECTOR_TYPE* matlab::diag(const MATRIX_TYPE* m, int k) { +VECTOR_T* matlab::diag(const MATRIX_T* m, int k) { if (k <= -(int)m->size1 || k >= (int)m->size2) { return NULL; } @@ -113,30 +132,30 @@ VECTOR_TYPE* matlab::diag(const MATRIX_TYPE* m, int k) { int n_rows = m->size1 - i0; int n_cols = m->size2 - j0; int n = (n_rows < n_cols) ? n_rows : n_cols; - VECTOR_TYPE* diag_v = VECTOR_ID(alloc)(n); + VECTOR_T* diag_v = VECTOR_ID(alloc)(n); for (int i = 0; i < n; i++) { VECTOR_ID(set)(diag_v, i, MATRIX_ID(get)(m, i0 + i, j0 + i)); } return diag_v; } -MATRIX_TYPE* matlab::FP_ID(eye)(int size) { - return FP_ID(eye)(size, size); +MATRIX_T* matlab::eye(int size) { + return eye(size, size); } -MATRIX_TYPE* matlab::FP_ID(eye)(int size1, int size2) { - MATRIX_TYPE* eye_m = MATRIX_ID(calloc)(size1, size2); +MATRIX_T* matlab::eye(int size1, int size2) { + MATRIX_T* eye_m = MATRIX_ID(calloc)(size1, size2); VECTOR_ID(view) diag_eye_m = MATRIX_ID(diagonal)(eye_m); VECTOR_ID(set_all)(&diag_eye_m.vector, 1.0); return eye_m; } -VECTOR_TYPE* matlab::find(const VECTOR_TYPE* v, int n, const std::string& direction) { +VECTOR_T* matlab::find(const VECTOR_T* v, int n, const std::string& direction) { int n_find = nnz(v); if (n_find == 0 || n < 1) { return NULL; } - VECTOR_TYPE* find_v = VECTOR_ID(alloc)((n < n_find) ? n : n_find); + VECTOR_T* find_v = VECTOR_ID(alloc)((n < n_find) ? n : n_find); if (direction == "first") { int position = 0; for (int i = 0; i < (int)v->size && position < (int)find_v->size; i++) { @@ -161,9 +180,9 @@ VECTOR_TYPE* matlab::find(const VECTOR_TYPE* v, int n, const std::string& direct } } -VECTOR_TYPE* matlab::find(const MATRIX_TYPE* m, int n, const std::string& direction) { - VECTOR_TYPE* v = to_vector(m); - VECTOR_TYPE* find_v = find(v, n, direction); +VECTOR_T* matlab::find(const MATRIX_T* m, int n, const std::string& direction) { + VECTOR_T* v = to_vector(m); + VECTOR_T* find_v = find(v, n, direction); VECTOR_ID(free)(v); return find_v; } @@ -171,51 +190,51 @@ VECTOR_TYPE* matlab::find(const MATRIX_TYPE* m, int n, const std::string& direct /* * Emulates the two-return version of "find". */ -MATRIX_TYPE* matlab::find_ij(const MATRIX_TYPE* m, int n, const std::string& direction) { - VECTOR_TYPE* find_v = find(m, n, direction); +MATRIX_T* matlab::find_ij(const MATRIX_T* m, int n, const std::string& direction) { + VECTOR_T* find_v = find(m, n, direction); if (find_v == NULL) { return NULL; } else { - MATRIX_TYPE* find_m = MATRIX_ID(alloc)(find_v->size, 2); + MATRIX_T* find_m = MATRIX_ID(alloc)(find_v->size, 2); for (int i = 0; i < (int)find_v->size; i++) { int index = (int)VECTOR_ID(get)(find_v, i); int row = index % (int)m->size1; int column = index / (int)m->size1; - MATRIX_ID(set)(find_m, i, 0, (FP_TYPE)row); - MATRIX_ID(set)(find_m, i, 1, (FP_TYPE)column); + MATRIX_ID(set)(find_m, i, 0, (FP_T)row); + MATRIX_ID(set)(find_m, i, 1, (FP_T)column); } VECTOR_ID(free)(find_v); return find_m; } } -VECTOR_TYPE* matlab::hist(const VECTOR_TYPE* v, int n) { - VECTOR_TYPE* centers = VECTOR_ID(alloc)(n); - FP_TYPE min_value = min(v); - FP_TYPE max_value = max(v); - FP_TYPE width = (max_value - min_value) / (FP_TYPE)n; +VECTOR_T* matlab::hist(const VECTOR_T* v, int n) { + VECTOR_T* centers = VECTOR_ID(alloc)(n); + FP_T min_value = min(v); + FP_T max_value = max(v); + FP_T width = (max_value - min_value) / (FP_T)n; for (int i = 0; i < n; i++) { VECTOR_ID(set)(centers, i, min_value + (i + 0.5) * width); } - VECTOR_TYPE* hist_v = hist(v, centers); + VECTOR_T* hist_v = hist(v, centers); VECTOR_ID(free)(centers); return hist_v; } -VECTOR_TYPE* matlab::hist(const VECTOR_TYPE* v, const VECTOR_TYPE* centers) { +VECTOR_T* matlab::hist(const VECTOR_T* v, const VECTOR_T* centers) { int n = centers->size; - VECTOR_TYPE* hist_v = VECTOR_ID(calloc)(n); + VECTOR_T* hist_v = VECTOR_ID(calloc)(n); for (int i = 0; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); int index = n - 1; for (int j = 0; j < n - 1; j++) { - FP_TYPE left = VECTOR_ID(get)(centers, j); - FP_TYPE right = VECTOR_ID(get)(centers, j + 1); + FP_T left = VECTOR_ID(get)(centers, j); + FP_T right = VECTOR_ID(get)(centers, j + 1); if (value < left) { index = j; break; } else if (value < right) { - FP_TYPE middle = (left + right) / 2.0; + FP_T middle = (left + right) / 2.0; if (fp_less_or_equal(value, middle)) { index = j; } else { @@ -229,15 +248,39 @@ VECTOR_TYPE* matlab::hist(const VECTOR_TYPE* v, const VECTOR_TYPE* centers) { return hist_v; } -int matlab::length(const VECTOR_TYPE* v) { +MATRIX_T* matlab::inv(const MATRIX_T* m) { + if (m->size1 != m->size2) { + return NULL; + } + gsl_matrix* lu = to_matrix_double(m); + gsl_permutation* p = gsl_permutation_alloc(m->size1); + int signum; + gsl_linalg_LU_decomp(lu, p, &signum); + gsl_matrix* inv_m = NULL; + if (fp_nonzero(gsl_linalg_LU_det(lu, signum))) { + inv_m = gsl_matrix_alloc(m->size1, m->size2); + gsl_linalg_LU_invert(lu, p, inv_m); + } + gsl_matrix_free(lu); + gsl_permutation_free(p); + if (inv_m == NULL) { + return NULL; + } else { + MATRIX_T* ret = to_matrix(inv_m); + gsl_matrix_free(inv_m); + return ret; + } +} + +int matlab::length(const VECTOR_T* v) { return v->size; } -int matlab::length(const MATRIX_TYPE* m) { +int matlab::length(const MATRIX_T* m) { return (m->size1 > m->size2) ? m->size1 : m->size2; } -FP_TYPE matlab::max(FP_TYPE x, FP_TYPE y) { +FP_T matlab::max(FP_T x, FP_T y) { if (gsl_isnan((double)x) == 1) { return y; } else if (gsl_isnan((double)y) == 1) { @@ -247,18 +290,18 @@ FP_TYPE matlab::max(FP_TYPE x, FP_TYPE y) { } } -FP_TYPE matlab::max(const VECTOR_TYPE* v) { - FP_TYPE max = (FP_TYPE)GSL_NAN; +FP_T matlab::max(const VECTOR_T* v) { + FP_T max = (FP_T)GSL_NAN; int i = 0; for ( ; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); if (gsl_isnan((double)value) == 0) { max = value; break; } } for ( ; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); if (gsl_isnan((double)value) == 0 && value > max) { max = value; } @@ -269,20 +312,20 @@ FP_TYPE matlab::max(const VECTOR_TYPE* v) { /* * Emulates (max(m)) or (max(m')). */ -VECTOR_TYPE* matlab::max(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::max(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* max_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* max_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); - FP_TYPE value = max(&m_col_i.vector); + FP_T value = max(&m_col_i.vector); VECTOR_ID(set)(max_v, i, value); } return max_v; } else if (dim == 2) { - VECTOR_TYPE* max_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* max_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); - FP_TYPE value = max(&m_row_i.vector); + FP_T value = max(&m_row_i.vector); VECTOR_ID(set)(max_v, i, value); } return max_v; @@ -291,44 +334,44 @@ VECTOR_TYPE* matlab::max(const MATRIX_TYPE* m, int dim) { } } -FP_TYPE matlab::mean(const VECTOR_TYPE* v, const std::string& opt) { +FP_T matlab::mean(const VECTOR_T* v, const std::string& opt) { if (opt == "a") { - FP_TYPE sum = 0.0; + FP_T sum = 0.0; for (int i = 0; i < (int)v->size; i++) { sum += VECTOR_ID(get)(v, i); } - return sum / (FP_TYPE)v->size; + return sum / (FP_T)v->size; } else if (opt == "g") { - FP_TYPE product = 1.0; + FP_T product = 1.0; for (int i = 0; i < (int)v->size; i++) { product *= VECTOR_ID(get)(v, i); } - return std::pow(product, (FP_TYPE)1.0 / (FP_TYPE)v->size); + return std::pow(product, (FP_T)1.0 / (FP_T)v->size); } else if (opt == "h") { - FP_TYPE sum = 0.0; + FP_T sum = 0.0; for (int i = 0; i < (int)v->size; i++) { sum += 1.0 / VECTOR_ID(get)(v, i); } - return (FP_TYPE)v->size / sum; + return (FP_T)v->size / sum; } else { return GSL_NAN; } } -VECTOR_TYPE* matlab::mean(const MATRIX_TYPE* m, int dim, const std::string& opt) { +VECTOR_T* matlab::mean(const MATRIX_T* m, int dim, const std::string& opt) { if (dim == 1) { - VECTOR_TYPE* mean_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* mean_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); - FP_TYPE value = mean(&m_col_i.vector, opt); + FP_T value = mean(&m_col_i.vector, opt); VECTOR_ID(set)(mean_v, i, value); } return mean_v; } else if (dim == 2) { - VECTOR_TYPE* mean_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* mean_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); - FP_TYPE value = mean(&m_row_i.vector, opt); + FP_T value = mean(&m_row_i.vector, opt); VECTOR_ID(set)(mean_v, i, value); } return mean_v; @@ -337,7 +380,7 @@ VECTOR_TYPE* matlab::mean(const MATRIX_TYPE* m, int dim, const std::string& opt) } } -FP_TYPE matlab::min(FP_TYPE x, FP_TYPE y) { +FP_T matlab::min(FP_T x, FP_T y) { if (gsl_isnan((double)x) == 1) { return y; } else if (gsl_isnan((double)y) == 1) { @@ -347,18 +390,18 @@ FP_TYPE matlab::min(FP_TYPE x, FP_TYPE y) { } } -FP_TYPE matlab::min(const VECTOR_TYPE* v) { - FP_TYPE min = (FP_TYPE)GSL_NAN; +FP_T matlab::min(const VECTOR_T* v) { + FP_T min = (FP_T)GSL_NAN; int i = 0; for ( ; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); if (gsl_isnan((double)value) == 0) { min = value; break; } } for ( ; i < (int)v->size; i++) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); if (gsl_isnan((double)value) == 0 && value < min) { min = value; } @@ -369,20 +412,20 @@ FP_TYPE matlab::min(const VECTOR_TYPE* v) { /* * Emulates (min(m)) or (min(m')). */ -VECTOR_TYPE* matlab::min(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::min(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* min_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* min_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); - FP_TYPE value = min(&m_col_i.vector); + FP_T value = min(&m_col_i.vector); VECTOR_ID(set)(min_v, i, value); } return min_v; } else if (dim == 2) { - VECTOR_TYPE* min_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* min_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); - FP_TYPE value = min(&m_row_i.vector); + FP_T value = min(&m_row_i.vector); VECTOR_ID(set)(min_v, i, value); } return min_v; @@ -391,7 +434,7 @@ VECTOR_TYPE* matlab::min(const MATRIX_TYPE* m, int dim) { } } -int matlab::nnz(const VECTOR_TYPE* v) { +int matlab::nnz(const VECTOR_T* v) { int nnz = 0; for (int i = 0; i < (int)v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(v, i))) { @@ -401,41 +444,56 @@ int matlab::nnz(const VECTOR_TYPE* v) { return nnz; } -int matlab::nnz(const MATRIX_TYPE* m) { - VECTOR_TYPE* v = to_vector(m); +int matlab::nnz(const MATRIX_T* m) { + VECTOR_T* v = to_vector(m); int nnz_v = nnz(v); VECTOR_ID(free)(v); return nnz_v; } -VECTOR_TYPE* matlab::nonzeros(const MATRIX_TYPE* m) { - VECTOR_TYPE* nz_v = find(m); +VECTOR_T* matlab::nonzeros(const MATRIX_T* m) { + VECTOR_T* nz_v = find(m); if (nz_v != NULL) { for (int i = 0; i < (int)nz_v->size; i++) { int i_m = (int)VECTOR_ID(get)(nz_v, i); - FP_TYPE value = ordinal_index(m, i_m); + FP_T value = ordinal_index(m, i_m); VECTOR_ID(set)(nz_v, i, value); } } return nz_v; } -VECTOR_TYPE* matlab::normpdf(const VECTOR_TYPE* v, FP_TYPE mean, FP_TYPE stdev) { - VECTOR_TYPE* pdf_v = VECTOR_ID(alloc)(v->size); +/* + * Currently only supports p > 1. + */ +FP_T matlab::norm(const VECTOR_T* v, int p) { + if (p > 1) { + FP_T sum = 0.0; + for (int i = 0; i < (int)v->size; i++) { + sum += std::pow(std::abs(VECTOR_ID(get)(v, i)), p); + } + return std::pow(sum, (FP_T)1.0 / p); + } else { + return 0.0; + } +} + +VECTOR_T* matlab::normpdf(const VECTOR_T* v, FP_T mean, FP_T stdev) { + VECTOR_T* pdf_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { double x = (double)VECTOR_ID(get)(v, i); double p = gsl_ran_gaussian_pdf(x - mean, stdev); - VECTOR_ID(set)(pdf_v, i, (FP_TYPE)p); + VECTOR_ID(set)(pdf_v, i, (FP_T)p); } return pdf_v; } -MATRIX_TYPE* matlab::FP_ID(ones)(int size) { - return FP_ID(ones)(size, size); +MATRIX_T* matlab::ones(int size) { + return ones(size, size); } -MATRIX_TYPE* matlab::FP_ID(ones)(int size1, int size2) { - MATRIX_TYPE* ones_m = MATRIX_ID(alloc)(size1, size2); +MATRIX_T* matlab::ones(int size1, int size2) { + MATRIX_T* ones_m = MATRIX_ID(alloc)(size1, size2); MATRIX_ID(set_all)(ones_m, 1.0); return ones_m; } @@ -443,23 +501,23 @@ MATRIX_TYPE* matlab::FP_ID(ones)(int size1, int size2) { /* * Emulates (ones(size, 1)) or (ones(1, size)). */ -VECTOR_TYPE* matlab::FP_ID(ones_vector)(int size) { - VECTOR_TYPE* ones_v = VECTOR_ID(alloc)(size); +VECTOR_T* matlab::ones_vector(int size) { + VECTOR_T* ones_v = VECTOR_ID(alloc)(size); VECTOR_ID(set_all)(ones_v, 1.0); return ones_v; } -FP_TYPE matlab::prod(const VECTOR_TYPE* v) { - FP_TYPE prod = 1.0; +FP_T matlab::prod(const VECTOR_T* v) { + FP_T prod = 1.0; for (int i = 0; i < (int)v->size; i++) { prod *= VECTOR_ID(get)(v, i); } return prod; } -VECTOR_TYPE* matlab::prod(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::prod(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* prod_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* prod_v = VECTOR_ID(alloc)(m->size2); VECTOR_ID(set_all)(prod_v, 1.0); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); @@ -467,7 +525,7 @@ VECTOR_TYPE* matlab::prod(const MATRIX_TYPE* m, int dim) { } return prod_v; } else if (dim == 2) { - VECTOR_TYPE* prod_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* prod_v = VECTOR_ID(alloc)(m->size1); VECTOR_ID(set_all)(prod_v, 1.0); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); @@ -479,39 +537,55 @@ VECTOR_TYPE* matlab::prod(const MATRIX_TYPE* m, int dim) { } } -MATRIX_TYPE* matlab::FP_ID(rand)(int size) { - return FP_ID(rand)(size, size); +MATRIX_T* matlab::rand(int size) { + return rand(size, size); } -MATRIX_TYPE* matlab::FP_ID(rand)(int size1, int size2) { - gsl_rng* rng = get_gsl_rng(); - MATRIX_TYPE* rand_m = MATRIX_ID(alloc)(size1, size2); +MATRIX_T* matlab::rand(int size1, int size2) { + gsl_rng* rng = get_rng(); + MATRIX_T* rand_m = MATRIX_ID(alloc)(size1, size2); for (int i = 0; i < size1; i++) { for (int j = 0; j < size2; j++) { - MATRIX_ID(set)(rand_m, i, j, (FP_TYPE)gsl_rng_uniform(rng)); + MATRIX_ID(set)(rand_m, i, j, (FP_T)gsl_rng_uniform(rng)); } } return rand_m; } -VECTOR_TYPE* matlab::FP_ID(rand_vector)(int size) { - gsl_rng* rng = get_gsl_rng(); - VECTOR_TYPE* rand_v = VECTOR_ID(alloc)(size); +VECTOR_T* matlab::rand_vector(int size) { + gsl_rng* rng = get_rng(); + VECTOR_T* rand_v = VECTOR_ID(alloc)(size); for (int i = 0; i < size; i++) { - VECTOR_ID(set)(rand_v, i, (FP_TYPE)gsl_rng_uniform(rng)); + VECTOR_ID(set)(rand_v, i, (FP_T)gsl_rng_uniform(rng)); } return rand_v; } -VECTOR_TYPE* matlab::reverse(const VECTOR_TYPE* v) { - VECTOR_TYPE* rev_v = VECTOR_ID(alloc)(v->size); +/* + * Generates a permutation of the integers 0 to (size - 1), whereas the MATLAB + * version uses the integers 1 to size. + */ +gsl_permutation* matlab::randperm(int size) { + gsl_rng* rng = get_rng(); + FP_T values[size]; + for (int i = 0; i < size; i++) { + values[i] = (FP_T)i; + } + gsl_ran_shuffle(rng, values, size, sizeof(FP_T)); + VECTOR_ID(view) values_vv = VECTOR_ID(view_array)(values, size); + gsl_permutation* values_p = to_permutation(&values_vv.vector); + return values_p; +} + +VECTOR_T* matlab::reverse(const VECTOR_T* v) { + VECTOR_T* rev_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { VECTOR_ID(set)(rev_v, i, VECTOR_ID(get)(v, v->size - 1 - i)); } return rev_v; } -VECTOR_TYPE* matlab::setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +VECTOR_T* matlab::setxor(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1 == NULL && v2 == NULL) { return NULL; } @@ -521,15 +595,15 @@ VECTOR_TYPE* matlab::setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { if (v2 == NULL) { return unique(v1); } - VECTOR_TYPE* unique_v1 = unique(v1); - VECTOR_TYPE* unique_v2 = unique(v2); - VECTOR_TYPE* unsized_v = VECTOR_ID(alloc)(v1->size + v2->size); + VECTOR_T* unique_v1 = unique(v1); + VECTOR_T* unique_v2 = unique(v2); + VECTOR_T* unsized_v = VECTOR_ID(alloc)(v1->size + v2->size); int n = 0; for (int i = 0; i < (int)unique_v1->size; i++) { bool found = false; - FP_TYPE v1_value = VECTOR_ID(get)(unique_v1, i); + FP_T v1_value = VECTOR_ID(get)(unique_v1, i); for (int j = 0; j < (int)unique_v2->size; j++) { - FP_TYPE v2_value = VECTOR_ID(get)(unique_v2, j); + FP_T v2_value = VECTOR_ID(get)(unique_v2, j); if (fp_equal(v1_value, v2_value)) { found = true; break; @@ -541,9 +615,9 @@ VECTOR_TYPE* matlab::setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { } for (int i = 0; i < (int)unique_v2->size; i++) { bool found = false; - FP_TYPE v2_value = VECTOR_ID(get)(unique_v2, i); + FP_T v2_value = VECTOR_ID(get)(unique_v2, i); for (int j = 0; j < (int)unique_v1->size; j++) { - FP_TYPE v1_value = VECTOR_ID(get)(unique_v1, j); + FP_T v1_value = VECTOR_ID(get)(unique_v1, j); if (fp_equal(v2_value, v1_value)) { found = true; break; @@ -556,11 +630,11 @@ VECTOR_TYPE* matlab::setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { VECTOR_ID(free)(unique_v1); VECTOR_ID(free)(unique_v2); if (n > 0) { - VECTOR_TYPE* unsorted_v = VECTOR_ID(alloc)(n); + VECTOR_T* unsorted_v = VECTOR_ID(alloc)(n); VECTOR_ID(view) unsized_subv = VECTOR_ID(subvector)(unsized_v, 0, n); VECTOR_ID(memcpy)(unsorted_v, &unsized_subv.vector); VECTOR_ID(free)(unsized_v); - VECTOR_TYPE* setxor_v = sort(unsorted_v); + VECTOR_T* setxor_v = sort(unsorted_v); VECTOR_ID(free)(unsorted_v); return setxor_v; } else { @@ -569,11 +643,11 @@ VECTOR_TYPE* matlab::setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { } } -VECTOR_TYPE* matlab::sort(const VECTOR_TYPE* v, const std::string& mode, VECTOR_TYPE** ind) { +VECTOR_T* matlab::sort(const VECTOR_T* v, const std::string& mode, VECTOR_T** ind) { if (mode != "ascend" && mode != "descend") { return NULL; } - FP_TYPE elements[v->size]; + FP_T elements[v->size]; to_array(v, elements); std::size_t indices[v->size]; if (mode == "ascend") { @@ -581,7 +655,7 @@ VECTOR_TYPE* matlab::sort(const VECTOR_TYPE* v, const std::string& mode, VECTOR_ } else { stable_sort_index(indices, elements, v->size, fp_greater); } - VECTOR_TYPE* sort_v = VECTOR_ID(alloc)(v->size); + VECTOR_T* sort_v = VECTOR_ID(alloc)(v->size); if (ind != NULL) { *ind = VECTOR_ID(alloc)(v->size); } @@ -589,28 +663,28 @@ VECTOR_TYPE* matlab::sort(const VECTOR_TYPE* v, const std::string& mode, VECTOR_ int index = indices[i]; VECTOR_ID(set)(sort_v, i, elements[index]); if (ind != NULL) { - VECTOR_ID(set)(*ind, i, (FP_TYPE)index); + VECTOR_ID(set)(*ind, i, (FP_T)index); } } return sort_v; } -MATRIX_TYPE* matlab::sort(const MATRIX_TYPE* m, int dim, const std::string& mode, MATRIX_TYPE** ind) { +MATRIX_T* matlab::sort(const MATRIX_T* m, int dim, const std::string& mode, MATRIX_T** ind) { if (mode != "ascend" && mode != "descend") { return NULL; } if (dim == 1) { - MATRIX_TYPE* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); if (ind != NULL) { *ind = MATRIX_ID(alloc)(m->size1, m->size2); } for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); - VECTOR_TYPE* sort_m_col_i; + VECTOR_T* sort_m_col_i; if (ind == NULL) { sort_m_col_i = sort(&m_col_i.vector, mode); } else { - VECTOR_TYPE* ind_col_i; + VECTOR_T* ind_col_i; sort_m_col_i = sort(&m_col_i.vector, mode, &ind_col_i); MATRIX_ID(set_col)(*ind, i, ind_col_i); VECTOR_ID(free)(ind_col_i); @@ -620,17 +694,17 @@ MATRIX_TYPE* matlab::sort(const MATRIX_TYPE* m, int dim, const std::string& mode } return sort_m; } else if (dim == 2) { - MATRIX_TYPE* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); if (ind != NULL) { *ind = MATRIX_ID(alloc)(m->size1, m->size2); } for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); - VECTOR_TYPE* sort_m_row_i; + VECTOR_T* sort_m_row_i; if (ind == NULL) { sort_m_row_i = sort(&m_row_i.vector, mode); } else { - VECTOR_TYPE* ind_row_i; + VECTOR_T* ind_row_i; sort_m_row_i = sort(&m_row_i.vector, mode, &ind_row_i); MATRIX_ID(set_row)(*ind, i, ind_row_i); VECTOR_ID(free)(ind_row_i); @@ -647,12 +721,12 @@ MATRIX_TYPE* matlab::sort(const MATRIX_TYPE* m, int dim, const std::string& mode /* * Emulates (sortrows(v)) for a column vector. */ -VECTOR_TYPE* matlab::sortrows(const VECTOR_TYPE* v, VECTOR_TYPE** ind) { +VECTOR_T* matlab::sortrows(const VECTOR_T* v, VECTOR_T** ind) { return sort(v, "ascend", ind); } -MATRIX_TYPE* matlab::sortrows(const MATRIX_TYPE* m, VECTOR_TYPE** ind) { - VECTOR_TYPE* rows[m->size1]; +MATRIX_T* matlab::sortrows(const MATRIX_T* m, VECTOR_T** ind) { + VECTOR_T* rows[m->size1]; for (int i = 0; i < (int)m->size1; i++) { rows[i] = VECTOR_ID(alloc)(m->size2); MATRIX_ID(get_row)(rows[i], m, i); @@ -662,7 +736,7 @@ MATRIX_TYPE* matlab::sortrows(const MATRIX_TYPE* m, VECTOR_TYPE** ind) { for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(free)(rows[i]); } - MATRIX_TYPE* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* sort_m = MATRIX_ID(alloc)(m->size1, m->size2); if (ind != NULL) { *ind = VECTOR_ID(alloc)(m->size1); } @@ -671,41 +745,41 @@ MATRIX_TYPE* matlab::sortrows(const MATRIX_TYPE* m, VECTOR_TYPE** ind) { VECTOR_ID(const_view) m_row_index = MATRIX_ID(const_row)(m, index); MATRIX_ID(set_row)(sort_m, i, &m_row_index.vector); if (ind != NULL) { - VECTOR_ID(set)(*ind, i, (FP_TYPE)index); + VECTOR_ID(set)(*ind, i, (FP_T)index); } } return sort_m; } -FP_TYPE matlab::std(const VECTOR_TYPE* v, int opt) { - FP_TYPE mu = mean(v); - FP_TYPE err = 0.0; +FP_T matlab::std(const VECTOR_T* v, int opt) { + FP_T mu = mean(v); + FP_T err = 0.0; for (int i = 0; i < (int)v->size; i++) { err += std::pow(VECTOR_ID(get)(v, i) - mu, 2); } if (opt == 0) { - return std::sqrt(err / (FP_TYPE)(v->size - 1)); + return std::sqrt(err / (FP_T)(v->size - 1)); } else if (opt == 1) { - return std::sqrt(err / (FP_TYPE)v->size); + return std::sqrt(err / (FP_T)v->size); } else { return GSL_NAN; } } -VECTOR_TYPE* matlab::std(const MATRIX_TYPE* m, int opt, int dim) { +VECTOR_T* matlab::std(const MATRIX_T* m, int opt, int dim) { if (dim == 1) { - VECTOR_TYPE* std_v = VECTOR_ID(alloc)(m->size2); + VECTOR_T* std_v = VECTOR_ID(alloc)(m->size2); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); - FP_TYPE value = matlab::std(&m_col_i.vector, opt); + FP_T value = matlab::std(&m_col_i.vector, opt); VECTOR_ID(set)(std_v, i, value); } return std_v; } else if (dim == 2) { - VECTOR_TYPE* std_v = VECTOR_ID(alloc)(m->size1); + VECTOR_T* std_v = VECTOR_ID(alloc)(m->size1); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); - FP_TYPE value = matlab::std(&m_row_i.vector, opt); + FP_T value = matlab::std(&m_row_i.vector, opt); VECTOR_ID(set)(std_v, i, value); } return std_v; @@ -714,24 +788,24 @@ VECTOR_TYPE* matlab::std(const MATRIX_TYPE* m, int opt, int dim) { } } -FP_TYPE matlab::sum(const VECTOR_TYPE* v) { - FP_TYPE sum = 0.0; +FP_T matlab::sum(const VECTOR_T* v) { + FP_T sum = 0.0; for (int i = 0; i < (int)v->size; i++) { sum += VECTOR_ID(get)(v, i); } return sum; } -VECTOR_TYPE* matlab::sum(const MATRIX_TYPE* m, int dim) { +VECTOR_T* matlab::sum(const MATRIX_T* m, int dim) { if (dim == 1) { - VECTOR_TYPE* sum_v = VECTOR_ID(calloc)(m->size2); + VECTOR_T* sum_v = VECTOR_ID(calloc)(m->size2); for (int i = 0; i < (int)m->size1; i++) { VECTOR_ID(const_view) m_row_i = MATRIX_ID(const_row)(m, i); VECTOR_ID(add)(sum_v, &m_row_i.vector); } return sum_v; } else if (dim == 2) { - VECTOR_TYPE* sum_v = VECTOR_ID(calloc)(m->size1); + VECTOR_T* sum_v = VECTOR_ID(calloc)(m->size1); for (int i = 0; i < (int)m->size2; i++) { VECTOR_ID(const_view) m_col_i = MATRIX_ID(const_column)(m, i); VECTOR_ID(add)(sum_v, &m_col_i.vector); @@ -742,17 +816,17 @@ VECTOR_TYPE* matlab::sum(const MATRIX_TYPE* m, int dim) { } } -MATRIX_TYPE* matlab::toeplitz(const VECTOR_TYPE* column, const VECTOR_TYPE* row) { - const VECTOR_TYPE* _row; +MATRIX_T* matlab::toeplitz(const VECTOR_T* column, const VECTOR_T* row) { + const VECTOR_T* _row; if (row == NULL) { _row = column; } else { _row = row; } - MATRIX_TYPE* toe_m = MATRIX_ID(alloc)(column->size, _row->size); + MATRIX_T* toe_m = MATRIX_ID(alloc)(column->size, _row->size); for (int i = 0; i < (int)column->size; i++) { for (int j = 0; j < (int)_row->size; j++) { - FP_TYPE value; + FP_T value; if (i - j >= 0) { value = VECTOR_ID(get)(column, i - j); } else { @@ -764,11 +838,11 @@ MATRIX_TYPE* matlab::toeplitz(const VECTOR_TYPE* column, const VECTOR_TYPE* row) return toe_m; } -MATRIX_TYPE* matlab::tril(const MATRIX_TYPE* m, int k) { +MATRIX_T* matlab::tril(const MATRIX_T* m, int k) { if (k < -(int)m->size1 || k > (int)m->size2) { return NULL; } - MATRIX_TYPE* tril_m = copy(m); + MATRIX_T* tril_m = copy(m); for (int i = 0; i < (int)m->size1; i++) { for (int j = i + k + 1; j < (int)m->size2; j++) { if (j >= 0) { @@ -779,11 +853,11 @@ MATRIX_TYPE* matlab::tril(const MATRIX_TYPE* m, int k) { return tril_m; } -MATRIX_TYPE* matlab::triu(const MATRIX_TYPE* m, int k) { +MATRIX_T* matlab::triu(const MATRIX_T* m, int k) { if (k < -(int)m->size1 || k > (int)m->size2) { return NULL; } - MATRIX_TYPE* triu_m = copy(m); + MATRIX_T* triu_m = copy(m); for (int i = 0; i < (int)m->size1; i++) { for (int j = i + k - 1; j >= 0; j--) { if (j < (int)m->size2) { @@ -794,23 +868,23 @@ MATRIX_TYPE* matlab::triu(const MATRIX_TYPE* m, int k) { return triu_m; } -VECTOR_TYPE* matlab::unique(const VECTOR_TYPE* v, const std::string& first_or_last, VECTOR_TYPE** i, VECTOR_TYPE** j) { +VECTOR_T* matlab::unique(const VECTOR_T* v, const std::string& first_or_last, VECTOR_T** i, VECTOR_T** j) { if (first_or_last != "first" && first_or_last != "last") { return NULL; } - VECTOR_TYPE* sort_v = sort(v); - VECTOR_TYPE* unsized_v = VECTOR_ID(alloc)(v->size); + VECTOR_T* sort_v = sort(v); + VECTOR_T* unsized_v = VECTOR_ID(alloc)(v->size); VECTOR_ID(set)(unsized_v, 0, VECTOR_ID(get)(sort_v, 0)); int n = 1; for (int x = 1; x < (int)v->size; x++) { - FP_TYPE prev_value = VECTOR_ID(get)(sort_v, x - 1); - FP_TYPE value = VECTOR_ID(get)(sort_v, x); + FP_T prev_value = VECTOR_ID(get)(sort_v, x - 1); + FP_T value = VECTOR_ID(get)(sort_v, x); if (fp_not_equal(prev_value, value)) { VECTOR_ID(set)(unsized_v, n++, value); } } VECTOR_ID(free)(sort_v); - VECTOR_TYPE* unique_v = VECTOR_ID(alloc)(n); + VECTOR_T* unique_v = VECTOR_ID(alloc)(n); VECTOR_ID(view) unsized_subv = VECTOR_ID(subvector)(unsized_v, 0, n); VECTOR_ID(memcpy)(unique_v, &unsized_subv.vector); VECTOR_ID(free)(unsized_v); @@ -841,9 +915,9 @@ VECTOR_TYPE* matlab::unique(const VECTOR_TYPE* v, const std::string& first_or_la return unique_v; } -VECTOR_TYPE* matlab::unique(const MATRIX_TYPE* m, const std::string& first_or_last, VECTOR_TYPE** i, VECTOR_TYPE** j) { - VECTOR_TYPE* v = to_vector(m); - VECTOR_TYPE* unique_v = unique(v, first_or_last, i, j); +VECTOR_T* matlab::unique(const MATRIX_T* m, const std::string& first_or_last, VECTOR_T** i, VECTOR_T** j) { + VECTOR_T* v = to_vector(m); + VECTOR_T* unique_v = unique(v, first_or_last, i, j); VECTOR_ID(free)(v); return unique_v; } @@ -851,12 +925,12 @@ VECTOR_TYPE* matlab::unique(const MATRIX_TYPE* m, const std::string& first_or_la /* * Emulates (unique(m, "rows", first_or_last)). */ -MATRIX_TYPE* matlab::unique_rows(const MATRIX_TYPE* m, const std::string& first_or_last, VECTOR_TYPE** i, VECTOR_TYPE** j) { +MATRIX_T* matlab::unique_rows(const MATRIX_T* m, const std::string& first_or_last, VECTOR_T** i, VECTOR_T** j) { if (first_or_last != "first" && first_or_last != "last") { return NULL; } - MATRIX_TYPE* sort_m = sortrows(m); - MATRIX_TYPE* unsized_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* sort_m = sortrows(m); + MATRIX_T* unsized_m = MATRIX_ID(alloc)(m->size1, m->size2); VECTOR_ID(view) first_row = MATRIX_ID(row)(sort_m, 0); MATRIX_ID(set_row)(unsized_m, 0, &first_row.vector); int n_unique = 1; @@ -868,7 +942,7 @@ MATRIX_TYPE* matlab::unique_rows(const MATRIX_TYPE* m, const std::string& first_ } } MATRIX_ID(free)(sort_m); - MATRIX_TYPE* unique_m = MATRIX_ID(alloc)(n_unique, m->size2); + MATRIX_T* unique_m = MATRIX_ID(alloc)(n_unique, m->size2); MATRIX_ID(view) unsized_subm = MATRIX_ID(submatrix)(unsized_m, 0, 0, n_unique, m->size2); MATRIX_ID(memcpy)(unique_m, &unsized_subm.matrix); MATRIX_ID(free)(unsized_m); @@ -903,17 +977,17 @@ MATRIX_TYPE* matlab::unique_rows(const MATRIX_TYPE* m, const std::string& first_ return unique_m; } -MATRIX_TYPE* matlab::FP_ID(zeros)(int size) { +MATRIX_T* matlab::zeros(int size) { return MATRIX_ID(calloc)(size, size); } -MATRIX_TYPE* matlab::FP_ID(zeros)(int size1, int size2) { +MATRIX_T* matlab::zeros(int size1, int size2) { return MATRIX_ID(calloc)(size1, size2); } /* * Emulates (zeros(size, 1)) or (zeros(1, size)). */ -VECTOR_TYPE* matlab::FP_ID(zeros_vector)(int size) { +VECTOR_T* matlab::zeros_vector(int size) { return VECTOR_ID(calloc)(size); } diff --git a/matlab/index.cpp b/matlab/index.cpp index b6d218c..3dede16 100644 --- a/matlab/index.cpp +++ b/matlab/index.cpp @@ -1,5 +1,4 @@ -#include -#include +#include "matlab.h" /* * Our indexing-with-assignment functions do not automatically resize vectors @@ -17,47 +16,47 @@ // Vector-by-vector indexing -VECTOR_TYPE* matlab::ordinal_index(const VECTOR_TYPE* v, const VECTOR_TYPE* indices) { - VECTOR_TYPE* index_v = VECTOR_ID(alloc)(indices->size); +VECTOR_T* matlab::ordinal_index(const VECTOR_T* v, const VECTOR_T* indices) { + VECTOR_T* index_v = VECTOR_ID(alloc)(indices->size); for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); - FP_TYPE value = VECTOR_ID(get)(v, index); + FP_T value = VECTOR_ID(get)(v, index); VECTOR_ID(set)(index_v, i, value); } return index_v; } -void matlab::ordinal_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* indices, FP_TYPE value) { +void matlab::ordinal_index_assign(VECTOR_T* v, const VECTOR_T* indices, FP_T value) { for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); VECTOR_ID(set)(v, index, value); } } -void matlab::ordinal_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* indices, const VECTOR_TYPE* values) { +void matlab::ordinal_index_assign(VECTOR_T* v, const VECTOR_T* indices, const VECTOR_T* values) { for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); - FP_TYPE value = VECTOR_ID(get)(values, i); + FP_T value = VECTOR_ID(get)(values, i); VECTOR_ID(set)(v, index, value); } } -VECTOR_TYPE* matlab::logical_index(const VECTOR_TYPE* v, const VECTOR_TYPE* logical_v) { +VECTOR_T* matlab::logical_index(const VECTOR_T* v, const VECTOR_T* logical_v) { int n_index = nnz(logical_v); if (n_index == 0) { return NULL; } - VECTOR_TYPE* index_v = VECTOR_ID(alloc)(n_index); + VECTOR_T* index_v = VECTOR_ID(alloc)(n_index); for (int i = 0, index = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { - FP_TYPE value = VECTOR_ID(get)(v, i); + FP_T value = VECTOR_ID(get)(v, i); VECTOR_ID(set)(index_v, index++, value); } } return index_v; } -void matlab::logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, FP_TYPE value) { +void matlab::logical_index_assign(VECTOR_T* v, const VECTOR_T* logical_v, FP_T value) { for (int i = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { VECTOR_ID(set)(v, i, value); @@ -65,10 +64,10 @@ void matlab::logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, } } -void matlab::logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, const VECTOR_TYPE* values) { +void matlab::logical_index_assign(VECTOR_T* v, const VECTOR_T* logical_v, const VECTOR_T* values) { for (int i = 0, index = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { - FP_TYPE value = VECTOR_ID(get)(values, index++); + FP_T value = VECTOR_ID(get)(values, index++); VECTOR_ID(set)(v, i, value); } } @@ -76,13 +75,13 @@ void matlab::logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, // Matrix-by-integer indexing -FP_TYPE matlab::ordinal_index(const MATRIX_TYPE* m, int index) { +FP_T matlab::ordinal_index(const MATRIX_T* m, int index) { int row = index % (int)m->size1; int column = index / (int)m->size1; return MATRIX_ID(get)(m, row, column); } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, int index, FP_TYPE value) { +void matlab::ordinal_index_assign(MATRIX_T* m, int index, FP_T value) { int row = index % (int)m->size1; int column = index / (int)m->size1; MATRIX_ID(set)(m, row, column, value); @@ -90,47 +89,47 @@ void matlab::ordinal_index_assign(MATRIX_TYPE* m, int index, FP_TYPE value) { // Matrix-by-vector indexing -VECTOR_TYPE* matlab::ordinal_index(const MATRIX_TYPE* m, const VECTOR_TYPE* indices) { - VECTOR_TYPE* index_v = VECTOR_ID(alloc)(indices->size); +VECTOR_T* matlab::ordinal_index(const MATRIX_T* m, const VECTOR_T* indices) { + VECTOR_T* index_v = VECTOR_ID(alloc)(indices->size); for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); - FP_TYPE value = ordinal_index(m, index); + FP_T value = ordinal_index(m, index); VECTOR_ID(set)(index_v, i, value); } return index_v; } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* indices, FP_TYPE value) { +void matlab::ordinal_index_assign(MATRIX_T* m, const VECTOR_T* indices, FP_T value) { for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); ordinal_index_assign(m, index, value); } } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* indices, const VECTOR_TYPE* values) { +void matlab::ordinal_index_assign(MATRIX_T* m, const VECTOR_T* indices, const VECTOR_T* values) { for (int i = 0; i < (int)indices->size; i++) { int index = (int)VECTOR_ID(get)(indices, i); - FP_TYPE value = VECTOR_ID(get)(values, i); + FP_T value = VECTOR_ID(get)(values, i); ordinal_index_assign(m, index, value); } } -VECTOR_TYPE* matlab::logical_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_v) { +VECTOR_T* matlab::logical_index(const MATRIX_T* m, const VECTOR_T* logical_v) { int n_index = nnz(logical_v); if (n_index == 0) { return NULL; } - VECTOR_TYPE* index_v = VECTOR_ID(alloc)(n_index); + VECTOR_T* index_v = VECTOR_ID(alloc)(n_index); for (int i = 0, index = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { - FP_TYPE value = ordinal_index(m, i); + FP_T value = ordinal_index(m, i); VECTOR_ID(set)(index_v, index++, value); } } return index_v; } -void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, FP_TYPE value) { +void matlab::logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_v, FP_T value) { for (int i = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { ordinal_index_assign(m, i, value); @@ -138,10 +137,10 @@ void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, } } -void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, const VECTOR_TYPE* values) { +void matlab::logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_v, const VECTOR_T* values) { for (int i = 0, index = 0; i < (int)logical_v->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_v, i))) { - FP_TYPE value = VECTOR_ID(get)(values, index++); + FP_T value = VECTOR_ID(get)(values, index++); ordinal_index_assign(m, i, value); } } @@ -149,20 +148,20 @@ void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, // Matrix-by-two-vectors indexing (non-mixed) -MATRIX_TYPE* matlab::ordinal_index(const MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns) { - MATRIX_TYPE* index_m = MATRIX_ID(alloc)(rows->size, columns->size); +MATRIX_T* matlab::ordinal_index(const MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns) { + MATRIX_T* index_m = MATRIX_ID(alloc)(rows->size, columns->size); for (int i = 0; i < (int)rows->size; i++) { int row = (int)VECTOR_ID(get)(rows, i); for (int j = 0; j < (int)columns->size; j++) { int column = (int)VECTOR_ID(get)(columns, j); - FP_TYPE value = MATRIX_ID(get)(m, row, column); + FP_T value = MATRIX_ID(get)(m, row, column); MATRIX_ID(set)(index_m, i, j, value); } } return index_m; } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns, FP_TYPE value) { +void matlab::ordinal_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns, FP_T value) { for (int i = 0; i < (int)rows->size; i++) { int row = (int)VECTOR_ID(get)(rows, i); for (int j = 0; j < (int)columns->size; j++) { @@ -172,29 +171,29 @@ void matlab::ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const } } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns, const MATRIX_TYPE* values) { +void matlab::ordinal_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns, const MATRIX_T* values) { for (int i = 0; i < (int)rows->size; i++) { int row = (int)VECTOR_ID(get)(rows, i); for (int j = 0; j < (int)columns->size; j++) { int column = (int)VECTOR_ID(get)(columns, j); - FP_TYPE value = MATRIX_ID(get)(values, i, j); + FP_T value = MATRIX_ID(get)(values, i, j); MATRIX_ID(set)(m, row, column, value); } } } -MATRIX_TYPE* matlab::logical_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns) { +MATRIX_T* matlab::logical_index(const MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns) { int n_rows = nnz(logical_rows); int n_columns = nnz(logical_columns); if (n_rows == 0 || n_columns == 0) { return NULL; } - MATRIX_TYPE* index_m = MATRIX_ID(alloc)(n_rows, n_columns); + MATRIX_T* index_m = MATRIX_ID(alloc)(n_rows, n_columns); for (int i = 0, row = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0, column = 0; j < (int)logical_columns->size; j++) { if (fp_nonzero(VECTOR_ID(get)(logical_columns, j))) { - FP_TYPE value = MATRIX_ID(get)(m, i, j); + FP_T value = MATRIX_ID(get)(m, i, j); MATRIX_ID(set)(index_m, row, column, value); column++; } @@ -205,7 +204,7 @@ MATRIX_TYPE* matlab::logical_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logi return index_m; } -void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns, FP_TYPE value) { +void matlab::logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns, FP_T value) { for (int i = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0; j < (int)logical_columns->size; j++) { @@ -217,12 +216,12 @@ void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_row } } -void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns, const MATRIX_TYPE* values) { +void matlab::logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns, const MATRIX_T* values) { for (int i = 0, row = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0, column = 0; j < (int)logical_columns->size; j++) { if (fp_nonzero(VECTOR_ID(get)(logical_columns, j))) { - FP_TYPE value = MATRIX_ID(get)(values, row, column); + FP_T value = MATRIX_ID(get)(values, row, column); MATRIX_ID(set)(m, i, j, value); column++; } @@ -234,17 +233,17 @@ void matlab::logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_row // Matrix-by-two-vectors indexing (mixed) -MATRIX_TYPE* matlab::ord_log_index(const MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns) { +MATRIX_T* matlab::ord_log_index(const MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns) { int n_columns = nnz(logical_columns); if (n_columns == 0) { return NULL; } - MATRIX_TYPE* index_m = MATRIX_ID(alloc)(rows->size, n_columns); + MATRIX_T* index_m = MATRIX_ID(alloc)(rows->size, n_columns); for (int j = 0, column = 0; j < (int)logical_columns->size; j++) { if (fp_nonzero(VECTOR_ID(get)(logical_columns, j))) { for (int i = 0; i < (int)rows->size; i++) { int row = (int)VECTOR_ID(get)(rows, i); - FP_TYPE value = MATRIX_ID(get)(m, row, j); + FP_T value = MATRIX_ID(get)(m, row, j); MATRIX_ID(set)(index_m, i, column, value); } column++; @@ -253,7 +252,7 @@ MATRIX_TYPE* matlab::ord_log_index(const MATRIX_TYPE* m, const VECTOR_TYPE* rows return index_m; } -void matlab::ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns, FP_TYPE value) { +void matlab::ord_log_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns, FP_T value) { for (int j = 0; j < (int)logical_columns->size; j++) { if (fp_nonzero(VECTOR_ID(get)(logical_columns, j))) { for (int i = 0; i < (int)rows->size; i++) { @@ -264,12 +263,12 @@ void matlab::ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const } } -void matlab::ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns, const MATRIX_TYPE* values) { +void matlab::ord_log_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns, const MATRIX_T* values) { for (int j = 0, column = 0; j < (int)logical_columns->size; j++) { if (fp_nonzero(VECTOR_ID(get)(logical_columns, j))) { for (int i = 0; i < (int)rows->size; i++) { int row = (int)VECTOR_ID(get)(rows, i); - FP_TYPE value = MATRIX_ID(get)(values, i, column); + FP_T value = MATRIX_ID(get)(values, i, column); MATRIX_ID(set)(m, row, j, value); } column++; @@ -277,17 +276,17 @@ void matlab::ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const } } -MATRIX_TYPE* matlab::log_ord_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns) { +MATRIX_T* matlab::log_ord_index(const MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns) { int n_rows = nnz(logical_rows); if (n_rows == 0) { return NULL; } - MATRIX_TYPE* index_m = MATRIX_ID(alloc)(n_rows, columns->size); + MATRIX_T* index_m = MATRIX_ID(alloc)(n_rows, columns->size); for (int i = 0, row = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0; j < (int)columns->size; j++) { int column = (int)VECTOR_ID(get)(columns, j); - FP_TYPE value = MATRIX_ID(get)(m, i, column); + FP_T value = MATRIX_ID(get)(m, i, column); MATRIX_ID(set)(index_m, row, j, value); } row++; @@ -296,7 +295,7 @@ MATRIX_TYPE* matlab::log_ord_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logi return index_m; } -void matlab::log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns, FP_TYPE value) { +void matlab::log_ord_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns, FP_T value) { for (int i = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0; j < (int)columns->size; j++) { @@ -307,12 +306,12 @@ void matlab::log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_row } } -void matlab::log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns, const MATRIX_TYPE* values) { +void matlab::log_ord_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns, const MATRIX_T* values) { for (int i = 0, row = 0; i < (int)logical_rows->size; i++) { if (fp_nonzero(VECTOR_ID(get)(logical_rows, i))) { for (int j = 0; j < (int)columns->size; j++) { int column = (int)VECTOR_ID(get)(columns, j); - FP_TYPE value = MATRIX_ID(get)(values, row, j); + FP_T value = MATRIX_ID(get)(values, row, j); MATRIX_ID(set)(m, i, column, value); } row++; @@ -322,19 +321,19 @@ void matlab::log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_row // Matrix-by-matrix indexing -MATRIX_TYPE* matlab::ordinal_index(const MATRIX_TYPE* m, const MATRIX_TYPE* indices) { - MATRIX_TYPE* index_m = MATRIX_ID(alloc)(indices->size1, indices->size2); +MATRIX_T* matlab::ordinal_index(const MATRIX_T* m, const MATRIX_T* indices) { + MATRIX_T* index_m = MATRIX_ID(alloc)(indices->size1, indices->size2); for (int i = 0; i < (int)indices->size1; i++) { for (int j = 0; j < (int)indices->size2; j++) { int index = (int)MATRIX_ID(get)(indices, i, j); - FP_TYPE value = ordinal_index(m, index); + FP_T value = ordinal_index(m, index); MATRIX_ID(set)(index_m, i, j, value); } } return index_m; } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* indices, FP_TYPE value) { +void matlab::ordinal_index_assign(MATRIX_T* m, const MATRIX_T* indices, FP_T value) { for (int i = 0; i < (int)indices->size1; i++) { for (int j = 0; j < (int)indices->size2; j++) { int index = (int)MATRIX_ID(get)(indices, i, j); @@ -343,26 +342,26 @@ void matlab::ordinal_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* indices, FP } } -void matlab::ordinal_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* indices, const MATRIX_TYPE* values) { +void matlab::ordinal_index_assign(MATRIX_T* m, const MATRIX_T* indices, const MATRIX_T* values) { for (int i = 0; i < (int)indices->size1; i++) { for (int j = 0; j < (int)indices->size2; j++) { int index = (int)MATRIX_ID(get)(indices, i, j); - FP_TYPE value = MATRIX_ID(get)(values, i, j); + FP_T value = MATRIX_ID(get)(values, i, j); ordinal_index_assign(m, index, value); } } } -VECTOR_TYPE* matlab::logical_index(const MATRIX_TYPE* m, const MATRIX_TYPE* logical_m) { +VECTOR_T* matlab::logical_index(const MATRIX_T* m, const MATRIX_T* logical_m) { int n_index = nnz(logical_m); if (n_index == 0) { return NULL; } - VECTOR_TYPE* index_v = VECTOR_ID(alloc)(n_index); + VECTOR_T* index_v = VECTOR_ID(alloc)(n_index); for (int j = 0, index = 0; j < (int)logical_m->size2; j++) { for (int i = 0; i < (int)logical_m->size1; i++) { if (fp_nonzero(MATRIX_ID(get)(logical_m, i, j))) { - FP_TYPE value = MATRIX_ID(get)(m, i, j); + FP_T value = MATRIX_ID(get)(m, i, j); VECTOR_ID(set)(index_v, index++, value); } } @@ -370,7 +369,7 @@ VECTOR_TYPE* matlab::logical_index(const MATRIX_TYPE* m, const MATRIX_TYPE* logi return index_v; } -void matlab::logical_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* logical_m, FP_TYPE value) { +void matlab::logical_index_assign(MATRIX_T* m, const MATRIX_T* logical_m, FP_T value) { for (int j = 0; j < (int)logical_m->size2; j++) { for (int i = 0; i < (int)logical_m->size1; i++) { if (fp_nonzero(MATRIX_ID(get)(logical_m, i, j))) { @@ -380,11 +379,11 @@ void matlab::logical_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* logical_m, } } -void matlab::logical_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* logical_m, const VECTOR_TYPE* values) { +void matlab::logical_index_assign(MATRIX_T* m, const MATRIX_T* logical_m, const VECTOR_T* values) { for (int j = 0, index = 0; j < (int)logical_m->size2; j++) { for (int i = 0; i < (int)logical_m->size1; i++) { if (fp_nonzero(MATRIX_ID(get)(logical_m, i, j))) { - FP_TYPE value = VECTOR_ID(get)(values, index++); + FP_T value = VECTOR_ID(get)(values, index++); MATRIX_ID(set)(m, i, j, value); } } diff --git a/matlab/macros.h b/matlab/macros.h deleted file mode 100644 index d5ffc16..0000000 --- a/matlab/macros.h +++ /dev/null @@ -1,33 +0,0 @@ -#undef FP_TYPE -#undef FP_ID -#undef VECTOR_TYPE -#undef VECTOR_ID -#undef MATRIX_TYPE -#undef MATRIX_ID - -#ifdef GSL_FLOAT -#define FP_TYPE float -#define FP_ID(id) id##_##float -#define VECTOR_TYPE gsl_vector_float -#define VECTOR_ID(id) gsl_vector_float##_##id -#define MATRIX_TYPE gsl_matrix_float -#define MATRIX_ID(id) gsl_matrix_float##_##id -#endif - -#ifdef GSL_DOUBLE -#define FP_TYPE double -#define FP_ID(id) id##_##double -#define VECTOR_TYPE gsl_vector -#define VECTOR_ID(id) gsl_vector##_##id -#define MATRIX_TYPE gsl_matrix -#define MATRIX_ID(id) gsl_matrix##_##id -#endif - -#ifdef GSL_LONG_DOUBLE -#define FP_TYPE long double -#define FP_ID(id) id##_##long_double -#define VECTOR_TYPE gsl_vector_long_double -#define VECTOR_ID(id) gsl_vector_long_double##_##id -#define MATRIX_TYPE gsl_matrix_long_double -#define MATRIX_ID(id) gsl_matrix_long_double##_##id -#endif diff --git a/matlab/matlab.cpp b/matlab/matlab.cpp deleted file mode 100644 index c3d45f0..0000000 --- a/matlab/matlab.cpp +++ /dev/null @@ -1,125 +0,0 @@ -#define GSL_DOUBLE -#include "macros.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include "matlab.h" -#include - -/* - * This file contains functions for MATLAB emulation that do not depend on the - * desired floating-point precision. - */ - -std::string matlab::dec2bin(int n) { - return dec2bin(n, 0); -} - -std::string matlab::dec2bin(int n, int len) { - if (n < 0) { - return ""; - } - int binlen = (int)(std::floor(1.0 + std::log(n) / std::log(2))); - std::string bin((len > binlen) ? len : binlen, '0'); - for (int i = bin.size() - 1; i >= 0; i--) { - int remainder = n % 2; - if (remainder) { - bin[i] = '1'; - } - n >>= 1; - } - return bin; -} - -gsl_matrix* matlab::inv(const gsl_matrix* m) { - if (m->size1 != m->size2) { - return NULL; - } - gsl_matrix* LU = copy(m); - gsl_permutation* p = gsl_permutation_alloc(m->size1); - int signum; - gsl_linalg_LU_decomp(LU, p, &signum); - gsl_matrix* inv_m = NULL; - if (fp_nonzero(gsl_linalg_LU_det(LU, signum))) { - inv_m = gsl_matrix_alloc(m->size1, m->size2); - gsl_linalg_LU_invert(LU, p, inv_m); - } - gsl_matrix_free(LU); - gsl_permutation_free(p); - return inv_m; -} - -/* - * Generates a permutation of the integers 0 to (size - 1), whereas the MATLAB - * version uses the integers 1 to size. - */ -gsl_permutation* matlab::randperm(int size) { - gsl_rng* rng = get_gsl_rng(); - double values[size]; - for (int i = 0; i < size; i++) { - values[i] = (double)i; - } - gsl_ran_shuffle(rng, values, size, sizeof(double)); - gsl_vector_view values_vv = gsl_vector_view_array(values, size); - gsl_permutation* values_p = to_permutation(&values_vv.vector); - return values_p; -} - -/* - * Emulates (m1 \ m2) = (inv(m1) * m2). - */ -gsl_matrix* matlab::div_left(const gsl_matrix* m1, const gsl_matrix* m2) { - if (m1->size1 != m1->size2 || m2->size1 != m2->size2 || m1->size1 != m2->size1) { - return NULL; - } - gsl_matrix* inv_m1 = inv(m1); - gsl_matrix* div_m = mul(inv_m1, m2); - gsl_matrix_free(inv_m1); - return div_m; -} - -/* - * Emulates (m1 / m2) = ((inv(m2') * m1')'). - */ -gsl_matrix* matlab::div_right(const gsl_matrix* m1, const gsl_matrix* m2) { - if (m1->size1 != m1->size2 || m2->size1 != m2->size2 || m1->size1 != m2->size1) { - return NULL; - } - gsl_matrix* m2_transpose = gsl_matrix_alloc(m2->size2, m2->size1); - gsl_matrix_transpose_memcpy(m2_transpose, m2); - gsl_matrix* inv_m2_transpose = inv(m2_transpose); - gsl_matrix_free(m2_transpose); - gsl_matrix* m1_transpose = gsl_matrix_alloc(m1->size2, m1->size1); - gsl_matrix_transpose_memcpy(m1_transpose, m1); - gsl_matrix* div_m = mul(inv_m2_transpose, m1_transpose); - gsl_matrix_free(inv_m2_transpose); - gsl_matrix_free(m1_transpose); - gsl_matrix_transpose(div_m); - return div_m; -} - -/* - * Returns a random number generator that is guaranteed to be seeded only once - * during program execution. This generator should not be freed by the caller. - */ -gsl_rng* matlab::get_gsl_rng() { - static gsl_rng* rng = NULL; - if (rng == NULL) { - gsl_rng_default_seed = std::time(NULL); - rng = gsl_rng_alloc(gsl_rng_default); - } - return rng; -} - -/* - * Seeds the given random number generator. - */ -void matlab::seed_rng(const gsl_rng* rng, unsigned long seed) { - gsl_rng_set(rng, seed); -} diff --git a/matlab/matlab.h b/matlab/matlab.h index e9906e6..2a0a9be 100644 --- a/matlab/matlab.h +++ b/matlab/matlab.h @@ -1,211 +1,198 @@ -#include +#ifndef MATLAB_H +#define MATLAB_H + +#include "../precision.h" + #include #include #include #include #include -#include "sort.h" #include namespace matlab { - // --------------------------------- - // Precision-independent definitions - // --------------------------------- - -#ifndef MATLAB_H -#define MATLAB_H - // Functions + VECTOR_T* abs(const VECTOR_T* v); + MATRIX_T* abs(const MATRIX_T* m); + int all(const VECTOR_T* v); + VECTOR_T* all(const MATRIX_T* m, int dim = 1); + int any(const VECTOR_T* v); + VECTOR_T* any(const MATRIX_T* m, int dim = 1); std::string dec2bin(int n); std::string dec2bin(int n, int len); - gsl_matrix* inv(const gsl_matrix* m); + MATRIX_T* diag(const VECTOR_T* v, int k = 0); + VECTOR_T* diag(const MATRIX_T* m, int k = 0); + MATRIX_T* eye(int size); + MATRIX_T* eye(int size1, int size2); + VECTOR_T* find(const VECTOR_T* v, int n = std::numeric_limits::max(), const std::string& direction = "first"); + VECTOR_T* find(const MATRIX_T* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); + MATRIX_T* find_ij(const MATRIX_T* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); + VECTOR_T* hist(const VECTOR_T* v, int n = 10); + VECTOR_T* hist(const VECTOR_T* v, const VECTOR_T* centers); + MATRIX_T* inv(const MATRIX_T* m); + int length(const VECTOR_T* v); + int length(const MATRIX_T* m); + FP_T max(FP_T x, FP_T y); + FP_T max(const VECTOR_T* v); + VECTOR_T* max(const MATRIX_T* m, int dim = 1); + FP_T mean(const VECTOR_T* v, const std::string& opt = "a"); + VECTOR_T* mean(const MATRIX_T* m, int dim = 1, const std::string& opt = "a"); + FP_T min(FP_T x, FP_T y); + FP_T min(const VECTOR_T* v); + VECTOR_T* min(const MATRIX_T* m, int dim = 1); + int nnz(const VECTOR_T* v); + int nnz(const MATRIX_T* m); + VECTOR_T* nonzeros(const MATRIX_T* m); + FP_T norm(const VECTOR_T* v, int p); + VECTOR_T* normpdf(const VECTOR_T* v, FP_T mean, FP_T stdev); + MATRIX_T* ones(int size); + MATRIX_T* ones(int size1, int size2); + VECTOR_T* ones_vector(int size); + FP_T prod(const VECTOR_T* v); + VECTOR_T* prod(const MATRIX_T* m, int dim = 1); + MATRIX_T* rand(int size); + MATRIX_T* rand(int size1, int size2); + VECTOR_T* rand_vector(int size); gsl_permutation* randperm(int size); + VECTOR_T* reverse(const VECTOR_T* v); + VECTOR_T* setxor(const VECTOR_T* v1, const VECTOR_T* v2); + VECTOR_T* sort(const VECTOR_T* v, const std::string& mode = "ascend", VECTOR_T** ind = NULL); + MATRIX_T* sort(const MATRIX_T* m, int dim = 1, const std::string& mode = "ascend", MATRIX_T** ind = NULL); + VECTOR_T* sortrows(const VECTOR_T* v, VECTOR_T** ind = NULL); + MATRIX_T* sortrows(const MATRIX_T* m, VECTOR_T** ind = NULL); + FP_T std(const VECTOR_T* v, int opt = 0); + VECTOR_T* std(const MATRIX_T* m, int opt = 0, int dim = 1); + FP_T sum(const VECTOR_T* v); + VECTOR_T* sum(const MATRIX_T* m, int dim = 1); + MATRIX_T* toeplitz(const VECTOR_T* column, const VECTOR_T* row = NULL); + MATRIX_T* tril(const MATRIX_T* m, int k = 0); + MATRIX_T* triu(const MATRIX_T* m, int k = 0); + VECTOR_T* unique(const VECTOR_T* v, const std::string& first_or_last = "last", VECTOR_T** i = NULL, VECTOR_T** j = NULL); + VECTOR_T* unique(const MATRIX_T* m, const std::string& first_or_last = "last", VECTOR_T** i = NULL, VECTOR_T** j = NULL); + MATRIX_T* unique_rows(const MATRIX_T* m, const std::string& first_or_last = "last", VECTOR_T** i = NULL, VECTOR_T** j = NULL); + MATRIX_T* zeros(int size); + MATRIX_T* zeros(int size1, int size2); + VECTOR_T* zeros_vector(int size); // Operators - gsl_matrix* div_left(const gsl_matrix* m1, const gsl_matrix* m2); - gsl_matrix* div_right(const gsl_matrix* m1, const gsl_matrix* m2); - - // Utility - gsl_rng* get_gsl_rng(); - void seed_rng(const gsl_rng* rng, unsigned long seed); -#endif - - // ------------------------------- - // Precision-dependent definitions - // ------------------------------- - - // Functions - VECTOR_TYPE* abs(const VECTOR_TYPE* v); - MATRIX_TYPE* abs(const MATRIX_TYPE* m); - int all(const VECTOR_TYPE* v); - VECTOR_TYPE* all(const MATRIX_TYPE* m, int dim = 1); - int any(const VECTOR_TYPE* v); - VECTOR_TYPE* any(const MATRIX_TYPE* m, int dim = 1); - MATRIX_TYPE* diag(const VECTOR_TYPE* v, int k = 0); - VECTOR_TYPE* diag(const MATRIX_TYPE* m, int k = 0); - MATRIX_TYPE* FP_ID(eye)(int size); - MATRIX_TYPE* FP_ID(eye)(int size1, int size2); - VECTOR_TYPE* find(const VECTOR_TYPE* v, int n = std::numeric_limits::max(), const std::string& direction = "first"); - VECTOR_TYPE* find(const MATRIX_TYPE* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); - MATRIX_TYPE* find_ij(const MATRIX_TYPE* m, int n = std::numeric_limits::max(), const std::string& direction = "first"); - VECTOR_TYPE* hist(const VECTOR_TYPE* v, int n = 10); - VECTOR_TYPE* hist(const VECTOR_TYPE* v, const VECTOR_TYPE* centers); - int length(const VECTOR_TYPE* v); - int length(const MATRIX_TYPE* m); - FP_TYPE max(FP_TYPE x, FP_TYPE y); - FP_TYPE max(const VECTOR_TYPE* v); - VECTOR_TYPE* max(const MATRIX_TYPE* m, int dim = 1); - FP_TYPE mean(const VECTOR_TYPE* v, const std::string& opt = "a"); - VECTOR_TYPE* mean(const MATRIX_TYPE* m, int dim = 1, const std::string& opt = "a"); - FP_TYPE min(FP_TYPE x, FP_TYPE y); - FP_TYPE min(const VECTOR_TYPE* v); - VECTOR_TYPE* min(const MATRIX_TYPE* m, int dim = 1); - int nnz(const VECTOR_TYPE* v); - int nnz(const MATRIX_TYPE* m); - VECTOR_TYPE* nonzeros(const MATRIX_TYPE* m); - VECTOR_TYPE* normpdf(const VECTOR_TYPE* v, FP_TYPE mean, FP_TYPE stdev); - MATRIX_TYPE* FP_ID(ones)(int size); - MATRIX_TYPE* FP_ID(ones)(int size1, int size2); - VECTOR_TYPE* FP_ID(ones_vector)(int size); - FP_TYPE prod(const VECTOR_TYPE* v); - VECTOR_TYPE* prod(const MATRIX_TYPE* m, int dim = 1); - MATRIX_TYPE* FP_ID(rand)(int size); - MATRIX_TYPE* FP_ID(rand)(int size1, int size2); - VECTOR_TYPE* FP_ID(rand_vector)(int size); - VECTOR_TYPE* reverse(const VECTOR_TYPE* v); - VECTOR_TYPE* setxor(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - VECTOR_TYPE* sort(const VECTOR_TYPE* v, const std::string& mode = "ascend", VECTOR_TYPE** ind = NULL); - MATRIX_TYPE* sort(const MATRIX_TYPE* m, int dim = 1, const std::string& mode = "ascend", MATRIX_TYPE** ind = NULL); - VECTOR_TYPE* sortrows(const VECTOR_TYPE* v, VECTOR_TYPE** ind = NULL); - MATRIX_TYPE* sortrows(const MATRIX_TYPE* m, VECTOR_TYPE** ind = NULL); - FP_TYPE std(const VECTOR_TYPE* v, int opt = 0); - VECTOR_TYPE* std(const MATRIX_TYPE* m, int opt = 0, int dim = 1); - FP_TYPE sum(const VECTOR_TYPE* v); - VECTOR_TYPE* sum(const MATRIX_TYPE* m, int dim = 1); - MATRIX_TYPE* toeplitz(const VECTOR_TYPE* column, const VECTOR_TYPE* row = NULL); - MATRIX_TYPE* tril(const MATRIX_TYPE* m, int k = 0); - MATRIX_TYPE* triu(const MATRIX_TYPE* m, int k = 0); - VECTOR_TYPE* unique(const VECTOR_TYPE* v, const std::string& first_or_last = "last", VECTOR_TYPE** i = NULL, VECTOR_TYPE** j = NULL); - VECTOR_TYPE* unique(const MATRIX_TYPE* m, const std::string& first_or_last = "last", VECTOR_TYPE** i = NULL, VECTOR_TYPE** j = NULL); - MATRIX_TYPE* unique_rows(const MATRIX_TYPE* m, const std::string& first_or_last = "last", VECTOR_TYPE** i = NULL, VECTOR_TYPE** j = NULL); - MATRIX_TYPE* FP_ID(zeros)(int size); - MATRIX_TYPE* FP_ID(zeros)(int size1, int size2); - VECTOR_TYPE* FP_ID(zeros_vector)(int size); - - // Operators - VECTOR_TYPE* concatenate(const VECTOR_TYPE* v, FP_TYPE x); - VECTOR_TYPE* concatenate(FP_TYPE x, const VECTOR_TYPE* v); - VECTOR_TYPE* concatenate(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - MATRIX_TYPE* concatenate_columns(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - MATRIX_TYPE* concatenate_columns(const MATRIX_TYPE* m, const VECTOR_TYPE* v); - MATRIX_TYPE* concatenate_columns(const VECTOR_TYPE* v, const MATRIX_TYPE* m); - MATRIX_TYPE* concatenate_columns(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - MATRIX_TYPE* concatenate_rows(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - MATRIX_TYPE* concatenate_rows(const MATRIX_TYPE* m, const VECTOR_TYPE* v); - MATRIX_TYPE* concatenate_rows(const VECTOR_TYPE* v, const MATRIX_TYPE* m); - MATRIX_TYPE* concatenate_rows(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - VECTOR_TYPE* copy(const VECTOR_TYPE* v); - MATRIX_TYPE* copy(const MATRIX_TYPE* m); - VECTOR_TYPE* logical_and(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - MATRIX_TYPE* logical_and(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - VECTOR_TYPE* logical_not(const VECTOR_TYPE* v); - MATRIX_TYPE* logical_not(const MATRIX_TYPE* m); - VECTOR_TYPE* logical_or(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - MATRIX_TYPE* logical_or(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - MATRIX_TYPE* mul(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - MATRIX_TYPE* pow(const MATRIX_TYPE* m, int power); - VECTOR_TYPE* pow_elements(const VECTOR_TYPE* v, FP_TYPE power); - VECTOR_TYPE* pow_elements(const VECTOR_TYPE* v, const VECTOR_TYPE* powers); - MATRIX_TYPE* pow_elements(const MATRIX_TYPE* m, FP_TYPE power); - MATRIX_TYPE* pow_elements(const MATRIX_TYPE* m, const MATRIX_TYPE* powers); - VECTOR_TYPE* FP_ID(sequence)(int start, int end); - VECTOR_TYPE* FP_ID(sequence)(int start, int step, int end); + VECTOR_T* concatenate(const VECTOR_T* v, FP_T x); + VECTOR_T* concatenate(FP_T x, const VECTOR_T* v); + VECTOR_T* concatenate(const VECTOR_T* v1, const VECTOR_T* v2); + MATRIX_T* concatenate_columns(const VECTOR_T* v1, const VECTOR_T* v2); + MATRIX_T* concatenate_columns(const MATRIX_T* m, const VECTOR_T* v); + MATRIX_T* concatenate_columns(const VECTOR_T* v, const MATRIX_T* m); + MATRIX_T* concatenate_columns(const MATRIX_T* m1, const MATRIX_T* m2); + MATRIX_T* concatenate_rows(const VECTOR_T* v1, const VECTOR_T* v2); + MATRIX_T* concatenate_rows(const MATRIX_T* m, const VECTOR_T* v); + MATRIX_T* concatenate_rows(const VECTOR_T* v, const MATRIX_T* m); + MATRIX_T* concatenate_rows(const MATRIX_T* m1, const MATRIX_T* m2); + VECTOR_T* copy(const VECTOR_T* v); + MATRIX_T* copy(const MATRIX_T* m); + MATRIX_T* div_left(const MATRIX_T* m1, const MATRIX_T* m2); + MATRIX_T* div_right(const MATRIX_T* m1, const MATRIX_T* m2); + VECTOR_T* logical_and(const VECTOR_T* v1, const VECTOR_T* v2); + MATRIX_T* logical_and(const MATRIX_T* m1, const MATRIX_T* m2); + VECTOR_T* logical_not(const VECTOR_T* v); + MATRIX_T* logical_not(const MATRIX_T* m); + VECTOR_T* logical_or(const VECTOR_T* v1, const VECTOR_T* v2); + MATRIX_T* logical_or(const MATRIX_T* m1, const MATRIX_T* m2); + MATRIX_T* mul(const MATRIX_T* m1, const MATRIX_T* m2); + MATRIX_T* pow(const MATRIX_T* m, int power); + VECTOR_T* pow_elements(const VECTOR_T* v, FP_T power); + VECTOR_T* pow_elements(const VECTOR_T* v, const VECTOR_T* powers); + MATRIX_T* pow_elements(const MATRIX_T* m, FP_T power); + MATRIX_T* pow_elements(const MATRIX_T* m, const MATRIX_T* powers); + VECTOR_T* sequence(int start, int end); + VECTOR_T* sequence(int start, int step, int end); // Floating-point comparison - extern FP_TYPE FP_ID(epsilon); - int fp_compare(FP_TYPE x, FP_TYPE y); - typedef bool (*FP_ID(fp_cmp_fn))(FP_TYPE, FP_TYPE); - bool fp_zero(FP_TYPE x); - bool fp_nonzero(FP_TYPE x); - bool fp_equal(FP_TYPE x, FP_TYPE y); - bool fp_not_equal(FP_TYPE x, FP_TYPE y); - bool fp_less(FP_TYPE x, FP_TYPE y); - bool fp_less_or_equal(FP_TYPE x, FP_TYPE y); - bool fp_greater(FP_TYPE x, FP_TYPE y); - bool fp_greater_or_equal(FP_TYPE x, FP_TYPE y); + extern FP_T epsilon; + int fp_compare(FP_T x, FP_T y); + bool fp_zero(FP_T x); + bool fp_nonzero(FP_T x); + bool fp_equal(FP_T x, FP_T y); + bool fp_not_equal(FP_T x, FP_T y); + bool fp_less(FP_T x, FP_T y); + bool fp_less_or_equal(FP_T x, FP_T y); + bool fp_greater(FP_T x, FP_T y); + bool fp_greater_or_equal(FP_T x, FP_T y); // Vector/matrix comparison - int compare_vectors(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2); - bool vector_less(VECTOR_TYPE* v1, VECTOR_TYPE* v2); - int compare_matrices(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2); - bool matrix_less(MATRIX_TYPE* m1, MATRIX_TYPE* m2); - VECTOR_TYPE* compare_elements(const VECTOR_TYPE* v, FP_ID(fp_cmp_fn) compare, FP_TYPE x); - VECTOR_TYPE* compare_elements(const VECTOR_TYPE* v1, FP_ID(fp_cmp_fn) compare, const VECTOR_TYPE* v2); - MATRIX_TYPE* compare_elements(const MATRIX_TYPE* m, FP_ID(fp_cmp_fn) compare, FP_TYPE x); - MATRIX_TYPE* compare_elements(const MATRIX_TYPE* m1, FP_ID(fp_cmp_fn) compare, const MATRIX_TYPE* m2); + typedef bool (*comparator)(FP_T, FP_T); + int compare_vectors(const VECTOR_T* v1, const VECTOR_T* v2); + bool vector_less(VECTOR_T* v1, VECTOR_T* v2); + int compare_matrices(const MATRIX_T* m1, const MATRIX_T* m2); + bool matrix_less(MATRIX_T* m1, MATRIX_T* m2); + VECTOR_T* compare_elements(const VECTOR_T* v, comparator compare, FP_T x); + VECTOR_T* compare_elements(const VECTOR_T* v1, comparator compare, const VECTOR_T* v2); + MATRIX_T* compare_elements(const MATRIX_T* m, comparator compare, FP_T x); + MATRIX_T* compare_elements(const MATRIX_T* m1, comparator compare, const MATRIX_T* m2); // Vector-by-vector indexing - VECTOR_TYPE* ordinal_index(const VECTOR_TYPE* v, const VECTOR_TYPE* indices); - void ordinal_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* indices, FP_TYPE value); - void ordinal_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* indices, const VECTOR_TYPE* values); - VECTOR_TYPE* logical_index(const VECTOR_TYPE* v, const VECTOR_TYPE* logical_v); - void logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, FP_TYPE values); - void logical_index_assign(VECTOR_TYPE* v, const VECTOR_TYPE* logical_v, const VECTOR_TYPE* values); + VECTOR_T* ordinal_index(const VECTOR_T* v, const VECTOR_T* indices); + void ordinal_index_assign(VECTOR_T* v, const VECTOR_T* indices, FP_T value); + void ordinal_index_assign(VECTOR_T* v, const VECTOR_T* indices, const VECTOR_T* values); + VECTOR_T* logical_index(const VECTOR_T* v, const VECTOR_T* logical_v); + void logical_index_assign(VECTOR_T* v, const VECTOR_T* logical_v, FP_T values); + void logical_index_assign(VECTOR_T* v, const VECTOR_T* logical_v, const VECTOR_T* values); // Matrix-by-integer indexing - FP_TYPE ordinal_index(const MATRIX_TYPE* m, int index); - void ordinal_index_assign(MATRIX_TYPE* m, int index, FP_TYPE value); + FP_T ordinal_index(const MATRIX_T* m, int index); + void ordinal_index_assign(MATRIX_T* m, int index, FP_T value); // Matrix-by-vector indexing - VECTOR_TYPE* ordinal_index(const MATRIX_TYPE* m, const VECTOR_TYPE* indices); - void ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* indices, FP_TYPE value); - void ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* indices, const VECTOR_TYPE* values); - VECTOR_TYPE* logical_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_v); - void logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, FP_TYPE value); - void logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_v, const VECTOR_TYPE* values); + VECTOR_T* ordinal_index(const MATRIX_T* m, const VECTOR_T* indices); + void ordinal_index_assign(MATRIX_T* m, const VECTOR_T* indices, FP_T value); + void ordinal_index_assign(MATRIX_T* m, const VECTOR_T* indices, const VECTOR_T* values); + VECTOR_T* logical_index(const MATRIX_T* m, const VECTOR_T* logical_v); + void logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_v, FP_T value); + void logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_v, const VECTOR_T* values); // Matrix-by-two-vectors indexing (non-mixed) - MATRIX_TYPE* ordinal_index(const MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns); - void ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns, FP_TYPE value); - void ordinal_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* columns, const MATRIX_TYPE* values); - MATRIX_TYPE* logical_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns); - void logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns, FP_TYPE value); - void logical_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* logical_columns, const MATRIX_TYPE* values); + MATRIX_T* ordinal_index(const MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns); + void ordinal_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns, FP_T value); + void ordinal_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* columns, const MATRIX_T* values); + MATRIX_T* logical_index(const MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns); + void logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns, FP_T value); + void logical_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* logical_columns, const MATRIX_T* values); // Matrix-by-two-vectors indexing (mixed) - MATRIX_TYPE* ord_log_index(const MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns); - void ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns, FP_TYPE value); - void ord_log_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* rows, const VECTOR_TYPE* logical_columns, const MATRIX_TYPE* values); - MATRIX_TYPE* log_ord_index(const MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns); - void log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns, FP_TYPE value); - void log_ord_index_assign(MATRIX_TYPE* m, const VECTOR_TYPE* logical_rows, const VECTOR_TYPE* columns, const MATRIX_TYPE* values); + MATRIX_T* ord_log_index(const MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns); + void ord_log_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns, FP_T value); + void ord_log_index_assign(MATRIX_T* m, const VECTOR_T* rows, const VECTOR_T* logical_columns, const MATRIX_T* values); + MATRIX_T* log_ord_index(const MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns); + void log_ord_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns, FP_T value); + void log_ord_index_assign(MATRIX_T* m, const VECTOR_T* logical_rows, const VECTOR_T* columns, const MATRIX_T* values); // Matrix-by-matrix indexing - MATRIX_TYPE* ordinal_index(const MATRIX_TYPE* m, const MATRIX_TYPE* indices); - void ordinal_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* indices, FP_TYPE value); - void ordinal_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* indices, const MATRIX_TYPE* values); - VECTOR_TYPE* logical_index(const MATRIX_TYPE* m, const MATRIX_TYPE* logical_m); - void logical_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* logical_m, FP_TYPE value); - void logical_index_assign(MATRIX_TYPE* m, const MATRIX_TYPE* logical_m, const VECTOR_TYPE* values); + MATRIX_T* ordinal_index(const MATRIX_T* m, const MATRIX_T* indices); + void ordinal_index_assign(MATRIX_T* m, const MATRIX_T* indices, FP_T value); + void ordinal_index_assign(MATRIX_T* m, const MATRIX_T* indices, const MATRIX_T* values); + VECTOR_T* logical_index(const MATRIX_T* m, const MATRIX_T* logical_m); + void logical_index_assign(MATRIX_T* m, const MATRIX_T* logical_m, FP_T value); + void logical_index_assign(MATRIX_T* m, const MATRIX_T* logical_m, const VECTOR_T* values); // Vector/matrix conversion - void to_array(const VECTOR_TYPE* v, FP_TYPE* array); - bool to_bool(const VECTOR_TYPE* v); - bool to_bool(const MATRIX_TYPE* m); - gsl_vector_float* to_vector_float(const VECTOR_TYPE* v); - gsl_vector* to_vector_double(const VECTOR_TYPE* v); - gsl_vector_long_double* to_vector_long_double(const VECTOR_TYPE* v); - VECTOR_TYPE* to_vector(const MATRIX_TYPE* m); - gsl_matrix_float* to_matrix_float(const MATRIX_TYPE* m); - gsl_matrix* to_matrix_double(const MATRIX_TYPE* m); - gsl_matrix_long_double* to_matrix_long_double(const MATRIX_TYPE* m); - MATRIX_TYPE* to_column_matrix(const VECTOR_TYPE* v); - MATRIX_TYPE* to_row_matrix(const VECTOR_TYPE* v); - VECTOR_TYPE* FP_ID(to_vector)(const gsl_permutation* p); - gsl_permutation* to_permutation(const VECTOR_TYPE* v); + void to_array(const VECTOR_T* v, FP_T* array); + bool to_bool(const VECTOR_T* v); + bool to_bool(const MATRIX_T* m); + VECTOR_T* to_vector(const gsl_vector* v_d); + gsl_vector* to_vector_double(const VECTOR_T* v); + VECTOR_T* to_vector(const MATRIX_T* m); + MATRIX_T* to_column_matrix(const VECTOR_T* v); + MATRIX_T* to_row_matrix(const VECTOR_T* v); + MATRIX_T* to_matrix(const gsl_matrix* m_d); + gsl_matrix* to_matrix_double(const MATRIX_T* m); + VECTOR_T* to_vector(const gsl_permutation* p); + gsl_permutation* to_permutation(const VECTOR_T* v); // Utility - MATRIX_TYPE* permute_columns(const gsl_permutation* p, const MATRIX_TYPE* m); - MATRIX_TYPE* permute_rows(const gsl_permutation* p, const MATRIX_TYPE* m); + gsl_rng* get_rng(); + void seed_rng(const gsl_rng* rng, unsigned long seed); + VECTOR_T* permute(const gsl_permutation* p, const VECTOR_T* v); + MATRIX_T* permute_columns(const gsl_permutation* p, const MATRIX_T* m); + MATRIX_T* permute_rows(const gsl_permutation* p, const MATRIX_T* m); } + +#endif diff --git a/matlab/matlab_double.cpp b/matlab/matlab_double.cpp deleted file mode 100644 index b47ba1b..0000000 --- a/matlab/matlab_double.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#define GSL_DOUBLE -#include "macros.h" -#include "matlab.h" - -#include "compare.cpp" -#include "convert.cpp" -#include "functions.cpp" -#include "index.cpp" -#include "operators.cpp" -#include "utility.cpp" diff --git a/matlab/matlab_double.h b/matlab/matlab_double.h deleted file mode 100644 index 6f848a6..0000000 --- a/matlab/matlab_double.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef MATLAB_DOUBLE_H -#define MATLAB_DOUBLE_H - -#undef GSL_FLOAT -#define GSL_DOUBLE -#undef GSL_LONG_DOUBLE -#include "macros.h" -#include "matlab.h" - -#endif diff --git a/matlab/matlab_float.cpp b/matlab/matlab_float.cpp deleted file mode 100644 index 2fe08ac..0000000 --- a/matlab/matlab_float.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#define GSL_FLOAT -#include "macros.h" -#include "matlab.h" - -#include "compare.cpp" -#include "convert.cpp" -#include "functions.cpp" -#include "index.cpp" -#include "operators.cpp" -#include "utility.cpp" diff --git a/matlab/matlab_float.h b/matlab/matlab_float.h deleted file mode 100644 index cc5c170..0000000 --- a/matlab/matlab_float.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef MATLAB_FLOAT_H -#define MATLAB_FLOAT_H - -#define GSL_FLOAT -#undef GSL_DOUBLE -#undef GSL_LONG_DOUBLE -#include "macros.h" -#include "matlab.h" - -#endif diff --git a/matlab/matlab_long_double.cpp b/matlab/matlab_long_double.cpp deleted file mode 100644 index 2ed5e3a..0000000 --- a/matlab/matlab_long_double.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#define GSL_LONG_DOUBLE -#include "macros.h" -#include "matlab.h" - -#include "compare.cpp" -#include "convert.cpp" -#include "functions.cpp" -#include "index.cpp" -#include "operators.cpp" -#include "utility.cpp" diff --git a/matlab/matlab_long_double.h b/matlab/matlab_long_double.h deleted file mode 100644 index 97c8fb2..0000000 --- a/matlab/matlab_long_double.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef MATLAB_LONG_DOUBLE_H -#define MATLAB_LONG_DOUBLE_H - -#undef GSL_FLOAT -#undef GSL_DOUBLE -#define GSL_LONG_DOUBLE -#include "macros.h" -#include "matlab.h" - -#endif diff --git a/matlab/operators.cpp b/matlab/operators.cpp index 883673c..e4c6324 100644 --- a/matlab/operators.cpp +++ b/matlab/operators.cpp @@ -1,18 +1,18 @@ #include #include -#include -#include + +#include "matlab.h" /* * Emulates ([v x]) for a row vector or ([v ; x]) for a column vector. */ -VECTOR_TYPE* matlab::concatenate(const VECTOR_TYPE* v, FP_TYPE x) { +VECTOR_T* matlab::concatenate(const VECTOR_T* v, FP_T x) { if (v == NULL) { - VECTOR_TYPE* cat_v = VECTOR_ID(alloc)(1); + VECTOR_T* cat_v = VECTOR_ID(alloc)(1); VECTOR_ID(set)(cat_v, 0, x); return cat_v; } - VECTOR_TYPE* cat_v = VECTOR_ID(alloc)(v->size + 1); + VECTOR_T* cat_v = VECTOR_ID(alloc)(v->size + 1); VECTOR_ID(view) cat_subv = VECTOR_ID(subvector)(cat_v, 0, v->size); VECTOR_ID(memcpy)(&cat_subv.vector, v); VECTOR_ID(set)(cat_v, v->size, x); @@ -22,13 +22,13 @@ VECTOR_TYPE* matlab::concatenate(const VECTOR_TYPE* v, FP_TYPE x) { /* * Emulates ([x v]) for a row vector or ([x ; v]) for a column vector. */ -VECTOR_TYPE* matlab::concatenate(FP_TYPE x, const VECTOR_TYPE* v) { +VECTOR_T* matlab::concatenate(FP_T x, const VECTOR_T* v) { if (v == NULL) { - VECTOR_TYPE* cat_v = VECTOR_ID(alloc)(1); + VECTOR_T* cat_v = VECTOR_ID(alloc)(1); VECTOR_ID(set)(cat_v, 0, x); return cat_v; } - VECTOR_TYPE* cat_v = VECTOR_ID(alloc)(v->size + 1); + VECTOR_T* cat_v = VECTOR_ID(alloc)(v->size + 1); VECTOR_ID(view) cat_subv = VECTOR_ID(subvector)(cat_v, 1, v->size); VECTOR_ID(memcpy)(&cat_subv.vector, v); VECTOR_ID(set)(cat_v, 0, x); @@ -38,7 +38,7 @@ VECTOR_TYPE* matlab::concatenate(FP_TYPE x, const VECTOR_TYPE* v) { /* * Emulates ([v1 v2]) for row vectors or ([v1 ; v2]) for column vectors. */ -VECTOR_TYPE* matlab::concatenate(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +VECTOR_T* matlab::concatenate(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1 == NULL && v2 == NULL) { return NULL; } else if (v1 == NULL) { @@ -46,7 +46,7 @@ VECTOR_TYPE* matlab::concatenate(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { } else if (v2 == NULL) { return copy(v1); } - VECTOR_TYPE* cat_v = VECTOR_ID(alloc)(v1->size + v2->size); + VECTOR_T* cat_v = VECTOR_ID(alloc)(v1->size + v2->size); VECTOR_ID(view) cat_subv1 = VECTOR_ID(subvector)(cat_v, 0, v1->size); VECTOR_ID(view) cat_subv2 = VECTOR_ID(subvector)(cat_v, v1->size, v2->size); VECTOR_ID(memcpy)(&cat_subv1.vector, v1); @@ -57,7 +57,7 @@ VECTOR_TYPE* matlab::concatenate(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { /* * Emulates ([v1 ; v2]) for row vectors. */ -MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +MATRIX_T* matlab::concatenate_columns(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1 == NULL && v2 == NULL) { return NULL; } else if (v1 == NULL) { @@ -67,7 +67,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v1, const VECTOR_TYP } else if (v1->size != v2->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(2, v1->size); + MATRIX_T* cat_m = MATRIX_ID(alloc)(2, v1->size); MATRIX_ID(set_row)(cat_m, 0, v1); MATRIX_ID(set_row)(cat_m, 1, v2); return cat_m; @@ -76,7 +76,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v1, const VECTOR_TYP /* * Emulates ([m ; v]) for a row vector. */ -MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m, const VECTOR_TYPE* v) { +MATRIX_T* matlab::concatenate_columns(const MATRIX_T* m, const VECTOR_T* v) { if (m == NULL && v == NULL) { return NULL; } else if (m == NULL) { @@ -86,7 +86,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m, const VECTOR_TYPE } else if (m->size2 != v->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m->size1 + 1, m->size2); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m->size1 + 1, m->size2); MATRIX_ID(view) cat_subm = MATRIX_ID(submatrix)(cat_m, 0, 0, m->size1, m->size2); MATRIX_ID(memcpy)(&cat_subm.matrix, m); MATRIX_ID(set_row)(cat_m, m->size1, v); @@ -96,7 +96,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m, const VECTOR_TYPE /* * Emulates ([v ; m]) for a row vector. */ -MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v, const MATRIX_TYPE* m) { +MATRIX_T* matlab::concatenate_columns(const VECTOR_T* v, const MATRIX_T* m) { if (m == NULL && v == NULL) { return NULL; } else if (m == NULL) { @@ -106,7 +106,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v, const MATRIX_TYPE } else if (m->size2 != v->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m->size1 + 1, m->size2); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m->size1 + 1, m->size2); MATRIX_ID(set_row)(cat_m, 0, v); MATRIX_ID(view) cat_subm = MATRIX_ID(submatrix)(cat_m, 1, 0, m->size1, m->size2); MATRIX_ID(memcpy)(&cat_subm.matrix, m); @@ -116,7 +116,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const VECTOR_TYPE* v, const MATRIX_TYPE /* * Emulates ([m1 ; m2]). */ -MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { +MATRIX_T* matlab::concatenate_columns(const MATRIX_T* m1, const MATRIX_T* m2) { if (m1 == NULL && m2 == NULL) { return NULL; } else if (m1 == NULL) { @@ -126,7 +126,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m1, const MATRIX_TYP } else if (m1->size2 != m2->size2) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m1->size1 + m2->size1, m1->size2); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m1->size1 + m2->size1, m1->size2); MATRIX_ID(view) cat_subm1 = MATRIX_ID(submatrix)(cat_m, 0, 0, m1->size1, m1->size2); MATRIX_ID(view) cat_subm2 = MATRIX_ID(submatrix)(cat_m, m1->size1, 0, m2->size1, m2->size2); MATRIX_ID(memcpy)(&cat_subm1.matrix, m1); @@ -137,7 +137,7 @@ MATRIX_TYPE* matlab::concatenate_columns(const MATRIX_TYPE* m1, const MATRIX_TYP /* * Emulates ([v1 v2]) for column vectors. */ -MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +MATRIX_T* matlab::concatenate_rows(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1 == NULL && v2 == NULL) { return NULL; } else if (v1 == NULL) { @@ -147,7 +147,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v1, const VECTOR_TYPE* } else if (v1->size != v2->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(v1->size, 2); + MATRIX_T* cat_m = MATRIX_ID(alloc)(v1->size, 2); MATRIX_ID(set_col)(cat_m, 0, v1); MATRIX_ID(set_col)(cat_m, 1, v2); return cat_m; @@ -156,7 +156,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v1, const VECTOR_TYPE* /* * Emulates ([m v]) for a column vector. */ -MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m, const VECTOR_TYPE* v) { +MATRIX_T* matlab::concatenate_rows(const MATRIX_T* m, const VECTOR_T* v) { if (m == NULL && v == NULL) { return NULL; } else if (m == NULL) { @@ -166,7 +166,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m, const VECTOR_TYPE* v } else if (m->size1 != v->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m->size1, m->size2 + 1); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m->size1, m->size2 + 1); MATRIX_ID(view) cat_subm = MATRIX_ID(submatrix)(cat_m, 0, 0, m->size1, m->size2); MATRIX_ID(memcpy)(&cat_subm.matrix, m); MATRIX_ID(set_col)(cat_m, m->size2, v); @@ -176,7 +176,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m, const VECTOR_TYPE* v /* * Emulates ([v m]) for a column vector. */ -MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v, const MATRIX_TYPE* m) { +MATRIX_T* matlab::concatenate_rows(const VECTOR_T* v, const MATRIX_T* m) { if (m == NULL && v == NULL) { return NULL; } else if (m == NULL) { @@ -186,7 +186,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v, const MATRIX_TYPE* m } else if (m->size1 != v->size) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m->size1, m->size2 + 1); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m->size1, m->size2 + 1); MATRIX_ID(set_col)(cat_m, 0, v); MATRIX_ID(view) cat_subm = MATRIX_ID(submatrix)(cat_m, 0, 1, m->size1, m->size2); MATRIX_ID(memcpy)(&cat_subm.matrix, m); @@ -196,7 +196,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const VECTOR_TYPE* v, const MATRIX_TYPE* m /* * Emulates ([m1 m2]). */ -MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { +MATRIX_T* matlab::concatenate_rows(const MATRIX_T* m1, const MATRIX_T* m2) { if (m1 == NULL && m2 == NULL) { return NULL; } else if (m1 == NULL) { @@ -206,7 +206,7 @@ MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m1, const MATRIX_TYPE* } else if (m1->size1 != m2->size1) { return NULL; } - MATRIX_TYPE* cat_m = MATRIX_ID(alloc)(m1->size1, m1->size2 + m2->size2); + MATRIX_T* cat_m = MATRIX_ID(alloc)(m1->size1, m1->size2 + m2->size2); MATRIX_ID(view) cat_subm1 = MATRIX_ID(submatrix)(cat_m, 0, 0, m1->size1, m1->size2); MATRIX_ID(view) cat_subm2 = MATRIX_ID(submatrix)(cat_m, 0, m1->size2, m2->size1, m2->size2); MATRIX_ID(memcpy)(&cat_subm1.matrix, m1); @@ -217,8 +217,8 @@ MATRIX_TYPE* matlab::concatenate_rows(const MATRIX_TYPE* m1, const MATRIX_TYPE* /* * Emulates copy assignment. */ -VECTOR_TYPE* matlab::copy(const VECTOR_TYPE* v) { - VECTOR_TYPE* copy_v = VECTOR_ID(alloc)(v->size); +VECTOR_T* matlab::copy(const VECTOR_T* v) { + VECTOR_T* copy_v = VECTOR_ID(alloc)(v->size); VECTOR_ID(memcpy)(copy_v, v); return copy_v; } @@ -226,24 +226,57 @@ VECTOR_TYPE* matlab::copy(const VECTOR_TYPE* v) { /* * Emulates copy assignment. */ -MATRIX_TYPE* matlab::copy(const MATRIX_TYPE* m) { - MATRIX_TYPE* copy_m = MATRIX_ID(alloc)(m->size1, m->size2); +MATRIX_T* matlab::copy(const MATRIX_T* m) { + MATRIX_T* copy_m = MATRIX_ID(alloc)(m->size1, m->size2); MATRIX_ID(memcpy)(copy_m, m); return copy_m; } +/* + * Emulates (m1 \ m2) = (inv(m1) * m2). + */ +MATRIX_T* matlab::div_left(const MATRIX_T* m1, const MATRIX_T* m2) { + if (m1->size1 != m1->size2 || m2->size1 != m2->size2 || m1->size1 != m2->size1) { + return NULL; + } + MATRIX_T* inv_m1 = inv(m1); + MATRIX_T* div_m = mul(inv_m1, m2); + MATRIX_ID(free)(inv_m1); + return div_m; +} + +/* + * Emulates (m1 / m2) = ((inv(m2') * m1')'). + */ +MATRIX_T* matlab::div_right(const MATRIX_T* m1, const MATRIX_T* m2) { + if (m1->size1 != m1->size2 || m2->size1 != m2->size2 || m1->size1 != m2->size1) { + return NULL; + } + MATRIX_T* m2_transpose = MATRIX_ID(alloc)(m2->size2, m2->size1); + MATRIX_ID(transpose_memcpy)(m2_transpose, m2); + MATRIX_T* inv_m2_transpose = inv(m2_transpose); + MATRIX_ID(free)(m2_transpose); + MATRIX_T* m1_transpose = MATRIX_ID(alloc)(m1->size2, m1->size1); + MATRIX_ID(transpose_memcpy)(m1_transpose, m1); + MATRIX_T* div_m = mul(inv_m2_transpose, m1_transpose); + MATRIX_ID(free)(inv_m2_transpose); + MATRIX_ID(free)(m1_transpose); + MATRIX_ID(transpose)(div_m); + return div_m; +} + /* * Emulates (v1 & v2). */ -VECTOR_TYPE* matlab::logical_and(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +VECTOR_T* matlab::logical_and(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1->size != v2->size) { return NULL; } - VECTOR_TYPE* and_v = VECTOR_ID(alloc)(v1->size); + VECTOR_T* and_v = VECTOR_ID(alloc)(v1->size); for (int i = 0; i < (int)v1->size; i++) { bool nz1 = fp_nonzero(VECTOR_ID(get)(v1, i)); bool nz2 = fp_nonzero(VECTOR_ID(get)(v2, i)); - VECTOR_ID(set)(and_v, i, (FP_TYPE)(nz1 && nz2)); + VECTOR_ID(set)(and_v, i, (FP_T)(nz1 && nz2)); } return and_v; } @@ -251,16 +284,16 @@ VECTOR_TYPE* matlab::logical_and(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { /* * Emulates (m1 & m2). */ -MATRIX_TYPE* matlab::logical_and(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { +MATRIX_T* matlab::logical_and(const MATRIX_T* m1, const MATRIX_T* m2) { if (m1->size1 != m2->size1 || m1->size2 != m2->size2) { return NULL; } - MATRIX_TYPE* and_m = MATRIX_ID(alloc)(m1->size1, m1->size2); + MATRIX_T* and_m = MATRIX_ID(alloc)(m1->size1, m1->size2); for (int i = 0; i < (int)m1->size1; i++) { for (int j = 0; j < (int)m1->size2; j++) { bool nz1 = fp_nonzero(MATRIX_ID(get)(m1, i, j)); bool nz2 = fp_nonzero(MATRIX_ID(get)(m2, i, j)); - MATRIX_ID(set)(and_m, i, j, (FP_TYPE)(nz1 && nz2)); + MATRIX_ID(set)(and_m, i, j, (FP_T)(nz1 && nz2)); } } return and_m; @@ -269,11 +302,11 @@ MATRIX_TYPE* matlab::logical_and(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { /* * Emulates (~v). */ -VECTOR_TYPE* matlab::logical_not(const VECTOR_TYPE* v) { - VECTOR_TYPE* not_v = VECTOR_ID(alloc)(v->size); +VECTOR_T* matlab::logical_not(const VECTOR_T* v) { + VECTOR_T* not_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { bool z = fp_zero(VECTOR_ID(get)(v, i)); - VECTOR_ID(set)(not_v, i, (FP_TYPE)z); + VECTOR_ID(set)(not_v, i, (FP_T)z); } return not_v; } @@ -281,12 +314,12 @@ VECTOR_TYPE* matlab::logical_not(const VECTOR_TYPE* v) { /* * Emulates (~m) */ -MATRIX_TYPE* matlab::logical_not(const MATRIX_TYPE* m) { - MATRIX_TYPE* not_m = MATRIX_ID(alloc)(m->size1, m->size2); +MATRIX_T* matlab::logical_not(const MATRIX_T* m) { + MATRIX_T* not_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { bool z = fp_zero(MATRIX_ID(get)(m, i, j)); - MATRIX_ID(set)(not_m, i, j, (FP_TYPE)z); + MATRIX_ID(set)(not_m, i, j, (FP_T)z); } } return not_m; @@ -295,15 +328,15 @@ MATRIX_TYPE* matlab::logical_not(const MATRIX_TYPE* m) { /* * Emulates (v1 | v2). */ -VECTOR_TYPE* matlab::logical_or(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { +VECTOR_T* matlab::logical_or(const VECTOR_T* v1, const VECTOR_T* v2) { if (v1->size != v2->size) { return NULL; } - VECTOR_TYPE* or_v = VECTOR_ID(alloc)(v1->size); + VECTOR_T* or_v = VECTOR_ID(alloc)(v1->size); for (int i = 0; i < (int)v1->size; i++) { bool nz1 = fp_nonzero(VECTOR_ID(get)(v1, i)); bool nz2 = fp_nonzero(VECTOR_ID(get)(v2, i)); - VECTOR_ID(set)(or_v, i, (FP_TYPE)(nz1 || nz2)); + VECTOR_ID(set)(or_v, i, (FP_T)(nz1 || nz2)); } return or_v; } @@ -311,16 +344,16 @@ VECTOR_TYPE* matlab::logical_or(const VECTOR_TYPE* v1, const VECTOR_TYPE* v2) { /* * Emulates (m1 | m2). */ -MATRIX_TYPE* matlab::logical_or(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { +MATRIX_T* matlab::logical_or(const MATRIX_T* m1, const MATRIX_T* m2) { if (m1->size1 != m2->size1 || m1->size2 != m2->size2) { return NULL; } - MATRIX_TYPE* or_m = MATRIX_ID(alloc)(m1->size1, m1->size2); + MATRIX_T* or_m = MATRIX_ID(alloc)(m1->size1, m1->size2); for (int i = 0; i < (int)m1->size1; i++) { for (int j = 0; j < (int)m1->size2; j++) { bool nz1 = fp_nonzero(MATRIX_ID(get)(m1, i, j)); bool nz2 = fp_nonzero(MATRIX_ID(get)(m2, i, j)); - MATRIX_ID(set)(or_m, i, j, (FP_TYPE)(nz1 || nz2)); + MATRIX_ID(set)(or_m, i, j, (FP_T)(nz1 || nz2)); } } return or_m; @@ -329,57 +362,35 @@ MATRIX_TYPE* matlab::logical_or(const MATRIX_TYPE* m1, const MATRIX_TYPE* m2) { /* * Emulates (m1 * m2). */ -#ifdef GSL_FLOAT -gsl_matrix_float* matlab::mul(const gsl_matrix_float* m1, const gsl_matrix_float* m2) { - if (m1->size2 != m2->size1) { - return NULL; - } - gsl_matrix_float* mul_m = gsl_matrix_float_alloc(m1->size1, m2->size2); - gsl_blas_sgemm(CblasNoTrans, CblasNoTrans, 1.0, m1, m2, 0.0, mul_m); - return mul_m; -} -#endif -#ifdef GSL_DOUBLE -gsl_matrix* matlab::mul(const gsl_matrix* m1, const gsl_matrix* m2) { - if (m1->size2 != m2->size1) { - return NULL; - } - gsl_matrix* mul_m = gsl_matrix_alloc(m1->size1, m2->size2); - gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, m1, m2, 0.0, mul_m); - return mul_m; -} -#endif -#ifdef GSL_LONG_DOUBLE -gsl_matrix_long_double* matlab::mul(const gsl_matrix_long_double* m1, const gsl_matrix_long_double* m2) { +MATRIX_T* matlab::mul(const MATRIX_T* m1, const MATRIX_T* m2) { if (m1->size2 != m2->size1) { return NULL; } - gsl_matrix_long_double* mul_m = gsl_matrix_long_double_alloc(m1->size1, m2->size2); + MATRIX_T* mul_m = MATRIX_ID(alloc)(m1->size1, m2->size2); for (int i = 0; i < (int)m1->size1; i++) { - gsl_vector_long_double_const_view row = gsl_matrix_long_double_const_row(m1, i); + VECTOR_ID(const_view) row = MATRIX_ID(const_row)(m1, i); for (int j = 0; j < (int)m2->size2; j++) { - gsl_vector_long_double_const_view col = gsl_matrix_long_double_const_column(m2, j); - long double value = 0.0L; + VECTOR_ID(const_view) col = MATRIX_ID(const_column)(m2, j); + FP_T value = 0.0; for (int k = 0; k < (int)m1->size2; k++) { - value += gsl_vector_long_double_get(&row.vector, k) * gsl_vector_long_double_get(&col.vector, k); + value += VECTOR_ID(get)(&row.vector, k) * VECTOR_ID(get)(&col.vector, k); } - gsl_matrix_long_double_set(mul_m, i, j, value); + MATRIX_ID(set)(mul_m, i, j, value); } } return mul_m; } -#endif /* * Emulates (m ^ power). */ -MATRIX_TYPE* matlab::pow(const MATRIX_TYPE* m, int power) { +MATRIX_T* matlab::pow(const MATRIX_T* m, int power) { if (m->size1 != m->size2 || power < 1) { return NULL; } - MATRIX_TYPE* pow_m = copy(m); + MATRIX_T* pow_m = copy(m); for (int i = 2; i <= power; i++) { - MATRIX_TYPE* temp_m = mul(pow_m, m); + MATRIX_T* temp_m = mul(pow_m, m); MATRIX_ID(free)(pow_m); pow_m = temp_m; } @@ -389,10 +400,10 @@ MATRIX_TYPE* matlab::pow(const MATRIX_TYPE* m, int power) { /* * Emulates (v .^ power). */ -VECTOR_TYPE* matlab::pow_elements(const VECTOR_TYPE* v, FP_TYPE power) { - VECTOR_TYPE* pow_v = VECTOR_ID(alloc)(v->size); +VECTOR_T* matlab::pow_elements(const VECTOR_T* v, FP_T power) { + VECTOR_T* pow_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { - FP_TYPE value = std::pow(VECTOR_ID(get)(v, i), power); + FP_T value = std::pow(VECTOR_ID(get)(v, i), power); VECTOR_ID(set)(pow_v, i, value); } return pow_v; @@ -401,13 +412,13 @@ VECTOR_TYPE* matlab::pow_elements(const VECTOR_TYPE* v, FP_TYPE power) { /* * Emulates (v .^ powers). */ -VECTOR_TYPE* matlab::pow_elements(const VECTOR_TYPE* v, const VECTOR_TYPE* powers) { +VECTOR_T* matlab::pow_elements(const VECTOR_T* v, const VECTOR_T* powers) { if (v->size != powers->size) { return NULL; } - VECTOR_TYPE* pow_v = VECTOR_ID(alloc)(v->size); + VECTOR_T* pow_v = VECTOR_ID(alloc)(v->size); for (int i = 0; i < (int)v->size; i++) { - FP_TYPE value = std::pow(VECTOR_ID(get)(v, i), VECTOR_ID(get)(powers, i)); + FP_T value = std::pow(VECTOR_ID(get)(v, i), VECTOR_ID(get)(powers, i)); VECTOR_ID(set)(pow_v, i, value); } return pow_v; @@ -416,11 +427,11 @@ VECTOR_TYPE* matlab::pow_elements(const VECTOR_TYPE* v, const VECTOR_TYPE* power /* * Emulates (m .^ power). */ -MATRIX_TYPE* matlab::pow_elements(const MATRIX_TYPE* m, FP_TYPE power) { - MATRIX_TYPE* pow_m = MATRIX_ID(alloc)(m->size1, m->size2); +MATRIX_T* matlab::pow_elements(const MATRIX_T* m, FP_T power) { + MATRIX_T* pow_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - FP_TYPE value = std::pow(MATRIX_ID(get)(m, i, j), power); + FP_T value = std::pow(MATRIX_ID(get)(m, i, j), power); MATRIX_ID(set)(pow_m, i, j, value); } } @@ -430,14 +441,14 @@ MATRIX_TYPE* matlab::pow_elements(const MATRIX_TYPE* m, FP_TYPE power) { /* * Emulates (m .^ powers). */ -MATRIX_TYPE* matlab::pow_elements(const MATRIX_TYPE* m, const MATRIX_TYPE* powers) { +MATRIX_T* matlab::pow_elements(const MATRIX_T* m, const MATRIX_T* powers) { if (m->size1 != powers->size1 || m->size2 != powers->size2) { return NULL; } - MATRIX_TYPE* pow_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* pow_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - FP_TYPE value = std::pow(MATRIX_ID(get)(m, i, j), MATRIX_ID(get)(powers, i, j)); + FP_T value = std::pow(MATRIX_ID(get)(m, i, j), MATRIX_ID(get)(powers, i, j)); MATRIX_ID(set)(pow_m, i, j, value); } } @@ -447,19 +458,19 @@ MATRIX_TYPE* matlab::pow_elements(const MATRIX_TYPE* m, const MATRIX_TYPE* power /* * Emulates (start:end). */ -VECTOR_TYPE* matlab::FP_ID(sequence)(int start, int end) { - return FP_ID(sequence)(start, 1, end); +VECTOR_T* matlab::sequence(int start, int end) { + return sequence(start, 1, end); } /* * Emulates (start:step:end). */ -VECTOR_TYPE* matlab::FP_ID(sequence)(int start, int step, int end) { +VECTOR_T* matlab::sequence(int start, int step, int end) { int n_seq = (end - start) / step + 1; if (n_seq <= 0) { return NULL; } - VECTOR_TYPE* seq_v = VECTOR_ID(alloc)(n_seq); + VECTOR_T* seq_v = VECTOR_ID(alloc)(n_seq); for (int i = 0, value = start; i < n_seq; i++, value += step) { VECTOR_ID(set)(seq_v, i, value); } diff --git a/matlab/utility.cpp b/matlab/utility.cpp index 659987e..77edef2 100644 --- a/matlab/utility.cpp +++ b/matlab/utility.cpp @@ -1,13 +1,47 @@ -#include -#include -#include +#include + +#include "matlab.h" + +/* + * Returns a random number generator that is guaranteed to be seeded only once + * during program execution. This generator should not be freed by the caller. + */ +gsl_rng* matlab::get_rng() { + static gsl_rng* rng = NULL; + if (rng == NULL) { + gsl_rng_default_seed = std::time(NULL); + rng = gsl_rng_alloc(gsl_rng_default); + } + return rng; +} + +/* + * Seeds the given random number generator. + */ +void matlab::seed_rng(const gsl_rng* rng, unsigned long seed) { + gsl_rng_set(rng, seed); +} + +/* + * Permutes the elements of a vector. + */ +VECTOR_T* matlab::permute(const gsl_permutation* p, const VECTOR_T* v) { + if (p->size != v->size) return NULL; + VECTOR_T* permuted_v = VECTOR_ID(alloc)(v->size); + for (int i = 0; i < (int)p->size; i++) { + int index = gsl_permutation_get(p, i); + FP_T value = VECTOR_ID(get)(v, index); + VECTOR_ID(set)(permuted_v, i, value); + } + return permuted_v; +} /* * Permutes the columns of a matrix. */ -MATRIX_TYPE* matlab::permute_columns(const gsl_permutation* p, const MATRIX_TYPE* m) { +MATRIX_T* matlab::permute_columns(const gsl_permutation* p, const MATRIX_T* m) { if (p->size != m->size2) return NULL; - MATRIX_TYPE* permuted_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* permuted_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)p->size; i++) { int i_col = gsl_permutation_get(p, i); VECTOR_ID(const_view) m_col_i_col = MATRIX_ID(const_column)(m, i_col); @@ -19,9 +53,9 @@ MATRIX_TYPE* matlab::permute_columns(const gsl_permutation* p, const MATRIX_TYPE /* * Permutes the rows of a matrix. */ -MATRIX_TYPE* matlab::permute_rows(const gsl_permutation* p, const MATRIX_TYPE* m) { +MATRIX_T* matlab::permute_rows(const gsl_permutation* p, const MATRIX_T* m) { if (p->size != m->size1) return NULL; - MATRIX_TYPE* permuted_m = MATRIX_ID(alloc)(m->size1, m->size2); + MATRIX_T* permuted_m = MATRIX_ID(alloc)(m->size1, m->size2); for (int i = 0; i < (int)p->size; i++) { int i_row = gsl_permutation_get(p, i); VECTOR_ID(const_view) m_row_i_row = MATRIX_ID(const_row)(m, i_row); diff --git a/modularity_louvain.cpp b/modularity_louvain.cpp index 3ffdce5..0f0bc8e 100644 --- a/modularity_louvain.cpp +++ b/modularity_louvain.cpp @@ -1,9 +1,6 @@ #include "bct.h" -#include -#include -#include -bool modularity_und_louvain(const gsl_matrix*, double*, gsl_vector**, int); +bool modularity_louvain_und(const MATRIX_T*, FP_T*, VECTOR_T**, int); /* * Detects communities in an undirected graph via Louvain modularity. While the @@ -12,62 +9,62 @@ bool modularity_und_louvain(const gsl_matrix*, double*, gsl_vector**, int); * makes use of an additional argument N that specifies the maximum number of * node permutations to attempt when maximizing modularity. */ -double bct::modularity_und_louvain(const gsl_matrix* W, gsl_vector** Ci, int N) { - if (safe_mode) check_status(W, SQUARE | UNDIRECTED, "modularity_und_louvain"); +FP_T bct::modularity_louvain_und(const MATRIX_T* W, VECTOR_T** Ci, int N) { + if (safe_mode) check_status(W, SQUARE | UNDIRECTED, "modularity_louvain_und"); - double Q; + FP_T Q; while (true) { - if (modularity_und_louvain(W, &Q, Ci, N)) { + if (modularity_louvain_und(W, &Q, Ci, N)) { break; } } return Q; } -bool modularity_und_louvain(const gsl_matrix* W, double* Q, gsl_vector** Ci, int N) { +bool modularity_louvain_und(const MATRIX_T* W, FP_T* Q, VECTOR_T** Ci, int N) { using namespace bct; // n=length(W); int n = length(W); // s=sum(W(:)); - gsl_vector* sum_W = sum(W); - double s = sum(sum_W); - gsl_vector_free(sum_W); + VECTOR_T* sum_W = sum(W); + FP_T s = sum(sum_W); + VECTOR_ID(free)(sum_W); // h=1; int h = 0; // Ci{h}=1:n; - std::vector _Ci; - _Ci.push_back(sequence_double(1, n)); + std::vector _Ci; + _Ci.push_back(sequence(1, n)); // Q{h}=-1; - std::vector _Q; + std::vector _Q; _Q.push_back(-1.0); // n0=n; int n0 = n; - gsl_matrix* _W = copy(W); + MATRIX_T* _W = copy(W); // while true while (true) { // K=sum(W); - gsl_vector* K = sum(_W); + VECTOR_T* K = sum(_W); // Km=K; - gsl_vector* Km = copy(K); + VECTOR_T* Km = copy(K); // Knm=W; - gsl_matrix* Knm = copy(_W); + MATRIX_T* Knm = copy(_W); // M=1:n; - gsl_vector* M = sequence_double(0, n - 1); + VECTOR_T* M = sequence(0, n - 1); // Nm=ones(1,n); - gsl_vector* Nm = ones_vector_double(n); + VECTOR_T* Nm = ones_vector(n); // flag=true; bool flag = true; @@ -90,102 +87,102 @@ bool modularity_und_louvain(const gsl_matrix* W, double* Q, gsl_vector** Ci, int int i = gsl_permutation_get(randperm_n, i_randperm_n); // dQ=(Knm(i,:)-Knm(i,M(i))+W(i,i)) - K(i).*(Km-Km(M(i))+K(i))/s; - gsl_vector* dQ1 = gsl_vector_alloc(Knm->size2); - gsl_matrix_get_row(dQ1, Knm, i); - int M_i = (int)gsl_vector_get(M, i); - gsl_vector_add_constant(dQ1, -gsl_matrix_get(Knm, i, M_i)); - gsl_vector_add_constant(dQ1, gsl_matrix_get(_W, i, i)); - gsl_vector* dQ2 = copy(Km); - gsl_vector_add_constant(dQ2, -gsl_vector_get(Km, M_i)); - gsl_vector_add_constant(dQ2, gsl_vector_get(K, i)); - gsl_vector_scale(dQ2, gsl_vector_get(K, i) / s); - gsl_vector* dQ = dQ1; - gsl_vector_sub(dQ, dQ2); - gsl_vector_free(dQ2); + VECTOR_T* dQ1 = VECTOR_ID(alloc)(Knm->size2); + MATRIX_ID(get_row)(dQ1, Knm, i); + int M_i = (int)VECTOR_ID(get)(M, i); + VECTOR_ID(add_constant)(dQ1, -MATRIX_ID(get)(Knm, i, M_i)); + VECTOR_ID(add_constant)(dQ1, MATRIX_ID(get)(_W, i, i)); + VECTOR_T* dQ2 = copy(Km); + VECTOR_ID(add_constant)(dQ2, -VECTOR_ID(get)(Km, M_i)); + VECTOR_ID(add_constant)(dQ2, VECTOR_ID(get)(K, i)); + VECTOR_ID(scale)(dQ2, VECTOR_ID(get)(K, i) / s); + VECTOR_T* dQ = dQ1; + VECTOR_ID(sub)(dQ, dQ2); + VECTOR_ID(free)(dQ2); // dQ(M(i))=0; - gsl_vector_set(dQ, M_i, 0.0); + VECTOR_ID(set)(dQ, M_i, 0.0); // max_dQ=max(dQ); - double max_dQ = max(dQ); + FP_T max_dQ = max(dQ); // if max_dQ>0; if (max_dQ > 0.0) { // j=find(dQ==max_dQ,1); - gsl_vector* dQ_eq_max_dQ = compare_elements(dQ, fp_equal, max_dQ); - gsl_vector* j_v = find(dQ_eq_max_dQ, 1); - gsl_vector_free(dQ_eq_max_dQ); - int j = (int)gsl_vector_get(j_v, 0); - gsl_vector_free(j_v); + VECTOR_T* dQ_eq_max_dQ = compare_elements(dQ, fp_equal, max_dQ); + VECTOR_T* j_v = find(dQ_eq_max_dQ, 1); + VECTOR_ID(free)(dQ_eq_max_dQ); + int j = (int)VECTOR_ID(get)(j_v, 0); + VECTOR_ID(free)(j_v); // Knm(:,j)=Knm(:,j)+W(:,i); - gsl_vector_view Knm_col_j = gsl_matrix_column(Knm, j); - gsl_vector_view _W_col_i = gsl_matrix_column(_W, i); - gsl_vector_add(&Knm_col_j.vector, &_W_col_i.vector); + VECTOR_ID(view) Knm_col_j = MATRIX_ID(column)(Knm, j); + VECTOR_ID(view) _W_col_i = MATRIX_ID(column)(_W, i); + VECTOR_ID(add)(&Knm_col_j.vector, &_W_col_i.vector); // Knm(:,M(i))=Knm(:,M(i))-W(:,i); - gsl_vector_view Knm_col_M_i = gsl_matrix_column(Knm, M_i); - gsl_vector_sub(&Knm_col_M_i.vector, &_W_col_i.vector); + VECTOR_ID(view) Knm_col_M_i = MATRIX_ID(column)(Knm, M_i); + VECTOR_ID(sub)(&Knm_col_M_i.vector, &_W_col_i.vector); // Km(j)=Km(j)+K(i); - gsl_vector_set(Km, j, gsl_vector_get(Km, j) + gsl_vector_get(K, i)); + VECTOR_ID(set)(Km, j, VECTOR_ID(get)(Km, j) + VECTOR_ID(get)(K, i)); // Km(M(i))=Km(M(i))-K(i); - gsl_vector_set(Km, M_i, gsl_vector_get(Km, M_i) - gsl_vector_get(K, i)); + VECTOR_ID(set)(Km, M_i, VECTOR_ID(get)(Km, M_i) - VECTOR_ID(get)(K, i)); // Nm(j)=Nm(j)+1; - gsl_vector_set(Nm, j, gsl_vector_get(Nm, j) + 1.0); + VECTOR_ID(set)(Nm, j, VECTOR_ID(get)(Nm, j) + 1.0); // Nm(M(i))=Nm(M(i))-1; - gsl_vector_set(Nm, M_i, gsl_vector_get(Nm, M_i) - 1.0); + VECTOR_ID(set)(Nm, M_i, VECTOR_ID(get)(Nm, M_i) - 1.0); // M(i)=j; - gsl_vector_set(M, i, (double)j); + VECTOR_ID(set)(M, i, (FP_T)j); // flag=true; flag = true; } - gsl_vector_free(dQ); + VECTOR_ID(free)(dQ); } gsl_permutation_free(randperm_n); } - gsl_vector_free(K); - gsl_vector_free(Km); - gsl_matrix_free(Knm); - gsl_vector_free(Nm); + VECTOR_ID(free)(K); + VECTOR_ID(free)(Km); + MATRIX_ID(free)(Knm); + VECTOR_ID(free)(Nm); // [x x M1]=unique(M); - gsl_vector* x1; - gsl_vector* M1; - gsl_vector* x2 = unique(M, "last", &x1, &M1); - gsl_vector_free(M); - gsl_vector_free(x1); - gsl_vector_free(x2); + VECTOR_T* x1; + VECTOR_T* M1; + VECTOR_T* x2 = unique(M, "last", &x1, &M1); + VECTOR_ID(free)(M); + VECTOR_ID(free)(x1); + VECTOR_ID(free)(x2); // h=h+1; h++; // Ci{h}=zeros(1,n0); - _Ci.push_back(zeros_vector_double(n0)); + _Ci.push_back(zeros_vector(n0)); // for i=1:n for (int i = 0; i < n; i++) { // Ci{h}(Ci{h-1}==i)=M1(i); - gsl_vector* _Ci_h_sub_1_eq_i_add_1 = compare_elements(_Ci[h - 1], fp_equal, (double)(i + 1)); - logical_index_assign(_Ci[h], _Ci_h_sub_1_eq_i_add_1, gsl_vector_get(M1, i) + 1.0); - gsl_vector_free(_Ci_h_sub_1_eq_i_add_1); + VECTOR_T* _Ci_h_sub_1_eq_i_add_1 = compare_elements(_Ci[h - 1], fp_equal, (FP_T)(i + 1)); + logical_index_assign(_Ci[h], _Ci_h_sub_1_eq_i_add_1, VECTOR_ID(get)(M1, i) + 1.0); + VECTOR_ID(free)(_Ci_h_sub_1_eq_i_add_1); } // n=max(M1); n = (int)max(M1) + 1; // W1=zeros(n); - gsl_matrix* _W1 = gsl_matrix_alloc(n, n); + MATRIX_T* _W1 = MATRIX_ID(alloc)(n, n); // for i=1:n for (int i = 0; i < n; i++) { @@ -194,62 +191,62 @@ bool modularity_und_louvain(const gsl_matrix* W, double* Q, gsl_vector** Ci, int for (int j = 0; j < n; j++) { // w=sum(sum(W(M1==i,M1==j))); - gsl_vector* M1_eq_i = compare_elements(M1, fp_equal, (double)i); - gsl_vector* M1_eq_j = compare_elements(M1, fp_equal, (double)j); - gsl_matrix* _W_idx = logical_index(_W, M1_eq_i, M1_eq_j); - gsl_vector_free(M1_eq_i); - gsl_vector_free(M1_eq_j); - gsl_vector* sum__W_idx = sum(_W_idx); - gsl_matrix_free(_W_idx); - double w = sum(sum__W_idx); - gsl_vector_free(sum__W_idx); + VECTOR_T* M1_eq_i = compare_elements(M1, fp_equal, (FP_T)i); + VECTOR_T* M1_eq_j = compare_elements(M1, fp_equal, (FP_T)j); + MATRIX_T* _W_idx = logical_index(_W, M1_eq_i, M1_eq_j); + VECTOR_ID(free)(M1_eq_i); + VECTOR_ID(free)(M1_eq_j); + VECTOR_T* sum__W_idx = sum(_W_idx); + MATRIX_ID(free)(_W_idx); + FP_T w = sum(sum__W_idx); + VECTOR_ID(free)(sum__W_idx); // W1(i,j)=w; - gsl_matrix_set(_W1, i, j, w); + MATRIX_ID(set)(_W1, i, j, w); // W1(j,i)=w; - gsl_matrix_set(_W1, j, i, w); + MATRIX_ID(set)(_W1, j, i, w); } } - gsl_vector_free(M1); + VECTOR_ID(free)(M1); // W=W1; - gsl_matrix_free(_W); + MATRIX_ID(free)(_W); _W = _W1; // Q{h}=sum(diag(W))/s-sum(sum((W/s)^2)); - gsl_vector* diag__W = diag(_W); - double sum_diag__W = sum(diag__W); - gsl_vector_free(diag__W); - gsl_matrix* _W_div_s = copy(_W); - gsl_matrix_scale(_W_div_s, 1.0 / s); - gsl_matrix* _W_div_s_pow_2 = pow(_W_div_s, 2); - gsl_matrix_free(_W_div_s); - gsl_vector* sum__W_div_s_pow_2 = sum(_W_div_s_pow_2); - gsl_matrix_free(_W_div_s_pow_2); - double sum_sum__W_div_s_pow_2 = sum(sum__W_div_s_pow_2); - gsl_vector_free(sum__W_div_s_pow_2); + VECTOR_T* diag__W = diag(_W); + FP_T sum_diag__W = sum(diag__W); + VECTOR_ID(free)(diag__W); + MATRIX_T* _W_div_s = copy(_W); + MATRIX_ID(scale)(_W_div_s, 1.0 / s); + MATRIX_T* _W_div_s_pow_2 = pow(_W_div_s, 2); + MATRIX_ID(free)(_W_div_s); + VECTOR_T* sum__W_div_s_pow_2 = sum(_W_div_s_pow_2); + MATRIX_ID(free)(_W_div_s_pow_2); + FP_T sum_sum__W_div_s_pow_2 = sum(sum__W_div_s_pow_2); + VECTOR_ID(free)(sum__W_div_s_pow_2); _Q.push_back(sum_diag__W / s - sum_sum__W_div_s_pow_2); // if Q{h}-Q{h-1}<=eps - if (fp_less_or_equal(_Q[h] - _Q[h - 1], epsilon_double)) { + if (fp_less_or_equal(_Q[h] - _Q[h - 1], epsilon)) { // break break; } } - gsl_matrix_free(_W); + MATRIX_ID(free)(_W); // Ci([1 end])=[]; for (int i = 0; i < (int)_Ci.size(); i++) { if (i != (int)_Ci.size() - 2) { - gsl_vector_free(_Ci[i]); + VECTOR_ID(free)(_Ci[i]); } } if (Ci == NULL) { - gsl_vector_free(_Ci[_Ci.size() - 2]); + VECTOR_ID(free)(_Ci[_Ci.size() - 2]); } else { *Ci = _Ci[_Ci.size() - 2]; } diff --git a/modularity_newman.cpp b/modularity_newman.cpp index a73f863..af34a5e 100644 --- a/modularity_newman.cpp +++ b/modularity_newman.cpp @@ -1,79 +1,78 @@ -#include "bct.h" #include #include #include -#include -#include -gsl_vector* modularity(const gsl_matrix* B, int N, double m); +#include "bct.h" + +VECTOR_T* modularity(const MATRIX_T* B, int N, FP_T m); /* * Detects communities in a directed graph via Newman modularity. Since GSL * solves eigensystems differently from MATLAB, communities may be numbered * differently. */ -double bct::modularity_dir(const gsl_matrix* A, gsl_vector** Ci) { +FP_T bct::modularity_dir(const MATRIX_T* A, VECTOR_T** Ci) { if (safe_mode) check_status(A, SQUARE | DIRECTED, "modularity_dir"); // Ki=sum(A,1); - gsl_vector* Ki = sum(A, 1); + VECTOR_T* Ki = sum(A, 1); // Ko=sum(A,2); - gsl_vector* Ko = sum(A, 2); + VECTOR_T* Ko = sum(A, 2); // N=length(A); int N = length(A); // m=sum(Ki); - double m = sum(Ki); + FP_T m = sum(Ki); // b=A-(Ko*Ki).'/m; - gsl_matrix* Ko_m = to_column_matrix(Ko); - gsl_vector_free(Ko); - gsl_matrix* Ki_m = to_row_matrix(Ki); - gsl_vector_free(Ki); - gsl_matrix* Ko_mul_Ki_transpose = mul(Ko_m, Ki_m); - gsl_matrix_free(Ko_m); - gsl_matrix_free(Ki_m); - gsl_matrix_transpose(Ko_mul_Ki_transpose); - gsl_matrix_scale(Ko_mul_Ki_transpose, 1.0 / m); - gsl_matrix* b = copy(A); - gsl_matrix_sub(b, Ko_mul_Ki_transpose); - gsl_matrix_free(Ko_mul_Ki_transpose); + MATRIX_T* Ko_m = to_column_matrix(Ko); + VECTOR_ID(free)(Ko); + MATRIX_T* Ki_m = to_row_matrix(Ki); + VECTOR_ID(free)(Ki); + MATRIX_T* Ko_mul_Ki_transpose = mul(Ko_m, Ki_m); + MATRIX_ID(free)(Ko_m); + MATRIX_ID(free)(Ki_m); + MATRIX_ID(transpose)(Ko_mul_Ki_transpose); + MATRIX_ID(scale)(Ko_mul_Ki_transpose, 1.0 / m); + MATRIX_T* b = copy(A); + MATRIX_ID(sub)(b, Ko_mul_Ki_transpose); + MATRIX_ID(free)(Ko_mul_Ki_transpose); // B=b+b.'; - gsl_matrix* b_transpose = gsl_matrix_alloc(b->size2, b->size1); - gsl_matrix_transpose_memcpy(b_transpose, b); - gsl_matrix* B = b; - gsl_matrix_add(B, b_transpose); - gsl_matrix_free(b_transpose); + MATRIX_T* b_transpose = MATRIX_ID(alloc)(b->size2, b->size1); + MATRIX_ID(transpose_memcpy)(b_transpose, b); + MATRIX_T* B = b; + MATRIX_ID(add)(B, b_transpose); + MATRIX_ID(free)(b_transpose); - gsl_vector* _Ci = modularity(B, N, m); + VECTOR_T* _Ci = modularity(B, N, m); // s=Ci(:,ones(1,N)); - gsl_matrix* s = gsl_matrix_alloc(N, N); + MATRIX_T* s = MATRIX_ID(alloc)(N, N); for (int i = 0; i < N; i++) { - gsl_matrix_set_col(s, i, _Ci); + MATRIX_ID(set_col)(s, i, _Ci); } // Q=~(s-s.').*B/(2*m); - gsl_matrix* s_transpose = gsl_matrix_alloc(s->size2, s->size1); - gsl_matrix_transpose_memcpy(s_transpose, s); - gsl_matrix_sub(s, s_transpose); - gsl_matrix_free(s_transpose); - gsl_matrix* Q_m = logical_not(s); - gsl_matrix_free(s); - gsl_matrix_mul_elements(Q_m, B); - gsl_matrix_free(B); - gsl_matrix_scale(Q_m, 1.0 / (2.0 * m)); + MATRIX_T* s_transpose = MATRIX_ID(alloc)(s->size2, s->size1); + MATRIX_ID(transpose_memcpy)(s_transpose, s); + MATRIX_ID(sub)(s, s_transpose); + MATRIX_ID(free)(s_transpose); + MATRIX_T* Q_m = logical_not(s); + MATRIX_ID(free)(s); + MATRIX_ID(mul_elements)(Q_m, B); + MATRIX_ID(free)(B); + MATRIX_ID(scale)(Q_m, 1.0 / (2.0 * m)); // Q=sum(Q(:)); - gsl_vector* sum_Q_m = sum(Q_m); - gsl_matrix_free(Q_m); - double Q = sum(sum_Q_m); - gsl_vector_free(sum_Q_m); + VECTOR_T* sum_Q_m = sum(Q_m); + MATRIX_ID(free)(Q_m); + FP_T Q = sum(sum_Q_m); + VECTOR_ID(free)(sum_Q_m); - if (Ci != NULL) *Ci = _Ci; else gsl_vector_free(_Ci); + if (Ci != NULL) *Ci = _Ci; else VECTOR_ID(free)(_Ci); return Q; } @@ -82,78 +81,78 @@ double bct::modularity_dir(const gsl_matrix* A, gsl_vector** Ci) { * solves eigensystems differently from MATLAB, communities may be numbered * differently. */ -double bct::modularity_und(const gsl_matrix* A, gsl_vector** Ci) { +FP_T bct::modularity_und(const MATRIX_T* A, VECTOR_T** Ci) { if (safe_mode) check_status(A, SQUARE | UNDIRECTED, "modularity_und"); // K=sum(A); - gsl_vector* K = sum(A); + VECTOR_T* K = sum(A); // N=length(A); int N = length(A); // m=sum(K); - double m = sum(K); + FP_T m = sum(K); // B=A-(K.'*K)/m; - gsl_matrix* K_m_transpose = to_column_matrix(K); - gsl_matrix* K_m = to_row_matrix(K); - gsl_vector_free(K); - gsl_matrix* K_m_transpose_mul_K_m = mul(K_m_transpose, K_m); - gsl_matrix_free(K_m_transpose); - gsl_matrix_free(K_m); - gsl_matrix_scale(K_m_transpose_mul_K_m, 1.0 / m); - gsl_matrix* B = copy(A); - gsl_matrix_sub(B, K_m_transpose_mul_K_m); - gsl_matrix_free(K_m_transpose_mul_K_m); + MATRIX_T* K_m_transpose = to_column_matrix(K); + MATRIX_T* K_m = to_row_matrix(K); + VECTOR_ID(free)(K); + MATRIX_T* K_m_transpose_mul_K_m = mul(K_m_transpose, K_m); + MATRIX_ID(free)(K_m_transpose); + MATRIX_ID(free)(K_m); + MATRIX_ID(scale)(K_m_transpose_mul_K_m, 1.0 / m); + MATRIX_T* B = copy(A); + MATRIX_ID(sub)(B, K_m_transpose_mul_K_m); + MATRIX_ID(free)(K_m_transpose_mul_K_m); - gsl_vector* _Ci = modularity(B, N, m); + VECTOR_T* _Ci = modularity(B, N, m); // s=Ci(:,ones(1,N)); - gsl_matrix* s = gsl_matrix_alloc(N, N); + MATRIX_T* s = MATRIX_ID(alloc)(N, N); for (int i = 0; i < N; i++) { - gsl_matrix_set_col(s, i, _Ci); + MATRIX_ID(set_col)(s, i, _Ci); } // Q=~(s-s.').*B/m; - gsl_matrix* s_transpose = gsl_matrix_alloc(s->size2, s->size1); - gsl_matrix_transpose_memcpy(s_transpose, s); - gsl_matrix_sub(s, s_transpose); - gsl_matrix_free(s_transpose); - gsl_matrix* Q_m = logical_not(s); - gsl_matrix_free(s); - gsl_matrix_mul_elements(Q_m, B); - gsl_matrix_free(B); - gsl_matrix_scale(Q_m, 1.0 / m); + MATRIX_T* s_transpose = MATRIX_ID(alloc)(s->size2, s->size1); + MATRIX_ID(transpose_memcpy)(s_transpose, s); + MATRIX_ID(sub)(s, s_transpose); + MATRIX_ID(free)(s_transpose); + MATRIX_T* Q_m = logical_not(s); + MATRIX_ID(free)(s); + MATRIX_ID(mul_elements)(Q_m, B); + MATRIX_ID(free)(B); + MATRIX_ID(scale)(Q_m, 1.0 / m); // Q=sum(Q(:)); - gsl_vector* sum_Q_m = sum(Q_m); - gsl_matrix_free(Q_m); - double Q = sum(sum_Q_m); - gsl_vector_free(sum_Q_m); + VECTOR_T* sum_Q_m = sum(Q_m); + MATRIX_ID(free)(Q_m); + FP_T Q = sum(sum_Q_m); + VECTOR_ID(free)(sum_Q_m); - if (Ci != NULL) *Ci = _Ci; else gsl_vector_free(_Ci); + if (Ci != NULL) *Ci = _Ci; else VECTOR_ID(free)(_Ci); return Q; } -gsl_vector* modularity(const gsl_matrix* B, int N, double m) { +VECTOR_T* modularity(const MATRIX_T* B, int N, FP_T m) { using namespace bct; // Ci=ones(N,1); - gsl_vector* Ci = ones_vector_double(N); + VECTOR_T* Ci = ones_vector(N); // cn=1; int cn = 1; // U=[1 0]; - gsl_vector* U = gsl_vector_alloc(2); - gsl_vector_set(U, 0, 1.0); - gsl_vector_set(U, 1, 0.0); + VECTOR_T* U = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(U, 0, 1.0); + VECTOR_ID(set)(U, 1, 0.0); // ind=1:N; - gsl_vector* ind = sequence_double(0, N - 1); + VECTOR_T* ind = sequence(0, N - 1); // Bg=B; - gsl_matrix* Bg = copy(B); + MATRIX_T* Bg = copy(B); // Ng=N; int Ng = N; @@ -161,7 +160,7 @@ gsl_vector* modularity(const gsl_matrix* B, int N, double m) { gsl_eigen_symmv_workspace* eig = gsl_eigen_symmv_alloc(Bg->size1); // while U(1) - while (fp_nonzero(gsl_vector_get(U, 0))) { + while (fp_nonzero(VECTOR_ID(get)(U, 0))) { // [V D]=eig(Bg); // [d1 i1]=max(diag(D)); @@ -170,89 +169,91 @@ gsl_vector* modularity(const gsl_matrix* B, int N, double m) { gsl_eigen_symmv_free(eig); eig = gsl_eigen_symmv_alloc(Bg->size1); } + gsl_matrix* temp = to_matrix_double(Bg); gsl_vector* eval = gsl_vector_alloc(Bg->size1); gsl_matrix* evec = gsl_matrix_alloc(Bg->size1, Bg->size1); - gsl_matrix* temp = copy(Bg); gsl_eigen_symmv(temp, eval, evec, eig); gsl_matrix_free(temp); gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_VAL_DESC); gsl_vector_free(eval); - gsl_vector* v1 = gsl_vector_alloc(evec->size1); - gsl_matrix_get_col(v1, evec, 0); + gsl_vector* v1_double = gsl_vector_alloc(evec->size1); + gsl_matrix_get_col(v1_double, evec, 0); gsl_matrix_free(evec); + VECTOR_T* v1 = to_vector(v1_double); + gsl_vector_free(v1_double); // S=ones(Ng,1); - gsl_matrix* S = ones_double(Ng, 1); + MATRIX_T* S = ones(Ng, 1); // S(v1<0)=-1; - gsl_vector* v1_lt_0 = compare_elements(v1, fp_less, 0.0); - gsl_vector_free(v1); + VECTOR_T* v1_lt_0 = compare_elements(v1, fp_less, 0.0); + VECTOR_ID(free)(v1); logical_index_assign(S, v1_lt_0, -1.0); - gsl_vector_free(v1_lt_0); + VECTOR_ID(free)(v1_lt_0); // q=S.'*Bg*S; - gsl_matrix* S_transpose = gsl_matrix_alloc(S->size2, S->size1); - gsl_matrix_transpose_memcpy(S_transpose, S); - gsl_matrix* S_transpose_mul_Bg = mul(S_transpose, Bg); - gsl_matrix_free(S_transpose); - gsl_matrix* q_m = mul(S_transpose_mul_Bg, S); - gsl_matrix_free(S_transpose_mul_Bg); - double q = gsl_matrix_get(q_m, 0, 0); - gsl_matrix_free(q_m); + MATRIX_T* S_transpose = MATRIX_ID(alloc)(S->size2, S->size1); + MATRIX_ID(transpose_memcpy)(S_transpose, S); + MATRIX_T* S_transpose_mul_Bg = mul(S_transpose, Bg); + MATRIX_ID(free)(S_transpose); + MATRIX_T* q_m = mul(S_transpose_mul_Bg, S); + MATRIX_ID(free)(S_transpose_mul_Bg); + FP_T q = MATRIX_ID(get)(q_m, 0, 0); + MATRIX_ID(free)(q_m); // if q>1e-10 if (q > 1e-10) { // qmax=q; - double qmax = q; + FP_T qmax = q; // Bg(logical(eye(Ng)))=0; - gsl_matrix* eye_Ng = eye_double(Ng); + MATRIX_T* eye_Ng = eye(Ng); logical_index_assign(Bg, eye_Ng, 0.0); - gsl_matrix_free(eye_Ng); + MATRIX_ID(free)(eye_Ng); // indg=ones(Ng,1); - gsl_matrix* indg = ones_double(Ng, 1); + MATRIX_T* indg = ones(Ng, 1); // Sit=S; - gsl_matrix* Sit = copy(S); + MATRIX_T* Sit = copy(S); // while any(indg); - gsl_vector* any_indg = any(indg); + VECTOR_T* any_indg = any(indg); bool any_indg_bool = to_bool(any_indg); - gsl_vector_free(any_indg); + VECTOR_ID(free)(any_indg); while (any_indg_bool) { // Qit=qmax-4*Sit.*(Bg*Sit); - gsl_matrix* Qit = mul(Bg, Sit); - gsl_matrix_mul_elements(Qit, Sit); - gsl_matrix_scale(Qit, -4.0); - gsl_matrix_add_constant(Qit, qmax); + MATRIX_T* Qit = mul(Bg, Sit); + MATRIX_ID(mul_elements)(Qit, Sit); + MATRIX_ID(scale)(Qit, -4.0); + MATRIX_ID(add_constant)(Qit, qmax); // qmax=max(Qit.*indg); - gsl_matrix* Qit_mul_indg = copy(Qit); - gsl_matrix_mul_elements(Qit_mul_indg, indg); - gsl_vector* qmax_v = max(Qit_mul_indg); - gsl_matrix_free(Qit_mul_indg); - qmax = gsl_vector_get(qmax_v, 0); - gsl_vector_free(qmax_v); + MATRIX_T* Qit_mul_indg = copy(Qit); + MATRIX_ID(mul_elements)(Qit_mul_indg, indg); + VECTOR_T* qmax_v = max(Qit_mul_indg); + MATRIX_ID(free)(Qit_mul_indg); + qmax = VECTOR_ID(get)(qmax_v, 0); + VECTOR_ID(free)(qmax_v); // TODO: Fix precision issue (differences of 1e-14 for macaque47/71) // imax=(Qit==qmax); - gsl_matrix* imax = compare_elements(Qit, fp_equal, qmax); - gsl_matrix_free(Qit); + MATRIX_T* imax = compare_elements(Qit, fp_equal, qmax); + MATRIX_ID(free)(Qit); // Sit(imax)=-Sit(imax); - gsl_vector* neg_Sit_imax = logical_index(Sit, imax); + VECTOR_T* neg_Sit_imax = logical_index(Sit, imax); if (neg_Sit_imax != NULL) { - gsl_vector_scale(neg_Sit_imax, -1.0); + VECTOR_ID(scale)(neg_Sit_imax, -1.0); logical_index_assign(Sit, imax, neg_Sit_imax); - gsl_vector_free(neg_Sit_imax); + VECTOR_ID(free)(neg_Sit_imax); } // indg(imax)=nan; logical_index_assign(indg, imax, GSL_NAN); - gsl_matrix_free(imax); + MATRIX_ID(free)(imax); // if qmax>q; if (qmax > q) { @@ -261,26 +262,26 @@ gsl_vector* modularity(const gsl_matrix* B, int N, double m) { q = qmax; // S=Sit; - gsl_matrix_free(S); + MATRIX_ID(free)(S); S = copy(Sit); } any_indg = any(indg); any_indg_bool = to_bool(any_indg); - gsl_vector_free(any_indg); + VECTOR_ID(free)(any_indg); } // if(abs(sum(S))==Ng - gsl_vector* sum_S_v = sum(S); - double sum_S = sum(sum_S_v); - gsl_vector_free(sum_S_v); - if (fp_equal(std::abs(sum_S), (double)Ng)) { + VECTOR_T* sum_S_v = sum(S); + FP_T sum_S = sum(sum_S_v); + VECTOR_ID(free)(sum_S_v); + if (fp_equal(std::abs(sum_S), (FP_T)Ng)) { // U(1)=[]; - gsl_vector* temp = gsl_vector_alloc(U->size - 1); - gsl_vector_view U_subv = gsl_vector_subvector(U, 1, U->size - 1); - gsl_vector_memcpy(temp, &U_subv.vector); - gsl_vector_free(U); + VECTOR_T* temp = VECTOR_ID(alloc)(U->size - 1); + VECTOR_ID(view) U_subv = VECTOR_ID(subvector)(U, 1, U->size - 1); + VECTOR_ID(memcpy)(temp, &U_subv.vector); + VECTOR_ID(free)(U); U = temp; } else { @@ -290,76 +291,76 @@ gsl_vector* modularity(const gsl_matrix* B, int N, double m) { if (ind != NULL) { // Ci(ind(S==1))=U(1); - gsl_matrix* S_eq_1_m = compare_elements(S, fp_equal, 1.0); - gsl_vector* S_eq_1 = to_vector(S_eq_1_m); - gsl_matrix_free(S_eq_1_m); - gsl_vector* ind_idx = logical_index(ind, S_eq_1); - gsl_vector_free(S_eq_1); + MATRIX_T* S_eq_1_m = compare_elements(S, fp_equal, 1.0); + VECTOR_T* S_eq_1 = to_vector(S_eq_1_m); + MATRIX_ID(free)(S_eq_1_m); + VECTOR_T* ind_idx = logical_index(ind, S_eq_1); + VECTOR_ID(free)(S_eq_1); if (ind_idx != NULL) { - ordinal_index_assign(Ci, ind_idx, gsl_vector_get(U, 0)); - gsl_vector_free(ind_idx); + ordinal_index_assign(Ci, ind_idx, VECTOR_ID(get)(U, 0)); + VECTOR_ID(free)(ind_idx); } // Ci(ind(S==-1))=cn; - gsl_matrix* S_eq_neg_1_m = compare_elements(S, fp_equal, -1.0); - gsl_vector* S_eq_neg_1 = to_vector(S_eq_neg_1_m); - gsl_matrix_free(S_eq_neg_1_m); + MATRIX_T* S_eq_neg_1_m = compare_elements(S, fp_equal, -1.0); + VECTOR_T* S_eq_neg_1 = to_vector(S_eq_neg_1_m); + MATRIX_ID(free)(S_eq_neg_1_m); ind_idx = logical_index(ind, S_eq_neg_1); - gsl_vector_free(S_eq_neg_1); + VECTOR_ID(free)(S_eq_neg_1); if (ind_idx != NULL) { - ordinal_index_assign(Ci, ind_idx, (double)cn); - gsl_vector_free(ind_idx); + ordinal_index_assign(Ci, ind_idx, (FP_T)cn); + VECTOR_ID(free)(ind_idx); } } // U=[cn U]; - gsl_vector* temp = concatenate((double)cn, U); - gsl_vector_free(U); + VECTOR_T* temp = concatenate((FP_T)cn, U); + VECTOR_ID(free)(U); U = temp; } - gsl_matrix_free(indg); - gsl_matrix_free(Sit); + MATRIX_ID(free)(indg); + MATRIX_ID(free)(Sit); } else { // U(1)=[]; - gsl_vector* temp = gsl_vector_alloc(U->size - 1); - gsl_vector_view U_subv = gsl_vector_subvector(U, 1, U->size - 1); - gsl_vector_memcpy(temp, &U_subv.vector); - gsl_vector_free(U); + VECTOR_T* temp = VECTOR_ID(alloc)(U->size - 1); + VECTOR_ID(view) U_subv = VECTOR_ID(subvector)(U, 1, U->size - 1); + VECTOR_ID(memcpy)(temp, &U_subv.vector); + VECTOR_ID(free)(U); U = temp; } - gsl_matrix_free(S); + MATRIX_ID(free)(S); // ind=find(Ci==U(1)); - gsl_vector* _Ci_eq_U_0 = compare_elements(Ci, fp_equal, gsl_vector_get(U, 0)); - gsl_vector_free(ind); + VECTOR_T* _Ci_eq_U_0 = compare_elements(Ci, fp_equal, VECTOR_ID(get)(U, 0)); + VECTOR_ID(free)(ind); ind = find(_Ci_eq_U_0); - gsl_vector_free(_Ci_eq_U_0); + VECTOR_ID(free)(_Ci_eq_U_0); if (ind != NULL) { // bg=B(ind,ind); - gsl_matrix* bg = ordinal_index(B, ind, ind); + MATRIX_T* bg = ordinal_index(B, ind, ind); // Bg=bg-diag(sum(bg)); - gsl_vector* sum_bg = sum(bg); - gsl_matrix* diag_sum_bg = diag(sum_bg); - gsl_vector_free(sum_bg); - gsl_matrix_free(Bg); + VECTOR_T* sum_bg = sum(bg); + MATRIX_T* diag_sum_bg = diag(sum_bg); + VECTOR_ID(free)(sum_bg); + MATRIX_ID(free)(Bg); Bg = bg; - gsl_matrix_sub(Bg, diag_sum_bg); - gsl_matrix_free(diag_sum_bg); + MATRIX_ID(sub)(Bg, diag_sum_bg); + MATRIX_ID(free)(diag_sum_bg); // Ng=length(ind); Ng = length(ind); } } - gsl_vector_free(U); - gsl_vector_free(ind); - gsl_matrix_free(Bg); + VECTOR_ID(free)(U); + VECTOR_ID(free)(ind); + MATRIX_ID(free)(Bg); gsl_eigen_symmv_free(eig); return Ci; diff --git a/module_degree_zscore.cpp b/module_degree_zscore.cpp index d554c7d..1fc1f14 100644 --- a/module_degree_zscore.cpp +++ b/module_degree_zscore.cpp @@ -1,43 +1,42 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes z-score for a binary graph and its corresponding community * structure. For a directed graph, computes out-neighbor z-score. */ -gsl_vector* bct::module_degree_zscore(const gsl_matrix* A, const gsl_vector* Ci) { +VECTOR_T* bct::module_degree_zscore(const MATRIX_T* A, const VECTOR_T* Ci) { if (safe_mode) check_status(A, SQUARE | BINARY, "module_degree_zscore"); // n=length(A); int n = length(A); // Z=zeros(n,1); - gsl_vector* Z = zeros_vector_double(n); + VECTOR_T* Z = zeros_vector(n); // for i=1:max(Ci) for (int i = 1; i <= (int)max(Ci); i++) { // Koi=sum(A(Ci==i,Ci==i),2); - gsl_vector* Ci_eq_i = compare_elements(Ci, fp_equal, (double)i); - gsl_matrix* A_idx = logical_index(A, Ci_eq_i, Ci_eq_i); - gsl_vector* Koi = sum(A_idx, 2); - gsl_matrix_free(A_idx); + VECTOR_T* Ci_eq_i = compare_elements(Ci, fp_equal, (FP_T)i); + MATRIX_T* A_idx = logical_index(A, Ci_eq_i, Ci_eq_i); + VECTOR_T* Koi = sum(A_idx, 2); + MATRIX_ID(free)(A_idx); // Z(Ci==i)=(Koi-mean(Koi))./std(Koi); - double std_Koi = matlab::std(Koi); - gsl_vector_add_constant(Koi, -mean(Koi)); - gsl_vector_scale(Koi, 1.0 / std_Koi); + FP_T std_Koi = matlab::std(Koi); + VECTOR_ID(add_constant)(Koi, -mean(Koi)); + VECTOR_ID(scale)(Koi, 1.0 / std_Koi); logical_index_assign(Z, Ci_eq_i, Koi); - gsl_vector_free(Ci_eq_i); - gsl_vector_free(Koi); + VECTOR_ID(free)(Ci_eq_i); + VECTOR_ID(free)(Koi); } // Z(isnan(Z))=0; for (int i = 0; i < (int)Z->size; i++) { - if (gsl_isnan(gsl_vector_get(Z, i)) == 1) { - gsl_vector_set(Z, i, 0.0); + if (gsl_isnan(VECTOR_ID(get)(Z, i)) == 1) { + VECTOR_ID(set)(Z, i, 0.0); } } diff --git a/motif3funct_bin.cpp b/motif3funct_bin.cpp index ed59dc0..2c17d83 100644 --- a/motif3funct_bin.cpp +++ b/motif3funct_bin.cpp @@ -1,172 +1,170 @@ #include "bct.h" -#include -#include /* * Counts occurrences of three-node functional motifs in a binary graph. */ -gsl_vector* bct::motif3funct_bin(const gsl_matrix* W, gsl_matrix** F) { +VECTOR_T* bct::motif3funct_bin(const MATRIX_T* W, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | BINARY, "motif3funct_bin"); // load motif34lib M3 ID3 N3 - gsl_vector* ID3; - gsl_vector* N3; - gsl_matrix* M3 = motif3generate(&ID3, &N3); + VECTOR_T* ID3; + VECTOR_T* N3; + MATRIX_T* M3 = motif3generate(&ID3, &N3); // n=length(W); int n = length(W); // f=zeros(13,1); - gsl_vector* f = zeros_vector_double(13); + VECTOR_T* f = zeros_vector(13); // F=zeros(13,n); if (F != NULL) { - *F = zeros_double(13, n); + *F = zeros(13, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-2 for (int u = 0; u < n - 2; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=([false(1,v1) As(u,v1+1:n)])|V2; - gsl_vector* V2_1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_1, As, u); + VECTOR_T* V2_1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_1, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_1, i, 0.0); + VECTOR_ID(set)(V2_1, i, 0.0); } - gsl_vector* V2_2 = V2; + VECTOR_T* V2_2 = V2; V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // a=[A(v1,u);A(v2,u);A(u,v1);A(v2,v1);A(u,v2);A(v1,v2)]; int A_rows[] = { v1, v2, u, v2, u, v1 }; int A_cols[] = { u, u, v1, v1, v2, v2 }; - gsl_matrix* a = gsl_matrix_alloc(6, 1); + MATRIX_T* a = MATRIX_ID(alloc)(6, 1); for (int i = 0; i < 6; i++) { - gsl_matrix_set(a, i, 0, gsl_matrix_get(A, A_rows[i], A_cols[i])); + MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, A_rows[i], A_cols[i])); } // ind=(M3*a)==N3; - gsl_matrix* M3_mul_a_m = mul(M3, a); - gsl_matrix_free(a); - gsl_vector* M3_mul_a = to_vector(M3_mul_a_m); - gsl_matrix_free(M3_mul_a_m); - gsl_vector* ind = compare_elements(M3_mul_a, fp_equal, N3); - gsl_vector_free(M3_mul_a); + MATRIX_T* M3_mul_a_m = mul(M3, a); + MATRIX_ID(free)(a); + VECTOR_T* M3_mul_a = to_vector(M3_mul_a_m); + MATRIX_ID(free)(M3_mul_a_m); + VECTOR_T* ind = compare_elements(M3_mul_a, fp_equal, N3); + VECTOR_ID(free)(M3_mul_a); // id=ID3(ind); - gsl_vector* id = logical_index(ID3, ind); - gsl_vector_free(ind); + VECTOR_T* id = logical_index(ID3, ind); + VECTOR_ID(free)(ind); if (id != NULL) { - gsl_vector_add_constant(id, -1.0); + VECTOR_ID(add_constant)(id, -1.0); // [idu j]=unique(id); - gsl_vector* j; - gsl_vector* idu = unique(id, "last", &j); - gsl_vector_free(id); + VECTOR_T* j; + VECTOR_T* idu = unique(id, "last", &j); + VECTOR_ID(free)(id); // j=[0;j]; - gsl_vector* temp = gsl_vector_alloc(j->size + 1); - gsl_vector_set(temp, 0, -1.0); - gsl_vector_view temp_subv = gsl_vector_subvector(temp, 1, j->size); - gsl_vector_memcpy(&temp_subv.vector, j); - gsl_vector_free(j); + VECTOR_T* temp = VECTOR_ID(alloc)(j->size + 1); + VECTOR_ID(set)(temp, 0, -1.0); + VECTOR_ID(view) temp_subv = VECTOR_ID(subvector)(temp, 1, j->size); + VECTOR_ID(memcpy)(&temp_subv.vector, j); + VECTOR_ID(free)(j); j = temp; // mu=length(idu); int mu = length(idu); // f2=zeros(mu,1); - gsl_vector* f2 = zeros_vector_double(mu); + VECTOR_T* f2 = zeros_vector(mu); // for h=1:mu for (int h = 0; h < mu; h++) { // f2(h)=j(h+1)-j(h); - double j_h_add_1 = gsl_vector_get(j, h + 1); - double j_h = gsl_vector_get(j, h); - gsl_vector_set(f2, h, j_h_add_1 - j_h); + FP_T j_h_add_1 = VECTOR_ID(get)(j, h + 1); + FP_T j_h = VECTOR_ID(get)(j, h); + VECTOR_ID(set)(f2, h, j_h_add_1 - j_h); } - gsl_vector_free(j); + VECTOR_ID(free)(j); // f(idu)=f(idu)+f2; - gsl_vector* f_idu_add_f2 = ordinal_index(f, idu); - gsl_vector_add(f_idu_add_f2, f2); + VECTOR_T* f_idu_add_f2 = ordinal_index(f, idu); + VECTOR_ID(add)(f_idu_add_f2, f2); ordinal_index_assign(f, idu, f_idu_add_f2); - gsl_vector_free(f_idu_add_f2); + VECTOR_ID(free)(f_idu_add_f2); // if nargout==2; F(idu,[u v1 v2])=F(idu,[u v1 v2])+[f2 f2 f2]; end if (F != NULL) { - double F_cols[] = { (double)u, (double)v1, (double)v2 }; - gsl_vector_view F_cols_vv = gsl_vector_view_array(F_cols, 3); - gsl_matrix* F_idx = ordinal_index(*F, idu, &F_cols_vv.vector); + FP_T F_cols[] = { (FP_T)u, (FP_T)v1, (FP_T)v2 }; + VECTOR_ID(view) F_cols_vv = VECTOR_ID(view_array)(F_cols, 3); + MATRIX_T* F_idx = ordinal_index(*F, idu, &F_cols_vv.vector); for (int i = 0; i < 3; i++) { - gsl_vector_view F_idx_col_i = gsl_matrix_column(F_idx, i); - gsl_vector_add(&F_idx_col_i.vector, f2); + VECTOR_ID(view) F_idx_col_i = MATRIX_ID(column)(F_idx, i); + VECTOR_ID(add)(&F_idx_col_i.vector, f2); } ordinal_index_assign(*F, idu, &F_cols_vv.vector, F_idx); - gsl_matrix_free(F_idx); + MATRIX_ID(free)(F_idx); } - gsl_vector_free(idu); - gsl_vector_free(f2); + VECTOR_ID(free)(idu); + VECTOR_ID(free)(f2); } } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID3); - gsl_vector_free(N3); - gsl_matrix_free(M3); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID3); + VECTOR_ID(free)(N3); + MATRIX_ID(free)(M3); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return f; } diff --git a/motif3funct_wei.cpp b/motif3funct_wei.cpp index 0e130f8..c4bd1f7 100644 --- a/motif3funct_wei.cpp +++ b/motif3funct_wei.cpp @@ -1,207 +1,205 @@ #include "bct.h" -#include -#include /* * Counts occurrences of three-node functional motifs in a weighted graph. * Returns intensity and (optionally) coherence and motif counts. */ -gsl_matrix* bct::motif3funct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix** F) { +MATRIX_T* bct::motif3funct_wei(const MATRIX_T* W, MATRIX_T** Q, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | WEIGHTED, "motif3funct_wei"); // load motif34lib M3 M3n ID3 N3 - gsl_vector* ID3; - gsl_vector* N3; - gsl_matrix* M3 = motif3generate(&ID3, &N3); + VECTOR_T* ID3; + VECTOR_T* N3; + MATRIX_T* M3 = motif3generate(&ID3, &N3); // n=length(W); int n = length(W); // I=zeros(13,n); - gsl_matrix* I = zeros_double(13, n); + MATRIX_T* I = zeros(13, n); // Q=zeros(13,n); if (Q != NULL) { - *Q = zeros_double(13, n); + *Q = zeros(13, n); } // F=zeros(13,n); if (F != NULL) { - *F = zeros_double(13, n); + *F = zeros(13, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-2 for (int u = 0; u < n - 2; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=([false(1,v1) As(u,v1+1:n)])|V2; - gsl_vector* V2_1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_1, As, u); + VECTOR_T* V2_1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_1, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_1, i, 0.0); + VECTOR_ID(set)(V2_1, i, 0.0); } - gsl_vector* V2_2 = V2; + VECTOR_T* V2_2 = V2; V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // w=[W(v1,u) W(v2,u) W(u,v1) W(v2,v1) W(u,v2) W(v1,v2)]; int WA_rows[] = { v1, v2, u, v2, u, v1 }; int WA_cols[] = { u, u, v1, v1, v2, v2 }; - gsl_vector* w = gsl_vector_alloc(6); + VECTOR_T* w = VECTOR_ID(alloc)(6); for (int i = 0; i < 6; i++) { - gsl_vector_set(w, i, gsl_matrix_get(W, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(w, i, MATRIX_ID(get)(W, WA_rows[i], WA_cols[i])); } // a=[A(v1,u);A(v2,u);A(u,v1);A(v2,v1);A(u,v2);A(v1,v2)]; - gsl_matrix* a = gsl_matrix_alloc(6, 1); + MATRIX_T* a = MATRIX_ID(alloc)(6, 1); for (int i = 0; i < 6; i++) { - gsl_matrix_set(a, i, 0, gsl_matrix_get(A, WA_rows[i], WA_cols[i])); + MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i])); } // ind=(M3*a)==N3; - gsl_matrix* M3_mul_a_m = mul(M3, a); - gsl_matrix_free(a); - gsl_vector* M3_mul_a = to_vector(M3_mul_a_m); - gsl_matrix_free(M3_mul_a_m); - gsl_vector* ind = compare_elements(M3_mul_a, fp_equal, N3); - gsl_vector_free(M3_mul_a); + MATRIX_T* M3_mul_a_m = mul(M3, a); + MATRIX_ID(free)(a); + VECTOR_T* M3_mul_a = to_vector(M3_mul_a_m); + MATRIX_ID(free)(M3_mul_a_m); + VECTOR_T* ind = compare_elements(M3_mul_a, fp_equal, N3); + VECTOR_ID(free)(M3_mul_a); // m=sum(ind); int m = (int)sum(ind); if (m > 0) { // M=M3(ind,:).*repmat(w,m,1); - gsl_vector* M3_cols = sequence_double(0, M3->size2 - 1); - gsl_matrix* M = log_ord_index(M3, ind, M3_cols); - gsl_vector_free(M3_cols); + VECTOR_T* M3_cols = sequence(0, M3->size2 - 1); + MATRIX_T* M = log_ord_index(M3, ind, M3_cols); + VECTOR_ID(free)(M3_cols); for (int i = 0; i < (int)M->size1; i++) { - gsl_vector_view M_row_i = gsl_matrix_row(M, i); - gsl_vector_mul(&M_row_i.vector, w); + VECTOR_ID(view) M_row_i = MATRIX_ID(row)(M, i); + VECTOR_ID(mul)(&M_row_i.vector, w); } // id=ID3(ind); - gsl_vector* id = logical_index(ID3, ind); - gsl_vector_add_constant(id, -1.0); + VECTOR_T* id = logical_index(ID3, ind); + VECTOR_ID(add_constant)(id, -1.0); // l=N3(ind); - gsl_vector* l = logical_index(N3, ind); + VECTOR_T* l = logical_index(N3, ind); // x=sum(M,2)./l; - gsl_vector* x = sum(M, 2); - gsl_vector_div(x, l); + VECTOR_T* x = sum(M, 2); + VECTOR_ID(div)(x, l); // M(M==0)=1; - gsl_matrix* M_eq_0 = compare_elements(M, fp_equal, 0.0); + MATRIX_T* M_eq_0 = compare_elements(M, fp_equal, 0.0); logical_index_assign(M, M_eq_0, 1.0); - gsl_matrix_free(M_eq_0); + MATRIX_ID(free)(M_eq_0); // i=prod(M,2).^(1./l); - gsl_vector* prod_M = prod(M, 2); - gsl_matrix_free(M); - gsl_vector* l_pow_neg_1 = pow_elements(l, -1.0); - gsl_vector_free(l); - gsl_vector* i = pow_elements(prod_M, l_pow_neg_1); - gsl_vector_free(prod_M); - gsl_vector_free(l_pow_neg_1); + VECTOR_T* prod_M = prod(M, 2); + MATRIX_ID(free)(M); + VECTOR_T* l_pow_neg_1 = pow_elements(l, -1.0); + VECTOR_ID(free)(l); + VECTOR_T* i = pow_elements(prod_M, l_pow_neg_1); + VECTOR_ID(free)(prod_M); + VECTOR_ID(free)(l_pow_neg_1); // q = i./x; - gsl_vector* q = copy(i); - gsl_vector_div(q, x); - gsl_vector_free(x); + VECTOR_T* q = copy(i); + VECTOR_ID(div)(q, x); + VECTOR_ID(free)(x); // [idu j]=unique(id); - gsl_vector* j; - gsl_vector* idu = unique(id, "last", &j); - gsl_vector_free(id); + VECTOR_T* j; + VECTOR_T* idu = unique(id, "last", &j); + VECTOR_ID(free)(id); // j=[0;j]; - gsl_vector* temp = gsl_vector_alloc(j->size + 1); - gsl_vector_set(temp, 0, -1.0); - gsl_vector_view temp_subv = gsl_vector_subvector(temp, 1, j->size); - gsl_vector_memcpy(&temp_subv.vector, j); - gsl_vector_free(j); + VECTOR_T* temp = VECTOR_ID(alloc)(j->size + 1); + VECTOR_ID(set)(temp, 0, -1.0); + VECTOR_ID(view) temp_subv = VECTOR_ID(subvector)(temp, 1, j->size); + VECTOR_ID(memcpy)(&temp_subv.vector, j); + VECTOR_ID(free)(j); j = temp; // mu=length(idu); int mu = length(idu); // i2=zeros(mu,1); - gsl_vector* i2 = zeros_vector_double(mu); + VECTOR_T* i2 = zeros_vector(mu); // q2=i2; f2=i2; - gsl_vector* q2 = copy(i2); - gsl_vector* f2 = copy(i2); + VECTOR_T* q2 = copy(i2); + VECTOR_T* f2 = copy(i2); // for h=1:mu for (int h = 0; h < mu; h++) { // i2(h)=sum(i(j(h)+1:j(h+1))); - int j_h = (int)gsl_vector_get(j, h); - int j_h_add_1 = (int)gsl_vector_get(j, h + 1); - gsl_vector* iq_indices = sequence_double(j_h + 1, j_h_add_1); - gsl_vector* i_idx = ordinal_index(i, iq_indices); - gsl_vector_set(i2, h, sum(i_idx)); - gsl_vector_free(i_idx); + int j_h = (int)VECTOR_ID(get)(j, h); + int j_h_add_1 = (int)VECTOR_ID(get)(j, h + 1); + VECTOR_T* iq_indices = sequence(j_h + 1, j_h_add_1); + VECTOR_T* i_idx = ordinal_index(i, iq_indices); + VECTOR_ID(set)(i2, h, sum(i_idx)); + VECTOR_ID(free)(i_idx); // q2(h)=sum(q(j(h)+1:j(h+1))); - gsl_vector* q_idx = ordinal_index(q, iq_indices); - gsl_vector_free(iq_indices); - gsl_vector_set(q2, h, sum(q_idx)); - gsl_vector_free(q_idx); + VECTOR_T* q_idx = ordinal_index(q, iq_indices); + VECTOR_ID(free)(iq_indices); + VECTOR_ID(set)(q2, h, sum(q_idx)); + VECTOR_ID(free)(q_idx); // f2(h)=j(h+1)-j(h); - gsl_vector_set(f2, h, (double)(j_h_add_1 - j_h)); + VECTOR_ID(set)(f2, h, (FP_T)(j_h_add_1 - j_h)); } - gsl_vector_free(i); - gsl_vector_free(q); - gsl_vector_free(j); + VECTOR_ID(free)(i); + VECTOR_ID(free)(q); + VECTOR_ID(free)(j); // I(idu,[u v1 v2])=I(idu,[u v1 v2])+[i2 i2 i2]; // Q(idu,[u v1 v2])=Q(idu,[u v1 v2])+[q2 q2 q2]; // F(idu,[u v1 v2])=F(idu,[u v1 v2])+[f2 f2 f2]; - double IQF_cols[] = { (double)u, (double)v1, (double)v2 }; - gsl_vector_view IQF_cols_vv = gsl_vector_view_array(IQF_cols, 3); - gsl_matrix* I_idx = ordinal_index(I, idu, &IQF_cols_vv.vector); - gsl_matrix* Q_idx = NULL; - gsl_matrix* F_idx = NULL; + FP_T IQF_cols[] = { (FP_T)u, (FP_T)v1, (FP_T)v2 }; + VECTOR_ID(view) IQF_cols_vv = VECTOR_ID(view_array)(IQF_cols, 3); + MATRIX_T* I_idx = ordinal_index(I, idu, &IQF_cols_vv.vector); + MATRIX_T* Q_idx = NULL; + MATRIX_T* F_idx = NULL; if (Q != NULL) { Q_idx = ordinal_index(*Q, idu, &IQF_cols_vv.vector); } @@ -209,73 +207,73 @@ gsl_matrix* bct::motif3funct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix F_idx = ordinal_index(*F, idu, &IQF_cols_vv.vector); } for (int j = 0; j < 3; j++) { - gsl_vector_view I_idx_col_j = gsl_matrix_column(I_idx, j); - gsl_vector_add(&I_idx_col_j.vector, i2); + VECTOR_ID(view) I_idx_col_j = MATRIX_ID(column)(I_idx, j); + VECTOR_ID(add)(&I_idx_col_j.vector, i2); if (Q != NULL) { - gsl_vector_view Q_idx_col_j = gsl_matrix_column(Q_idx, j); - gsl_vector_add(&Q_idx_col_j.vector, q2); + VECTOR_ID(view) Q_idx_col_j = MATRIX_ID(column)(Q_idx, j); + VECTOR_ID(add)(&Q_idx_col_j.vector, q2); } if (F != NULL) { - gsl_vector_view F_idx_col_j = gsl_matrix_column(F_idx, j); - gsl_vector_add(&F_idx_col_j.vector, f2); + VECTOR_ID(view) F_idx_col_j = MATRIX_ID(column)(F_idx, j); + VECTOR_ID(add)(&F_idx_col_j.vector, f2); } } - gsl_vector_free(i2); - gsl_vector_free(q2); - gsl_vector_free(f2); + VECTOR_ID(free)(i2); + VECTOR_ID(free)(q2); + VECTOR_ID(free)(f2); ordinal_index_assign(I, idu, &IQF_cols_vv.vector, I_idx); - gsl_matrix_free(I_idx); + MATRIX_ID(free)(I_idx); if (Q != NULL) { ordinal_index_assign(*Q, idu, &IQF_cols_vv.vector, Q_idx); - gsl_matrix_free(Q_idx); + MATRIX_ID(free)(Q_idx); } if (F != NULL) { ordinal_index_assign(*F, idu, &IQF_cols_vv.vector, F_idx); - gsl_matrix_free(F_idx); + MATRIX_ID(free)(F_idx); } - gsl_vector_free(idu); + VECTOR_ID(free)(idu); } - gsl_vector_free(w); - gsl_vector_free(ind); + VECTOR_ID(free)(w); + VECTOR_ID(free)(ind); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID3); - gsl_vector_free(N3); - gsl_matrix_free(M3); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID3); + VECTOR_ID(free)(N3); + MATRIX_ID(free)(M3); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return I; } /* * Returns per-motif metrics instead of per-motif, per-node metrics. */ -gsl_vector* bct::motif3funct_wei_v(const gsl_matrix* W, gsl_vector** Q, gsl_vector** F) { - gsl_matrix* _Q; - gsl_matrix* _F; - gsl_matrix* _I = motif3funct_wei(W, &_Q, &_F); +VECTOR_T* bct::motif3funct_wei_v(const MATRIX_T* W, VECTOR_T** Q, VECTOR_T** F) { + MATRIX_T* _Q; + MATRIX_T* _F; + MATRIX_T* _I = motif3funct_wei(W, &_Q, &_F); if (Q != NULL) { *Q = sum(_Q, 2); } - gsl_matrix_free(_Q); + MATRIX_ID(free)(_Q); if (F != NULL) { *F = sum(_F, 2); } - gsl_matrix_free(_F); - gsl_vector* I = sum(_I, 2); - gsl_matrix_free(_I); + MATRIX_ID(free)(_F); + VECTOR_T* I = sum(_I, 2); + MATRIX_ID(free)(_I); return I; } diff --git a/motif3struct_bin.cpp b/motif3struct_bin.cpp index a928d12..cabf363 100644 --- a/motif3struct_bin.cpp +++ b/motif3struct_bin.cpp @@ -1,124 +1,122 @@ #include "bct.h" -#include -#include /* * Counts occurrences of three-node structural motifs in a binary graph. */ -gsl_vector* bct::motif3struct_bin(const gsl_matrix* A, gsl_matrix** F) { +VECTOR_T* bct::motif3struct_bin(const MATRIX_T* A, MATRIX_T** F) { if (safe_mode) check_status(A, SQUARE | BINARY, "motif3struct_bin"); // load motif34lib M3n ID3 - gsl_vector* ID3; - gsl_matrix* M3 = motif3generate(&ID3); + VECTOR_T* ID3; + MATRIX_T* M3 = motif3generate(&ID3); // n=length(A); int n = length(A); // F=zeros(13,n); if (F != NULL) { - *F = zeros_double(13, n); + *F = zeros(13, n); } // f=zeros(13,1); - gsl_vector* f = zeros_vector_double(13); + VECTOR_T* f = zeros_vector(13); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-2 for (int u = 0; u < n - 2; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=([false(1,v1) As(u,v1+1:n)])|V2; - gsl_vector* V2_1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_1, As, u); + VECTOR_T* V2_1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_1, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_1, i, 0.0); + VECTOR_ID(set)(V2_1, i, 0.0); } - gsl_vector* V2_2 = V2; + VECTOR_T* V2_2 = V2; V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // s=uint32(sum(10.^(5:-1:0).*[A(v1,u) A(v2,u) A(u,v1) A(v2,v1) A(u,v2) A(v1,v2)])); int A_rows[] = { v1, v2, u, v2, u, v1 }; int A_cols[] = { u, u, v1, v1, v2, v2 }; - gsl_vector* s = gsl_vector_alloc(6); + VECTOR_T* s = VECTOR_ID(alloc)(6); for (int i = 0; i < 6; i++) { - gsl_vector_set(s, i, gsl_matrix_get(A, A_rows[i], A_cols[i])); + VECTOR_ID(set)(s, i, MATRIX_ID(get)(A, A_rows[i], A_cols[i])); } // ind=ID3(s==M3n); int i_M3 = 0; for ( ; i_M3 < (int)M3->size1; i_M3++) { - gsl_vector_view M3_row_i_M3 = gsl_matrix_row(M3, i_M3); + VECTOR_ID(view) M3_row_i_M3 = MATRIX_ID(row)(M3, i_M3); if (compare_vectors(s, &M3_row_i_M3.vector) == 0) { break; } } - gsl_vector_free(s); + VECTOR_ID(free)(s); if (i_M3 < (int)M3->size1) { - int ind = (int)gsl_vector_get(ID3, i_M3) - 1; + int ind = (int)VECTOR_ID(get)(ID3, i_M3) - 1; // if nargout==2; F(ind,[u v1 v2])=F(ind,[u v1 v2])+1; end if (F != NULL) { int F_cols[] = { u, v1, v2 }; for (int i = 0; i < 3; i++) { - gsl_matrix_set(*F, ind, F_cols[i], gsl_matrix_get(*F, ind, F_cols[i]) + 1.0); + MATRIX_ID(set)(*F, ind, F_cols[i], MATRIX_ID(get)(*F, ind, F_cols[i]) + 1.0); } } // f(ind)=f(ind)+1; - gsl_vector_set(f, ind, gsl_vector_get(f, ind) + 1.0); + VECTOR_ID(set)(f, ind, VECTOR_ID(get)(f, ind) + 1.0); } } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID3); - gsl_matrix_free(M3); - gsl_matrix_free(As); + VECTOR_ID(free)(ID3); + MATRIX_ID(free)(M3); + MATRIX_ID(free)(As); return f; } diff --git a/motif3struct_wei.cpp b/motif3struct_wei.cpp index 443af41..f7c48d5 100644 --- a/motif3struct_wei.cpp +++ b/motif3struct_wei.cpp @@ -1,193 +1,192 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Counts occurrences of three-node structural motifs in a weighted graph. * Returns intensity and (optionally) coherence and motif counts. */ -gsl_matrix* bct::motif3struct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix** F) { +MATRIX_T* bct::motif3struct_wei(const MATRIX_T* W, MATRIX_T** Q, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | WEIGHTED, "motif3struct_wei"); // load motif34lib M3 M3n ID3 N3 - gsl_vector* ID3; - gsl_vector* N3; - gsl_matrix* M3 = motif3generate(&ID3, &N3); + VECTOR_T* ID3; + VECTOR_T* N3; + MATRIX_T* M3 = motif3generate(&ID3, &N3); // n=length(W); int n = length(W); // I=zeros(13,n); - gsl_matrix* I = zeros_double(13, n); + MATRIX_T* I = zeros(13, n); // Q=zeros(13,n); if (Q != NULL) { - *Q = zeros_double(13, n); + *Q = zeros(13, n); } // F=zeros(13,n); if (F != NULL) { - *F = zeros_double(13, n); + *F = zeros(13, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-2 for (int u = 0; u < n - 2; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=([false(1,v1) As(u,v1+1:n)])|V2; - gsl_vector* V2_1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_1, As, u); + VECTOR_T* V2_1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_1, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_1, i, 0.0); + VECTOR_ID(set)(V2_1, i, 0.0); } - gsl_vector* V2_2 = V2; + VECTOR_T* V2_2 = V2; V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // w=[W(v1,u) W(v2,u) W(u,v1) W(v2,v1) W(u,v2) W(v1,v2)]; int WA_rows[] = { v1, v2, u, v2, u, v1 }; int WA_cols[] = { u, u, v1, v1, v2, v2 }; - gsl_vector* w = gsl_vector_alloc(6); + VECTOR_T* w = VECTOR_ID(alloc)(6); for (int i = 0; i < 6; i++) { - gsl_vector_set(w, i, gsl_matrix_get(W, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(w, i, MATRIX_ID(get)(W, WA_rows[i], WA_cols[i])); } // s=uint32(sum(10.^(5:-1:0).*[A(v1,u) A(v2,u) A(u,v1) A(v2,v1) A(u,v2) A(v1,v2)])); - gsl_vector* s = gsl_vector_alloc(6); + VECTOR_T* s = VECTOR_ID(alloc)(6); for (int i = 0; i < 6; i++) { - gsl_vector_set(s, i, gsl_matrix_get(A, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(s, i, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i])); } // ind=(s==M3n); int ind = 0; for ( ; ind < (int)M3->size1; ind++) { - gsl_vector_view M3_row_ind = gsl_matrix_row(M3, ind); + VECTOR_ID(view) M3_row_ind = MATRIX_ID(row)(M3, ind); if (compare_vectors(s, &M3_row_ind.vector) == 0) { break; } } - gsl_vector_free(s); + VECTOR_ID(free)(s); if (ind < (int)M3->size1) { // M=w.*M3(ind,:); - gsl_vector* M = gsl_vector_alloc(M3->size2); - gsl_matrix_get_row(M, M3, ind); - gsl_vector_mul(M, w); + VECTOR_T* M = VECTOR_ID(alloc)(M3->size2); + MATRIX_ID(get_row)(M, M3, ind); + VECTOR_ID(mul)(M, w); // id=ID3(ind); - int id = (int)gsl_vector_get(ID3, ind) - 1; + int id = (int)VECTOR_ID(get)(ID3, ind) - 1; // l=N3(ind); - int l = (int)gsl_vector_get(N3, ind); + int l = (int)VECTOR_ID(get)(N3, ind); // x=sum(M,2)/l; - double x = sum(M) / (double)l; + FP_T x = sum(M) / (FP_T)l; // M(M==0)=1; - gsl_vector* M_eq_0 = compare_elements(M, fp_equal, 0.0); + VECTOR_T* M_eq_0 = compare_elements(M, fp_equal, 0.0); logical_index_assign(M, M_eq_0, 1.0); - gsl_vector_free(M_eq_0); + VECTOR_ID(free)(M_eq_0); // i=prod(M,2)^(1/l); - double i = std::pow(prod(M), 1.0 / (double)l); - gsl_vector_free(M); + FP_T i = std::pow(prod(M), (FP_T)1.0 / l); + VECTOR_ID(free)(M); // q=i/x; - double q = i / x; + FP_T q = i / x; // I(id,[u v1 v2])=I(id,[u v1 v2])+[i i i]; // Q(id,[u v1 v2])=Q(id,[u v1 v2])+[q q q]; // F(id,[u v1 v2])=F(id,[u v1 v2])+[1 1 1]; int IQF_cols[] = { u, v1, v2 }; for (int j = 0; j < 3; j++) { - gsl_matrix_set(I, id, IQF_cols[j], gsl_matrix_get(I, id, IQF_cols[j]) + i); + MATRIX_ID(set)(I, id, IQF_cols[j], MATRIX_ID(get)(I, id, IQF_cols[j]) + i); if (Q != NULL) { - gsl_matrix_set(*Q, id, IQF_cols[j], gsl_matrix_get(*Q, id, IQF_cols[j]) + q); + MATRIX_ID(set)(*Q, id, IQF_cols[j], MATRIX_ID(get)(*Q, id, IQF_cols[j]) + q); } if (F != NULL) { - gsl_matrix_set(*F, id, IQF_cols[j], gsl_matrix_get(*F, id, IQF_cols[j]) + 1.0); + MATRIX_ID(set)(*F, id, IQF_cols[j], MATRIX_ID(get)(*F, id, IQF_cols[j]) + 1.0); } } } - gsl_vector_free(w); + VECTOR_ID(free)(w); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID3); - gsl_vector_free(N3); - gsl_matrix_free(M3); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID3); + VECTOR_ID(free)(N3); + MATRIX_ID(free)(M3); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return I; } /* * Returns per-motif metrics instead of per-motif, per-node metrics. */ -gsl_vector* bct::motif3struct_wei_v(const gsl_matrix* W, gsl_vector** Q, gsl_vector** F) { - gsl_matrix* _Q; - gsl_matrix* _F; - gsl_matrix* _I = motif3struct_wei(W, &_Q, &_F); +VECTOR_T* bct::motif3struct_wei_v(const MATRIX_T* W, VECTOR_T** Q, VECTOR_T** F) { + MATRIX_T* _Q; + MATRIX_T* _F; + MATRIX_T* _I = motif3struct_wei(W, &_Q, &_F); if (Q != NULL) { *Q = sum(_Q, 2); } - gsl_matrix_free(_Q); + MATRIX_ID(free)(_Q); if (F != NULL) { *F = sum(_F, 2); } - gsl_matrix_free(_F); - gsl_vector* I = sum(_I, 2); - gsl_matrix_free(_I); + MATRIX_ID(free)(_F); + VECTOR_T* I = sum(_I, 2); + MATRIX_ID(free)(_I); return I; } diff --git a/motif4funct_bin.cpp b/motif4funct_bin.cpp index 05610a9..7abd0aa 100644 --- a/motif4funct_bin.cpp +++ b/motif4funct_bin.cpp @@ -1,222 +1,220 @@ #include "bct.h" -#include -#include /* * Counts occurrences of four-node functional motifs in a binary graph. */ -gsl_vector* bct::motif4funct_bin(const gsl_matrix* W, gsl_matrix** F) { +VECTOR_T* bct::motif4funct_bin(const MATRIX_T* W, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | BINARY, "motif4funct_bin"); // load motif34lib M4 ID4 N4 - gsl_vector* ID4; - gsl_vector* N4; - gsl_matrix* M4 = motif4generate(&ID4, &N4); + VECTOR_T* ID4; + VECTOR_T* N4; + MATRIX_T* M4 = motif4generate(&ID4, &N4); // n=length(W); int n = length(W); // f=zeros(199,1); - gsl_vector* f = zeros_vector_double(199); + VECTOR_T* f = zeros_vector(199); // F=zeros(199,n); if (F != NULL) { - *F = zeros_double(199, n); + *F = zeros(199, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-3 for (int u = 0; u < n - 3; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=V2|([false(1,v1) As(u,v1+1:n)]); - gsl_vector* V2_1 = V2; - gsl_vector* V2_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_2, As, u); + VECTOR_T* V2_1 = V2; + VECTOR_T* V2_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_2, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_2, i, 0.0); + VECTOR_ID(set)(V2_2, i, 0.0); } V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // vz=max(v1,v2); int vz = (v1 > v2) ? v1 : v2; // V3=([false(1,u) As(v2,u+1:n)]); - gsl_vector* V3 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3, As, v2); + VECTOR_T* V3 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3, As, v2); for (int i = 0; i <= u; i++) { - gsl_vector_set(V3, i, 0.0); + VECTOR_ID(set)(V3, i, 0.0); } // V3(V2)=0; logical_index_assign(V3, V2, 0.0); // V3=V3|([false(1,v2) As(v1,v2+1:n)]); - gsl_vector* V3_1 = V3; - gsl_vector* V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, v1); + VECTOR_T* V3_1 = V3; + VECTOR_T* V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, v1); for (int i = 0; i <= v2; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // V3(V1)=0; logical_index_assign(V3, V1, 0.0); // V3=V3|([false(1,vz) As(u,vz+1:n)]); V3_1 = V3; - V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, u); + V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, u); for (int i = 0; i <= vz; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // for v3=find(V3) - gsl_vector* find_V3 = find(V3); + VECTOR_T* find_V3 = find(V3); if (find_V3 != NULL ) { for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) { - int v3 = (int)gsl_vector_get(find_V3, i_find_V3); + int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3); // a=[A(v1,u);A(v2,u);A(v3,u);A(u,v1);A(v2,v1);A(v3,v1);A(u,v2);A(v1,v2);A(v3,v2);A(u,v3);A(v1,v3);A(v2,v3)]; int A_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 }; int A_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 }; - gsl_matrix* a = gsl_matrix_alloc(12, 1); + MATRIX_T* a = MATRIX_ID(alloc)(12, 1); for (int i = 0; i < 12; i++) { - gsl_matrix_set(a, i, 0, gsl_matrix_get(A, A_rows[i], A_cols[i])); + MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, A_rows[i], A_cols[i])); } // ind=(M4*a)==N4; - gsl_matrix* M4_mul_a_m = mul(M4, a); - gsl_matrix_free(a); - gsl_vector* M4_mul_a = to_vector(M4_mul_a_m); - gsl_matrix_free(M4_mul_a_m); - gsl_vector* ind = compare_elements(M4_mul_a, fp_equal, N4); - gsl_vector_free(M4_mul_a); + MATRIX_T* M4_mul_a_m = mul(M4, a); + MATRIX_ID(free)(a); + VECTOR_T* M4_mul_a = to_vector(M4_mul_a_m); + MATRIX_ID(free)(M4_mul_a_m); + VECTOR_T* ind = compare_elements(M4_mul_a, fp_equal, N4); + VECTOR_ID(free)(M4_mul_a); // id=ID4(ind); - gsl_vector* id = logical_index(ID4, ind); - gsl_vector_free(ind); + VECTOR_T* id = logical_index(ID4, ind); + VECTOR_ID(free)(ind); if (id != NULL) { - gsl_vector_add_constant(id, -1.0); + VECTOR_ID(add_constant)(id, -1.0); // [idu j]=unique(id); - gsl_vector* j; - gsl_vector* idu = unique(id, "last", &j); - gsl_vector_free(id); + VECTOR_T* j; + VECTOR_T* idu = unique(id, "last", &j); + VECTOR_ID(free)(id); // j=[0;j]; - gsl_vector* temp = gsl_vector_alloc(j->size + 1); - gsl_vector_set(temp, 0, -1.0); - gsl_vector_view temp_subv = gsl_vector_subvector(temp, 1, j->size); - gsl_vector_memcpy(&temp_subv.vector, j); - gsl_vector_free(j); + VECTOR_T* temp = VECTOR_ID(alloc)(j->size + 1); + VECTOR_ID(set)(temp, 0, -1.0); + VECTOR_ID(view) temp_subv = VECTOR_ID(subvector)(temp, 1, j->size); + VECTOR_ID(memcpy)(&temp_subv.vector, j); + VECTOR_ID(free)(j); j = temp; // mu=length(idu); int mu = length(idu); // f2=zeros(mu,1); - gsl_vector* f2 = zeros_vector_double(mu); + VECTOR_T* f2 = zeros_vector(mu); // for h=1:mu for (int h = 0; h < mu; h++) { // f2(h)=j(h+1)-j(h); - double j_h_add_1 = gsl_vector_get(j, h + 1); - double j_h = gsl_vector_get(j, h); - gsl_vector_set(f2, h, j_h_add_1 - j_h); + FP_T j_h_add_1 = VECTOR_ID(get)(j, h + 1); + FP_T j_h = VECTOR_ID(get)(j, h); + VECTOR_ID(set)(f2, h, j_h_add_1 - j_h); } - gsl_vector_free(j); + VECTOR_ID(free)(j); // f(idu)=f(idu)+f2; - gsl_vector* f_idu_add_f2 = ordinal_index(f, idu); - gsl_vector_add(f_idu_add_f2, f2); + VECTOR_T* f_idu_add_f2 = ordinal_index(f, idu); + VECTOR_ID(add)(f_idu_add_f2, f2); ordinal_index_assign(f, idu, f_idu_add_f2); - gsl_vector_free(f_idu_add_f2); + VECTOR_ID(free)(f_idu_add_f2); // if nargout==2; F(idu,[u v1 v2 v3])=F(idu,[u v1 v2 v3])+[f2 f2 f2 f2]; end if (F != NULL) { - double F_cols[] = { (double)u, (double)v1, (double)v2, (double)v3 }; - gsl_vector_view F_cols_vv = gsl_vector_view_array(F_cols, 4); - gsl_matrix* F_idx = ordinal_index(*F, idu, &F_cols_vv.vector); + FP_T F_cols[] = { (FP_T)u, (FP_T)v1, (FP_T)v2, (FP_T)v3 }; + VECTOR_ID(view) F_cols_vv = VECTOR_ID(view_array)(F_cols, 4); + MATRIX_T* F_idx = ordinal_index(*F, idu, &F_cols_vv.vector); for (int i = 0; i < 4; i++) { - gsl_vector_view F_idx_col_i = gsl_matrix_column(F_idx, i); - gsl_vector_add(&F_idx_col_i.vector, f2); + VECTOR_ID(view) F_idx_col_i = MATRIX_ID(column)(F_idx, i); + VECTOR_ID(add)(&F_idx_col_i.vector, f2); } ordinal_index_assign(*F, idu, &F_cols_vv.vector, F_idx); - gsl_matrix_free(F_idx); + MATRIX_ID(free)(F_idx); } - gsl_vector_free(idu); - gsl_vector_free(f2); + VECTOR_ID(free)(idu); + VECTOR_ID(free)(f2); } } - gsl_vector_free(find_V3); + VECTOR_ID(free)(find_V3); } - gsl_vector_free(V3); + VECTOR_ID(free)(V3); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID4); - gsl_vector_free(N4); - gsl_matrix_free(M4); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID4); + VECTOR_ID(free)(N4); + MATRIX_ID(free)(M4); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return f; } diff --git a/motif4funct_wei.cpp b/motif4funct_wei.cpp index 139885a..ed32aa3 100644 --- a/motif4funct_wei.cpp +++ b/motif4funct_wei.cpp @@ -1,251 +1,249 @@ #include "bct.h" -#include -#include /* * Counts occurrences of four-node functional motifs in a weighted graph. * Returns intensity and (optionally) coherence and motif counts. */ -gsl_matrix* bct::motif4funct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix** F) { +MATRIX_T* bct::motif4funct_wei(const MATRIX_T* W, MATRIX_T** Q, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | WEIGHTED, "motif4funct_wei"); // load motif4lib M4 ID4 N4 - gsl_vector* ID4; - gsl_vector* N4; - gsl_matrix* M4 = motif4generate(&ID4, &N4); + VECTOR_T* ID4; + VECTOR_T* N4; + MATRIX_T* M4 = motif4generate(&ID4, &N4); // n=length(W); int n = length(W); // I=zeros(199,n); - gsl_matrix* I = zeros_double(199, n); + MATRIX_T* I = zeros(199, n); // Q=zeros(199,n); if (Q != NULL) { - *Q = zeros_double(199, n); + *Q = zeros(199, n); } // F=zeros(199,n); if (F != NULL) { - *F = zeros_double(199, n); + *F = zeros(199, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-3 for (int u = 0; u < n - 3; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=V2|([false(1,v1) As(u,v1+1:n)]); - gsl_vector* V2_1 = V2; - gsl_vector* V2_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_2, As, u); + VECTOR_T* V2_1 = V2; + VECTOR_T* V2_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_2, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_2, i, 0.0); + VECTOR_ID(set)(V2_2, i, 0.0); } V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // vz=max(v1,v2); int vz = (v1 > v2) ? v1 : v2; // V3=([false(1,u) As(v2,u+1:n)]); - gsl_vector* V3 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3, As, v2); + VECTOR_T* V3 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3, As, v2); for (int i = 0; i <= u; i++) { - gsl_vector_set(V3, i, 0.0); + VECTOR_ID(set)(V3, i, 0.0); } // V3(V2)=0; logical_index_assign(V3, V2, 0.0); // V3=V3|([false(1,v2) As(v1,v2+1:n)]); - gsl_vector* V3_1 = V3; - gsl_vector* V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, v1); + VECTOR_T* V3_1 = V3; + VECTOR_T* V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, v1); for (int i = 0; i <= v2; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // V3(V1)=0; logical_index_assign(V3, V1, 0.0); // V3=V3|([false(1,vz) As(u,vz+1:n)]); V3_1 = V3; - V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, u); + V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, u); for (int i = 0; i <= vz; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // for v3=find(V3) - gsl_vector* find_V3 = find(V3); + VECTOR_T* find_V3 = find(V3); if (find_V3 != NULL ) { for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) { - int v3 = (int)gsl_vector_get(find_V3, i_find_V3); + int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3); // w=[W(v1,u) W(v2,u) W(v3,u) W(u,v1) W(v2,v1) W(v3,v1) W(u,v2) W(v1,v2) W(v3,v2) W(u,v3) W(v1,v3) W(v2,v3)]; int WA_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 }; int WA_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 }; - gsl_vector* w = gsl_vector_alloc(12); + VECTOR_T* w = VECTOR_ID(alloc)(12); for (int i = 0; i < 12; i++) { - gsl_vector_set(w, i, gsl_matrix_get(W, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(w, i, MATRIX_ID(get)(W, WA_rows[i], WA_cols[i])); } // a=[A(v1,u);A(v2,u);A(v3,u);A(u,v1);A(v2,v1);A(v3,v1);A(u,v2);A(v1,v2);A(v3,v2);A(u,v3);A(v1,v3);A(v2,v3)]; - gsl_matrix* a = gsl_matrix_alloc(12, 1); + MATRIX_T* a = MATRIX_ID(alloc)(12, 1); for (int i = 0; i < 12; i++) { - gsl_matrix_set(a, i, 0, gsl_matrix_get(A, WA_rows[i], WA_cols[i])); + MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i])); } // ind=(M4*a)==N4; - gsl_matrix* M4_mul_a_m = mul(M4, a); - gsl_matrix_free(a); - gsl_vector* M4_mul_a = to_vector(M4_mul_a_m); - gsl_matrix_free(M4_mul_a_m); - gsl_vector* ind = compare_elements(M4_mul_a, fp_equal, N4); - gsl_vector_free(M4_mul_a); + MATRIX_T* M4_mul_a_m = mul(M4, a); + MATRIX_ID(free)(a); + VECTOR_T* M4_mul_a = to_vector(M4_mul_a_m); + MATRIX_ID(free)(M4_mul_a_m); + VECTOR_T* ind = compare_elements(M4_mul_a, fp_equal, N4); + VECTOR_ID(free)(M4_mul_a); // m=sum(ind); int m = (int)sum(ind); if (m > 0) { // M=M4(ind,:).*repmat(w,m,1); - gsl_vector* M4_cols = sequence_double(0, M4->size2 - 1); - gsl_matrix* M = log_ord_index(M4, ind, M4_cols); - gsl_vector_free(M4_cols); + VECTOR_T* M4_cols = sequence(0, M4->size2 - 1); + MATRIX_T* M = log_ord_index(M4, ind, M4_cols); + VECTOR_ID(free)(M4_cols); for (int i = 0; i < (int)M->size1; i++) { - gsl_vector_view M_row_i = gsl_matrix_row(M, i); - gsl_vector_mul(&M_row_i.vector, w); + VECTOR_ID(view) M_row_i = MATRIX_ID(row)(M, i); + VECTOR_ID(mul)(&M_row_i.vector, w); } // id=ID4(ind); - gsl_vector* id = logical_index(ID4, ind); - gsl_vector_add_constant(id, -1.0); + VECTOR_T* id = logical_index(ID4, ind); + VECTOR_ID(add_constant)(id, -1.0); // l=N4(ind); - gsl_vector* l = logical_index(N4, ind); + VECTOR_T* l = logical_index(N4, ind); // x=sum(M,2)./l; - gsl_vector* x = sum(M, 2); - gsl_vector_div(x, l); + VECTOR_T* x = sum(M, 2); + VECTOR_ID(div)(x, l); // M(M==0)=1; - gsl_matrix* M_eq_0 = compare_elements(M, fp_equal, 0.0); + MATRIX_T* M_eq_0 = compare_elements(M, fp_equal, 0.0); logical_index_assign(M, M_eq_0, 1.0); - gsl_matrix_free(M_eq_0); + MATRIX_ID(free)(M_eq_0); // i=prod(M,2).^(1./l); - gsl_vector* prod_M = prod(M, 2); - gsl_matrix_free(M); - gsl_vector* l_pow_neg_1 = pow_elements(l, -1.0); - gsl_vector_free(l); - gsl_vector* i = pow_elements(prod_M, l_pow_neg_1); - gsl_vector_free(prod_M); - gsl_vector_free(l_pow_neg_1); + VECTOR_T* prod_M = prod(M, 2); + MATRIX_ID(free)(M); + VECTOR_T* l_pow_neg_1 = pow_elements(l, -1.0); + VECTOR_ID(free)(l); + VECTOR_T* i = pow_elements(prod_M, l_pow_neg_1); + VECTOR_ID(free)(prod_M); + VECTOR_ID(free)(l_pow_neg_1); // q = i./x; - gsl_vector* q = copy(i); - gsl_vector_div(q, x); - gsl_vector_free(x); + VECTOR_T* q = copy(i); + VECTOR_ID(div)(q, x); + VECTOR_ID(free)(x); // [idu j]=unique(id); - gsl_vector* j; - gsl_vector* idu = unique(id, "last", &j); - gsl_vector_free(id); + VECTOR_T* j; + VECTOR_T* idu = unique(id, "last", &j); + VECTOR_ID(free)(id); // j=[0;j]; - gsl_vector* temp = gsl_vector_alloc(j->size + 1); - gsl_vector_set(temp, 0, -1.0); - gsl_vector_view temp_subv = gsl_vector_subvector(temp, 1, j->size); - gsl_vector_memcpy(&temp_subv.vector, j); - gsl_vector_free(j); + VECTOR_T* temp = VECTOR_ID(alloc)(j->size + 1); + VECTOR_ID(set)(temp, 0, -1.0); + VECTOR_ID(view) temp_subv = VECTOR_ID(subvector)(temp, 1, j->size); + VECTOR_ID(memcpy)(&temp_subv.vector, j); + VECTOR_ID(free)(j); j = temp; // mu=length(idu); int mu = length(idu); // i2=zeros(mu,1); - gsl_vector* i2 = zeros_vector_double(mu); + VECTOR_T* i2 = zeros_vector(mu); // q2=i2; f2=i2; - gsl_vector* q2 = copy(i2); - gsl_vector* f2 = copy(i2); + VECTOR_T* q2 = copy(i2); + VECTOR_T* f2 = copy(i2); // for h=1:mu for (int h = 0; h < mu; h++) { // i2(h)=sum(i(j(h)+1:j(h+1))); - int j_h = (int)gsl_vector_get(j, h); - int j_h_add_1 = (int)gsl_vector_get(j, h + 1); - gsl_vector* iq_indices = sequence_double(j_h + 1, j_h_add_1); - gsl_vector* i_idx = ordinal_index(i, iq_indices); - gsl_vector_set(i2, h, sum(i_idx)); - gsl_vector_free(i_idx); + int j_h = (int)VECTOR_ID(get)(j, h); + int j_h_add_1 = (int)VECTOR_ID(get)(j, h + 1); + VECTOR_T* iq_indices = sequence(j_h + 1, j_h_add_1); + VECTOR_T* i_idx = ordinal_index(i, iq_indices); + VECTOR_ID(set)(i2, h, sum(i_idx)); + VECTOR_ID(free)(i_idx); // q2(h)=sum(q(j(h)+1:j(h+1))); - gsl_vector* q_idx = ordinal_index(q, iq_indices); - gsl_vector_free(iq_indices); - gsl_vector_set(q2, h, sum(q_idx)); - gsl_vector_free(q_idx); + VECTOR_T* q_idx = ordinal_index(q, iq_indices); + VECTOR_ID(free)(iq_indices); + VECTOR_ID(set)(q2, h, sum(q_idx)); + VECTOR_ID(free)(q_idx); // f2(h)=j(h+1)-j(h); - gsl_vector_set(f2, h, (double)(j_h_add_1 - j_h)); + VECTOR_ID(set)(f2, h, (FP_T)(j_h_add_1 - j_h)); } - gsl_vector_free(i); - gsl_vector_free(q); - gsl_vector_free(j); + VECTOR_ID(free)(i); + VECTOR_ID(free)(q); + VECTOR_ID(free)(j); // I(idu,[u v1 v2 v3])=I(idu,[u v1 v2 v3])+[i2 i2 i2 i2]; // Q(idu,[u v1 v2 v3])=Q(idu,[u v1 v2 v3])+[q2 q2 q2 q2]; // F(idu,[u v1 v2 v3])=F(idu,[u v1 v2 v3])+[f2 f2 f2 f2]; - double IQF_cols[] = { (double)u, (double)v1, (double)v2, (double)v3 }; - gsl_vector_view IQF_cols_vv = gsl_vector_view_array(IQF_cols, 4); - gsl_matrix* I_idx = ordinal_index(I, idu, &IQF_cols_vv.vector); - gsl_matrix* Q_idx = NULL; - gsl_matrix* F_idx = NULL; + FP_T IQF_cols[] = { (FP_T)u, (FP_T)v1, (FP_T)v2, (FP_T)v3 }; + VECTOR_ID(view) IQF_cols_vv = VECTOR_ID(view_array)(IQF_cols, 4); + MATRIX_T* I_idx = ordinal_index(I, idu, &IQF_cols_vv.vector); + MATRIX_T* Q_idx = NULL; + MATRIX_T* F_idx = NULL; if (Q != NULL) { Q_idx = ordinal_index(*Q, idu, &IQF_cols_vv.vector); } @@ -253,79 +251,79 @@ gsl_matrix* bct::motif4funct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix F_idx = ordinal_index(*F, idu, &IQF_cols_vv.vector); } for (int j = 0; j < 4; j++) { - gsl_vector_view I_idx_col_j = gsl_matrix_column(I_idx, j); - gsl_vector_add(&I_idx_col_j.vector, i2); + VECTOR_ID(view) I_idx_col_j = MATRIX_ID(column)(I_idx, j); + VECTOR_ID(add)(&I_idx_col_j.vector, i2); if (Q != NULL) { - gsl_vector_view Q_idx_col_j = gsl_matrix_column(Q_idx, j); - gsl_vector_add(&Q_idx_col_j.vector, q2); + VECTOR_ID(view) Q_idx_col_j = MATRIX_ID(column)(Q_idx, j); + VECTOR_ID(add)(&Q_idx_col_j.vector, q2); } if (F != NULL) { - gsl_vector_view F_idx_col_j = gsl_matrix_column(F_idx, j); - gsl_vector_add(&F_idx_col_j.vector, f2); + VECTOR_ID(view) F_idx_col_j = MATRIX_ID(column)(F_idx, j); + VECTOR_ID(add)(&F_idx_col_j.vector, f2); } } - gsl_vector_free(i2); - gsl_vector_free(q2); - gsl_vector_free(f2); + VECTOR_ID(free)(i2); + VECTOR_ID(free)(q2); + VECTOR_ID(free)(f2); ordinal_index_assign(I, idu, &IQF_cols_vv.vector, I_idx); - gsl_matrix_free(I_idx); + MATRIX_ID(free)(I_idx); if (Q != NULL) { ordinal_index_assign(*Q, idu, &IQF_cols_vv.vector, Q_idx); - gsl_matrix_free(Q_idx); + MATRIX_ID(free)(Q_idx); } if (F != NULL) { ordinal_index_assign(*F, idu, &IQF_cols_vv.vector, F_idx); - gsl_matrix_free(F_idx); + MATRIX_ID(free)(F_idx); } - gsl_vector_free(idu); + VECTOR_ID(free)(idu); } - gsl_vector_free(w); - gsl_vector_free(ind); + VECTOR_ID(free)(w); + VECTOR_ID(free)(ind); } - gsl_vector_free(find_V3); + VECTOR_ID(free)(find_V3); } - gsl_vector_free(V3); + VECTOR_ID(free)(V3); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID4); - gsl_vector_free(N4); - gsl_matrix_free(M4); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID4); + VECTOR_ID(free)(N4); + MATRIX_ID(free)(M4); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return I; } /* * Returns per-motif metrics instead of per-motif, per-node metrics. */ -gsl_vector* bct::motif4funct_wei_v(const gsl_matrix* W, gsl_vector** Q, gsl_vector** F) { - gsl_matrix* _Q; - gsl_matrix* _F; - gsl_matrix* _I = motif4funct_wei(W, &_Q, &_F); +VECTOR_T* bct::motif4funct_wei_v(const MATRIX_T* W, VECTOR_T** Q, VECTOR_T** F) { + MATRIX_T* _Q; + MATRIX_T* _F; + MATRIX_T* _I = motif4funct_wei(W, &_Q, &_F); if (Q != NULL) { *Q = sum(_Q, 2); } - gsl_matrix_free(_Q); + MATRIX_ID(free)(_Q); if (F != NULL) { *F = sum(_F, 2); } - gsl_matrix_free(_F); - gsl_vector* I = sum(_I, 2); - gsl_matrix_free(_I); + MATRIX_ID(free)(_F); + VECTOR_T* I = sum(_I, 2); + MATRIX_ID(free)(_I); return I; } diff --git a/motif4struct_bin.cpp b/motif4struct_bin.cpp index 0f79a44..101717e 100644 --- a/motif4struct_bin.cpp +++ b/motif4struct_bin.cpp @@ -1,174 +1,172 @@ #include "bct.h" -#include -#include /* * Counts occurrences of four-node structural motifs in a binary graph. */ -gsl_vector* bct::motif4struct_bin(const gsl_matrix* A, gsl_matrix** F) { +VECTOR_T* bct::motif4struct_bin(const MATRIX_T* A, MATRIX_T** F) { if (safe_mode) check_status(A, SQUARE | BINARY, "motif4struct_bin"); // load motif34lib M4n ID4 - gsl_vector* ID4; - gsl_matrix* M4 = motif4generate(&ID4); + VECTOR_T* ID4; + MATRIX_T* M4 = motif4generate(&ID4); // n=length(A); int n = length(A); // F=zeros(199,n); if (F != NULL) { - *F = zeros_double(199, n); + *F = zeros(199, n); } // f=zeros(199,1); - gsl_vector* f = zeros_vector_double(199); + VECTOR_T* f = zeros_vector(199); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-3 for (int u = 0; u < n - 3; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=V2|([false(1,v1) As(u,v1+1:n)]); - gsl_vector* V2_1 = V2; - gsl_vector* V2_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_2, As, u); + VECTOR_T* V2_1 = V2; + VECTOR_T* V2_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_2, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_2, i, 0.0); + VECTOR_ID(set)(V2_2, i, 0.0); } V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // vz=max(v1,v2); int vz = (v1 > v2) ? v1 : v2; // V3=([false(1,u) As(v2,u+1:n)]); - gsl_vector* V3 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3, As, v2); + VECTOR_T* V3 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3, As, v2); for (int i = 0; i <= u; i++) { - gsl_vector_set(V3, i, 0.0); + VECTOR_ID(set)(V3, i, 0.0); } // V3(V2)=0; logical_index_assign(V3, V2, 0.0); // V3=V3|([false(1,v2) As(v1,v2+1:n)]); - gsl_vector* V3_1 = V3; - gsl_vector* V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, v1); + VECTOR_T* V3_1 = V3; + VECTOR_T* V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, v1); for (int i = 0; i <= v2; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // V3(V1)=0; logical_index_assign(V3, V1, 0.0); // V3=V3|([false(1,vz) As(u,vz+1:n)]); V3_1 = V3; - V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, u); + V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, u); for (int i = 0; i <= vz; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // for v3=find(V3) - gsl_vector* find_V3 = find(V3); + VECTOR_T* find_V3 = find(V3); if (find_V3 != NULL ) { for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) { - int v3 = (int)gsl_vector_get(find_V3, i_find_V3); + int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3); // s=uint32(sum(10.^(11:-1:0).*[A(v1,u) A(v2,u) A(v3,u) A(u,v1) A(v2,v1) A(v3,v1) A(u,v2) A(v1,v2) A(v3,v2) A(u,v3) A(v1,v3) A(v2,v3)])); int A_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 }; int A_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 }; - gsl_vector* s = gsl_vector_alloc(12); + VECTOR_T* s = VECTOR_ID(alloc)(12); for (int i = 0; i < 12; i++) { - gsl_vector_set(s, i, gsl_matrix_get(A, A_rows[i], A_cols[i])); + VECTOR_ID(set)(s, i, MATRIX_ID(get)(A, A_rows[i], A_cols[i])); } // ind=ID4(s==M4n); int i_M4 = 0; for ( ; i_M4 < (int)M4->size1; i_M4++) { - gsl_vector_view M4_row_i_M4 = gsl_matrix_row(M4, i_M4); + VECTOR_ID(view) M4_row_i_M4 = MATRIX_ID(row)(M4, i_M4); if (compare_vectors(s, &M4_row_i_M4.vector) == 0) { break; } } - gsl_vector_free(s); + VECTOR_ID(free)(s); if (i_M4 < (int)M4->size1) { - int ind = (int)gsl_vector_get(ID4, i_M4) - 1; + int ind = (int)VECTOR_ID(get)(ID4, i_M4) - 1; // if nargout==2; F(ind,[u v1 v2 v3])=F(ind,[u v1 v2 v3])+1; end if (F != NULL) { int F_cols[] = { u, v1, v2, v3 }; for (int i = 0; i < 4; i++) { - gsl_matrix_set(*F, ind, F_cols[i], gsl_matrix_get(*F, ind, F_cols[i]) + 1.0); + MATRIX_ID(set)(*F, ind, F_cols[i], MATRIX_ID(get)(*F, ind, F_cols[i]) + 1.0); } } // f(ind)=f(ind)+1; - gsl_vector_set(f, ind, gsl_vector_get(f, ind) + 1.0); + VECTOR_ID(set)(f, ind, VECTOR_ID(get)(f, ind) + 1.0); } } - gsl_vector_free(find_V3); + VECTOR_ID(free)(find_V3); } - gsl_vector_free(V3); + VECTOR_ID(free)(V3); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID4); - gsl_matrix_free(M4); - gsl_matrix_free(As); + VECTOR_ID(free)(ID4); + MATRIX_ID(free)(M4); + MATRIX_ID(free)(As); return f; } diff --git a/motif4struct_wei.cpp b/motif4struct_wei.cpp index 619e114..2a7ad3f 100644 --- a/motif4struct_wei.cpp +++ b/motif4struct_wei.cpp @@ -1,243 +1,242 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Counts occurrences of four-node structural motifs in a weighted graph. * Returns intensity and (optionally) coherence and motif counts. */ -gsl_matrix* bct::motif4struct_wei(const gsl_matrix* W, gsl_matrix** Q, gsl_matrix** F) { +MATRIX_T* bct::motif4struct_wei(const MATRIX_T* W, MATRIX_T** Q, MATRIX_T** F) { if (safe_mode) check_status(W, SQUARE | WEIGHTED, "motif4struct_wei"); // load motif34lib M4 M4n ID4 N4 - gsl_vector* ID4; - gsl_vector* N4; - gsl_matrix* M4 = motif4generate(&ID4, &N4); + VECTOR_T* ID4; + VECTOR_T* N4; + MATRIX_T* M4 = motif4generate(&ID4, &N4); // n=length(W); int n = length(W); // I=zeros(199,n); - gsl_matrix* I = zeros_double(199, n); + MATRIX_T* I = zeros(199, n); // Q=zeros(199,n); if (Q != NULL) { - *Q = zeros_double(199, n); + *Q = zeros(199, n); } // F=zeros(199,n); if (F != NULL) { - *F = zeros_double(199, n); + *F = zeros(199, n); } // A=1*(W~=0); - gsl_matrix* A = compare_elements(W, fp_not_equal, 0.0); + MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0); // As=A|A.'; - gsl_matrix* A_transpose = gsl_matrix_alloc(A->size2, A->size1); - gsl_matrix_transpose_memcpy(A_transpose, A); - gsl_matrix* As = logical_or(A, A_transpose); - gsl_matrix_free(A_transpose); + MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1); + MATRIX_ID(transpose_memcpy)(A_transpose, A); + MATRIX_T* As = logical_or(A, A_transpose); + MATRIX_ID(free)(A_transpose); // for u=1:n-3 for (int u = 0; u < n - 3; u++) { // V1=[false(1,u) As(u,u+1:n)]; - gsl_vector* V1 = gsl_vector_alloc(n); - gsl_matrix_get_row(V1, As, u); + VECTOR_T* V1 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V1, As, u); for (int i = 0; i <= u; i++) { - gsl_vector_set(V1, i, 0.0); + VECTOR_ID(set)(V1, i, 0.0); } // for v1=find(V1) - gsl_vector* find_V1 = find(V1); + VECTOR_T* find_V1 = find(V1); if (find_V1 != NULL) { for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) { - int v1 = (int)gsl_vector_get(find_V1, i_find_V1); + int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1); // V2=[false(1,u) As(v1,u+1:n)]; - gsl_vector* V2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2, As, v1); + VECTOR_T* V2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2, As, v1); for (int i = 0; i <= u; i++) { - gsl_vector_set(V2, i, 0.0); + VECTOR_ID(set)(V2, i, 0.0); } // V2(V1)=0; logical_index_assign(V2, V1, 0.0); // V2=V2|([false(1,v1) As(u,v1+1:n)]); - gsl_vector* V2_1 = V2; - gsl_vector* V2_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V2_2, As, u); + VECTOR_T* V2_1 = V2; + VECTOR_T* V2_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V2_2, As, u); for (int i = 0; i <= v1; i++) { - gsl_vector_set(V2_2, i, 0.0); + VECTOR_ID(set)(V2_2, i, 0.0); } V2 = logical_or(V2_1, V2_2); - gsl_vector_free(V2_1); - gsl_vector_free(V2_2); + VECTOR_ID(free)(V2_1); + VECTOR_ID(free)(V2_2); // for v2=find(V2) - gsl_vector* find_V2 = find(V2); + VECTOR_T* find_V2 = find(V2); if (find_V2 != NULL) { for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) { - int v2 = (int)gsl_vector_get(find_V2, i_find_V2); + int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2); // vz=max(v1,v2); int vz = (v1 > v2) ? v1 : v2; // V3=([false(1,u) As(v2,u+1:n)]); - gsl_vector* V3 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3, As, v2); + VECTOR_T* V3 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3, As, v2); for (int i = 0; i <= u; i++) { - gsl_vector_set(V3, i, 0.0); + VECTOR_ID(set)(V3, i, 0.0); } // V3(V2)=0; logical_index_assign(V3, V2, 0.0); // V3=V3|([false(1,v2) As(v1,v2+1:n)]); - gsl_vector* V3_1 = V3; - gsl_vector* V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, v1); + VECTOR_T* V3_1 = V3; + VECTOR_T* V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, v1); for (int i = 0; i <= v2; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // V3(V1)=0; logical_index_assign(V3, V1, 0.0); // V3=V3|([false(1,vz) As(u,vz+1:n)]); V3_1 = V3; - V3_2 = gsl_vector_alloc(n); - gsl_matrix_get_row(V3_2, As, u); + V3_2 = VECTOR_ID(alloc)(n); + MATRIX_ID(get_row)(V3_2, As, u); for (int i = 0; i <= vz; i++) { - gsl_vector_set(V3_2, i, 0.0); + VECTOR_ID(set)(V3_2, i, 0.0); } V3 = logical_or(V3_1, V3_2); - gsl_vector_free(V3_1); - gsl_vector_free(V3_2); + VECTOR_ID(free)(V3_1); + VECTOR_ID(free)(V3_2); // for v3=find(V3) - gsl_vector* find_V3 = find(V3); + VECTOR_T* find_V3 = find(V3); if (find_V3 != NULL ) { for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) { - int v3 = (int)gsl_vector_get(find_V3, i_find_V3); + int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3); // w=[W(v1,u) W(v2,u) W(v3,u) W(u,v1) W(v2,v1) W(v3,v1) W(u,v2) W(v1,v2) W(v3,v2) W(u,v3) W(v1,v3) W(v2,v3)]; int WA_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 }; int WA_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 }; - gsl_vector* w = gsl_vector_alloc(12); + VECTOR_T* w = VECTOR_ID(alloc)(12); for (int i = 0; i < 12; i++) { - gsl_vector_set(w, i, gsl_matrix_get(W, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(w, i, MATRIX_ID(get)(W, WA_rows[i], WA_cols[i])); } // s=uint64(sum(10.^(11:-1:0).*[A(v1,u) A(v2,u) A(v3,u) A(u,v1) A(v2,v1) A(v3,v1) A(u,v2) A(v1,v2) A(v3,v2) A(u,v3) A(v1,v3) A(v2,v3)])); - gsl_vector* s = gsl_vector_alloc(12); + VECTOR_T* s = VECTOR_ID(alloc)(12); for (int i = 0; i < 12; i++) { - gsl_vector_set(s, i, gsl_matrix_get(A, WA_rows[i], WA_cols[i])); + VECTOR_ID(set)(s, i, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i])); } // ind=(s==M4n); int ind = 0; for ( ; ind < (int)M4->size1; ind++) { - gsl_vector_view M4_row_ind = gsl_matrix_row(M4, ind); + VECTOR_ID(view) M4_row_ind = MATRIX_ID(row)(M4, ind); if (compare_vectors(s, &M4_row_ind.vector) == 0) { break; } } - gsl_vector_free(s); + VECTOR_ID(free)(s); if (ind < (int)M4->size1) { // M=w.*M4(ind,:); - gsl_vector* M = gsl_vector_alloc(M4->size2); - gsl_matrix_get_row(M, M4, ind); - gsl_vector_mul(M, w); + VECTOR_T* M = VECTOR_ID(alloc)(M4->size2); + MATRIX_ID(get_row)(M, M4, ind); + VECTOR_ID(mul)(M, w); // id=ID4(ind); - int id = (int)gsl_vector_get(ID4, ind) - 1; + int id = (int)VECTOR_ID(get)(ID4, ind) - 1; // l=N4(ind); - int l = (int)gsl_vector_get(N4, ind); + int l = (int)VECTOR_ID(get)(N4, ind); // x=sum(M,2)/l; - double x = sum(M) / (double)l; + FP_T x = sum(M) / (FP_T)l; // M(M==0)=1; - gsl_vector* M_eq_0 = compare_elements(M, fp_equal, 0.0); + VECTOR_T* M_eq_0 = compare_elements(M, fp_equal, 0.0); logical_index_assign(M, M_eq_0, 1.0); - gsl_vector_free(M_eq_0); + VECTOR_ID(free)(M_eq_0); // i=prod(M,2)^(1/l); - double i = std::pow(prod(M), 1.0 / (double)l); - gsl_vector_free(M); + FP_T i = std::pow(prod(M), (FP_T)1.0 / l); + VECTOR_ID(free)(M); // q=i/x; - double q = i / x; + FP_T q = i / x; // I(id,[u v1 v2 v3])=I(id,[u v1 v2 v3])+[i i i i]; // Q(id,[u v1 v2 v3])=Q(id,[u v1 v2 v3])+[q q q q]; // F(id,[u v1 v2 v3])=F(id,[u v1 v2 v3])+[1 1 1 1]; int IQF_cols[] = { u, v1, v2, v3 }; for (int j = 0; j < 4; j++) { - gsl_matrix_set(I, id, IQF_cols[j], gsl_matrix_get(I, id, IQF_cols[j]) + i); + MATRIX_ID(set)(I, id, IQF_cols[j], MATRIX_ID(get)(I, id, IQF_cols[j]) + i); if (Q != NULL) { - gsl_matrix_set(*Q, id, IQF_cols[j], gsl_matrix_get(*Q, id, IQF_cols[j]) + q); + MATRIX_ID(set)(*Q, id, IQF_cols[j], MATRIX_ID(get)(*Q, id, IQF_cols[j]) + q); } if (F != NULL) { - gsl_matrix_set(*F, id, IQF_cols[j], gsl_matrix_get(*F, id, IQF_cols[j]) + 1.0); + MATRIX_ID(set)(*F, id, IQF_cols[j], MATRIX_ID(get)(*F, id, IQF_cols[j]) + 1.0); } } } - gsl_vector_free(w); + VECTOR_ID(free)(w); } - gsl_vector_free(find_V3); + VECTOR_ID(free)(find_V3); } - gsl_vector_free(V3); + VECTOR_ID(free)(V3); } - gsl_vector_free(find_V2); + VECTOR_ID(free)(find_V2); } - gsl_vector_free(V2); + VECTOR_ID(free)(V2); } - gsl_vector_free(find_V1); + VECTOR_ID(free)(find_V1); } - gsl_vector_free(V1); + VECTOR_ID(free)(V1); } - gsl_vector_free(ID4); - gsl_vector_free(N4); - gsl_matrix_free(M4); - gsl_matrix_free(A); - gsl_matrix_free(As); + VECTOR_ID(free)(ID4); + VECTOR_ID(free)(N4); + MATRIX_ID(free)(M4); + MATRIX_ID(free)(A); + MATRIX_ID(free)(As); return I; } /* * Returns per-motif metrics instead of per-motif, per-node metrics. */ -gsl_vector* bct::motif4struct_wei_v(const gsl_matrix* W, gsl_vector** Q, gsl_vector** F) { - gsl_matrix* _Q; - gsl_matrix* _F; - gsl_matrix* _I = motif4struct_wei(W, &_Q, &_F); +VECTOR_T* bct::motif4struct_wei_v(const MATRIX_T* W, VECTOR_T** Q, VECTOR_T** F) { + MATRIX_T* _Q; + MATRIX_T* _F; + MATRIX_T* _I = motif4struct_wei(W, &_Q, &_F); if (Q != NULL) { *Q = sum(_Q, 2); } - gsl_matrix_free(_Q); + MATRIX_ID(free)(_Q); if (F != NULL) { *F = sum(_F, 2); } - gsl_matrix_free(_F); - gsl_vector* I = sum(_I, 2); - gsl_matrix_free(_I); + MATRIX_ID(free)(_F); + VECTOR_T* I = sum(_I, 2); + MATRIX_ID(free)(_I); return I; } diff --git a/normalized_path_length.cpp b/normalized_path_length.cpp index 0e4d4f3..4bc8f08 100644 --- a/normalized_path_length.cpp +++ b/normalized_path_length.cpp @@ -1,47 +1,49 @@ -#include "bct.h" #include -#include + +#include "bct.h" /* - * IMPORTANT WARNING: normalized_path_length() takes a distance matrix, - * but normalized_path_length_m() takes a connection matrix. Both should - * be lengths, not weights (called distances in CalcMetric). + * WARNING: bct::normalized_path_length takes a distance matrix, but + * bct::normalized_path_length_m takes a connection matrix. Both should be + * lengths, not weights (called distances in CalcMetric). */ /* * Given a distance matrix, computes the normalized shortest path length. */ -double bct::normalized_path_length(const gsl_matrix* D, double wmax) { +FP_T bct::normalized_path_length(const MATRIX_T* D, FP_T wmax) { + if (safe_mode) check_status(D, SQUARE, "normalized_path_length"); int N = D->size1; - double dmin = 1.0 / wmax; - double dmax = (double)N / wmax; - double sum = 0.0; + FP_T dmin = 1.0 / wmax; + FP_T dmax = (FP_T)N / wmax; + FP_T sum = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double d = gsl_matrix_get(D, i, j); + FP_T d = MATRIX_ID(get)(D, i, j); sum += (d < dmax) ? d : dmax; } } - return std::abs(((sum / (double)(N * (N - 1))) - dmin) / (dmax - dmin)); + return std::abs(((sum / (FP_T)(N * (N - 1))) - dmin) / (dmax - dmin)); } /* * Computes the normalized shortest path length using dmax = N * lmean, where * lmean is the average distance between all directly connected nodes. */ -double bct::normalized_path_length_m(const gsl_matrix* L, double wmax) { +FP_T bct::normalized_path_length_m(const MATRIX_T* L, FP_T wmax) { + if (safe_mode) check_status(L, SQUARE, "normalized_path_length_m"); int N = L->size1; int nonzeros = 0; - double lmean = 0.0; + FP_T lmean = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double l = gsl_matrix_get(L, i, j); + FP_T l = MATRIX_ID(get)(L, i, j); if (fp_nonzero(l)) { nonzeros++; lmean += l; @@ -49,19 +51,19 @@ double bct::normalized_path_length_m(const gsl_matrix* L, double wmax) { } } lmean /= nonzeros; - gsl_matrix* D = distance_wei(L); - double dmin = 1.0 / wmax; - double dmax = (double)N * lmean; - double sum = 0.0; + MATRIX_T* D = distance_wei(L); + FP_T dmin = 1.0 / wmax; + FP_T dmax = (FP_T)N * lmean; + FP_T sum = 0.0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (i == j) { continue; } - double d = gsl_matrix_get(D, i, j); + FP_T d = MATRIX_ID(get)(D, i, j); sum += (d < dmax) ? d : dmax; } } - gsl_matrix_free(D); - return std::abs(((sum / (double)(N * (N - 1))) - dmin) / (dmax - dmin)); + MATRIX_ID(free)(D); + return std::abs(((sum / (FP_T)(N * (N - 1))) - dmin) / (dmax - dmin)); } diff --git a/participation_coef.cpp b/participation_coef.cpp index 884381d..1e9cd65 100644 --- a/participation_coef.cpp +++ b/participation_coef.cpp @@ -1,58 +1,57 @@ -#include "bct.h" #include -#include -#include + +#include "bct.h" /* * Computes nodal participation coefficient for a binary graph and its * corresponding community structure. For a directed graph, computes "out- * neighbor" participation coefficient. */ -gsl_vector* bct::participation_coef(const gsl_matrix* A, const gsl_vector* Ci) { +VECTOR_T* bct::participation_coef(const MATRIX_T* A, const VECTOR_T* Ci) { if (safe_mode) check_status(A, SQUARE | BINARY, "participation_coef"); // n=length(A); int n = length(A); // Ko=sum(A,2); - gsl_vector* Ko = sum(A, 2); + VECTOR_T* Ko = sum(A, 2); // Ko(~Ko)=inf; - gsl_vector* not_Ko = logical_not(Ko); + VECTOR_T* not_Ko = logical_not(Ko); logical_index_assign(Ko, not_Ko, GSL_POSINF); - gsl_vector_free(not_Ko); + VECTOR_ID(free)(not_Ko); // Gc=A*diag(Ci); - gsl_matrix* diag_Ci = diag(Ci); - gsl_matrix* Gc = mul(A, diag_Ci); - gsl_matrix_free(diag_Ci); + MATRIX_T* diag_Ci = diag(Ci); + MATRIX_T* Gc = mul(A, diag_Ci); + MATRIX_ID(free)(diag_Ci); // Kc2=zeros(n,1); - gsl_vector* Kc2 = zeros_vector_double(n); + VECTOR_T* Kc2 = zeros_vector(n); // for i=1:max(Ci); for (int i = 1; i <= (int)max(Ci); i++) { // Kc2=Kc2+(sum(Gc==i,2).^2); - gsl_matrix* Gc_eq_i = compare_elements(Gc, fp_equal, (double)i); - gsl_vector* sum_Gc_eq_i = sum(Gc_eq_i, 2); - gsl_matrix_free(Gc_eq_i); - gsl_vector* sum_Gc_eq_i_pow_2 = pow_elements(sum_Gc_eq_i, 2.0); - gsl_vector_free(sum_Gc_eq_i); - gsl_vector_add(Kc2, sum_Gc_eq_i_pow_2); - gsl_vector_free(sum_Gc_eq_i_pow_2); + MATRIX_T* Gc_eq_i = compare_elements(Gc, fp_equal, (FP_T)i); + VECTOR_T* sum_Gc_eq_i = sum(Gc_eq_i, 2); + MATRIX_ID(free)(Gc_eq_i); + VECTOR_T* sum_Gc_eq_i_pow_2 = pow_elements(sum_Gc_eq_i, 2.0); + VECTOR_ID(free)(sum_Gc_eq_i); + VECTOR_ID(add)(Kc2, sum_Gc_eq_i_pow_2); + VECTOR_ID(free)(sum_Gc_eq_i_pow_2); } - gsl_matrix_free(Gc); + MATRIX_ID(free)(Gc); // P=ones(n,1)-Kc2./(Ko.^2); - gsl_vector* Ko_pow_2 = pow_elements(Ko, 2.0); - gsl_vector_free(Ko); - gsl_vector_div(Kc2, Ko_pow_2); - gsl_vector_free(Ko_pow_2); - gsl_vector* P = ones_vector_double(n); - gsl_vector_sub(P, Kc2); - gsl_vector_free(Kc2); + VECTOR_T* Ko_pow_2 = pow_elements(Ko, 2.0); + VECTOR_ID(free)(Ko); + VECTOR_ID(div)(Kc2, Ko_pow_2); + VECTOR_ID(free)(Ko_pow_2); + VECTOR_T* P = ones_vector(n); + VECTOR_ID(sub)(P, Kc2); + VECTOR_ID(free)(Kc2); return P; } diff --git a/precision.h b/precision.h new file mode 100644 index 0000000..3462b96 --- /dev/null +++ b/precision.h @@ -0,0 +1,39 @@ +#undef FP_T +#undef FP_ID +#undef VECTOR_T +#undef VECTOR_ID +#undef MATRIX_T +#undef MATRIX_ID + +#ifdef GSL_FLOAT +#define FP_T float +#define FP_ID(id) id##_##float +#define VECTOR_T gsl_vector_float +#define VECTOR_ID(id) gsl_vector_float##_##id +#define MATRIX_T gsl_matrix_float +#define MATRIX_ID(id) gsl_matrix_float##_##id +#include +#include +#endif + +#ifdef GSL_DOUBLE +#define FP_T double +#define FP_ID(id) id##_##double +#define VECTOR_T gsl_vector +#define VECTOR_ID(id) gsl_vector##_##id +#define MATRIX_T gsl_matrix +#define MATRIX_ID(id) gsl_matrix##_##id +#include +#include +#endif + +#ifdef GSL_LONG_DOUBLE +#define FP_T long double +#define FP_ID(id) id##_##long_double +#define VECTOR_T gsl_vector_long_double +#define VECTOR_ID(id) gsl_vector_long_double##_##id +#define MATRIX_T gsl_matrix_long_double +#define MATRIX_ID(id) gsl_matrix_long_double##_##id +#include +#include +#endif diff --git a/randmio_dir.cpp b/randmio_dir.cpp index 42bf8b8..75a6528 100644 --- a/randmio_dir.cpp +++ b/randmio_dir.cpp @@ -1,23 +1,19 @@ #include "bct.h" -#include -#include -#include -#include /* * Returns a randomized graph with equivalent degree sequence to the original * weighted directed graph. On average, each edge is rewired ITER times. Out- * strength is preserved for weighted graphs, while in-strength is not. */ -gsl_matrix* bct::randmio_dir(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::randmio_dir(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | DIRECTED, "randmio_dir"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // [i j]=find(R); - gsl_matrix* find_R = find_ij(R); - gsl_vector_view i = gsl_matrix_column(find_R, 0); - gsl_vector_view j = gsl_matrix_column(find_R, 1); + MATRIX_T* find_R = find_ij(R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_R, 1); // K=length(i); int K = length(&i.vector); @@ -25,7 +21,7 @@ gsl_matrix* bct::randmio_dir(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -53,12 +49,12 @@ gsl_matrix* bct::randmio_dir(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -69,21 +65,21 @@ gsl_matrix* bct::randmio_dir(const gsl_matrix* R, int ITER) { } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -91,6 +87,6 @@ gsl_matrix* bct::randmio_dir(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(find_R); + MATRIX_ID(free)(find_R); return _R; } diff --git a/randmio_dir_connected.cpp b/randmio_dir_connected.cpp index e8adc92..9748cb2 100644 --- a/randmio_dir_connected.cpp +++ b/randmio_dir_connected.cpp @@ -1,8 +1,4 @@ #include "bct.h" -#include -#include -#include -#include /* * Returns a randomized graph with equivalent degree sequence to the original @@ -10,15 +6,15 @@ * edge is rewired ITER times. Out-strength is preserved for weighted graphs, * while in-strength is not. */ -gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::randmio_dir_connected(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | DIRECTED, "randmio_dir_connected"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // [i j]=find(R); - gsl_matrix* find_R = find_ij(R); - gsl_vector_view i = gsl_matrix_column(find_R, 0); - gsl_vector_view j = gsl_matrix_column(find_R, 1); + MATRIX_T* find_R = find_ij(R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_R, 1); // K=length(i); int K = length(&i.vector); @@ -26,7 +22,7 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -57,12 +53,12 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -73,91 +69,91 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if ~(any([R(a,c) R(d,b) R(d,c)]) && any([R(c,a) R(b,d) R(b,a)])) - gsl_vector* _R_idx_1 = gsl_vector_alloc(3); - gsl_vector_set(_R_idx_1, 0, gsl_matrix_get(_R, a, c)); - gsl_vector_set(_R_idx_1, 1, gsl_matrix_get(_R, d, b)); - gsl_vector_set(_R_idx_1, 2, gsl_matrix_get(_R, d, c)); - gsl_vector* _R_idx_2 = gsl_vector_alloc(3); - gsl_vector_set(_R_idx_2, 0, gsl_matrix_get(_R, c, a)); - gsl_vector_set(_R_idx_2, 1, gsl_matrix_get(_R, b, d)); - gsl_vector_set(_R_idx_2, 2, gsl_matrix_get(_R, b, a)); + VECTOR_T* _R_idx_1 = VECTOR_ID(alloc)(3); + VECTOR_ID(set)(_R_idx_1, 0, MATRIX_ID(get)(_R, a, c)); + VECTOR_ID(set)(_R_idx_1, 1, MATRIX_ID(get)(_R, d, b)); + VECTOR_ID(set)(_R_idx_1, 2, MATRIX_ID(get)(_R, d, c)); + VECTOR_T* _R_idx_2 = VECTOR_ID(alloc)(3); + VECTOR_ID(set)(_R_idx_2, 0, MATRIX_ID(get)(_R, c, a)); + VECTOR_ID(set)(_R_idx_2, 1, MATRIX_ID(get)(_R, b, d)); + VECTOR_ID(set)(_R_idx_2, 2, MATRIX_ID(get)(_R, b, a)); bool any_R_idx_1_and_any_R_idx_2 = any(_R_idx_1) && any(_R_idx_2); - gsl_vector_free(_R_idx_1); - gsl_vector_free(_R_idx_2); + VECTOR_ID(free)(_R_idx_1); + VECTOR_ID(free)(_R_idx_2); if (!any_R_idx_1_and_any_R_idx_2) { // P=R([a c],:); - gsl_vector* _R_rows = gsl_vector_alloc(2); - gsl_vector_set(_R_rows, 0, (double)a); - gsl_vector_set(_R_rows, 1, (double)c); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* P = ordinal_index(_R, _R_rows, _R_cols); - gsl_vector_free(_R_rows); - gsl_vector_free(_R_cols); + VECTOR_T* _R_rows = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(_R_rows, 0, (FP_T)a); + VECTOR_ID(set)(_R_rows, 1, (FP_T)c); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* P = ordinal_index(_R, _R_rows, _R_cols); + VECTOR_ID(free)(_R_rows); + VECTOR_ID(free)(_R_cols); // P(1,b)=0; P(1,d)=1; - gsl_matrix_set(P, 0, b, 0.0); - gsl_matrix_set(P, 0, d, 1.0); + MATRIX_ID(set)(P, 0, b, 0.0); + MATRIX_ID(set)(P, 0, d, 1.0); // P(2,d)=0; P(2,b)=1; - gsl_matrix_set(P, 1, d, 0.0); - gsl_matrix_set(P, 1, b, 1.0); + MATRIX_ID(set)(P, 1, d, 0.0); + MATRIX_ID(set)(P, 1, b, 1.0); // PN=P; - gsl_matrix* PN = copy(P); + MATRIX_T* PN = copy(P); // PN(1,a)=1; PN(2,c)=1; - gsl_matrix_set(PN, 0, a, 1.0); - gsl_matrix_set(PN, 1, c, 1.0); + MATRIX_ID(set)(PN, 0, a, 1.0); + MATRIX_ID(set)(PN, 1, c, 1.0); // while 1 while (true) { // P(1,:)=any(R(P(1,:)~=0,:),1); - gsl_vector_view P_row_0 = gsl_matrix_row(P, 0); - gsl_vector* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); - gsl_vector_free(P_row_0_neq_0); + VECTOR_ID(view) P_row_0 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); + VECTOR_ID(free)(P_row_0_neq_0); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 0, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 0, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_0.vector); + VECTOR_ID(set_zero)(&P_row_0.vector); } // P(2,:)=any(R(P(2,:)~=0,:),1); - gsl_vector_view P_row_1 = gsl_matrix_row(P, 0); - gsl_vector* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); + VECTOR_ID(view) P_row_1 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); _R_idx = log_ord_index(_R, P_row_1_neq_0, _R_cols); - gsl_vector_free(P_row_1_neq_0); - gsl_vector_free(_R_cols); + VECTOR_ID(free)(P_row_1_neq_0); + VECTOR_ID(free)(_R_cols); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 1, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 1, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_1.vector); + VECTOR_ID(set_zero)(&P_row_1.vector); } // P=P.*(~PN); - gsl_matrix* not_PN = logical_not(PN); - gsl_matrix_mul_elements(P, not_PN); - gsl_matrix_free(not_PN); + MATRIX_T* not_PN = logical_not(PN); + MATRIX_ID(mul_elements)(P, not_PN); + MATRIX_ID(free)(not_PN); // PN=PN+P - gsl_matrix_add(PN, P); + MATRIX_ID(add)(PN, P); // if ~all(any(P,2)) - gsl_vector* any_P = any(P, 2); + VECTOR_T* any_P = any(P, 2); bool all_any_P = all(any_P); - gsl_vector_free(any_P); + VECTOR_ID(free)(any_P); if (!all_any_P) { // rewire=0; @@ -168,15 +164,15 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { } // elseif any(PN(1,[b c])) && any(PN(2,[d a])) - gsl_vector* PN_idx_1 = gsl_vector_alloc(2); - gsl_vector_set(PN_idx_1, 0, gsl_matrix_get(PN, 0, b)); - gsl_vector_set(PN_idx_1, 1, gsl_matrix_get(PN, 0, c)); - gsl_vector* PN_idx_2 = gsl_vector_alloc(2); - gsl_vector_set(PN_idx_2, 0, gsl_matrix_get(PN, 1, d)); - gsl_vector_set(PN_idx_2, 1, gsl_matrix_get(PN, 1, a)); + VECTOR_T* PN_idx_1 = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(PN_idx_1, 0, MATRIX_ID(get)(PN, 0, b)); + VECTOR_ID(set)(PN_idx_1, 1, MATRIX_ID(get)(PN, 0, c)); + VECTOR_T* PN_idx_2 = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(PN_idx_2, 0, MATRIX_ID(get)(PN, 1, d)); + VECTOR_ID(set)(PN_idx_2, 1, MATRIX_ID(get)(PN, 1, a)); bool any_PN_idx_1_and_any_PN_idx_2 = any(PN_idx_1) && any(PN_idx_2); - gsl_vector_free(PN_idx_1); - gsl_vector_free(PN_idx_2); + VECTOR_ID(free)(PN_idx_1); + VECTOR_ID(free)(PN_idx_2); if (any_PN_idx_1_and_any_PN_idx_2) { // break @@ -184,26 +180,26 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(P); - gsl_matrix_free(PN); + MATRIX_ID(free)(P); + MATRIX_ID(free)(PN); } // if rewire if (rewire) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -212,6 +208,6 @@ gsl_matrix* bct::randmio_dir_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(find_R); + MATRIX_ID(free)(find_R); return _R; } diff --git a/randmio_und.cpp b/randmio_und.cpp index 7fbaae5..675a2e1 100644 --- a/randmio_und.cpp +++ b/randmio_und.cpp @@ -1,25 +1,21 @@ #include "bct.h" -#include -#include -#include -#include /* * Returns a randomized graph with equivalent degree sequence to the original * weighted undirected graph. On average, each edge is rewired ITER time. * Strength distributions are not preserved for weighted graphs. */ -gsl_matrix* bct::randmio_und(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::randmio_und(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | UNDIRECTED, "randmio_und"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // [i j]=find(tril(R)); - gsl_matrix* tril_R = tril(R); - gsl_matrix* find_tril_R = find_ij(tril_R); - gsl_matrix_free(tril_R); - gsl_vector_view i = gsl_matrix_column(find_tril_R, 0); - gsl_vector_view j = gsl_matrix_column(find_tril_R, 1); + MATRIX_T* tril_R = tril(R); + MATRIX_T* find_tril_R = find_ij(tril_R); + MATRIX_ID(free)(tril_R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_tril_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_tril_R, 1); // K=length(i); int K = length(&i.vector); @@ -27,7 +23,7 @@ gsl_matrix* bct::randmio_und(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -55,12 +51,12 @@ gsl_matrix* bct::randmio_und(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -74,38 +70,38 @@ gsl_matrix* bct::randmio_und(const gsl_matrix* R, int ITER) { if (gsl_rng_uniform(rng) > 0.5) { // i(e2)=d; j(e2)=c; - gsl_vector_set(&i.vector, e2, (double)d); - gsl_vector_set(&j.vector, e2, (double)c); + VECTOR_ID(set)(&i.vector, e2, (FP_T)d); + VECTOR_ID(set)(&j.vector, e2, (FP_T)c); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(d,a)=R(b,a); R(b,a)=0; - gsl_matrix_set(_R, d, a, gsl_matrix_get(_R, b, a)); - gsl_matrix_set(_R, b, a, 0.0); + MATRIX_ID(set)(_R, d, a, MATRIX_ID(get)(_R, b, a)); + MATRIX_ID(set)(_R, b, a, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // R(b,c)=R(d,c); R(d,c)=0; - gsl_matrix_set(_R, b, c, gsl_matrix_get(_R, d, c)); - gsl_matrix_set(_R, d, c, 0.0); + MATRIX_ID(set)(_R, b, c, MATRIX_ID(get)(_R, d, c)); + MATRIX_ID(set)(_R, d, c, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -113,6 +109,6 @@ gsl_matrix* bct::randmio_und(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(find_tril_R); + MATRIX_ID(free)(find_tril_R); return _R; } diff --git a/randmio_und_connected.cpp b/randmio_und_connected.cpp index 4f6065f..a20aedd 100644 --- a/randmio_und_connected.cpp +++ b/randmio_und_connected.cpp @@ -1,8 +1,4 @@ #include "bct.h" -#include -#include -#include -#include /* * Returns a randomized graph with equivalent degree sequence to the original @@ -10,17 +6,17 @@ * each edge is rewired ITER times. Strength distributions are not preserved * for weighted graphs. */ -gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { +MATRIX_T* bct::randmio_und_connected(const MATRIX_T* R, int ITER) { if (safe_mode) check_status(R, SQUARE | UNDIRECTED, "randmio_und_connected"); - gsl_rng* rng = get_gsl_rng(); + gsl_rng* rng = get_rng(); // [i j]=find(tril(R)); - gsl_matrix* tril_R = tril(R); - gsl_matrix* find_tril_R = find_ij(tril_R); - gsl_matrix_free(tril_R); - gsl_vector_view i = gsl_matrix_column(find_tril_R, 0); - gsl_vector_view j = gsl_matrix_column(find_tril_R, 1); + MATRIX_T* tril_R = tril(R); + MATRIX_T* find_tril_R = find_ij(tril_R); + MATRIX_ID(free)(tril_R); + VECTOR_ID(view) i = MATRIX_ID(column)(find_tril_R, 0); + VECTOR_ID(view) j = MATRIX_ID(column)(find_tril_R, 1); // K=length(i); int K = length(&i.vector); @@ -28,7 +24,7 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { // ITER=K*ITER; ITER = K * ITER; - gsl_matrix* _R = copy(R); + MATRIX_T* _R = copy(R); // for iter=1:ITER for (int iter = 1; iter <= ITER; iter++) { @@ -59,12 +55,12 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { } // a=i(e1); b=j(e1); - a = (int)gsl_vector_get(&i.vector, e1); - b = (int)gsl_vector_get(&j.vector, e1); + a = (int)VECTOR_ID(get)(&i.vector, e1); + b = (int)VECTOR_ID(get)(&j.vector, e1); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); // if all(a~=[c d]) && all(b~=[c d]); if (a != c && a != d && b != c && b != d) { @@ -78,84 +74,84 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { if (gsl_rng_uniform(rng) > 0.5) { // i(e2)=d; j(e2)=c; - gsl_vector_set(&i.vector, e2, (double)d); - gsl_vector_set(&j.vector, e2, (double)c); + VECTOR_ID(set)(&i.vector, e2, (FP_T)d); + VECTOR_ID(set)(&j.vector, e2, (FP_T)c); // c=i(e2); d=j(e2); - c = (int)gsl_vector_get(&i.vector, e2); - d = (int)gsl_vector_get(&j.vector, e2); + c = (int)VECTOR_ID(get)(&i.vector, e2); + d = (int)VECTOR_ID(get)(&j.vector, e2); } // if ~(R(a,d) || R(c,b)) - if (fp_zero(gsl_matrix_get(_R, a, d)) && fp_zero(gsl_matrix_get(_R, c, b))) { + if (fp_zero(MATRIX_ID(get)(_R, a, d)) && fp_zero(MATRIX_ID(get)(_R, c, b))) { // if ~(R(a,c) || R(b,d)) - if (fp_zero(gsl_matrix_get(_R, a, c)) && fp_zero(gsl_matrix_get(_R, b, d))) { + if (fp_zero(MATRIX_ID(get)(_R, a, c)) && fp_zero(MATRIX_ID(get)(_R, b, d))) { // P=R([a d],:); - gsl_vector* _R_rows = gsl_vector_alloc(2); - gsl_vector_set(_R_rows, 0, (double)a); - gsl_vector_set(_R_rows, 1, (double)d); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* P = ordinal_index(_R, _R_rows, _R_cols); - gsl_vector_free(_R_rows); - gsl_vector_free(_R_cols); + VECTOR_T* _R_rows = VECTOR_ID(alloc)(2); + VECTOR_ID(set)(_R_rows, 0, (FP_T)a); + VECTOR_ID(set)(_R_rows, 1, (FP_T)d); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* P = ordinal_index(_R, _R_rows, _R_cols); + VECTOR_ID(free)(_R_rows); + VECTOR_ID(free)(_R_cols); // P(1,b)=0; P(2,c)=0; - gsl_matrix_set(P, 0, b, 0.0); - gsl_matrix_set(P, 1, c, 0.0); + MATRIX_ID(set)(P, 0, b, 0.0); + MATRIX_ID(set)(P, 1, c, 0.0); // PN=P; - gsl_matrix* PN = copy(P); + MATRIX_T* PN = copy(P); // PN(:,d)=1; PN(:,a)=1; - gsl_vector_view PN_col_d = gsl_matrix_column(PN, d); - gsl_vector_set_all(&PN_col_d.vector, 1.0); - gsl_vector_view PN_col_a = gsl_matrix_column(PN, a); - gsl_vector_set_all(&PN_col_a.vector, 1.0); + VECTOR_ID(view) PN_col_d = MATRIX_ID(column)(PN, d); + VECTOR_ID(set_all)(&PN_col_d.vector, 1.0); + VECTOR_ID(view) PN_col_a = MATRIX_ID(column)(PN, a); + VECTOR_ID(set_all)(&PN_col_a.vector, 1.0); // while 1 while (true) { // P(1,:)=any(R(P(1,:)~=0,:),1); - gsl_vector_view P_row_0 = gsl_matrix_row(P, 0); - gsl_vector* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); - gsl_vector* _R_cols = sequence_double(0, _R->size2 - 1); - gsl_matrix* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); - gsl_vector_free(P_row_0_neq_0); + VECTOR_ID(view) P_row_0 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_0_neq_0 = compare_elements(&P_row_0.vector, fp_not_equal, 0.0); + VECTOR_T* _R_cols = sequence(0, _R->size2 - 1); + MATRIX_T* _R_idx = log_ord_index(_R, P_row_0_neq_0, _R_cols); + VECTOR_ID(free)(P_row_0_neq_0); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 0, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 0, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_0.vector); + VECTOR_ID(set_zero)(&P_row_0.vector); } // P(2,:)=any(R(P(2,:)~=0,:),1); - gsl_vector_view P_row_1 = gsl_matrix_row(P, 0); - gsl_vector* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); + VECTOR_ID(view) P_row_1 = MATRIX_ID(row)(P, 0); + VECTOR_T* P_row_1_neq_0 = compare_elements(&P_row_1.vector, fp_not_equal, 0.0); _R_idx = log_ord_index(_R, P_row_1_neq_0, _R_cols); - gsl_vector_free(P_row_1_neq_0); - gsl_vector_free(_R_cols); + VECTOR_ID(free)(P_row_1_neq_0); + VECTOR_ID(free)(_R_cols); if (_R_idx != NULL) { - gsl_vector* any__R_idx = any(_R_idx, 1); - gsl_matrix_free(_R_idx); - gsl_matrix_set_row(P, 1, any__R_idx); - gsl_vector_free(any__R_idx); + VECTOR_T* any__R_idx = any(_R_idx, 1); + MATRIX_ID(free)(_R_idx); + MATRIX_ID(set_row)(P, 1, any__R_idx); + VECTOR_ID(free)(any__R_idx); } else { - gsl_vector_set_zero(&P_row_1.vector); + VECTOR_ID(set_zero)(&P_row_1.vector); } // P=P.*(~PN); - gsl_matrix* not_PN = logical_not(PN); - gsl_matrix_mul_elements(P, not_PN); - gsl_matrix_free(not_PN); + MATRIX_T* not_PN = logical_not(PN); + MATRIX_ID(mul_elements)(P, not_PN); + MATRIX_ID(free)(not_PN); // if ~all(any(P,2)) - gsl_vector* any_P = any(P, 2); + VECTOR_T* any_P = any(P, 2); bool all_any_P = all(any_P); - gsl_vector_free(any_P); + VECTOR_ID(free)(any_P); if (!all_any_P) { // rewire=0; @@ -166,13 +162,13 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { } // elseif any(any(P(:,[b c]))) - gsl_vector_view P_col_b = gsl_matrix_column(P, b); - gsl_vector_view P_col_c = gsl_matrix_column(P, c); - gsl_matrix* P_idx = concatenate_rows(&P_col_b.vector, &P_col_c.vector); - gsl_vector* any_P_idx = any(P_idx); - gsl_matrix_free(P_idx); + VECTOR_ID(view) P_col_b = MATRIX_ID(column)(P, b); + VECTOR_ID(view) P_col_c = MATRIX_ID(column)(P, c); + MATRIX_T* P_idx = concatenate_rows(&P_col_b.vector, &P_col_c.vector); + VECTOR_T* any_P_idx = any(P_idx); + MATRIX_ID(free)(P_idx); bool any_any_P_idx = any(any_P_idx); - gsl_vector_free(any_P_idx); + VECTOR_ID(free)(any_P_idx); if (any_any_P_idx) { // break @@ -180,37 +176,37 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { } // PN=PN+P; - gsl_matrix_add(PN, P); + MATRIX_ID(add)(PN, P); } - gsl_matrix_free(P); - gsl_matrix_free(PN); + MATRIX_ID(free)(P); + MATRIX_ID(free)(PN); } // if rewire if (rewire) { // R(a,d)=R(a,b); R(a,b)=0; - gsl_matrix_set(_R, a, d, gsl_matrix_get(_R, a, b)); - gsl_matrix_set(_R, a, b, 0.0); + MATRIX_ID(set)(_R, a, d, MATRIX_ID(get)(_R, a, b)); + MATRIX_ID(set)(_R, a, b, 0.0); // R(d,a)=R(b,a); R(b,a)=0; - gsl_matrix_set(_R, d, a, gsl_matrix_get(_R, b, a)); - gsl_matrix_set(_R, b, a, 0.0); + MATRIX_ID(set)(_R, d, a, MATRIX_ID(get)(_R, b, a)); + MATRIX_ID(set)(_R, b, a, 0.0); // R(c,b)=R(c,d); R(c,d)=0; - gsl_matrix_set(_R, c, b, gsl_matrix_get(_R, c, d)); - gsl_matrix_set(_R, c, d, 0.0); + MATRIX_ID(set)(_R, c, b, MATRIX_ID(get)(_R, c, d)); + MATRIX_ID(set)(_R, c, d, 0.0); // R(b,c)=R(d,c); R(d,c)=0; - gsl_matrix_set(_R, b, c, gsl_matrix_get(_R, d, c)); - gsl_matrix_set(_R, d, c, 0.0); + MATRIX_ID(set)(_R, b, c, MATRIX_ID(get)(_R, d, c)); + MATRIX_ID(set)(_R, d, c, 0.0); // j(e1) = d; - gsl_vector_set(&j.vector, e1, (double)d); + VECTOR_ID(set)(&j.vector, e1, (FP_T)d); // j(e2) = b; - gsl_vector_set(&j.vector, e2, (double)b); + VECTOR_ID(set)(&j.vector, e2, (FP_T)b); // break; break; @@ -219,6 +215,6 @@ gsl_matrix* bct::randmio_und_connected(const gsl_matrix* R, int ITER) { } } - gsl_matrix_free(find_tril_R); + MATRIX_ID(free)(find_tril_R); return _R; } diff --git a/reachdist.cpp b/reachdist.cpp index 7a496d4..20e9c9d 100644 --- a/reachdist.cpp +++ b/reachdist.cpp @@ -1,19 +1,18 @@ -#include "bct.h" #include -#include -#include -void reachdist2(const gsl_matrix*, gsl_matrix**, gsl_matrix**, gsl_matrix**, int, int*, gsl_vector*, gsl_vector*); +#include "bct.h" + +void reachdist2(const MATRIX_T*, MATRIX_T**, MATRIX_T**, MATRIX_T**, int, int*, VECTOR_T*, VECTOR_T*); /* * Computes reachability and distance matrices based on the power of the * adjacency matrix. */ -gsl_matrix* bct::reachdist(const gsl_matrix* CIJ, gsl_matrix** D) { +MATRIX_T* bct::reachdist(const MATRIX_T* CIJ, MATRIX_T** D) { if (safe_mode) check_status(CIJ, SQUARE, "reachdist"); // R = CIJ; - gsl_matrix* R = copy(CIJ); + MATRIX_T* R = copy(CIJ); // D = CIJ; if (D != NULL) { @@ -27,57 +26,57 @@ gsl_matrix* bct::reachdist(const gsl_matrix* CIJ, gsl_matrix** D) { int N = CIJ->size1; // CIJpwr = CIJ; - gsl_matrix* CIJpwr = copy(CIJ); + MATRIX_T* CIJpwr = copy(CIJ); // id = sum(CIJ,1); - gsl_vector* id = sum(CIJ, 1); + VECTOR_T* id = sum(CIJ, 1); // od = sum(CIJ,2)'; - gsl_vector* od = sum(CIJ, 2); + VECTOR_T* od = sum(CIJ, 2); // id_0 = find(id==0); - gsl_vector* id_eq_0 = compare_elements(id, fp_equal, 0.0); - gsl_vector_free(id); - gsl_vector* id_0 = find(id_eq_0); - gsl_vector_free(id_eq_0); + VECTOR_T* id_eq_0 = compare_elements(id, fp_equal, 0.0); + VECTOR_ID(free)(id); + VECTOR_T* id_0 = find(id_eq_0); + VECTOR_ID(free)(id_eq_0); // od_0 = find(od==0); - gsl_vector* od_eq_0 = compare_elements(od, fp_equal, 0.0); - gsl_vector_free(od); - gsl_vector* od_0 = find(od_eq_0); - gsl_vector_free(od_eq_0); + VECTOR_T* od_eq_0 = compare_elements(od, fp_equal, 0.0); + VECTOR_ID(free)(od); + VECTOR_T* od_0 = find(od_eq_0); + VECTOR_ID(free)(od_eq_0); // col = setxor(1:N,id_0); - gsl_vector* i_all = sequence_double(0, N - 1); - gsl_vector* col = setxor(i_all, id_0); + VECTOR_T* i_all = sequence(0, N - 1); + VECTOR_T* col = setxor(i_all, id_0); // row = setxor(1:N,od_0); - gsl_vector* row = setxor(i_all, od_0); - gsl_vector_free(i_all); + VECTOR_T* row = setxor(i_all, od_0); + VECTOR_ID(free)(i_all); // [R,D,powr] = reachdist2(CIJ,CIJpwr,R,D,N,powr,col,row); reachdist2(CIJ, &CIJpwr, &R, D, N, &powr, col, row); - gsl_matrix_free(CIJpwr); + MATRIX_ID(free)(CIJpwr); if (col != NULL) { - gsl_vector_free(col); + VECTOR_ID(free)(col); } if (row != NULL) { - gsl_vector_free(row); + VECTOR_ID(free)(row); } if (D != NULL) { // D = powr - D+1; - gsl_matrix_scale(*D, -1.0); - gsl_matrix_add_constant(*D, (double)(powr + 1)); + MATRIX_ID(scale)(*D, -1.0); + MATRIX_ID(add_constant)(*D, (FP_T)(powr + 1)); // D(D==(N+2)) = Inf; - gsl_matrix* D_eq_N_add_2 = compare_elements(*D, fp_equal, (double)(N + 2)); + MATRIX_T* D_eq_N_add_2 = compare_elements(*D, fp_equal, (FP_T)(N + 2)); logical_index_assign(*D, D_eq_N_add_2, GSL_POSINF); - gsl_matrix_free(D_eq_N_add_2); + MATRIX_ID(free)(D_eq_N_add_2); // D(:,id_0) = Inf; - gsl_vector* D_rows_cols = sequence_double(0, N - 1); + VECTOR_T* D_rows_cols = sequence(0, N - 1); if (id_0 != NULL) { ordinal_index_assign(*D, D_rows_cols, id_0, GSL_POSINF); } @@ -86,48 +85,48 @@ gsl_matrix* bct::reachdist(const gsl_matrix* CIJ, gsl_matrix** D) { if (od_0 != NULL) { ordinal_index_assign(*D, od_0, D_rows_cols, GSL_POSINF); } - gsl_vector_free(D_rows_cols); + VECTOR_ID(free)(D_rows_cols); } if (id_0 != NULL) { - gsl_vector_free(id_0); + VECTOR_ID(free)(id_0); } if (od_0 != NULL) { - gsl_vector_free(od_0); + VECTOR_ID(free)(od_0); } return R; } -void reachdist2(const gsl_matrix* CIJ, gsl_matrix** CIJpwr, gsl_matrix** R, gsl_matrix** D, int N, int* powr, gsl_vector* col, gsl_vector* row) { +void reachdist2(const MATRIX_T* CIJ, MATRIX_T** CIJpwr, MATRIX_T** R, MATRIX_T** D, int N, int* powr, VECTOR_T* col, VECTOR_T* row) { using namespace bct; // CIJpwr = CIJpwr*CIJ; - gsl_matrix* temp = mul(*CIJpwr, CIJ); - gsl_matrix_free(*CIJpwr); + MATRIX_T* temp = mul(*CIJpwr, CIJ); + MATRIX_ID(free)(*CIJpwr); *CIJpwr = temp; - // R = double(R | ((CIJpwr)~=0)); - gsl_matrix* CIJpwr_neq_0 = compare_elements(*CIJpwr, fp_not_equal, 0.0); - gsl_matrix* R_or_CIJpwr_neq_0 = logical_or(*R, CIJpwr_neq_0); - gsl_matrix_free(CIJpwr_neq_0); - gsl_matrix_free(*R); + // R = FP_T(R | ((CIJpwr)~=0)); + MATRIX_T* CIJpwr_neq_0 = compare_elements(*CIJpwr, fp_not_equal, 0.0); + MATRIX_T* R_or_CIJpwr_neq_0 = logical_or(*R, CIJpwr_neq_0); + MATRIX_ID(free)(CIJpwr_neq_0); + MATRIX_ID(free)(*R); *R = R_or_CIJpwr_neq_0; // D = D+R; if (D != NULL) { - gsl_matrix_add(*D, *R); + MATRIX_ID(add)(*D, *R); } // if ((powr<=N)&&(~isempty(nonzeros(R(row,col)==0)))) if (*powr <= N) { if (row != NULL && col != NULL) { - gsl_matrix* R_idx = ordinal_index(*R, row, col); - gsl_matrix* R_idx_eq_0 = compare_elements(R_idx, fp_equal, 0.0); - gsl_matrix_free(R_idx); - gsl_vector* nonzeros_R_idx_eq_0 = nonzeros(R_idx_eq_0); - gsl_matrix_free(R_idx_eq_0); + MATRIX_T* R_idx = ordinal_index(*R, row, col); + MATRIX_T* R_idx_eq_0 = compare_elements(R_idx, fp_equal, 0.0); + MATRIX_ID(free)(R_idx); + VECTOR_T* nonzeros_R_idx_eq_0 = nonzeros(R_idx_eq_0); + MATRIX_ID(free)(R_idx_eq_0); if (nonzeros_R_idx_eq_0 != NULL) { - gsl_vector_free(nonzeros_R_idx_eq_0); + VECTOR_ID(free)(nonzeros_R_idx_eq_0); // powr = powr+1; (*powr)++; diff --git a/status.cpp b/status.cpp index c6eca99..6e9b35b 100644 --- a/status.cpp +++ b/status.cpp @@ -1,9 +1,6 @@ -#include "bct.h" -#include -#include #include -#include -#include + +#include "bct.h" bool bct::safe_mode = true; @@ -14,53 +11,7 @@ void bct::set_safe_mode(bool safe_mode) { bct::safe_mode = safe_mode; } * Returns whether a matrix matches the given status flags. If the check fails, * a message is printed to stderr starting with the given text. */ -bool bct::check_status(const gsl_matrix* m, int flags, const std::string& text) { - status prop[] = { - SQUARE, RECTANGULAR, - UNDIRECTED, DIRECTED, - BINARY, WEIGHTED, - POSITIVE, SIGNED, - NO_LOOPS, LOOPS - }; - std::string propstr[] = { - "square", "rectangular", - "undirected", "directed", - "binary", "weighted", - "positive", "signed", - "no_loops", "loops" - }; - bool (*propfn[])(const gsl_matrix*) = { - is_square, is_rectangular, - is_undirected, is_directed, - is_binary, is_weighted, - is_positive, is_signed, - has_no_loops, has_loops - }; - bool ret = true; - std::vector failures; - for (int i = 0; i < 10; i++) { - if (flags & (int)prop[i]) { - if (!propfn[i](m)) { - ret = false; - failures.push_back(propstr[i]); - } - } - } - if (!ret) { - std::cerr << text << ": Matrix status check failed (not "; - for (int i = 0; i < (int)failures.size(); i++) { - std::cerr << failures[i]; - if (i < (int)failures.size() - 1) { - std::cerr << ", "; - } - } - std::cerr << ")." << std::endl; - } - return ret; -} - -/*float version*/ -bool bct::check_status(const gsl_matrix_float* m, int flags, const std::string& text) { +bool bct::check_status(const MATRIX_T* m, int flags, const std::string& text) { status prop[] = { SQUARE, RECTANGULAR, UNDIRECTED, DIRECTED, @@ -75,7 +26,7 @@ bool bct::check_status(const gsl_matrix_float* m, int flags, const std::string& "positive", "signed", "no_loops", "loops" }; - bool (*propfn[])(const gsl_matrix_float*) = { + bool (*propfn[])(const MATRIX_T*) = { is_square, is_rectangular, is_undirected, is_directed, is_binary, is_weighted, @@ -105,62 +56,34 @@ bool bct::check_status(const gsl_matrix_float* m, int flags, const std::string& return ret; } - - /* * Returns whether the given matrix is square. */ -bool bct::is_square(const gsl_matrix* m) { - return m->size1 == m->size2; -} - -bool bct::is_square(const gsl_matrix_float* m) { +bool bct::is_square(const MATRIX_T* m) { return m->size1 == m->size2; } - /* * Returns whether the given matrix is rectangular. */ -bool bct::is_rectangular(const gsl_matrix* m) { +bool bct::is_rectangular(const MATRIX_T* m) { return m->size1 != m->size2; } -bool bct::is_rectangular(const gsl_matrix_float* m) { - return m->size1 != m->size2; -} - - /* * Returns whether the given matrix is undirected. */ -bool bct::is_undirected(const gsl_matrix* m) { - return !is_directed(m); -} - -bool bct::is_undirected(const gsl_matrix_float* m) { +bool bct::is_undirected(const MATRIX_T* m) { return !is_directed(m); } - /* * Returns whether the given matrix is directed. */ -bool bct::is_directed(const gsl_matrix* m) { - for (int i = 0; i < (int)m->size1; i++) { - for (int j = 0; j < (int)m->size2; j++) { - if (fp_not_equal(gsl_matrix_get(m, i, j), gsl_matrix_get(m, j, i))) { - return true; - } - } - } - return false; -} - -bool bct::is_directed(const gsl_matrix_float* m) { +bool bct::is_directed(const MATRIX_T* m) { for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - if (fp_not_equal(gsl_matrix_float_get(m, i, j), gsl_matrix_float_get(m, j, i))) { + if (fp_not_equal(MATRIX_ID(get)(m, i, j), MATRIX_ID(get)(m, j, i))) { return true; } } @@ -168,26 +91,20 @@ bool bct::is_directed(const gsl_matrix_float* m) { return false; } - /* * Returns whether the given matrix is binary. */ -bool bct::is_binary(const gsl_matrix* m) { +bool bct::is_binary(const MATRIX_T* m) { return !is_weighted(m); } -bool bct::is_binary(const gsl_matrix_float* m) { - return !is_weighted(m); -} - - /* * Returns whether the given matrix is weighted. */ -bool bct::is_weighted(const gsl_matrix* m) { +bool bct::is_weighted(const MATRIX_T* m) { for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - double value = gsl_matrix_get(m, i, j); + FP_T value = MATRIX_ID(get)(m, i, j); if (fp_nonzero(value) && fp_not_equal(value, 1.0)) { return true; } @@ -196,49 +113,20 @@ bool bct::is_weighted(const gsl_matrix* m) { return false; } -bool bct::is_weighted(const gsl_matrix_float* m) { - for (int i = 0; i < (int)m->size1; i++) { - for (int j = 0; j < (int)m->size2; j++) { - float value = gsl_matrix_float_get(m, i, j); - if (fp_nonzero(value) && fp_not_equal(value, (float)1.0)) { - return true; - } - } - } - return false; -} - - /* * Returns whether the given matrix is positive. */ -bool bct::is_positive(const gsl_matrix* m) { +bool bct::is_positive(const MATRIX_T* m) { return !is_signed(m); } -bool bct::is_positive(const gsl_matrix_float* m) { - return !is_signed(m); -} - - /* * Returns whether the given matrix is signed. */ -bool bct::is_signed(const gsl_matrix* m) { - for (int i = 0; i < (int)m->size1; i++) { - for (int j = 0; j < (int)m->size2; j++) { - if (gsl_matrix_get(m, i, j) < 0.0) { - return true; - } - } - } - return false; -} - -bool bct::is_signed(const gsl_matrix_float* m) { +bool bct::is_signed(const MATRIX_T* m) { for (int i = 0; i < (int)m->size1; i++) { for (int j = 0; j < (int)m->size2; j++) { - if (gsl_matrix_float_get(m, i, j) < 0.0) { + if (MATRIX_ID(get)(m, i, j) < 0.0) { return true; } } @@ -246,28 +134,17 @@ bool bct::is_signed(const gsl_matrix_float* m) { return false; } - /* * Returns whether the given matrix has loops. */ -bool bct::has_loops(const gsl_matrix* m) { +bool bct::has_loops(const MATRIX_T* m) { return !has_no_loops(m); } -bool bct::has_loops(const gsl_matrix_float* m) { - return !has_no_loops(m); -} - - /* * Returns whether the given matrix has no loops. */ -bool bct::has_no_loops(const gsl_matrix* m) { - gsl_vector_const_view diag_m = gsl_matrix_const_diagonal(m); - return gsl_vector_isnull(&diag_m.vector) == 1; -} - -bool bct::has_no_loops(const gsl_matrix_float* m) { - gsl_vector_float_const_view diag_m = gsl_matrix_float_const_diagonal(m); - return gsl_vector_float_isnull(&diag_m.vector) == 1; +bool bct::has_no_loops(const MATRIX_T* m) { + VECTOR_ID(const_view) diag_m = MATRIX_ID(const_diagonal)(m); + return VECTOR_ID(isnull)(&diag_m.vector) == 1; } diff --git a/strengths_dir.cpp b/strengths_dir.cpp index 1cc759e..9e96c11 100755 --- a/strengths_dir.cpp +++ b/strengths_dir.cpp @@ -1,24 +1,22 @@ #include "bct.h" -#include -#include /* * Computes strength, in-strength, and out-strength for a directed graph. */ -gsl_vector* bct::strengths_dir(const gsl_matrix* CIJ, gsl_vector** is, gsl_vector** os) { +VECTOR_T* bct::strengths_dir(const MATRIX_T* CIJ, VECTOR_T** is, VECTOR_T** os) { if (safe_mode) check_status(CIJ, SQUARE | DIRECTED, "strengths_dir"); // is = sum(CIJ,1); - gsl_vector* _is = sum(CIJ, 1); + VECTOR_T* _is = sum(CIJ, 1); // os = sum(CIJ,2); - gsl_vector* _os = sum(CIJ, 2); + VECTOR_T* _os = sum(CIJ, 2); // str = is+os; - gsl_vector* str = copy(_is); - gsl_vector_add(str, _os); + VECTOR_T* str = copy(_is); + VECTOR_ID(add)(str, _os); - if (is != NULL) *is = _is; else gsl_vector_free(_is); - if (os != NULL) *os = _os; else gsl_vector_free(_os); + if (is != NULL) *is = _is; else VECTOR_ID(free)(_is); + if (os != NULL) *os = _os; else VECTOR_ID(free)(_os); return str; } diff --git a/strengths_und.cpp b/strengths_und.cpp index d81d38a..58b4eb5 100755 --- a/strengths_und.cpp +++ b/strengths_und.cpp @@ -1,11 +1,9 @@ #include "bct.h" -#include -#include /* * Computes strength for an undirected graph. */ -gsl_vector* bct::strengths_und(const gsl_matrix* CIJ) { +VECTOR_T* bct::strengths_und(const MATRIX_T* CIJ) { if (safe_mode) check_status(CIJ, SQUARE | UNDIRECTED, "strengths_und"); // str = sum(CIJ); diff --git a/test/Makefile b/test/Makefile index a780dac..aa707d4 100644 --- a/test/Makefile +++ b/test/Makefile @@ -47,7 +47,7 @@ filenames = assortativity_dir_cpp \ matching_ind_out_cpp \ modularity_dir_cpp \ modularity_und_cpp \ - modularity_und_louvain_cpp \ + modularity_louvain_und_cpp \ module_degree_zscore_cpp \ motif3funct_bin_cpp \ motif3funct_wei_cpp \ diff --git a/test/assortativity_dir_cpp.cpp b/test/assortativity_dir_cpp.cpp index ea9a8bd..1a25def 100644 --- a/test/assortativity_dir_cpp.cpp +++ b/test/assortativity_dir_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(assortativity_dir) diff --git a/test/assortativity_und_cpp.cpp b/test/assortativity_und_cpp.cpp index 21b9d5f..145a10e 100644 --- a/test/assortativity_und_cpp.cpp +++ b/test/assortativity_und_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(assortativity_und) diff --git a/test/bct_test.cpp b/test/bct_test.cpp index d3b7b1b..c7896e6 100644 --- a/test/bct_test.cpp +++ b/test/bct_test.cpp @@ -1,12 +1,6 @@ #ifndef BCT_TEST_CPP #define BCT_TEST_CPP -#include "bct_test.h" -#include -#include -#include -#include - /* * Converts a GSL vector to an Octave matrix. */ diff --git a/test/bct_test.h b/test/bct_test.h index 9c15468..d2ef78d 100644 --- a/test/bct_test.h +++ b/test/bct_test.h @@ -1,6 +1,7 @@ #ifndef BCT_TEST_H #define BCT_TEST_H +#include #include #include #include diff --git a/test/bct_test_modularity.m b/test/bct_test_modularity.m index 40d3398..a4cabbe 100644 --- a/test/bct_test_modularity.m +++ b/test/bct_test_modularity.m @@ -34,20 +34,20 @@ bct_test(sprintf("modularity_und %s Q", mname{i}), abs(Q - Q_cpp) < 1e-6) end -% modularity_und_louvain +% modularity_louvain_und for i = 1:size(m)(2) ms = m{i} | m{i}'; - [Ci Q] = modularity_und_louvain(ms); + [Ci Q] = modularity_louvain_und(ms); result = 0; tries = 0; while (~result && tries < 100) - [Ci_cpp Q_cpp] = modularity_und_louvain_cpp(ms); - if (mapmatch(Ci{end}, Ci_cpp) && abs(Q{end} - Q_cpp) < 1e-6) + [Ci_cpp Q_cpp] = modularity_louvain_und_cpp(ms); + if (mapmatch(Ci, Ci_cpp) && abs(Q - Q_cpp) < 1e-6) result = 1; end tries = tries + 1; end - bct_test(sprintf("modularity_und_louvain %s", mname{i}), result) + bct_test(sprintf("modularity_louvain_und %s", mname{i}), result) end % module_degree_zscore diff --git a/test/betweenness_bin_cpp.cpp b/test/betweenness_bin_cpp.cpp index 30afa56..04c59ba 100644 --- a/test/betweenness_bin_cpp.cpp +++ b/test/betweenness_bin_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(betweenness_bin) diff --git a/test/betweenness_wei_cpp.cpp b/test/betweenness_wei_cpp.cpp index db2ce0f..b3509a5 100644 --- a/test/betweenness_wei_cpp.cpp +++ b/test/betweenness_wei_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(betweenness_wei) diff --git a/test/breadth_cpp.cpp b/test/breadth_cpp.cpp index 4330e64..1d7224e 100644 --- a/test/breadth_cpp.cpp +++ b/test/breadth_cpp.cpp @@ -1,8 +1,6 @@ -#include +#include + #include "bct_test.h" -#include -#include -#include DEFUN_DLD(breadth_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/breadthdist_cpp.cpp b/test/breadthdist_cpp.cpp index f4bbdeb..c7c26ab 100644 --- a/test/breadthdist_cpp.cpp +++ b/test/breadthdist_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(breadthdist_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/charpath_ecc_cpp.cpp b/test/charpath_ecc_cpp.cpp index 721f3a6..79b7d09 100644 --- a/test/charpath_ecc_cpp.cpp +++ b/test/charpath_ecc_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(charpath_ecc_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/charpath_lambda_cpp.cpp b/test/charpath_lambda_cpp.cpp index 7333612..34a947f 100644 --- a/test/charpath_lambda_cpp.cpp +++ b/test/charpath_lambda_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(charpath_lambda) diff --git a/test/clustering_coef_bd_cpp.cpp b/test/clustering_coef_bd_cpp.cpp index 5d27b75..0ee8d35 100644 --- a/test/clustering_coef_bd_cpp.cpp +++ b/test/clustering_coef_bd_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(clustering_coef_bd) diff --git a/test/clustering_coef_bu_cpp.cpp b/test/clustering_coef_bu_cpp.cpp index 40e45ed..edc1bfd 100644 --- a/test/clustering_coef_bu_cpp.cpp +++ b/test/clustering_coef_bu_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(clustering_coef_bu) diff --git a/test/clustering_coef_wd_cpp.cpp b/test/clustering_coef_wd_cpp.cpp index 100b855..f50080b 100644 --- a/test/clustering_coef_wd_cpp.cpp +++ b/test/clustering_coef_wd_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(clustering_coef_wd) diff --git a/test/clustering_coef_wu_cpp.cpp b/test/clustering_coef_wu_cpp.cpp index 4bf0cc3..2b5e55e 100644 --- a/test/clustering_coef_wu_cpp.cpp +++ b/test/clustering_coef_wu_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(clustering_coef_wu) diff --git a/test/cycprob_fcyc_cpp.cpp b/test/cycprob_fcyc_cpp.cpp index ea47b23..635ac4b 100644 --- a/test/cycprob_fcyc_cpp.cpp +++ b/test/cycprob_fcyc_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(cycprob_fcyc_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/cycprob_pcyc_cpp.cpp b/test/cycprob_pcyc_cpp.cpp index c502fc6..19a8ff5 100644 --- a/test/cycprob_pcyc_cpp.cpp +++ b/test/cycprob_pcyc_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(cycprob_pcyc_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/degrees_dir_cpp.cpp b/test/degrees_dir_cpp.cpp index 890f0a1..13e3b5d 100644 --- a/test/degrees_dir_cpp.cpp +++ b/test/degrees_dir_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(degrees_dir) diff --git a/test/degrees_und_cpp.cpp b/test/degrees_und_cpp.cpp index 356e092..f4114bc 100644 --- a/test/degrees_und_cpp.cpp +++ b/test/degrees_und_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(degrees_und) diff --git a/test/density_dir_cpp.cpp b/test/density_dir_cpp.cpp index d340a5a..b6abb07 100644 --- a/test/density_dir_cpp.cpp +++ b/test/density_dir_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(density_dir) diff --git a/test/density_und_cpp.cpp b/test/density_und_cpp.cpp index ce89818..ed064a6 100644 --- a/test/density_und_cpp.cpp +++ b/test/density_und_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(density_und) diff --git a/test/distance_bin_cpp.cpp b/test/distance_bin_cpp.cpp index 75dfaf7..d48bfc1 100644 --- a/test/distance_bin_cpp.cpp +++ b/test/distance_bin_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(distance_bin) diff --git a/test/distance_wei_cpp.cpp b/test/distance_wei_cpp.cpp index 3aad763..d8c31d3 100644 --- a/test/distance_wei_cpp.cpp +++ b/test/distance_wei_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(distance_wei) diff --git a/test/edge_betweenness_bin_cpp.cpp b/test/edge_betweenness_bin_cpp.cpp index 4659858..cdafe2f 100644 --- a/test/edge_betweenness_bin_cpp.cpp +++ b/test/edge_betweenness_bin_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(edge_betweenness_bin) diff --git a/test/edge_betweenness_wei_cpp.cpp b/test/edge_betweenness_wei_cpp.cpp index 89ae1a4..46796f7 100644 --- a/test/edge_betweenness_wei_cpp.cpp +++ b/test/edge_betweenness_wei_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(edge_betweenness_wei) diff --git a/test/efficiency_global_cpp.cpp b/test/efficiency_global_cpp.cpp index 09da6de..45fafd4 100644 --- a/test/efficiency_global_cpp.cpp +++ b/test/efficiency_global_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(efficiency_global) diff --git a/test/efficiency_local_cpp.cpp b/test/efficiency_local_cpp.cpp index 3dd1534..f79a337 100644 --- a/test/efficiency_local_cpp.cpp +++ b/test/efficiency_local_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(efficiency_local) diff --git a/test/erange_cpp.cpp b/test/erange_cpp.cpp index 5335c11..7c1b680 100644 --- a/test/erange_cpp.cpp +++ b/test/erange_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(erange_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/find_motif34_cpp.cpp b/test/find_motif34_cpp.cpp index 8c728b6..7abd017 100644 --- a/test/find_motif34_cpp.cpp +++ b/test/find_motif34_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(find_motif34_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/findpaths_cpp.cpp b/test/findpaths_cpp.cpp index bdfc730..05bd2d8 100644 --- a/test/findpaths_cpp.cpp +++ b/test/findpaths_cpp.cpp @@ -1,9 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include -#include DEFUN_DLD(findpaths_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 3) { diff --git a/test/findwalks_cpp.cpp b/test/findwalks_cpp.cpp index 8ac23ea..0c50b8c 100644 --- a/test/findwalks_cpp.cpp +++ b/test/findwalks_cpp.cpp @@ -1,9 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include -#include DEFUN_DLD(findwalks_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/jdegree_bl_cpp.cpp b/test/jdegree_bl_cpp.cpp index 83d11f3..8e7cf4d 100644 --- a/test/jdegree_bl_cpp.cpp +++ b/test/jdegree_bl_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(jdegree_bl) diff --git a/test/jdegree_cpp.cpp b/test/jdegree_cpp.cpp index e2975a7..5fc4c97 100644 --- a/test/jdegree_cpp.cpp +++ b/test/jdegree_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(jdegree) diff --git a/test/jdegree_id_cpp.cpp b/test/jdegree_id_cpp.cpp index 08714c9..5be5a64 100644 --- a/test/jdegree_id_cpp.cpp +++ b/test/jdegree_id_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(jdegree_id) diff --git a/test/jdegree_od_cpp.cpp b/test/jdegree_od_cpp.cpp index 5aa4e92..09b9441 100644 --- a/test/jdegree_od_cpp.cpp +++ b/test/jdegree_od_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_SCALAR_FUNCTION(jdegree_od) diff --git a/test/latmio_dir_connected_cpp.cpp b/test/latmio_dir_connected_cpp.cpp index 338d032..8097819 100644 --- a/test/latmio_dir_connected_cpp.cpp +++ b/test/latmio_dir_connected_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(latmio_dir_connected_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/latmio_dir_cpp.cpp b/test/latmio_dir_cpp.cpp index b93410b..f1a5941 100644 --- a/test/latmio_dir_cpp.cpp +++ b/test/latmio_dir_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(latmio_dir_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/latmio_und_connected_cpp.cpp b/test/latmio_und_connected_cpp.cpp index 275fc68..9e440fb 100644 --- a/test/latmio_und_connected_cpp.cpp +++ b/test/latmio_und_connected_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(latmio_und_connected_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/latmio_und_cpp.cpp b/test/latmio_und_cpp.cpp index 59844a8..4135e83 100644 --- a/test/latmio_und_cpp.cpp +++ b/test/latmio_und_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(latmio_und_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/makeevenCIJ_cpp.cpp b/test/makeevenCIJ_cpp.cpp index cc6aa40..0ebcc57 100644 --- a/test/makeevenCIJ_cpp.cpp +++ b/test/makeevenCIJ_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makeevenCIJ_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 3) { diff --git a/test/makefractalCIJ_cpp.cpp b/test/makefractalCIJ_cpp.cpp index c4b52fa..9fe6146 100644 --- a/test/makefractalCIJ_cpp.cpp +++ b/test/makefractalCIJ_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makefractalCIJ_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 3) { diff --git a/test/makelatticeCIJ_cpp.cpp b/test/makelatticeCIJ_cpp.cpp index 3943a05..ee64335 100644 --- a/test/makelatticeCIJ_cpp.cpp +++ b/test/makelatticeCIJ_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makelatticeCIJ_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/makerandCIJ_bd_cpp.cpp b/test/makerandCIJ_bd_cpp.cpp index c0645f7..3edfbae 100644 --- a/test/makerandCIJ_bd_cpp.cpp +++ b/test/makerandCIJ_bd_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makerandCIJ_bd_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/makerandCIJ_bu_cpp.cpp b/test/makerandCIJ_bu_cpp.cpp index 6ae225f..fabf69d 100644 --- a/test/makerandCIJ_bu_cpp.cpp +++ b/test/makerandCIJ_bu_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makerandCIJ_bu_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/makerandCIJdegreesfixed_cpp.cpp b/test/makerandCIJdegreesfixed_cpp.cpp index 48d6ace..231a220 100644 --- a/test/makerandCIJdegreesfixed_cpp.cpp +++ b/test/makerandCIJdegreesfixed_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(makerandCIJdegreesfixed_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/makeringlatticeCIJ_cpp.cpp b/test/makeringlatticeCIJ_cpp.cpp index 568fd97..6027934 100644 --- a/test/makeringlatticeCIJ_cpp.cpp +++ b/test/makeringlatticeCIJ_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(makeringlatticeCIJ_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/maketoeplitzCIJ_cpp.cpp b/test/maketoeplitzCIJ_cpp.cpp index 9c0b851..203ea8d 100644 --- a/test/maketoeplitzCIJ_cpp.cpp +++ b/test/maketoeplitzCIJ_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(maketoeplitzCIJ_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 3) { diff --git a/test/matching_ind_cpp.cpp b/test/matching_ind_cpp.cpp index cc1a3cd..7276345 100644 --- a/test/matching_ind_cpp.cpp +++ b/test/matching_ind_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(matching_ind) diff --git a/test/matching_ind_in_cpp.cpp b/test/matching_ind_in_cpp.cpp index 2a8a05e..5dfe542 100644 --- a/test/matching_ind_in_cpp.cpp +++ b/test/matching_ind_in_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(matching_ind_in) diff --git a/test/matching_ind_out_cpp.cpp b/test/matching_ind_out_cpp.cpp index ab053fc..c187f6b 100644 --- a/test/matching_ind_out_cpp.cpp +++ b/test/matching_ind_out_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_MATRIX_FUNCTION(matching_ind_out) diff --git a/test/modularity_dir_cpp.cpp b/test/modularity_dir_cpp.cpp index 2eb5ee1..a43ad44 100644 --- a/test/modularity_dir_cpp.cpp +++ b/test/modularity_dir_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(modularity_dir_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/modularity_und_louvain_cpp.cpp b/test/modularity_louvain_und_cpp.cpp similarity index 65% rename from test/modularity_und_louvain_cpp.cpp rename to test/modularity_louvain_und_cpp.cpp index bd07485..5481170 100644 --- a/test/modularity_und_louvain_cpp.cpp +++ b/test/modularity_louvain_und_cpp.cpp @@ -1,10 +1,6 @@ -#include #include "bct_test.h" -#include -#include -#include -DEFUN_DLD(modularity_und_louvain_cpp, args, , "Wrapper for C++ function.") { +DEFUN_DLD(modularity_louvain_und_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { return octave_value_list(); } @@ -12,7 +8,7 @@ DEFUN_DLD(modularity_und_louvain_cpp, args, , "Wrapper for C++ function.") { if (!error_state) { gsl_matrix* W_gsl = bct_test::to_gslm(W); gsl_vector* Ci; - double Q = bct::modularity_und_louvain(W_gsl, &Ci); + double Q = bct::modularity_louvain_und(W_gsl, &Ci); octave_value_list ret; ret(0) = octave_value(bct_test::from_gsl(Ci)); ret(1) = octave_value(Q); diff --git a/test/modularity_und_cpp.cpp b/test/modularity_und_cpp.cpp index c4c345e..095cd02 100644 --- a/test/modularity_und_cpp.cpp +++ b/test/modularity_und_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(modularity_und_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/module_degree_zscore_cpp.cpp b/test/module_degree_zscore_cpp.cpp index 23c322e..8cf2c9c 100644 --- a/test/module_degree_zscore_cpp.cpp +++ b/test/module_degree_zscore_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(module_degree_zscore_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/motif3funct_bin_cpp.cpp b/test/motif3funct_bin_cpp.cpp index 122fffb..fde1056 100644 --- a/test/motif3funct_bin_cpp.cpp +++ b/test/motif3funct_bin_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif3funct_bin_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif3funct_wei_cpp.cpp b/test/motif3funct_wei_cpp.cpp index e714cee..8d2cc55 100644 --- a/test/motif3funct_wei_cpp.cpp +++ b/test/motif3funct_wei_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(motif3funct_wei_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif3generate_cpp.cpp b/test/motif3generate_cpp.cpp index fe62e62..e3cfc81 100644 --- a/test/motif3generate_cpp.cpp +++ b/test/motif3generate_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif3generate_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif3struct_bin_cpp.cpp b/test/motif3struct_bin_cpp.cpp index e9be5c2..e060826 100644 --- a/test/motif3struct_bin_cpp.cpp +++ b/test/motif3struct_bin_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif3struct_bin_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif3struct_wei_cpp.cpp b/test/motif3struct_wei_cpp.cpp index 110b4f9..338ed31 100644 --- a/test/motif3struct_wei_cpp.cpp +++ b/test/motif3struct_wei_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(motif3struct_wei_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif4funct_bin_cpp.cpp b/test/motif4funct_bin_cpp.cpp index 3f2dd5a..3448a48 100644 --- a/test/motif4funct_bin_cpp.cpp +++ b/test/motif4funct_bin_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif4funct_bin_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif4funct_wei_cpp.cpp b/test/motif4funct_wei_cpp.cpp index 339c68f..6047dbc 100644 --- a/test/motif4funct_wei_cpp.cpp +++ b/test/motif4funct_wei_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(motif4funct_wei_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif4generate_cpp.cpp b/test/motif4generate_cpp.cpp index cd6f2a1..e821664 100644 --- a/test/motif4generate_cpp.cpp +++ b/test/motif4generate_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif4generate_cpp, args, , "Wrapper for C++ function.") { gsl_vector* ID; diff --git a/test/motif4struct_bin_cpp.cpp b/test/motif4struct_bin_cpp.cpp index ff88f1c..e83796e 100644 --- a/test/motif4struct_bin_cpp.cpp +++ b/test/motif4struct_bin_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(motif4struct_bin_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/motif4struct_wei_cpp.cpp b/test/motif4struct_wei_cpp.cpp index 532ea7b..2d2797a 100644 --- a/test/motif4struct_wei_cpp.cpp +++ b/test/motif4struct_wei_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(motif4struct_wei_cpp, args, , "Wrapper for C++ function.") { bct::set_motif_mode(bct::SPORNS); diff --git a/test/participation_coef_cpp.cpp b/test/participation_coef_cpp.cpp index 228a4eb..3f67eb6 100644 --- a/test/participation_coef_cpp.cpp +++ b/test/participation_coef_cpp.cpp @@ -1,8 +1,4 @@ -#include #include "bct_test.h" -#include -#include -#include DEFUN_DLD(participation_coef_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/randmio_dir_connected_cpp.cpp b/test/randmio_dir_connected_cpp.cpp index 73d2cff..38c6294 100644 --- a/test/randmio_dir_connected_cpp.cpp +++ b/test/randmio_dir_connected_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(randmio_dir_connected_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/randmio_dir_cpp.cpp b/test/randmio_dir_cpp.cpp index 90eeea6..a22fa32 100644 --- a/test/randmio_dir_cpp.cpp +++ b/test/randmio_dir_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(randmio_dir_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/randmio_und_connected_cpp.cpp b/test/randmio_und_connected_cpp.cpp index 16f03ac..d5fb807 100644 --- a/test/randmio_und_connected_cpp.cpp +++ b/test/randmio_und_connected_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(randmio_und_connected_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/randmio_und_cpp.cpp b/test/randmio_und_cpp.cpp index 6ae88ce..efaf375 100644 --- a/test/randmio_und_cpp.cpp +++ b/test/randmio_und_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(randmio_und_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/reachdist_cpp.cpp b/test/reachdist_cpp.cpp index d02da7c..1b9b0ed 100644 --- a/test/reachdist_cpp.cpp +++ b/test/reachdist_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(reachdist_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 1) { diff --git a/test/strengths_dir_cpp.cpp b/test/strengths_dir_cpp.cpp index 6c84d36..8e76feb 100644 --- a/test/strengths_dir_cpp.cpp +++ b/test/strengths_dir_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(strengths_dir) diff --git a/test/strengths_und_cpp.cpp b/test/strengths_und_cpp.cpp index d77b49d..126dd0f 100644 --- a/test/strengths_und_cpp.cpp +++ b/test/strengths_und_cpp.cpp @@ -1,4 +1,3 @@ -#include #include "bct_test.h" MATRIX_TO_VECTOR_FUNCTION(strengths_und) diff --git a/test/threshold_absolute_cpp.cpp b/test/threshold_absolute_cpp.cpp index fb93ccf..008ef33 100644 --- a/test/threshold_absolute_cpp.cpp +++ b/test/threshold_absolute_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(threshold_absolute_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/threshold_proportional_dir_cpp.cpp b/test/threshold_proportional_dir_cpp.cpp index bc8eea4..4fa8634 100644 --- a/test/threshold_proportional_dir_cpp.cpp +++ b/test/threshold_proportional_dir_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(threshold_proportional_dir_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/test/threshold_proportional_und_cpp.cpp b/test/threshold_proportional_und_cpp.cpp index e5372b4..7988990 100644 --- a/test/threshold_proportional_und_cpp.cpp +++ b/test/threshold_proportional_und_cpp.cpp @@ -1,7 +1,4 @@ -#include #include "bct_test.h" -#include -#include DEFUN_DLD(threshold_proportional_und_cpp, args, , "Wrapper for C++ function.") { if (args.length() != 2) { diff --git a/threshold_absolute.cpp b/threshold_absolute.cpp index a77e737..0ab3777 100644 --- a/threshold_absolute.cpp +++ b/threshold_absolute.cpp @@ -1,24 +1,23 @@ #include "bct.h" -#include /* * Applies an absolute weight threshold to a graph. All weights below this * threshold, as well as those on the main diagonal, are set to zero. */ -gsl_matrix* bct::threshold_absolute(const gsl_matrix* W, double thr) { +MATRIX_T* bct::threshold_absolute(const MATRIX_T* W, FP_T thr) { if (safe_mode) check_status(W, SQUARE, "threshold_absolute"); - gsl_matrix* W_thr = copy(W); + MATRIX_T* W_thr = copy(W); // W(1:size(W,1)+1:end)=0; for (int i = 0; i < (int)W_thr->size1; i++) { - gsl_matrix_set(W_thr, i, i, 0.0); + MATRIX_ID(set)(W_thr, i, i, 0.0); } // W(W -#include -#include + +#include "bct.h" /* * Preserves a given proportion of the strongest weights in a directed graph. * All other weights, as well as those on the main diagonal, are set to zero. */ -gsl_matrix* bct::threshold_proportional_dir(const gsl_matrix* W, double p) { +MATRIX_T* bct::threshold_proportional_dir(const MATRIX_T* W, FP_T p) { if (safe_mode) check_status(W, SQUARE | DIRECTED, "threshold_proportional_dir"); // n=size(W,1); int n = W->size1; // W(1:n+1:end)=0; - gsl_matrix* W_thr = copy(W); + MATRIX_T* W_thr = copy(W); for (int i = 0; i < (int)W_thr->size1; i++) { - gsl_matrix_set(W_thr, i, i, 0.0); + MATRIX_ID(set)(W_thr, i, i, 0.0); } // ind=find(W); - gsl_vector* ind = find(W_thr); + VECTOR_T* ind = find(W_thr); // E=sortrows([ind W(ind)], -2); - gsl_vector* W_thr_ind = ordinal_index(W_thr, ind); - gsl_vector* sort_ind; - gsl_vector* sort_W_thr_ind = sort(W_thr_ind, "descend", &sort_ind); - gsl_vector_free(W_thr_ind); - gsl_vector_free(sort_W_thr_ind); + VECTOR_T* W_thr_ind = ordinal_index(W_thr, ind); + VECTOR_T* sort_ind; + VECTOR_T* sort_W_thr_ind = sort(W_thr_ind, "descend", &sort_ind); + VECTOR_ID(free)(W_thr_ind); + VECTOR_ID(free)(sort_W_thr_ind); // en=round((n^2-n)*p); int en = (int)std::floor(n * (n - 1) * p + 0.5); // W(E(en+1:end,1))=0; for (int i = en; i < (int)sort_ind->size; i++) { - int index = gsl_vector_get(ind, gsl_vector_get(sort_ind, i)); + int index = VECTOR_ID(get)(ind, VECTOR_ID(get)(sort_ind, i)); ordinal_index_assign(W_thr, index, 0.0); } - gsl_vector_free(ind); - gsl_vector_free(sort_ind); + VECTOR_ID(free)(ind); + VECTOR_ID(free)(sort_ind); return W_thr; } @@ -47,41 +46,41 @@ gsl_matrix* bct::threshold_proportional_dir(const gsl_matrix* W, double p) { * Preserves a given proportion of the strongest weights in an undirected graph. * All other weights, as well as those on the main diagonal, are set to zero. */ -gsl_matrix* bct::threshold_proportional_und(const gsl_matrix* W, double p) { +MATRIX_T* bct::threshold_proportional_und(const MATRIX_T* W, FP_T p) { if (safe_mode) check_status(W, SQUARE | UNDIRECTED, "threshold_proportional_und"); // n=size(W,1); int n = W->size1; // W(1:n+1:end)=0; - gsl_matrix* W_thr = triu(W, 1); + MATRIX_T* W_thr = triu(W, 1); // ind=find(W); - gsl_vector* ind = find(W_thr); + VECTOR_T* ind = find(W_thr); // E=sortrows([ind W(ind)], -2); - gsl_vector* W_thr_ind = ordinal_index(W_thr, ind); - gsl_vector* sort_ind; - gsl_vector* sort_W_thr_ind = sort(W_thr_ind, "descend", &sort_ind); - gsl_vector_free(W_thr_ind); - gsl_vector_free(sort_W_thr_ind); + VECTOR_T* W_thr_ind = ordinal_index(W_thr, ind); + VECTOR_T* sort_ind; + VECTOR_T* sort_W_thr_ind = sort(W_thr_ind, "descend", &sort_ind); + VECTOR_ID(free)(W_thr_ind); + VECTOR_ID(free)(sort_W_thr_ind); // en=round((n^2-n)*p); int en = (int)std::floor(0.5 * n * (n - 1) * p + 0.5); // W(E(en+1:end,1))=0; for (int i = en; i < (int)sort_ind->size; i++) { - int index = gsl_vector_get(ind, gsl_vector_get(sort_ind, i)); + int index = VECTOR_ID(get)(ind, VECTOR_ID(get)(sort_ind, i)); ordinal_index_assign(W_thr, index, 0.0); } for (int i = 0; i < (int)W_thr->size1; i++) { for (int j = i + 1; j < (int)W_thr->size2; j++) { - double value = gsl_matrix_get(W_thr, i, j); - gsl_matrix_set(W_thr, j, i, value); + FP_T value = MATRIX_ID(get)(W_thr, i, j); + MATRIX_ID(set)(W_thr, j, i, value); } } - gsl_vector_free(ind); - gsl_vector_free(sort_ind); + VECTOR_ID(free)(ind); + VECTOR_ID(free)(sort_ind); return W_thr; } diff --git a/utility.cpp b/utility.cpp index 7e77871..3d3bd47 100644 --- a/utility.cpp +++ b/utility.cpp @@ -1,11 +1,7 @@ -#include "bct.h" #include -#include -#include -#include #include -#include -#include + +#include "bct.h" /* * Catches GSL errors and throws BCT exceptions. @@ -19,12 +15,12 @@ void bct::gsl_error_handler(const char* reason, const char* file, int line, int /* * Overloaded convenience function for freeing GSL vectors and matrices. */ -void bct::gsl_free(gsl_vector* v) { gsl_vector_free(v); } -void bct::gsl_free(gsl_matrix* m) { gsl_matrix_free(m); } -void bct::gsl_free(std::vector& m) { +void bct::gsl_free(VECTOR_T* v) { VECTOR_ID(free)(v); } +void bct::gsl_free(MATRIX_T* m) { MATRIX_ID(free)(m); } +void bct::gsl_free(std::vector& m) { for (int i = 0; i < (int)m.size(); i++) { if (m[i] != NULL) { - gsl_matrix_free(m[i]); + MATRIX_ID(free)(m[i]); m[i] = NULL; } } @@ -41,23 +37,23 @@ void bct::init() { /* * Returns the number of edges in a directed graph. */ -int bct::number_of_edges_dir(const gsl_matrix* m) { +int bct::number_of_edges_dir(const MATRIX_T* m) { return nnz(m); } /* * Returns the number of edges in an undirected graph. */ -int bct::number_of_edges_und(const gsl_matrix* m) { - gsl_matrix* triu_m = triu(m); +int bct::number_of_edges_und(const MATRIX_T* m) { + MATRIX_T* triu_m = triu(m); int ret = nnz(triu_m); - gsl_matrix_free(triu_m); + MATRIX_ID(free)(triu_m); return ret; } /* * Returns the number of nodes in a graph. */ -int bct::number_of_nodes(const gsl_matrix* m) { +int bct::number_of_nodes(const MATRIX_T* m) { return (int)m->size1; }