【C语言标准库函数】三角函数

// sin函数泰勒级数伪代码（简化版）
#define EPSILON 1e-10  // 精度控制阈值
double sin(double x) {
    double sum = 0.0;
    double term = x;  // 第一项：x^1/1!
    int n = 1;
    // 迭代计算直到项的绝对值小于精度阈值
    while (fabs(term) > EPSILON) {
        sum += term;
        // 递推计算下一项：-x²/[(2n)(2n+1)] * 前一项
        term = -term * x * x / ((2 * n) * (2 * n + 1));
        n++;
    }
    return sum;
}

// cos函数泰勒级数伪代码（简化版）
double cos(double x) {
    double sum = 1.0;  // 第一项：x^0/0! = 1
    double term = 1.0;
    int n = 1;
    while (fabs(term) > EPSILON) {
        term = -term * x * x / ((2 * n - 1) * (2 * n));  // 递推公式
        sum += term;
        n++;
    }
    return sum;
}

// tan函数基于sin和cos实现
double tan(double x) {
    return sin(x) / cos(x);
}

// asin函数牛顿迭代法伪代码（简化版）
#define EPSILON 1e-10
#define MAX_ITER 100  // 最大迭代次数
double asin(double x) {
    // 参数合法性检查
    if (x < -1.0 || x > 1.0) return NAN;
    // 初始猜测值：小x时近似x，大x时近似π/2（x=1）或-π/2（x=-1）
    double y = (x > 0.5 || x < -0.5) ? (x > 0 ? M_PI/2 : -M_PI/2) : x;
    int iter = 0;
    double delta;
    do {
        // 牛顿迭代公式：y(n+1) = y(n) - [sin(y(n)) - x]/cos(y(n))
        delta = (sin(y) - x) / cos(y);
        y -= delta;
        iter++;
    } while (fabs(delta) > EPSILON && iter < MAX_ITER);
    return y;
}

// acos基于asin推导：acos(x) = π/2 - asin(x)
double acos(double x) {
    if (x < -1.0 || x > 1.0) return NAN;
    return M_PI / 2 - asin(x);
}

// atan2函数伪代码（简化版）
double atan2(double y, double x) {
    if (x == 0.0 && y == 0.0) return 0.0;  // 特殊情况：原点返回0
    if (x > 0.0) {
        // 第一、四象限：直接调用atan(y/x)
        return atan(y / x);
    } else if (x < 0.0) {
        if (y >= 0.0) {
            // 第二象限：atan(y/x) + π
            return atan(y / x) + M_PI;
        } else {
            // 第三象限：atan(y/x) - π
            return atan(y / x) - M_PI;
        }
    } else {
        // x=0：y正为π/2，y负为-π/2
        return y > 0.0 ? M_PI/2 : -M_PI/2;
    }
}

#include <math.h>
// 度数转弧度
#define DEG_TO_RAD(deg) ((deg) * M_PI / 180.0)
// 弧度转度数
#define RAD_TO_DEG(rad) ((rad) * 180.0 / M_PI)

// 示例：计算30度的正弦值
int main() {
    double deg = 30.0;
    double rad = DEG_TO_RAD(deg);
    double sin_val = sin(rad);
    printf("sin(%.1f度) = %.6f\n", deg, sin_val);  // 输出：sin(30.0度) = 0.500000
    return 0;
}

#include <stdio.h>
#include <math.h>

typedef struct {
    double x;
    double y;
} Point;

// 点绕原点旋转θ度（逆时针）
Point rotate_point(Point p, double deg) {
    Point res;
    double rad = DEG_TO_RAD(deg);
    double cos_theta = cos(rad);
    double sin_theta = sin(rad);
    res.x = p.x * cos_theta - p.y * sin_theta;
    res.y = p.x * sin_theta + p.y * cos_theta;
    return res;
}

int main() {
    Point p = {1.0, 0.0};  // 初始点在(1,0)
    Point rotated = rotate_point(p, 90.0);  // 旋转90度
    printf("旋转后坐标：(%.6f, %.6f)\n", rotated.x, rotated.y);  // 输出：(0.000000, 1.000000)
    return 0;
}

