[예제코드] "mathlib.h" & "mathlib.cpp"

#pragma once

// 문제 1: 기본 최대/최소
int max_int(int a, int b);
int min_int(int a, int b);

// 문제 2: 배열 최대/최소
int max_int(int arr[], int n);
int min_int(int arr[], int n);

// 문제 3: 제곱 함수
float square(float x);
void square(float arrOut[], const float arrIn[], int n);

// 문제 4: 수학 공식
float convertToCelsius(float fahrenheit);
double calculateUniversalForce(double m1, double m2, double r, double G = 6.674E-11);
double calculateEuclideanDistance(double x1, double y1, double x2, double y2);

// 문제 5: 복소수 구조체 및 연산
struct Complex
{
    double real;
    double imag;
};

Complex complex_add(Complex c1, Complex c2);
Complex complex_sub(Complex c1, Complex c2);
Complex complex_mul(Complex c1, Complex c2);
Complex complex_div(Complex c1, Complex c2);

// 문제 6: 이차방정식 해
enum EqSoIType
{
    EQST_TWO_REAL,
    EQST_ONE_REAL,
    EQST_TWO_IMAG
};

struct QuadEqSoI
{
    EqSoIType type;  // 해의 타입
    Complex root1;   // 첫 번째 해
    Complex root2;   // 두 번째 해
};

// 이차방정식 풀이 함수 (문제 6에 필요할 것 같음)
QuadEqSoI solveQuadraticEquation(double a, double b, double c);

// (a) 두 정수 중 최대값 반환
int max_int(int a, int b)
{
    if (a > b) {
        return a;
    } else {
        return b;
    }

    // 또는 삼항 연산자로 간단히:
    // return (a > b) ? a : b;
}

// (b) 두 정수 중 최소값 반환
int min_int(int a, int b)
{
    if (a < b) {
        return a;
    } else {
        return b;
    }

    // 또는 삼항 연산자로:
    // return (a < b) ? a : b;
}

// (a) 배열에서 최대값 찾기
int max_int(int arr[], int n)
{
    // 배열이 비어있을 경우 처리
    if (n <= 0) {
        return 0; // 또는 에러 처리 (과제에서 명시되지 않음)
    }

    int max_val = arr[0]; // 첫 번째 요소로 초기화

    for (int i = 1; i < n; i++) {
        if (arr[i] > max_val) {
            max_val = arr[i];
        }
    }

    return max_val;
}

// (b) 배열에서 최소값 찾기
int min_int(int arr[], int n)
{
    // 배열이 비어있을 경우 처리
    if (n <= 0) {
        return 0; // 또는 에러 처리
    }

    int min_val = arr[0]; // 첫 번째 요소로 초기화

    for (int i = 1; i < n; i++) {
        if (arr[i] < min_val) {
            min_val = arr[i];
        }
    }

    return min_val;
}

// (a) 단일 float 값의 제곱 계산
float square(float x)
{
    return x * x;
}

// (b) float 배열의 각 요소를 제곱하여 다른 배열에 저장
void square(float arrOut[], const float arrIn[], int n)
{
    for (int i = 0; i < n; i++) {
        arrOut[i] = arrIn[i] * arrIn[i];
    }
}

// (a) 화씨를 섭씨로 변환
float convertToCelsius(float fahrenheit)
{
    return (fahrenheit - 32.0f) * (5.0f / 9.0f);
}

// (b) 만유인력 계산 (뉴턴의 만유인력 법칙)
double calculateUniversalForce(double m1, double m2, double r, double G)
{
    return (G * m1 * m2) / (r * r);
}

// (c) 유클리드 거리 계산
double calculateEuclideanDistance(double x1, double y1, double x2, double y2)
{
    double dx = x1 - x2;
    double dy = y1 - y2;
    return sqrt(dx * dx + dy * dy);
}

// (a) 복소수 덧셈: (a + bi) + (c + di) = (a+c) + (b+d)i
Complex complex_add(Complex c1, Complex c2)
{
    Complex result;
    result.real = c1.real + c2.real;
    result.imag = c1.imag + c2.imag;
    return result;
}

// (b) 복소수 뺄셈: (a + bi) - (c + di) = (a-c) + (b-d)i
Complex complex_sub(Complex c1, Complex c2)
{
    Complex result;
    result.real = c1.real - c2.real;
    result.imag = c1.imag - c2.imag;
    return result;
}

// (c) 복소수 곱셈: (a + bi) × (c + di) = (ac - bd) + (ad + bc)i
Complex complex_mul(Complex c1, Complex c2)
{
    Complex result;
    result.real = (c1.real * c2.real) - (c1.imag * c2.imag);
    result.imag = (c1.real * c2.imag) + (c1.imag * c2.real);
    return result;
}

// (d) 복소수 나눗셈: (a + bi) ÷ (c + di) = [(ac + bd)/(c² + d²)] + [(bc - ad)/(c² + d²)]i
Complex complex_div(Complex c1, Complex c2)
{
    Complex result;
    double denominator = (c2.real * c2.real) + (c2.imag * c2.imag);

    result.real = (c1.real * c2.real + c1.imag * c2.imag) / denominator;
    result.imag = (c1.imag * c2.real - c1.real * c2.imag) / denominator;
    return result;
}

// 이차방정식 풀이 함수
QuadEqSol solveQuadraticEquation(double a, double b, double c)
{
    QuadEqSol solution;
    double discriminant = b * b - 4 * a * c; // 판별식 D = b² - 4ac

    if (discriminant > 0) {
        // 두 개의 실근
        solution.type = EQST_TWO_REAL;
        solution.root1.real = (-b + sqrt(discriminant)) / (2 * a);
        solution.root1.imag = 0;
        solution.root2.real = (-b - sqrt(discriminant)) / (2 * a);
        solution.root2.imag = 0;
    }
    else if (discriminant == 0) {
        // 한 개의 실근 (중근)
        solution.type = EQST_ONE_REAL;
        solution.root1.real = -b / (2 * a);
        solution.root1.imag = 0;
        solution.root2 = solution.root1; // 같은 값
    }
    else {
        // 두 개의 허근
        solution.type = EQST_TWO_IMAG;
        double realPart = -b / (2 * a);
        double imagPart = sqrt(-discriminant) / (2 * a);

        solution.root1.real = realPart;
        solution.root1.imag = imagPart;
        solution.root2.real = realPart;
        solution.root2.imag = -imagPart; // 켤레복소수
    }

    return solution;
}