Perimeter calculation in C - c

Question

I'm trying to use the distance between points formula to calculate the perimeter of any geometric figure, but the function is not delivering the values it should. I have no clue of what I'm doing wrong
#include <math.h>
int perimeter(int flag, dot d[]){
float result, sum1, sum2, sum3, quad1, quad2, op[flag], sum;
for(int c=0;c<flag;c++){
sum1=d[c+1].x-d[c].x;
sum2=d[c+1].y-d[c].y;
quad1=pow(sum1, 2);
quad2=pow(sum2, 2);
sum3=quad1+quad2;
result=sqrt(sum3);
op[c]=result;
}
for(int c=0;c<flag;c++){
sum+=op[c];
}return sum;
}
Test values:
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct dot{
float x,y;
}dot;
int main(){
int flag=4;
dot d[flag];
d[0].x=9;
d[0].y=10;
d[1].x=21;
d[1].y=10;
d[2].x=21;
d[2].y=16;
d[3].x=9;
d[4].y=16;
float result, sum1, sum2, sum3, quad1, quad2, op[flag], sum=0.0;
for(int c=0;c<flag;c++){
sum1=d[c+1%flag].x-d[c].x;
sum2=d[c+1%flag].y-d[c].y;
quad1=pow(sum1, 2);
quad2=pow(sum2, 2);
sum3=quad1+quad2;
result=sqrt(sum3);
printf("distance %d: %d\n", c, result);
sum+=result;
}
printf("final result: %d\n", result);
}
Console log(printing steps):
gcc version 4.6.3
distance 0: 0
distance 1: 1
distance 2: 2
distance 3: 3
final result: 26533904

Answer 1

You should look up the hypot() functions declared in the <math.h> header. You could end up with:
float perimeter(int n_dots, dot d[])
{
float sum = 0.0;
for (int i = 0; i < n_dots; i++)
{
int n = (i+1) % n_dots;
sum += hypotf(d[n].x - d[i].x, d[n].y - d[i].y);
}
return sum;
}
If you need to report on the values calculated, you can capture the result of hypotf() before you add it to sum.
Note, too, that you should return a float value. In my book, you should change float to double throughout (and use hypot() in place of hypotf()), but that's somewhat separate as an issue. Returning float (or double) rather than int is rather important, I think.
The MCVE (Minimal, Complete, Verifiable Example) version of your code might be:
#include <math.h>
#include <stdio.h>
typedef struct dot
{
float x, y;
} dot;
float perimeter(int n_dots, dot d[]);
int main(void)
{
enum { num_dots = 4 };
dot d[num_dots] =
{
{ .x = 9, .y = 10 },
{ .x = 21, .y = 10 },
{ .x = 21, .y = 16 },
{ .x = 9, .y = 16 },
};
printf("Perimeter: %.3f\n", perimeter(num_dots, d));
return 0;
}
float perimeter(int n_dots, dot d[])
{
float sum = 0.0;
for (int i = 0; i < n_dots; i++)
{
int n = (i + 1) % n_dots;
sum += hypotf(d[n].x - d[i].x, d[n].y - d[i].y);
}
return sum;
}
Using a VLA prevents you using an initializer for it, so I made the array into a regular fixed size array.
Output:
Perimeter: 36.000
For the given data, this is correct (the four sides are of length 12, 6, 12, 6).

Answer 2

Initialize sum with 0.0.
Then
Replace
op[c]=result;
with
sum+=result;
You don't need the other for loop.
Secondly, make sure the value of the variable flag passed to the perimeter function is 1 less than the size of the dots array d.
Lastly, you need to add the distance between the last point and the first point to the sum. (After the for loop).
sum1 = d[flag+1].x - d[0].x;
sum2 = d[flag+1].y - d[0].y;
quad1=pow(sum1, 2);
quad2=pow(sum2, 2);
sum3=quad1+quad2;
result=sqrt(sum3);
sum+=result;

Answer 3

Here is my version, with better variable names,
#include <math.h>
float perimeter(int flag, dot d[]){
float sum_x, sum_y, quad_x, quad_y, sum = 0;
for(int c=0;c<flag;c++){
sum_x=d[(c+1) % flag].x-d[c].x;
sum_y=d[(c+1) % flag].y-d[c].y;
quad_x=pow(sum_x, 2);
quad_y=pow(sum_y, 2);
sum += sqrt(quad_x + quad_y);
}
return sum;
}