#include <stdio.h>
#include <math.h>

#define G 9.8  // 重力加速度(m/s²)

// 计算抛射运动参数
void projectile_motion(double v, double deg, double *t, double *s, double *h) {
    double rad = DEG_TO_RAD(deg);
    double sin_theta = sin(rad);
    double cos_theta = cos(rad);
    *t = 2 * v * sin_theta / G;          // 飞行时间
    *s = v * v * sin(2 * rad) / G;       // 射程
    *h = v * v * sin_theta * sin_theta / (2 * G);  // 最大高度
}

int main() {
    double v = 10.0;  // 初速度10m/s
    double deg = 45.0;  // 抛射角45度
    double t, s, h;
    projectile_motion(v, deg, &t, &s, &h);
    printf("飞行时间：%.2fs\n", t);    // 输出：1.44s
    printf("射程：%.2fm\n", s);       // 输出：10.20m
    printf("最大高度：%.2fm\n", h);   // 输出：2.55m
    return 0;
}

#include <stdio.h>
#include <math.h>

// 计算目标点相对原点的方位角（0-360度）
double get_azimuth(double x, double y) {
    double rad = atan2(y, x);
    double deg = RAD_TO_DEG(rad);
    // 转换为0-360度范围（atan2返回-180~180度）
    return deg < 0 ? deg + 360 : deg;
}

int main() {
    // 四个象限的目标点测试
    printf("(1,1)方位角：%.1f度\n", get_azimuth(1, 1));    // 45.0度（第一象限）
    printf("(-1,1)方位角：%.1f度\n", get_azimuth(-1, 1));  // 135.0度（第二象限）
    printf("(-1,-1)方位角：%.1f度\n", get_azimuth(-1, -1));// 225.0度（第三象限）
    printf("(1,-1)方位角：%.1f度\n", get_azimuth(1, -1));  // 315.0度（第四象限）
    return 0;
}

#include <stdio.h>
#include <math.h>

#define SAMPLING_RATE 44100  // 采样率（Hz）
#define AMPLITUDE 32767      // 振幅（16位音频最大值）
#define FREQUENCY 440        // 信号频率（Hz，A调）

// 生成1秒的正弦波数据
void generate_sine_wave(short *buffer, int length) {
    for (int i = 0; i < length; i++) {
        // 计算当前时间点的相位
        double time = (double)i / SAMPLING_RATE;
        double phase = 2 * M_PI * FREQUENCY * time;
        // 生成正弦波数据（范围：-AMPLITUDE~AMPLITUDE）
        buffer[i] = (short)(AMPLITUDE * sin(phase));
    }
}

int main() {
    int length = SAMPLING_RATE * 1;  // 1秒数据
    short *buffer = (short*)malloc(length * sizeof(short));
    generate_sine_wave(buffer, length);
    // 此处可将buffer写入WAV文件或直接输出
    printf("正弦波生成完成，共%d个采样点\n", length);
    free(buffer);
    return 0;
}

// 错误：直接传入度数30
double wrong = sin(30);  // 结果约-0.988031（30弧度≈1718.87度的正弦值）
// 正确：先转换为弧度
double correct = sin(DEG_TO_RAD(30));  // 结果0.5

double safe_asin(double x) {
    if (x > 1.0) x = 1.0;
    if (x < -1.0) x = -1.0;
    return asin(x);
}

double rad = DEG_TO_RAD(90);
if (sin(rad) == 1.0) {  // 可能返回false（实际结果约为0.9999999999999998）
    printf("正确");
} else {
    printf("错误");  // 实际执行此分支
}

#define TOLERANCE 1e-6
if (fabs(sin(rad) - 1.0) < TOLERANCE) {  // 正确
    printf("正确");
}

#include <math.h>
#include <stdio.h>

double process_trig(double x) {
    if (isnan(x) || isinf(x)) {
        printf("输入无效！\n");
        return 0.0;
    }
    return sin(x);
}

