Practice[Root Formula]

Practice[Root Formula]

 

Intro

This program computes the root formula.

 

Header File

/*====================================================================================
Handong Global University
--------------------------------------------------------------------------------------
Name: 		Taesan Kim
ID:			22300203
Create:		2024.07.17
Modifire:	2024.07.17
--------------------------------------------------------------------------------------
복소수(Complex Number)와 관련된 연산 및 출력 지원
====================================================================================*/

#ifndef MYCOMPLEX_H
#define MYCOMPLEX_H
#include <stdio.h>
#include <math.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

typedef struct//_complex 이거 원래 써야하는데, math.h쓰면 오류뜨니까 지워.
{
	double real;
	double imag;
 }  Complex;
 
/**
* @breif 복소수 덧셈
* 복소수 num1과 num2를 더한다
* @param num1: 복소수1
* @param num2: 복소수2
*
* @return: 복소수1과 복소수2를 더한 값 
*/
Complex add_com(Complex num1, Complex num2);

Complex sub_com(Complex num1, Complex num2);

Complex mul_com(Complex num1, Complex num2);

Complex div_com(Complex num1, Complex num2);

void print_com(Complex result);

typedef enum _Phase
{
	RAD = 0,
	ANGLE
} Phase;

/**
* @brief 복소수의 위상과 크기
* 복소수 result를 통해 위상을 구한다.
* @param result: 복소수
* 
* @return: 복소수의 위상값
*/
double rad(Complex result);

double ang(Complex result);

/**
* @brief 입력값의 복소수 변환
* 입력값을 받아 오일러 변환을 한다.
* @param result: 입력 복소수
* 
* @return: 오일러 변환값
*/

typedef struct
{
	double radious;
	double radian;
} Exp;

Exp euler_func(Complex result);

Exp euler_sqrt(Exp euler_result);

Exp euler_mul(Exp euler_result, int exponent);


/**
* @breif 근의공식을 지원한다.
* 3개의 계수를 배열로 받아 근의공식을 적용한 뒤, 복소수 배열을 출력
* @param coef: 입력 계수
* 
* @result: 복소수 배열
*/

void quadratic_formula(double coef[3], Complex quadratic_result[2]);

#endif //MYCOMPLEX_H

 

Source File

#include "../include/myComplex.h"

Complex add_com(Complex num1, Complex num2)
{
	Complex result;
	
	result.real = num1.real + num2.real;
	result.imag = num1.imag + num2.imag;
	
	return result;
}

Complex sub_com(Complex num1, Complex num2)
{
	Complex result;
	
	result.real = num1.real - num2.real;
	result.imag = num1.imag - num2.imag;

	return result;
}

Complex mul_com(Complex num1, Complex num2)
{
	Complex result;
	
	result.real = num1.real * num2.real - num1.imag * num2.imag;
	result.imag = num1.real * num2.imag + num1.imag * num2.real;

	return result;
}

Complex div_com(Complex num1, Complex num2)
{
	Complex result;
	
	result.real = (num1.real * num2.real + num1.imag * num2.imag)/(num2.real * num2.real + num2.imag * num2.imag);
	result.imag = (num1.imag * num2.real - num1.real * num2.imag)/(num2.real * num2.real + num2.imag * num2.imag);

	return result;
}

void print_com(Complex result)
{
	if (result.imag == 0.0)
	{
		printf("%f", result.real);
	}
	else if (result.imag != 0.0)
	{
		printf("%f + %fj\n", result.real, result.imag);
	}
}

double rad(Complex result)
{
	Phase Rad;
	double radian;
	double angle;

	radian = atan(result.imag / result.real);

	Rad = RAD;

	return radian;
}

double ang(Complex result)
{
	Phase Angle;
	double angle;

	angle = atan(result.imag / result.real) * 180 / M_PI;

	Angle = ANGLE;

	return angle;
}

Exp euler_func(Complex result)
{
	Exp euler_result;
	euler_result.radious = sqrt(result.real * result.real + result.imag * result.imag);
	euler_result.radian = atan(result.imag / result.real)/2;

	return euler_result;
}

Exp euler_sqrt(Exp euler_result)
{
	Exp sqrt_result;
	sqrt_result.radious = sqrt(euler_result.radious);
	sqrt_result.radian = euler_result.radian / 2;

	return sqrt_result;
}

Exp euler_mul(Exp euler_result, int exponent)
{
	Exp mul_result;
	mul_result.radious = pow(euler_result.radious, exponent);
	mul_result.radian = euler_result.radian * exponent;

	return mul_result;
}

void quadratic_formula(double coef[3], Complex quadratic_result[2])
{
	double a = coef[0];
	double b = coef[1];
	double c = coef[2];
	double discriminent = b * b - 4.0 * a * c;

	if (discriminent < 0.0)
	{
		quadratic_result[0].real = -b / (2.0 * a);
		quadratic_result[1].real = -b / (2.0 * a);
		quadratic_result[0].imag = sqrt(discriminent) / (2.0 * a);
		quadratic_result[1].imag = -sqrt(discriminent) / (2.0 * a);
	}
	else if (discriminent >= 0.0)
	{
		quadratic_result[0].real = (-b + sqrt(discriminent)) / (2.0 * a);
		quadratic_result[1].real = (-b - sqrt(discriminent)) / (2.0 * a);
		quadratic_result[0].imag = 0.0;
		quadratic_result[1].imag = 0.0;
	}
}

 

Main

#include "include/myComplex.h"


int main()
{
	Complex num1 = { 16.0, 24.0};
	Complex num2 = { 28.0, 31.0};
	
	Complex result = add_com(num1, num2);
	print_com(result);
	
	float num;
	printf("RADIAN:0, ANGLE:1 : ");
	scanf_s("%f", &num);

	if (num == 0.0) {
		printf("Print type is RADIAN!!!\n");
		printf("Value is %f\n", rad(result));
	}
	if (num == 1.0) {
		printf("Print type is ANGLE!!\n");
		printf("Value is %f\n", ang(result));
	}

	//오일러 변환값
	printf("Euler angle: %f*exp(%f)\n\n", euler_func(result).radious, euler_func(result).radian);
	Exp euler_result = euler_func(result);

	//제곱근을 씌운다.
	printf("Root of Euler angle: %f*exp(%f)\n\n", euler_sqrt(euler_result).radious, euler_sqrt(euler_result).radian);

	//거듭제곱값 받는다.
	int exponent;
	printf("Write how much want to exponent : ");
	scanf_s("%d", &exponent);
	printf("\n\n");

	//거듭제곱해서 준다.
	printf("Power of Euler angle: %f*exp(%f)\n\n", euler_mul(euler_result, exponent).radious, euler_mul(euler_result, exponent).radian);


	//근의 공식을 적용할 3개의 계수를 받는다.
	double coef[3] = { 1.0, 4.0, 4.0 };


	//근의 공식을 구한다.
	
	Complex quadratic_result[2];
	quadratic_formula(coef, quadratic_result);

	printf("첫번째 근은 : \n\n");
	print_com(quadratic_result[0]);
	printf("\n======================\n");
	printf("두번째 근은 : \n\n");
	print_com(quadratic_result[1]);
	printf("\n======================\n");

	return 0;
}