refactored elementwise univariate to resuse already computed values

Author: dance858

include/expr.h

@@ -7,6 +7,7 @@
 #include <stddef.h>
 
 #define JAC_IDXS_NOT_SET -1
+#define NOT_A_VARIABLE -1
 
 /* Function pointer types */
 struct expr;

src/bivariate/multiply.c

@@ -32,7 +32,7 @@ static void jacobian_init(expr *node)
         node->left->jacobian_init(node->left);
     }
 
-    if (node->right->var_id != -1)
+    if (node->right->var_id != NOT_A_VARIABLE)
     {
         node->right->jacobian_init(node->right);
     }

src/bivariate/quad_over_lin.c

@@ -36,7 +36,7 @@ static void jacobian_init(expr *node)
     expr *y = node->right;
 
     /* if left node is a variable */
-    if (x->var_id != -1)
+    if (x->var_id != NOT_A_VARIABLE)
     {
         node->jacobian = new_csr_matrix(1, node->n_vars, x->d1 + 1);
         node->jacobian->p[0] = 0;
@@ -110,7 +110,7 @@ static void eval_jacobian(expr *node)
     expr *y = node->right;
 
     /* if x is a variable */
-    if (x->var_id != -1)
+    if (x->var_id != NOT_A_VARIABLE)
     {
         /* if x has lower idx than y*/
         if (x->var_id < y->var_id)

src/elementwise_univariate/common.c

@@ -8,7 +8,7 @@ void jacobian_init_elementwise(expr *node)
     expr *child = node->left;
 
     /* if the variable is a child */
-    if (child->var_id != -1)
+    if (child->var_id != NOT_A_VARIABLE)
     {
         node->jacobian = new_csr_matrix(node->size, node->n_vars, node->size);
         for (int j = 0; j < node->size; j++)
@@ -18,7 +18,7 @@ void jacobian_init_elementwise(expr *node)
         }
         node->jacobian->p[node->size] = node->size;
     }
-    /* otherwise it should be a linear operator */
+    /* otherwise it will be a linear operator */
     else
     {
         node->jacobian = new_csr_matrix(child->jacobian->m, child->jacobian->n,
@@ -31,13 +31,13 @@ void eval_jacobian_elementwise(expr *node)
 {
     expr *child = node->left;
 
-    if (child->var_id != -1)
+    if (child->var_id != NOT_A_VARIABLE)
     {
         node->local_jacobian(node, node->jacobian->x);
     }
     else
     {
-        /* Child must be a linear operator */
+        /* Child will be a linear operator */
         linear_op_expr *lin_child = (linear_op_expr *) child;
         node->local_jacobian(node, node->dwork);
         diag_csr_mult(node->dwork, lin_child->A_csr, node->jacobian);
@@ -51,7 +51,7 @@ void wsum_hess_init_elementwise(expr *node)
     int i;
 
     /* if the variable is a child*/
-    if (id != -1)
+    if (id != NOT_A_VARIABLE)
     {
         node->wsum_hess = new_csr_matrix(node->n_vars, node->n_vars, node->size);
 
@@ -78,13 +78,13 @@ void eval_wsum_hess_elementwise(expr *node, const double *w)
 {
     expr *child = node->left;
 
-    if (child->var_id != -1)
+    if (child->var_id != NOT_A_VARIABLE)
     {
         node->local_wsum_hess(node, node->wsum_hess->x, w);
     }
     else
     {
-        /* Child must be a linear operator */
+        /* Child will be a linear operator */
         linear_op_expr *lin_child = (linear_op_expr *) child;
         node->local_wsum_hess(node, node->dwork, w);
         ATDA_values(lin_child->A_csc, node->dwork, node->wsum_hess);

src/elementwise_univariate/exp.c

@@ -21,10 +21,9 @@ static void local_jacobian(expr *node, double *vals)
 
 static void local_wsum_hess(expr *node, double *out, const double *w)
 {
-    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        out[j] = w[j] * exp(x[j]);
+        out[j] = w[j] * node->value[j];
     }
 }
 

src/elementwise_univariate/hyperbolic.c

@@ -23,10 +23,9 @@ static void sinh_local_jacobian(expr *node, double *vals)
 
 static void sinh_local_wsum_hess(expr *node, double *out, const double *w)
 {
-    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        out[j] = w[j] * sinh(x[j]);
+        out[j] = w[j] * node->value[j];
     }
 }
 
@@ -51,10 +50,10 @@ static void tanh_forward(expr *node, const double *u)
 
 static void tanh_local_jacobian(expr *node, double *vals)
 {
-    expr *child = node->left;
+    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        double c = cosh(child->value[j]);
+        double c = cosh(x[j]);
         vals[j] = 1.0 / (c * c);
     }
 }
@@ -65,7 +64,7 @@ static void tanh_local_wsum_hess(expr *node, double *out, const double *w)
     for (int j = 0; j < node->size; j++)
     {
         double c = cosh(x[j]);
-        out[j] = w[j] * (-2.0 * tanh(x[j]) / (c * c));
+        out[j] = w[j] * (-2.0 * node->value[j] / (c * c));
     }
 }
 

src/elementwise_univariate/logistic.c

@@ -42,10 +42,9 @@ static void local_jacobian(expr *node, double *vals)
 
 static void local_wsum_hess(expr *node, double *out, const double *w)
 {
-    double *x = node->left->value;
     double *sigmas;
 
-    if (node->left->var_id != -1)
+    if (node->left->var_id != NOT_A_VARIABLE)
     {
         sigmas = node->jacobian->x;
     }
@@ -54,23 +53,8 @@ static void local_wsum_hess(expr *node, double *out, const double *w)
         sigmas = node->dwork;
     }
 
-    // double sigma;
-
     for (int j = 0; j < node->size; j++)
     {
-        /*
-        if (x[j] >= 0)
-        {
-            sigma = 1.0 / (1.0 + exp(-x[j]));
-        }
-        else
-        {
-            double exp_x = exp(x[j]);
-            sigma = exp_x / (1.0 + exp_x);
-        }
-
-        out[j] = w[j] * sigma * (1.0 - sigma);
-        */
         out[j] = sigmas[j] * (1.0 - sigmas[j]) * w[j];
     }
 }

src/elementwise_univariate/power.c

@@ -45,10 +45,7 @@ expr *new_power(expr *child, int p)
     /* Allocate the type-specific struct */
     power_expr *pnode = (power_expr *) calloc(1, sizeof(power_expr));
     expr *node = &pnode->base;
-
-    /* Initialize base elementwise fields */
     init_elementwise(node, child);
-
     node->forward = forward;
     node->local_jacobian = local_jacobian;
     node->local_wsum_hess = local_wsum_hess;

src/elementwise_univariate/trig.c

@@ -13,20 +13,18 @@ static void sin_forward(expr *node, const double *u)
 
 static void sin_local_jacobian(expr *node, double *vals)
 {
-    expr *child = node->left;
+    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        vals[j] = cos(child->value[j]);
+        vals[j] = cos(x[j]);
     }
 }
 
 static void sin_local_wsum_hess(expr *node, double *out, const double *w)
 {
-    double *x = node->left->value;
-
     for (int j = 0; j < node->size; j++)
     {
-        out[j] = -w[j] * sin(x[j]);
+        out[j] = -w[j] * node->value[j];
     }
 }
 
@@ -51,20 +49,18 @@ static void cos_forward(expr *node, const double *u)
 
 static void cos_local_jacobian(expr *node, double *vals)
 {
-    expr *child = node->left;
+    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        vals[j] = -sin(child->value[j]);
+        vals[j] = -sin(x[j]);
     }
 }
 
 static void cos_local_wsum_hess(expr *node, double *out, const double *w)
 {
-    double *x = node->left->value;
-
     for (int j = 0; j < node->size; j++)
     {
-        out[j] = -w[j] * cos(x[j]);
+        out[j] = -w[j] * node->value[j];
     }
 }
 
@@ -104,7 +100,7 @@ static void tan_local_wsum_hess(expr *node, double *out, const double *w)
     for (int j = 0; j < node->size; j++)
     {
         double c = cos(x[j]);
-        out[j] = 2.0 * w[j] * tan(x[j]) / (c * c);
+        out[j] = 2.0 * w[j] * node->value[j] / (c * c);
     }
 }
 

src/elementwise_univariate/xexp.c

@@ -16,10 +16,10 @@ static void forward(expr *node, const double *u)
 
 static void local_jacobian(expr *node, double *vals)
 {
-    expr *child = node->left;
+    double *x = node->left->value;
     for (int j = 0; j < node->size; j++)
     {
-        vals[j] = (1.0 + child->value[j]) * exp(child->value[j]);
+        vals[j] = (1.0 + x[j]) * exp(x[j]);
     }
 }