Reduce function in c - c

Question

So I'm trying learn how to reduce my lines of code, and I came across one of my "larger" functions I wanted to look at.
int DTWDistance(int* x, int xsize, int* y, int ysize){
const double LARGE_VALUE = 1e30;
const int min_window = abs(xsize - ysize);
int i, j, minj, maxj, window;
double dist, min;
double **distances = malloc((xsize + 1) * sizeof(double *));
for(i = 0; i < xsize + 1; ++i)
distances[i] = malloc((ysize + 1) * sizeof(double));
window = 1*ysize;
if(xsize > ysize)
window = 1*xsize;
if(window < min_window)
window = min_window;
for(i = 0; i <= xsize; ++i)
for(j = 0; j <= ysize; ++j)
distances[i][j] = LARGE_VALUE;
distances[0][0] = 0;
for(i = 0; i < xsize; ++i)
{
minj = i - window;
if(minj < 0)
minj = 0;
maxj = i + window;
if(maxj > ysize)
maxj = ysize;
for(j = minj; j < maxj; ++j)
{
dist = abs(x[i] - y[j]);
min = distances[i][j];
if(min > distances[i][j+1])
min = distances[i][j+1];
if(min > distances[i+1][j])
min = distances[i+1][j];
distances[i+1][j+1] = dist + min;
}
}
dist = distances[xsize][ysize];
for(i = 0; i < xsize + 1; ++i)
free(distances[i]);
free(distances);
return dist;
}
To me it looks alright, but it might be because I've looked so many times at it now. So now I'm gonna ask a fresh pair of eye to look at this. Can you see an easier way of writing this or should I just go with this?
Note: this is for me to learn how I can write my code in another, maybe smarter way?
EDIT reduced code
//DTW - Dynamic Time Warping - Compare two -usually temporal- sequences
int DTWDistance(int* x, int xsize, int* y, int ysize){
const int LARGE_VALUE = INT_MAX;
int i, j, minj, maxj, fr, myMin, dist;
int **distances = malloc((xsize + 1) * sizeof(int *));
for(i = 0; i < xsize + 1; ++i)
distances[i] = malloc((ysize + 1) * sizeof(int));
for(i = 0; i <= xsize; ++i)
for(j = 0; j <= ysize; ++j)
distances[i][j] = LARGE_VALUE;
distances[0][0] = 0;
for(i = 0; i < xsize; ++i)
{
minj = max(i - ysize, 0);
maxj = min(i + ysize, ysize);
for(j = minj; j < maxj; ++j)
{
dist = abs(x[i] - y[j]);
fr = min(distances[i][j + 1], distances[i + 1][j]);
myMin = min(distances[i][j], fr);
distances[i+1][j+1] = dist + myMin;
}
}
dist = distances[xsize][ysize];
for(i = 0; i < xsize + 1; ++i)
free(distances[i]);
free(distances);
return dist;
}

Answer 1

Another simplification is using Variable Length Array.
If xsize * ysize is reasonable (up to about 100k) then you can use VLA with automatic storage (usually allocated on stack).
You can replace:
double **distances = malloc((xsize + 1) * sizeof(double *));
for(i = 0; i < xsize + 1; ++i)
distances[i] = malloc((ysize + 1) * sizeof(double));
with
double distances[xsize + 1][ysize + 1];
and remove all deallocation code:
for(i = 0; i < xsize + 1; ++i)
free(distances[i]);
free(distances);
If sizes are large then you can use VLA with dynamic storage:
double (*distances)[ysize + 1] = malloc((xsize + 1) * sizeof *distances);
and free it at the end with:
free(distances)
VLAs have other advantages over more popular "array of arrays".
Single large allocations is generally a lot faster than a bunch of smaller ones. Moreover, accessing a true 2D array usually more cache friendly and easier to be autovectorized by a compiler.

Answer 2

A lot of your code can be reduced if you make use of min and max macros:
#define min(a, b) ((a) < (b)) ? (a) : (b);
#define max(a, b) ((a) > (b)) ? (a) : (b);
This makes it possible to turn this into one single line:
// Old:
min = distances[i][j];
if(min > distances[i][j+1])
min = distances[i][j+1];
if(min > distances[i+1][j])
min = distances[i+1][j];
// New:
// note: renamed 'min' to avoid naming conflict with macro
myMin = min(distances[i][j], min(distances[i][j + 1], distances[i + 1][j]);
Likewise:
if(minj < 0)
minj = 0;
Could be replaced with:
minj = max(i - window, 0);
And:
if(maxj > ysize)
maxj = ysize;
Could be:
maxj = min(i + window, ysize);
Again:
if(window < min_window)
window = min_window;
Can be:
window = min(window, min_window);
There, I just turned your 51 line function into a 40 line function.