static inline A0_n asin(const A0_n a0_n)
{
const A0 a0 = { a0_n };
A0 sign, x;
x = nt2::abs(a0);
sign = bitofsign(a0);
const bA0 x_smaller_1e_4 = lt(x, single_constant<A0, 0x38d1b717>()); //1.0e-4f;
const bA0 x_larger_05 = gt(x, Half<A0>());
const bA0 x_else = logical_or(x_smaller_1e_4, x_larger_05);
A0 a = if_else_zero(x_smaller_1e_4, x);
const A0 b = if_else_zero(x_larger_05, Half<A0>()*oneminus(x));
A0 z = b_or(b_or(if_zero_else(x_else, sqr(x)), a), b);
x = if_zero_else(x_else, x);
a = if_else_zero(x_larger_05, sqrt(z));
x = b_or(a, x);
A0 z1 = madd(z, single_constant<A0, 0x3d2cb352>(), single_constant<A0, 0x3cc617e3>());
z1 = madd(z1, z, single_constant<A0, 0x3d3a3ec7>());
z1 = madd(z1, z, single_constant<A0, 0x3d9980f6>());
z1 = madd(z1, z, single_constant<A0, 0x3e2aaae4>());
z1 = madd(z1, z*x, x);
z = select(x_smaller_1e_4, z, z1);
z1 = z+z;
z1 = Pio_2<A0>()-z1;
z = select(x_larger_05, z1, z);
return b_xor(z, sign);
}
static inline A0 log2(const A0& a0)
{
A0 x, fe, x2, y;
kernel_log(a0, fe, x, x2, y);
y = madd(Mhalf<A0>(),x2, y);
// multiply log of fraction by log2(e)
A0 z = madd(x,single_constant<A0, 0x3ee2a8ed>(),mul(y,single_constant<A0, 0x3ee2a8ed>()));// 0.44269504088896340735992
A0 z1 = ((z+y)+x)+fe;
A0 y1 = a0-rec(abs(a0)); // trick to reduce selection testing
return seladd(is_inf(y1),if_nan_else(logical_or(is_ltz(a0), is_nan(a0)), z1),y1);
}
static inline A0 log(const A0& a0)
{
A0 x, fe, x2, y;
kernel_log(a0, fe, x, x2, y);
y = madd(fe, single_constant<A0, 0xb95e8083>(), y);
y = madd(Mhalf<A0>(), x2, y);
A0 z = x + y;
A0 y1 = a0-rec(abs(a0));// trick to reduce selection testing
A0 y2 = madd(single_constant<A0, 0x3f318000>(), fe, z);
y2 = if_nan_else(logical_or(is_ltz(a0), is_nan(a0)), y2);
return seladd(is_inf(y1), y2, y1);
}
static inline A0 log10(const A0& a0)
{
A0 x, fe, x2, y;
kernel_log(a0, fe, x, x2, y);
y = amul(y, -Half<A0>(), x2);
// multiply log of fraction by log10(e) and base 2 exponent by log10(2)
A0 z = mul(x+y, single_constant<A0, 0x3a37b152>());//7.00731903251827651129E-4f // log10(e)lo
z = amul(z, y, single_constant<A0, 0x3ede0000>()); //4.3359375E-1f // log10(e)hi
z = amul(z, x, single_constant<A0, 0x3ede0000>());
z = amul(z, fe, single_constant<A0, 0x39826a14>());//3.0078125E-1f // log10(2)hi
z = amul(z, fe, single_constant<A0, 0x3e9a0000>());//2.48745663981195213739E-4f // log10(2)lo
A0 y1 = a0-rec(abs(a0)); // trick to reduce selection testing perhaps bad TODO
return seladd(is_inf(y1), if_nan_else(logical_or(is_ltz(a0), is_nan(a0)), z),y1);
}
/*
* Counts occurrences of three-node functional motifs in a weighted graph.
* Returns intensity and (optionally) coherence and motif counts.
*/
MATRIX_T* BCT_NAMESPACE::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
VECTOR_T* ID3;
VECTOR_T* N3;
MATRIX_T* M3 = motif3generate(&ID3, &N3);
// n=length(W);
int n = length(W);
// I=zeros(13,n);
MATRIX_T* I = zeros(13, n);
// Q=zeros(13,n);
if (Q != NULL) {
*Q = zeros(13, n);
}
// F=zeros(13,n);
if (F != NULL) {
*F = zeros(13, n);
}
// A=1*(W~=0);
MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0);
// As=A|A.';
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)];
VECTOR_T* V1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V1, As, u);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V1, i, 0.0);
}
// for 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)VECTOR_ID(get)(find_V1, i_find_V1);
// V2=[false(1,u) As(v1,u+1:n)];
VECTOR_T* V2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2, As, v1);
for (int i = 0; i <= u; i++) {
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;
VECTOR_T* V2_1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2_1, As, u);
for (int i = 0; i <= v1; i++) {
VECTOR_ID(set)(V2_1, i, 0.0);
}
VECTOR_T* V2_2 = V2;
V2 = logical_or(V2_1, V2_2);
VECTOR_ID(free)(V2_1);
VECTOR_ID(free)(V2_2);
// for 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)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 };
VECTOR_T* w = VECTOR_ID(alloc)(6);
for (int i = 0; i < 6; 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)];
MATRIX_T* a = MATRIX_ID(alloc)(6, 1);
for (int i = 0; i < 6; i++) {
MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i]));
}
// ind=(M3*a)==N3;
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);
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++) {
VECTOR_ID(view) M_row_i = MATRIX_ID(row)(M, i);
VECTOR_ID(mul)(&M_row_i.vector, w);
}
// id=ID3(ind);
VECTOR_T* id = logical_index(ID3, ind);
VECTOR_ID(add_constant)(id, -1.0);
// l=N3(ind);
VECTOR_T* l = logical_index(N3, ind);
// x=sum(M,2)./l;
VECTOR_T* x = sum(M, 2);
VECTOR_ID(div)(x, l);
// M(M==0)=1;
MATRIX_T* M_eq_0 = compare_elements(M, fp_equal, 0.0);
logical_index_assign(M, M_eq_0, 1.0);
MATRIX_ID(free)(M_eq_0);
// i=prod(M,2).^(1./l);
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;
VECTOR_T* q = copy(i);
VECTOR_ID(div)(q, x);
VECTOR_ID(free)(x);
// [idu j]=unique(id);
VECTOR_T* j;
VECTOR_T* idu = unique(id, "last", &j);
VECTOR_ID(free)(id);
// j=[0;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);
VECTOR_T* i2 = zeros_vector(mu);
// q2=i2; f2=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)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)));
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);
VECTOR_ID(set)(f2, h, (FP_T)(j_h_add_1 - j_h));
}
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];
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);
}
if (F != NULL) {
F_idx = ordinal_index(*F, idu, &IQF_cols_vv.vector);
}
for (int j = 0; j < 3; j++) {
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) {
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) {
VECTOR_ID(view) F_idx_col_j = MATRIX_ID(column)(F_idx, j);
VECTOR_ID(add)(&F_idx_col_j.vector, f2);
}
}
VECTOR_ID(free)(i2);
VECTOR_ID(free)(q2);
VECTOR_ID(free)(f2);
ordinal_index_assign(I, idu, &IQF_cols_vv.vector, I_idx);
MATRIX_ID(free)(I_idx);
if (Q != NULL) {
ordinal_index_assign(*Q, idu, &IQF_cols_vv.vector, Q_idx);
MATRIX_ID(free)(Q_idx);
}
if (F != NULL) {
ordinal_index_assign(*F, idu, &IQF_cols_vv.vector, F_idx);
MATRIX_ID(free)(F_idx);
}
VECTOR_ID(free)(idu);
}
VECTOR_ID(free)(w);
VECTOR_ID(free)(ind);
}
VECTOR_ID(free)(find_V2);
}
VECTOR_ID(free)(V2);
}
VECTOR_ID(free)(find_V1);
}
VECTOR_ID(free)(V1);
}
VECTOR_ID(free)(ID3);
VECTOR_ID(free)(N3);
MATRIX_ID(free)(M3);
MATRIX_ID(free)(A);
MATRIX_ID(free)(As);
return I;
}
void Parser::executeAction(int production) try {
if (d_token__ != _UNDETERMINED_)
pushToken__(d_token__); // save an already available token
// $insert defaultactionreturn
// save default non-nested block $$
if (int size = s_productionInfo[production].d_size)
d_val__ = d_vsp__[1 - size];
switch (production) {
// $insert actioncases
case 1:
#line 43 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>();
res = d_val__.get<Tag__::basic>();
} break;
case 2:
#line 51 "parser.yy"
{
d_val__.get<Tag__::basic>() = add(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 3:
#line 54 "parser.yy"
{
d_val__.get<Tag__::basic>() = sub(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 4:
#line 57 "parser.yy"
{
d_val__.get<Tag__::basic>() = mul(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 5:
#line 60 "parser.yy"
{
d_val__.get<Tag__::basic>() = div(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 6:
#line 63 "parser.yy"
{
auto tup = parse_implicit_mul(d_vsp__[-2].data<Tag__::string>());
if (neq(*std::get<1>(tup), *one)) {
d_val__.get<Tag__::basic>() = mul(
std::get<0>(tup),
pow(std::get<1>(tup), d_vsp__[0].data<Tag__::basic>()));
} else {
d_val__.get<Tag__::basic>()
= pow(std::get<0>(tup), d_vsp__[0].data<Tag__::basic>());
}
} break;
case 7:
#line 73 "parser.yy"
{
d_val__.get<Tag__::basic>() = pow(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 8:
#line 76 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Lt(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 9:
#line 79 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Gt(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 10:
#line 82 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Le(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 11:
#line 85 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Ge(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 12:
#line 88 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Eq(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 13:
#line 91 "parser.yy"
{
set_boolean s;
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_or(s));
} break;
case 14:
#line 99 "parser.yy"
{
set_boolean s;
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_and(s));
} break;
case 15:
#line 107 "parser.yy"
{
vec_boolean s;
s.push_back(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.push_back(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_xor(s));
} break;
case 16:
#line 115 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[-1].data<Tag__::basic>();
} break;
case 17:
#line 118 "parser.yy"
{
d_val__.get<Tag__::basic>() = neg(d_vsp__[0].data<Tag__::basic>());
} break;
case 18:
#line 121 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
logical_not(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>())));
} break;
case 19:
#line 124 "parser.yy"
{
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(d_vsp__[0].data<Tag__::basic>());
} break;
case 20:
#line 129 "parser.yy"
{
d_val__.get<Tag__::basic>()
= parse_identifier(d_vsp__[0].data<Tag__::string>());
} break;
case 21:
#line 134 "parser.yy"
{
auto tup = parse_implicit_mul(d_vsp__[0].data<Tag__::string>());
d_val__.get<Tag__::basic>()
= mul(std::get<0>(tup), std::get<1>(tup));
} break;
case 22:
#line 140 "parser.yy"
{
d_val__.get<Tag__::basic>()
= parse_numeric(d_vsp__[0].data<Tag__::string>());
} break;
case 23:
#line 145 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>();
} break;
case 24:
#line 152 "parser.yy"
{
d_val__.get<Tag__::basic>()
= functionify(d_vsp__[-3].data<Tag__::string>(),
d_vsp__[-1].data<Tag__::basic_vec>());
} break;
case 25:
#line 160 "parser.yy"
{
d_val__.get<Tag__::basic_vec>()
= d_vsp__[-2].data<Tag__::basic_vec>();
d_val__.get<Tag__::basic_vec>().push_back(
d_vsp__[0].data<Tag__::basic>());
} break;
case 26:
#line 166 "parser.yy"
{
d_val__.get<Tag__::basic_vec>()
= vec_basic(1, d_vsp__[0].data<Tag__::basic>());
} break;
}
} catch (std::exception const &exc) {
exceptionHandler__(exc);
}
/*
* Counts occurrences of four-node functional motifs in a binary graph.
*/
VECTOR_T* BCT_NAMESPACE::motif4funct_bin(const MATRIX_T* W, MATRIX_T** F) {
if (safe_mode) check_status(W, SQUARE | BINARY, "motif4funct_bin");
// load motif34lib M4 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);
VECTOR_T* f = zeros_vector(199);
// F=zeros(199,n);
if (F != NULL) {
*F = zeros(199, n);
}
// A=1*(W~=0);
MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0);
// As=A|A.';
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)];
VECTOR_T* V1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V1, As, u);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V1, i, 0.0);
}
// for 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)VECTOR_ID(get)(find_V1, i_find_V1);
// V2=[false(1,u) As(v1,u+1:n)];
VECTOR_T* V2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2, As, v1);
for (int i = 0; i <= u; i++) {
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)]);
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++) {
VECTOR_ID(set)(V2_2, i, 0.0);
}
V2 = logical_or(V2_1, V2_2);
VECTOR_ID(free)(V2_1);
VECTOR_ID(free)(V2_2);
// for 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)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)]);
VECTOR_T* V3 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3, As, v2);
for (int i = 0; i <= u; i++) {
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)]);
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++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, 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 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3_2, As, u);
for (int i = 0; i <= vz; i++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, V3_2);
VECTOR_ID(free)(V3_1);
VECTOR_ID(free)(V3_2);
// for 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)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 };
MATRIX_T* a = MATRIX_ID(alloc)(12, 1);
for (int i = 0; i < 12; i++) {
MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, A_rows[i], A_cols[i]));
}
// ind=(M4*a)==N4;
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);
VECTOR_T* id = logical_index(ID4, ind);
VECTOR_ID(free)(ind);
if (id != NULL) {
VECTOR_ID(add_constant)(id, -1.0);
// [idu j]=unique(id);
VECTOR_T* j;
VECTOR_T* idu = unique(id, "last", &j);
VECTOR_ID(free)(id);
// j=[0;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);
VECTOR_T* f2 = zeros_vector(mu);
// for h=1:mu
for (int h = 0; h < mu; h++) {
// f2(h)=j(h+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);
}
VECTOR_ID(free)(j);
// f(idu)=f(idu)+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);
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) {
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++) {
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);
MATRIX_ID(free)(F_idx);
}
VECTOR_ID(free)(idu);
VECTOR_ID(free)(f2);
}
}
VECTOR_ID(free)(find_V3);
}
VECTOR_ID(free)(V3);
}
VECTOR_ID(free)(find_V2);
}
VECTOR_ID(free)(V2);
}
VECTOR_ID(free)(find_V1);
}
VECTOR_ID(free)(V1);
}
VECTOR_ID(free)(ID4);
VECTOR_ID(free)(N4);
MATRIX_ID(free)(M4);
MATRIX_ID(free)(A);
MATRIX_ID(free)(As);
return f;
}
/*
* Counts occurrences of three-node structural motifs in a binary graph.
*/
VECTOR_T* BCT_NAMESPACE::motif3struct_bin(const MATRIX_T* A, MATRIX_T** F) {
if (safe_mode) check_status(A, SQUARE | BINARY, "motif3struct_bin");
// load motif34lib M3n 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(13, n);
}
// f=zeros(13,1);
VECTOR_T* f = zeros_vector(13);
// As=A|A.';
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)];
VECTOR_T* V1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V1, As, u);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V1, i, 0.0);
}
// for 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)VECTOR_ID(get)(find_V1, i_find_V1);
// V2=[false(1,u) As(v1,u+1:n)];
VECTOR_T* V2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2, As, v1);
for (int i = 0; i <= u; i++) {
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;
VECTOR_T* V2_1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2_1, As, u);
for (int i = 0; i <= v1; i++) {
VECTOR_ID(set)(V2_1, i, 0.0);
}
VECTOR_T* V2_2 = V2;
V2 = logical_or(V2_1, V2_2);
VECTOR_ID(free)(V2_1);
VECTOR_ID(free)(V2_2);
// for 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)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 };
VECTOR_T* s = VECTOR_ID(alloc)(6);
for (int i = 0; i < 6; 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++) {
VECTOR_ID(view) M3_row_i_M3 = MATRIX_ID(row)(M3, i_M3);
if (compare_vectors(s, &M3_row_i_M3.vector) == 0) {
break;
}
}
VECTOR_ID(free)(s);
if (i_M3 < (int)M3->size1) {
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++) {
MATRIX_ID(set)(*F, ind, F_cols[i], MATRIX_ID(get)(*F, ind, F_cols[i]) + 1.0);
}
}
// f(ind)=f(ind)+1;
VECTOR_ID(set)(f, ind, VECTOR_ID(get)(f, ind) + 1.0);
}
}
VECTOR_ID(free)(find_V2);
}
VECTOR_ID(free)(V2);
}
VECTOR_ID(free)(find_V1);
}
VECTOR_ID(free)(V1);
}
VECTOR_ID(free)(ID3);
MATRIX_ID(free)(M3);
MATRIX_ID(free)(As);
return f;
}
S operator ()(const LExpr & l, const RExpr & r) const
{
const S & temp = evaluate(l);
return temp? temp : logical_or(temp, evaluate(r));
}
/*
* Counts occurrences of four-node structural motifs in a binary graph.
*/
VECTOR_T* BCT_NAMESPACE::motif4struct_bin(const MATRIX_T* A, MATRIX_T** F) {
if (safe_mode) check_status(A, SQUARE | BINARY, "motif4struct_bin");
// load motif34lib M4n 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(199, n);
}
// f=zeros(199,1);
VECTOR_T* f = zeros_vector(199);
// As=A|A.';
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)];
VECTOR_T* V1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V1, As, u);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V1, i, 0.0);
}
// for 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)VECTOR_ID(get)(find_V1, i_find_V1);
// V2=[false(1,u) As(v1,u+1:n)];
VECTOR_T* V2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2, As, v1);
for (int i = 0; i <= u; i++) {
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)]);
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++) {
VECTOR_ID(set)(V2_2, i, 0.0);
}
V2 = logical_or(V2_1, V2_2);
VECTOR_ID(free)(V2_1);
VECTOR_ID(free)(V2_2);
// for 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)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)]);
VECTOR_T* V3 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3, As, v2);
for (int i = 0; i <= u; i++) {
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)]);
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++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, 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 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3_2, As, u);
for (int i = 0; i <= vz; i++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, V3_2);
VECTOR_ID(free)(V3_1);
VECTOR_ID(free)(V3_2);
// for 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)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 };
VECTOR_T* s = VECTOR_ID(alloc)(12);
for (int i = 0; i < 12; 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++) {
VECTOR_ID(view) M4_row_i_M4 = MATRIX_ID(row)(M4, i_M4);
if (compare_vectors(s, &M4_row_i_M4.vector) == 0) {
break;
}
}
VECTOR_ID(free)(s);
if (i_M4 < (int)M4->size1) {
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++) {
MATRIX_ID(set)(*F, ind, F_cols[i], MATRIX_ID(get)(*F, ind, F_cols[i]) + 1.0);
}
}
// f(ind)=f(ind)+1;
VECTOR_ID(set)(f, ind, VECTOR_ID(get)(f, ind) + 1.0);
}
}
VECTOR_ID(free)(find_V3);
}
VECTOR_ID(free)(V3);
}
VECTOR_ID(free)(find_V2);
}
VECTOR_ID(free)(V2);
}
VECTOR_ID(free)(find_V1);
}
VECTOR_ID(free)(V1);
}
VECTOR_ID(free)(ID4);
MATRIX_ID(free)(M4);
MATRIX_ID(free)(As);
return f;
}
