Code consolidation

[Aaron Jackson]

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly different.
For example:

double
Chisqrd1(double *params, double *weight) { // CHANGE
int i;
double deltay, chiSqrd;
xy_t *data;

chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netCarriers(params, data->x); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
}

double
Chisqrd2(dopant_t *dopants, double *weight, double *Ef, double Eg) { //
CHANGE
int i;
double deltay, chiSqrd;
xy_t *data;

chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netIonized(dopants, data->x, Ef[i]); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
}

I was wondering if there are common ways to cut down on this type of
duplication without adding too much to the overall complexity. Does
anybody have any suggestions? Thanks.

Aaron

[Chris McDonald]

Aaron Jackson <no**@nospam.com> writes:

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly different.
For example: double
Chisqrd1(double *params, double *weight) { // CHANGE
int i;
double deltay, chiSqrd;
xy_t *data; chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netCarriers(params, data->x); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
} double
Chisqrd2(dopant_t *dopants, double *weight, double *Ef, double Eg) { //
CHANGE
int i;
double deltay, chiSqrd;
xy_t *data; chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netIonized(dopants, data->x, Ef[i]); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
} I was wondering if there are common ways to cut down on this type of
duplication without adding too much to the overall complexity. Does
anybody have any suggestions? Thanks.

I suggest making all of your functions, netXXXX, to be of the same
type signature (they all receive the same parameter types (even if they
don't use them all), and all return the same type), and then passing the
required netXXXX function as a parameter to a single Chisqrd function.

--
Chris.

[Zara]

Aaron Jackson wrote:

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly different.

(...)
try macros:

#define CHI(funDeclare,specifics)\
double funDeclare{\
int i;\
double deltay,chiSqrd;\
xy_t *data;\
\
chiSqrd = 0.0;\
data = dataList;\
for (i = 0; data != NULL; i++) {\
deltay = data->y - specifics;\
chiSqrd += weight[i] * deltay * deltay;
data = data->next;\
}\
return(chiSqrd);\
}

CHI(
Chisqrd1(double *params, double *weight),
netCarriers(params, data->x)
)

CHI(
Chisqrd2(dopant_t *dopants, double *weight, double *Ef, double Eg),
netIonized(dopants,data->x, Ef[i])
)

I don't like it at all, bit it is a valid solution

Have you read about templates in C++? They could have been a nicer solution!

[GMM50]

Consider putting all the similay functions in their own files.
Then they're all in front of you and then decisions perhaps will become
clearer.

george

[Malcolm]

"Aaron Jackson" <no**@nospam.com> wrote

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly different.
For example:

double
Chisqrd1(double *params, double *weight) { // CHANGE
int i;
double deltay, chiSqrd;
xy_t *data;

chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netCarriers(params, data->x); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
}

double
Chisqrd2(dopant_t *dopants, double *weight, double *Ef, double Eg) { //
CHANGE
int i;
double deltay, chiSqrd;
xy_t *data;

chiSqrd = 0.0;
data = dataList;
for (i = 0; data != NULL; i++) {
deltay = data->y - netIonized(dopants, data->x, Ef[i]); // CHANGE
chiSqrd += weight[i] * deltay * deltay;
data = data->next;
}
return(chiSqrd);
}

I was wondering if there are common ways to cut down on this type of
duplication without adding too much to the overall complexity. Does
anybody have any suggestions? Thanks.

The chi-squared test is inherently a comparision between two counts.
So write the function

double chi_squared(double *observed, double *expected, int N)

Now you data may not come in flat arrays of doubles. Not to worry, simply
write a little bit of "glue" code to transform it.
It is most unlikely that your chi-squared test is time critical. If it is,
then you do need to hard code some aspects of the test, to avoid this
overhead. Software engineering is often about compromises.

[E. Robert Tisdale]

Aaron Jackson wrote:

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly different.
For example: expand chisqrd.c

#include <stdlib.h>

typedef struct dopant_t dopant_t;
typedef struct xy_t xy_t;
struct xy_t {
double x;
double y;
xy_t* next;
};

extern
xy_t* dataList;

double
netCarriers(const double[], double);

double
Chisqrd1(const double params[], const double weight[]) {
// CHANGE
xy_t* data = dataList;
double chiSqrd = 0.0;
for (size_t i = 0; NULL != data; ++i) {
double deltay = data->y - netCarriers(params, data->x);
// CHANGE
chiSqrd += weight[i]*deltay*deltay;
data = data->next;
}
return chiSqrd;
}

double
netIonized(const dopant_t*, double, double);

double
Chisqrd2(const dopant_t* dopants, const double weight[],
const double Ef[], const double Eg[]) {
// CHANGE

xy_t* data = dataList;
double chiSqrd = 0.0;
for (size_t i = 0; NULL != data; ++i) {
double
deltay = data->y - netIonized(dopants, data->x, Ef[i]);
// CHANGE
chiSqrd += weight[i]*deltay*deltay;
data = data->next;
}
return chiSqrd;
}

[Martin Ambuhl]

E. Robert Tisdale wrote:

Aaron Jackson wrote:

I am in the process of writing my first large scale program and I find
myself in the position of writing several copies of functions that do
the same thing, with mostly the same code, but only slightly
different. For example:

> expand chisqrd.c

This is unbelievable. We try hard to make people understand that in
posting to newsgroups they should use spaces rather than tabs, and
Trollsdale purposely turns spaces into tabs.

[jxh]

Martin Ambuhl wrote:

E. Robert Tisdale wrote:

> expand chisqrd.c

This is unbelievable. We try hard to make people understand that in
posting to newsgroups they should use spaces rather than tabs, and
Trollsdale purposely turns spaces into tabs.

Well, expand actually turns tabs into spaces.

-- James

[E. Robert Tisdale]

jxh wrote:

Well, expand actually turns tabs into spaces.

unexpand turns spaces back into tabs.