// 低效：重复计算cos(rad)和sin(rad)
double x1 = x * cos(rad) - y * sin(rad);
double y1 = x * sin(rad) + y * cos(rad);
double x2 = x1 * cos(rad) - y1 * sin(rad);

// 高效：缓存计算结果
double c = cos(rad);
double s = sin(rad);
double x1 = x * c - y * s;
double y1 = x * s + y * c;
double x2 = x1 * c - y1 * s;

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

// 宏定义：单位转换
#define DEG_TO_RAD(deg) ((deg) * M_PI / 180.0)
#define RAD_TO_DEG(rad) ((rad) * 180.0 / M_PI)
// 宏定义：精度容差
#define TOLERANCE 1e-6

// 结构体：三角形
typedef struct {
    double a;  // 边a（BC边）
    double b;  // 边b（AC边）
    double c;  // 边c（AB边）
    double A;  // 角A（对边a）
    double B;  // 角B（对边b）
    double C;  // 角C（对边c）
} Triangle;

// 功能1：通过两边及夹角求第三边（余弦定理）
double cosine_law(double side1, double side2, double angle_deg) {
    double angle_rad = DEG_TO_RAD(angle_deg);
    // 余弦定理：c² = a² + b² - 2ab×cos(C)
    return sqrt(side1*side1 + side2*side2 - 2*side1*side2*cos(angle_rad));
}

// 功能2：通过三边求角度（余弦定理逆用）
void triangle_angles(Triangle *tri) {
    if (tri->a <= 0 || tri->b <= 0 || tri->c <= 0) {
        printf("三角形边长必须为正数！\n");
        return;
    }
    // 余弦定理逆用：cos(A) = (b² + c² - a²)/(2bc)
    tri->A = RAD_TO_DEG(acos((tri->b*tri->b + tri->c*tri->c - tri->a*tri->a)/(2*tri->b*tri->c)));
    tri->B = RAD_TO_DEG(acos((tri->a*tri->a + tri->c*tri->c - tri->b*tri->b)/(2*tri->a*tri->c)));
    tri->C = RAD_TO_DEG(acos((tri->a*tri->a + tri->b*tri->b - tri->c*tri->c)/(2*tri->a*tri->b)));
    // 验证角度和是否为180度（容差范围内）
    if (fabs(tri->A + tri->B + tri->C - 180) > TOLERANCE) {
        printf("角度计算异常，总和：%.2f度\n", tri->A + tri->B + tri->C);
    }
}

// 功能3：三角形顶点旋转（基于sin/cos）
typedef struct {
    double x;
    double y;
} Point;

Point rotate_point(Point p, double angle_deg) {
    Point res;
    double angle_rad = DEG_TO_RAD(angle_deg);
    double c = cos(angle_rad);
    double s = sin(angle_rad);
    res.x = p.x * c - p.y * s;
    res.y = p.x * s + p.y * c;
    return res;
}

int main() {
    // 场景1：计算三角形参数
    Triangle tri;
    tri.b = 3.0;  // 边b=3
    tri.c = 4.0;  // 边c=4
    tri.A = 90.0; // 角A=90度
    tri.a = cosine_law(tri.b, tri.c, tri.A);  // 求边a
    triangle_angles(&tri);  // 求其余角度
    printf("三角形参数：\n");
    printf("边长：a=%.2f, b=%.2f, c=%.2f\n", tri.a, tri.b, tri.c);
    printf("角度：A=%.1f°, B=%.1f°, C=%.1f°\n", tri.A, tri.B, tri.C);

    // 场景2：旋转三角形顶点
    Point p = {tri.b, 0.0};  // 顶点B坐标(3,0)
    Point rotated_p = rotate_point(p, 30.0);  // 旋转30度
    printf("\n顶点B旋转30度后坐标：(%.2f, %.2f)\n", rotated_p.x, rotated_p.y);

    return 0;
}

# 编译命令（GCC）
gcc trigonometric_demo.c -o trigonometric_demo -lm

# 运行输出
三角形参数：
边长：a=5.00, b=3.00, c=4.00
角度：A=90.0°, B=36.9°, C=53.1°

顶点B旋转30度后坐标：(2.59, 1.50)