cube/zenzicubi.co
cube/zenzicubi.co
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang-format stereography c files

Browse Source
This commit is contained in:
queue-miscreant 2025-07-22 00:16:00 -05:00
parent 5fbf8970c2
commit 32294879c9
3 changed files with 232 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
posts/stereo/1/.clang-format Normal file
View File

@ -0,0 +1,9 @@
BasedOnStyle: llvm
IndentWidth: 4
AlignAfterOpenBracket: BlockIndent
BinPackParameters: OnePerLine
BreakBeforeBraces: Custom
BraceWrapping:
AfterFunction: true
PointerAlignment: Left

221
posts/stereo/1/stereo_complex.c
View File

@ -1,143 +1,156 @@
#include <complex.h>
#include <math.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <math.h>
#include <complex.h>
#define STRRED "\x1b[31m" #define STRRED "\x1b[31m"
#define STRGREEN "\x1b[32m" #define STRGREEN "\x1b[32m"
#define STRNORM "\x1b[m" #define STRNORM "\x1b[m"
#define SECONDS_PER_NANOSECOND 1000000000
#define NUM_LOOPS 100000 #define NUM_LOOPS 100000
double complex complex_turn(double turn) double complex complex_turn(double turn) { return cexp(I * M_PI * turn); }
{
return cexp(I*M_PI*turn);
}
double complex approx_turn(double turn) double complex approx_turn(double turn)
{ {
const static double a = 8*M_SQRT2/3 - 3; const static double a = 8 * M_SQRT2 / 3 - 3;
const static double b = 4 - 8*M_SQRT2/3; const static double b = 4 - 8 * M_SQRT2 / 3;
double p = turn*(b * turn * turn + a); double p = turn * (b * turn * turn + a);
double q = p*p; double q = p * p;
double r = 1 + q; double r = 1 + q;
double c = (1 - q) / r, s = 2*p / r; double c = (1 - q) / r, s = 2 * p / r;
return (c*c - s*s) + I*(2*c*s); return (c * c - s * s) + I * (2 * c * s);
} }
void print_errors(const double *inputs, void print_errors(
const double complex *ideals, const double* inputs,
const double complex *approxs, const double complex* ideals,
int n) const double complex* approxs,
int n
)
{ {
double c_error, s_error; double c_error, s_error;
double largest_c_error, largest_s_error; double largest_c_error, largest_s_error;
size_t largest_c_index, largest_s_index; size_t largest_c_index, largest_s_index;
double total_c_error = 0, total_s_error = 0; double total_c_error = 0, total_s_error = 0;
size_t i; size_t i;
double complex ideal, approx; double complex ideal, approx;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
ideal = ideals[i]; ideal = ideals[i];
approx = approxs[i]; approx = approxs[i];
//squared error in c components // squared error in c components
c_error = creal(ideal) - creal(approx); c_error = creal(ideal) - creal(approx);
c_error *= c_error; c_error *= c_error;
//squared error in s components // squared error in s components
s_error = cimag(ideal) - cimag(approx); s_error = cimag(ideal) - cimag(approx);
s_error *= s_error; s_error *= s_error;
if (largest_c_error < c_error) { if (largest_c_error < c_error) {
largest_c_error = c_error; largest_c_error = c_error;
largest_c_index = i; largest_c_index = i;
} }
if (largest_s_error < s_error) { if (largest_s_error < s_error) {
largest_s_error = s_error; largest_s_error = s_error;
largest_s_index = i; largest_s_index = i;
} }
total_c_error += c_error; total_c_error += c_error;
total_s_error += s_error; total_s_error += s_error;
} }
//these now contain the *average* squared error // these now contain the *average* squared error
total_c_error /= (double) n; total_c_error /= (double)n;
total_s_error /= (double) n; total_s_error /= (double)n;
printf("Squared error in cosines: \n"\ printf(
"\tAverage: %f (%f%% error)\n""\tLargest: %f (%f%% error)" \ "Squared error in cosines: \n"
"\n\t\tInput:\t\t%f\n\t\tValue:\t\t%f\n\t\tApproximation:\t%f\n" "\tAverage: %f (%f%% error)\n"
, total_c_error, sqrt(total_c_error) * 100 "\tLargest: %f (%f%% error)"
, largest_c_error, sqrt(largest_c_error) * 100 "\n\t\tInput:\t\t%f\n\t\tValue:\t\t%f\n\t\tApproximation:\t%f\n",
, inputs[largest_c_index] total_c_error, sqrt(total_c_error) * 100, largest_c_error,
, creal(ideals[largest_c_index]), creal(approxs[largest_c_index])); sqrt(largest_c_error) * 100, inputs[largest_c_index],
printf("Squared error in sines: \n"\ creal(ideals[largest_c_index]), creal(approxs[largest_c_index])
"\tAverage: %f (%f%% error)\n\tLargest: %f (%f%% error)" \ );
"\n\t\tInput:\t\t%f\n\t\tValue:\t\t%f\n\t\tApproximation:\t%f\n" printf(
, total_s_error, sqrt(total_s_error) * 100 "Squared error in sines: \n"
, largest_s_error, sqrt(largest_s_error) * 100 "\tAverage: %f (%f%% error)\n\tLargest: %f (%f%% error)"
, inputs[largest_c_index] "\n\t\tInput:\t\t%f\n\t\tValue:\t\t%f\n\t\tApproximation:\t%f\n",
, cimag(ideals[largest_s_index]), cimag(approxs[largest_s_index])); total_s_error, sqrt(total_s_error) * 100, largest_s_error,
sqrt(largest_s_error) * 100, inputs[largest_c_index],
cimag(ideals[largest_s_index]), cimag(approxs[largest_s_index])
);
} }
//time the length of the computation `f` in nanoseconds // time the length of the computation `f` in nanoseconds
long time_computation( double complex (*f)(double), long time_computation(
const double *inputs, double complex (*f)(double),
double complex *results, const double* inputs,
int n) double complex* results,
int n
)
{ {
size_t i; size_t i;
long tick; long tick_s;
struct timespec tp; long tick_ns;
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
tick = tp.tv_nsec; tick_ns = tp.tv_nsec;
for (i = 0; i < n; i++) { tick_s = tp.tv_sec;
results[i] = f(inputs[i]); for (i = 0; i < n; i++) {
} results[i] = f(inputs[i]);
//this isn't quite proper, since the clock may have ticked over a second }
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_nsec - tick; return SECONDS_PER_NANOSECOND * (tp.tv_sec - tick_s) +
(tp.tv_nsec - tick_ns);
} }
int main(int argn, char **args) int main(int argn, char** args)
{ {
long trig_time, rat_time; long trig_time, rat_time;
double rands[NUM_LOOPS]; double rands[NUM_LOOPS];
double complex trigs[NUM_LOOPS]; double complex trigs[NUM_LOOPS];
double complex rats[NUM_LOOPS]; double complex rats[NUM_LOOPS];
size_t i; size_t i;
for (i = 0; i < NUM_LOOPS; i++) { for (i = 0; i < NUM_LOOPS; i++) {
rands[i] = rand() / (double) RAND_MAX; rands[i] = rand() / (double)RAND_MAX;
} }
trig_time = time_computation(&complex_turn, rands, trigs, NUM_LOOPS); trig_time = time_computation(&complex_turn, rands, trigs, NUM_LOOPS);
printf("Timing for %d math.h sin and cos:\t%ldns\n", NUM_LOOPS, trig_time); printf("Timing for %d math.h sin and cos:\t%ldns\n", NUM_LOOPS, trig_time);
rat_time = time_computation(&approx_turn, rands, rats, NUM_LOOPS); rat_time = time_computation(&approx_turn, rands, rats, NUM_LOOPS);
printf("Timing for %d approximations:\t%ldns\n", NUM_LOOPS, rat_time); printf("Timing for %d approximations:\t%ldns\n", NUM_LOOPS, rat_time);
long diff = rat_time - trig_time; long diff = rat_time - trig_time;
double frac_speed; double frac_speed;
if (diff > 0) { if (diff > 0) {
frac_speed = rat_time / (double) trig_time; frac_speed = rat_time / (double)trig_time;
printf(STRRED "math.h" STRNORM " faster, speedup: %ldns (%2.2fx)\n", printf(
diff, frac_speed); STRRED "math.h" STRNORM " faster, speedup: %ldns (%2.2fx)\n", diff,
} else { frac_speed
frac_speed = trig_time / (double) rat_time; );
printf(STRGREEN "Approximation" STRNORM " faster, speedup: %ldns (%2.2fx)\n", } else {
-diff, frac_speed); frac_speed = trig_time / (double)rat_time;
print_errors(rands, trigs, rats, NUM_LOOPS); printf(
} STRGREEN "Approximation" STRNORM
" faster, speedup: %ldns (%2.2fx)\n",
-diff, frac_speed
);
print_errors(rands, trigs, rats, NUM_LOOPS);
}
return 0; return 0;
} }

194
posts/stereo/1/stereo_math.c
View File

@ -1,128 +1,140 @@
#include <stdio.h>
#include <math.h> #include <math.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#define STRRED "\x1b[31m" #define STRRED "\x1b[31m"
#define STRGREEN "\x1b[32m" #define STRGREEN "\x1b[32m"
#define STRNORM "\x1b[m" #define STRNORM "\x1b[m"
struct circle { struct circle {
double c; double c;
double s; double s;
}; };
double a = 8*M_SQRT2/3 - 3; double a = 8 * M_SQRT2 / 3 - 3;
double b = 4 - 8*M_SQRT2/3; double b = 4 - 8 * M_SQRT2 / 3;
void trig(double turn, struct circle *ret) void trig(double turn, struct circle* ret)
{ {
double arg = M_PI * turn; double arg = M_PI * turn;
ret->c = cos(arg); ret->c = cos(arg);
ret->s = sin(arg); ret->s = sin(arg);
} }
void rational(double turn, struct circle *ret) void rational(double turn, struct circle* ret)
{ {
double p = turn*(b * turn * turn + a); double p = turn * (b * turn * turn + a);
double q = p*p; double q = p * p;
double r = 1 + q; double r = 1 + q;
double c = (1 - q) / r, s = 2*p / r; double c = (1 - q) / r, s = 2 * p / r;
ret->c = c*c - s*s; ret->c = c * c - s * s;
ret->s = 2*c*s; ret->s = 2 * c * s;
} }
double errors(int n, const struct circle *circles1, const struct circle *circles2) double
errors(int n, const struct circle* circles1, const struct circle* circles2)
{ {
double c_error, s_error; double c_error, s_error;
double largest_c_error, largest_s_error; double largest_c_error, largest_s_error;
double total_c_error = 0, total_s_error = 0; double total_c_error = 0, total_s_error = 0;
int i; int i;
struct circle circle1, circle2; struct circle circle1, circle2;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
circle1 = circles1[i]; circle1 = circles1[i];
circle2 = circles2[i]; circle2 = circles2[i];
//squared error in c components // squared error in c components
c_error = circle1.c - circle2.c; c_error = circle1.c - circle2.c;
c_error *= c_error; c_error *= c_error;
//squared error in s components // squared error in s components
s_error = circle1.s - circle2.s; s_error = circle1.s - circle2.s;
s_error *= s_error; s_error *= s_error;
if (largest_c_error < c_error) if (largest_c_error < c_error)
largest_c_error = c_error; largest_c_error = c_error;
if (largest_s_error < s_error) if (largest_s_error < s_error)
largest_s_error = s_error; largest_s_error = s_error;
total_c_error += c_error; total_c_error += c_error;
total_s_error += s_error; total_s_error += s_error;
} }
//these now contain the *average* squared error // these now contain the *average* squared error
total_c_error /= (double) n; total_c_error /= (double)n;
total_s_error /= (double) n; total_s_error /= (double)n;
printf("Squared error in cosines: \n\tAverage: %f (%f%% error)\n\tLargest: %f (%f%% error)\n" printf(
, total_c_error, sqrt(total_c_error) * 100 "Squared error in cosines: \n\tAverage: %f (%f%% error)\n\tLargest: %f "
, largest_c_error, sqrt(largest_c_error) * 100); "(%f%% error)\n",
printf("Squared error in sines: \n\tAverage: %f (%f%% error)\n\tLargest: %f (%f%% error)\n" total_c_error, sqrt(total_c_error) * 100, largest_c_error,
, total_s_error, sqrt(total_s_error) * 100 sqrt(largest_c_error) * 100
, largest_s_error, sqrt(largest_s_error) * 100); );
printf(
"Squared error in sines: \n\tAverage: %f (%f%% error)\n\tLargest: %f "
"(%f%% error)\n",
total_s_error, sqrt(total_s_error) * 100, largest_s_error,
sqrt(largest_s_error) * 100
);
return 0; return 0;
} }
int main(int argn, char **args) int main(int argn, char** args)
{ {
//struct circle ret; // struct circle ret;
int i; int i;
struct timespec tp; struct timespec tp;
long tick; long tick;
long trig_time, rat_time; long trig_time, rat_time;
double rands[10000]; double rands[10000];
struct circle trigs[10000]; struct circle trigs[10000];
struct circle rats[10000]; struct circle rats[10000];
for (i = 0; i < 10000; i++) { for (i = 0; i < 10000; i++) {
rands[i] = rand() / (double) RAND_MAX; rands[i] = rand() / (double)RAND_MAX;
} }
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
tick = tp.tv_nsec; tick = tp.tv_nsec;
for (i = 0; i < 10000; i++) { for (i = 0; i < 10000; i++) {
trig(rands[i], trigs+i); trig(rands[i], trigs + i);
} }
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
// this isn't quite proper, since the clock may have ticked over a second // this isn't quite proper, since the clock may have ticked over a second
trig_time = tp.tv_nsec - tick; trig_time = tp.tv_nsec - tick;
printf("Timing for 10000 math.h sin and cos:\t%ldns\n", trig_time); printf("Timing for 10000 math.h sin and cos:\t%ldns\n", trig_time);
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
tick = tp.tv_nsec; tick = tp.tv_nsec;
for (i = 0; i < 10000; i++) { for (i = 0; i < 10000; i++) {
rational(rands[i], rats+i); rational(rands[i], rats + i);
} }
clock_gettime(CLOCK_MONOTONIC, &tp); clock_gettime(CLOCK_MONOTONIC, &tp);
rat_time = tp.tv_nsec - tick; rat_time = tp.tv_nsec - tick;
printf("Timing for 10000 approximations:\t%ldns\n", rat_time); printf("Timing for 10000 approximations:\t%ldns\n", rat_time);
double fracSpeed; double fracSpeed;
long linSpeed = rat_time - trig_time; long linSpeed = rat_time - trig_time;
if (linSpeed > 0) { if (linSpeed > 0) {
fracSpeed = rat_time / (double) trig_time; fracSpeed = rat_time / (double)trig_time;
printf(STRRED "math.h" STRNORM " faster, speedup: %ldns (%2.2fx)\n", printf(
linSpeed, fracSpeed); STRRED "math.h" STRNORM " faster, speedup: %ldns (%2.2fx)\n",
} else { linSpeed, fracSpeed
fracSpeed = trig_time / (double) rat_time; );
printf(STRGREEN "Approximation" STRNORM " faster, speedup: %ldns (%2.2fx)\n", } else {
-linSpeed, fracSpeed); fracSpeed = trig_time / (double)rat_time;
errors(10000, rats, trigs); printf(
} STRGREEN "Approximation" STRNORM
" faster, speedup: %ldns (%2.2fx)\n",
-linSpeed, fracSpeed
);
errors(10000, rats, trigs);
}
} }