MATH Archives - 18 중 2 번째 페이지

[PYTHON/COMMON] permutations 클래스 : 순열(permutation) 리스트 구하기

■ permutations 클래스를 사용해 순열(permutation) 리스트를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


from itertools import permutations

sourceList = [1,2,3]

permutations1 = permutations(sourceList, 2)

targetList = list(permutations1)

print(list(targetList))

"""
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
"""

from itertools import permutations

sourceList = [1,2,3]

permutations1 = permutations(sourceList, 2)

targetList = list(permutations1)

print(list(targetList))

"""

[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

"""

[PYTHON/COMMON] 에라토스테네스의 체(Sieve of Eratosthenes)를 사용해 소수 구하기

■ 에라토스테네스의 체(Sieve of Eratosthenes)를 사용해 소수를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import math

def getPrimeNumberList(value):
    isPrimeNumberList = [True] * value

    maximumLength = math.ceil(math.sqrt(value))

    for i in range(2, maximumLength):
        if isPrimeNumberList[i]:
            for j in range(i + i, value, i):
                isPrimeNumberList[j] = False

    return [i for i in range(2, value) if isPrimeNumberList[i]]

primeNumberList = getPrimeNumberList(100)

print(primeNumberList)

"""
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
"""

import math

def getPrimeNumberList(value):

isPrimeNumberList = [True] * value

maximumLength = math.ceil(math.sqrt(value))

for i in range(2, maximumLength):

if isPrimeNumberList[i]:

for j in range(i + i, value, i):

isPrimeNumberList[j] = False

return [i for i in range(2, value) if isPrimeNumberList[i]]

primeNumberList = getPrimeNumberList(100)

print(primeNumberList)

"""

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

"""

[PYTHON/COMMON] int 클래스 : 생성자 함수의 base 인자를 사용해 10진수 정수 구하기

■ int 클래스에서 생성자 함수의 base 인자를 사용해 10진수 정수를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


binaryValue = bin(5)

targetValue1 = int(binaryValue, base = 2)

print(targetValue1) # 5

octalValue = oct(7)

targetValue2 = int(octalValue, base = 8)

print(targetValue2) # 7

sourceString = "12345"

targetValue3 = int(sourceString, base = 10)

print(targetValue3) # 12345

hexadecimalValue = hex(255)

targetValue4 = int(hexadecimalValue, base = 16)

print(targetValue4) # 255

binaryValue = bin(5)

targetValue1 = int(binaryValue, base = 2)

print(targetValue1) # 5

octalValue = oct(7)

targetValue2 = int(octalValue, base = 8)

print(targetValue2) # 7

sourceString = "12345"

targetValue3 = int(sourceString, base = 10)

print(targetValue3) # 12345

hexadecimalValue = hex(255)

targetValue4 = int(hexadecimalValue, base = 16)

print(targetValue4) # 255

[PYTHON/COMMON] numexpr 패키지 설치하기

■ numexpr 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install numexpr

pip install numexpr

[PYTHON/COMMON] 논리 연산자 사용하기

■ 논리 연산자에 대한 정의를 보여준다. ▶ 논리 연산자


===============================================
연산자   정의
=======  ======================================
a and b  a, b 모두 True이면 True
a or b   a 또는 b가 True이면 True
not a    a가 False이면 True, a가 True이면 False
===============================================

===============================================

연산자 정의

======= ======================================

a and b a, b 모두 True이면 True

a or b a 또는 b가 True이면 True

not a a가 False이면 True, a가 True이면 False

===============================================

[PYTHON/COMMON] 대입 연산자 사용하기

■ 대입 연산자에 대한 정의를 보여준다. ▶ 대입 연산자


=================================================
연산자  정의
======  =========================================
=       대입한다.
+=      더하고 대입한다.
-=      빼고 대입한다.
*=      곱하고 대입한다.
/=      나누고 대입한다(소수점 이를 자르지 않음).
//=     나누고 대입한다(소수점 이하 반올림).
%=      나머지를 구해서 대입한다.
**==    거듭 제곱을 해서 대입한다.
=================================================

=================================================

연산자 정의

====== =========================================

= 대입한다.

+= 더하고 대입한다.

-= 빼고 대입한다.

*= 곱하고 대입한다.

/= 나누고 대입한다(소수점 이를 자르지 않음).

//= 나누고 대입한다(소수점 이하 반올림).

%= 나머지를 구해서 대입한다.

**== 거듭 제곱을 해서 대입한다.

=================================================

[PYTHON/COMMON] acos 함수 : 아크 코사인 값 구하기

■ acos 함수를 사용해 아크 코사인 값을 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import math

print(math.acos(-1))
print(math.acos( 0))
print(math.acos( 1))

"""
3.141592653589793
1.5707963267948966
0.0
"""

import math

print(math.acos(-1))

print(math.acos( 0))

print(math.acos( 1))

"""

3.141592653589793

1.5707963267948966

0.0

"""

※ -1에서 1 사이의 값, 이 범위를

[C#/COMMON/.NET6] Math 클래스 : Round 정적 메소드에서 Normal Rounding 사용하기

■ Math 클래스의 Round 정적 메소드에서 Normal Rounding을 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


//                         Banker's Rounding (Default)   Normal Rounding
Console.WriteLine($"0.5 : {Math.Round(0.5, 0)         } {Math.Round(0.5, 0, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"1.5 : {Math.Round(1.5, 0)         } {Math.Round(1.5, 0, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"2.5 : {Math.Round(2.5, 0)         } {Math.Round(2.5, 0, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"3.5 : {Math.Round(3.5, 0)         } {Math.Round(3.5, 0, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"4.5 : {Math.Round(4.5, 0)         } {Math.Round(4.5, 0, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"5.5 : {Math.Round(5.5, 0)         } {Math.Round(5.5, 0, MidpointRounding.AwayFromZero)}");

/*
0.5 : 0 1
1.5 : 2 2
2.5 : 2 3
3.5 : 4 4
4.5 : 4 5
5.5 : 6 6
*/

// Banker's Rounding (Default) Normal Rounding

Console.WriteLine($"0.5 : {Math.Round(0.5, 0) } {Math.Round(0.5, 0, MidpointRounding.AwayFromZero)}");

Console.WriteLine($"1.5 : {Math.Round(1.5, 0) } {Math.Round(1.5, 0, MidpointRounding.AwayFromZero)}");

Console.WriteLine($"2.5 : {Math.Round(2.5, 0) } {Math.Round(2.5, 0, MidpointRounding.AwayFromZero)}");

Console.WriteLine($"3.5 : {Math.Round(3.5, 0) } {Math.Round(3.5, 0, MidpointRounding.AwayFromZero)}");

Console.WriteLine($"4.5 : {Math.Round(4.5, 0) } {Math.Round(4.5, 0, MidpointRounding.AwayFromZero)}");

Console.WriteLine($"5.5 : {Math.Round(5.5, 0) } {Math.Round(5.5, 0, MidpointRounding.AwayFromZero)}");

0.5 : 0 1

1.5 : 2 2

2.5 : 2 3

3.5 : 4 4

4.5 : 4 5

5.5 : 6 6

[C#/COMMON/.NET6] IEEE 754 배정도 실수 확장 사용하기

■ IEEE 754 배정도 실수 확장을 사용하는 방법을 보여준다. ▶ NumericExtension.cs


using System;
using System.Runtime.InteropServices;

/// <summary>
/// 숫자 확장
/// </summary>
/// <remarks>
/// 컨트롤에서 사용하는 숫자 유틸리티 메소드이다.
/// 이러한 메소드는 범위가 WPF DoubleUtil 클래스와 유사하다.
/// </remarks>
public static class NumericExtensions
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Structure
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 배정도 실수 공용체 - DoubleUnion

    /// <summary>
    /// 배정도 실수 공용체
    /// </summary>
    /// <remarks>
    /// NanUnion은 double을 비트를 쉽게 조작할 수 있는 unsigned long으로 효율적으로 변환하는 데 사용되는 C++ 스타일 유형 공용체이다.
    /// </remarks>
    [StructLayout(LayoutKind.Explicit)]
    public struct DoubleUnion
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// 실수 값
        /// </summary>
        /// <remarks>
        /// 공용체의 부동 소수점 표현이다.
        /// </remarks>
        [FieldOffset(0)]
        public double FloatingValue;

        /// <summary>
        /// 정수 값
        /// </summary>
        /// <remarks>
        /// 공용체의 정수 표현이다.
        /// </remarks>
        [FieldOffset(0)]
        public ulong IntegerValue;

        #endregion
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Structure
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 0 여부 구하기 - IsZero(value)

    /// <summary>
    /// 0 여부 구하기
    /// </summary>
    /// <param name="value">배정도 실수 값</param>
    /// <returns>0 여부</returns>
    public static bool IsZero(this double value)
    {
        return Math.Abs(value) < 2.2204460492503131E-15;
    }

    #endregion
    #region 비숫자 여부 구하기 - IsNaN(value)

    /// <summary>
    /// 비숫자 여부 구하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns>비숫자 여부</returns>
    public static bool IsNaN(this double value)
    {
        DoubleUnion union = new DoubleUnion { FloatingValue = value };

        // IEEE 754 배정밀도 부동 소수점 숫자는 지수가 2047이고 가수가 0이 아닌 경우 NaN이다.
        ulong exponent = union.IntegerValue & 0xfff0000000000000L;

        if((exponent != 0x7ff0000000000000L) && (exponent != 0xfff0000000000000L))
        {
            return false;
        }

        ulong mantissa = union.IntegerValue & 0x000fffffffffffffL;

        return mantissa != 0L;
    }

    #endregion
    #region 두 숫자의 값이 비슷한지 여부 구하기 - AreClose(left, right)

    /// <summary>
    /// 두 숫자의 값이 비슷한지 여부 구하기
    /// </summary>
    /// <param name="left">왼쪽 값</param>
    /// <param name="right">오른쪽 값</param>
    /// <returns>두 숫자의 값이 비슷한지 여부</returns>
    public static bool AreClose(double left, double right)
    {
        if(left == right)
        {
            return true;
        }

        double a = (Math.Abs(left) + Math.Abs(right) + 10.0) * 2.2204460492503131E-16;
        double b = left - right;

        return (-a < b) && (a > b);
    }

    #endregion
    #region 값 이상 여부 구하기 - IsGreaterThan(left, right)

    /// <summary>
    /// 값 이상 여부 구하기
    /// </summary>
    /// <param name="left">왼쪽 값</param>
    /// <param name="right">오른쪽 값</param>
    /// <returns>값 이상 여부</returns>
    public static bool IsGreaterThan(double left, double right)
    {
        return (left > right) && !AreClose(left, right);
    }

    #endregion
    #region 값 이하 여부 구하기 - IsLessThanOrClose(left, right)

    /// <summary>
    /// 값 이하 여부 구하기
    /// </summary>
    /// <param name="left">왼쪽 값</param>
    /// <param name="right">오른쪽 값</param>
    /// <returns>값 이하 여부</returns>
    public static bool IsLessThanOrClose(double left, double right)
    {
        return (left < right) || AreClose(left, right);
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

using System;

using System.Runtime.InteropServices;

/// <summary>

/// 숫자 확장

/// </summary>

/// <remarks>

/// 컨트롤에서 사용하는 숫자 유틸리티 메소드이다.

/// 이러한 메소드는 범위가 WPF DoubleUtil 클래스와 유사하다.

/// </remarks>

public static class NumericExtensions

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Structure

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 배정도 실수 공용체 - DoubleUnion

/// <summary>

/// 배정도 실수 공용체

/// </summary>

/// <remarks>

/// NanUnion은 double을 비트를 쉽게 조작할 수 있는 unsigned long으로 효율적으로 변환하는 데 사용되는 C++ 스타일 유형 공용체이다.

/// </remarks>

[StructLayout(LayoutKind.Explicit)]

public struct DoubleUnion

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 실수 값

/// </summary>

/// <remarks>

/// 공용체의 부동 소수점 표현이다.

/// </remarks>

[FieldOffset(0)]

public double FloatingValue;

/// <summary>

/// 정수 값

/// </summary>

/// <remarks>

/// 공용체의 정수 표현이다.

/// </remarks>

[FieldOffset(0)]

public ulong IntegerValue;

#endregion

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Structure

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 0 여부 구하기 - IsZero(value)

/// <summary>

/// 0 여부 구하기

/// </summary>

/// <param name="value">배정도 실수 값</param>

/// <returns>0 여부</returns>

public static bool IsZero(this double value)

{

return Math.Abs(value) < 2.2204460492503131E-15;

}

#endregion

#region 비숫자 여부 구하기 - IsNaN(value)

/// <summary>

/// 비숫자 여부 구하기

/// </summary>

/// <param name="value">값</param>

/// <returns>비숫자 여부</returns>

public static bool IsNaN(this double value)

{

DoubleUnion union = new DoubleUnion { FloatingValue = value };

// IEEE 754 배정밀도 부동 소수점 숫자는 지수가 2047이고 가수가 0이 아닌 경우 NaN이다.

ulong exponent = union.IntegerValue & 0xfff0000000000000L;

if((exponent != 0x7ff0000000000000L) && (exponent != 0xfff0000000000000L))

{

return false;

}

ulong mantissa = union.IntegerValue & 0x000fffffffffffffL;

return mantissa != 0L;

}

#endregion

#region 두 숫자의 값이 비슷한지 여부 구하기 - AreClose(left, right)

/// <summary>

/// 두 숫자의 값이 비슷한지 여부 구하기

/// </summary>

/// <param name="left">왼쪽 값</param>

/// <param name="right">오른쪽 값</param>

/// <returns>두 숫자의 값이 비슷한지 여부</returns>

public static bool AreClose(double left, double right)

{

if(left == right)

{

return true;

}

double a = (Math.Abs(left) + Math.Abs(right) + 10.0) * 2.2204460492503131E-16;

double b = left - right;

return (-a < b) && (a > b);

}

#endregion

#region 값 이상 여부 구하기 - IsGreaterThan(left, right)

/// <summary>

/// 값 이상 여부 구하기

/// </summary>

/// <param name="left">왼쪽 값</param>

/// <param name="right">오른쪽 값</param>

/// <returns>값 이상 여부</returns>

public static bool IsGreaterThan(double left, double right)

{

return (left > right) && !AreClose(left, right);

}

#endregion

#region 값 이하 여부 구하기 - IsLessThanOrClose(left, right)

/// <summary>

/// 값 이하 여부 구하기

/// </summary>

/// <param name="left">왼쪽 값</param>

/// <param name="right">오른쪽 값</param>

/// <returns>값 이하 여부</returns>

public static bool IsLessThanOrClose(double left, double right)

{

return (left < right) || AreClose(left, right);

}

#endregion

}

[C#/WINFORM/TEECHART] Regression 클래스 : LinearRegression 정적 메소드를 사용해 데이터를 선형화 가능한 모델에 맞추기

■ Regression 클래스의 LinearRegression 정적 메소드를 사용해 데이터를 선형화 가능한 모델에 맞추는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Drawing;
using System.Windows.Forms;

using Steema.TeeChart.Functions;
using Steema.TeeChart.Styles;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 포인트 시리즈
        /// </summary>
        private Points points;

        /// <summary>
        /// Y 예측값 배열
        /// </summary>
        private double[] yHatArray;

        /// <summary>
        /// 계수 배열
        /// </summary>
        private double[] coefficientArray;

        /// <summary>
        /// 라인 시리즈
        /// </summary>
        private Line line;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            #region 포인트 시리즈를 생성한다.

            this.points = new Points();

            this.points.Title               = "Source";
            this.points.Pointer.Brush.Color = Color.FromArgb(115, 141, 192);
            this.points.Pointer.Pen.Color   = Color.FromArgb(69, 85, 115);
            this.points.Pointer.Style       = PointerStyles.Rectangle;

            #endregion
            #region 라인 시리즈를 생성한다.

            this.line = new Line();

            this.line.Title = "Fitted";
            this.line.Color = Color.Orange;

            #endregion
            #region 티차트를 설정한다.

            this.tChart.Series.Add(this.points);
            this.tChart.Series.Add(this.line);

            #endregion

            this.points.Add(1.1 , 1  );
            this.points.Add(1.2 , 2.5);
            this.points.Add(1.25, 4  );
            this.points.Add(1.3 , 3  );
            this.points.Add(1.9 , 5.5);
            this.points.Add(2.1 , 6.2);
            this.points.Add(2.2 , 6.6);
            this.points.Add(2.4 , 7.2);
            this.points.Add(3   , 8  );
            this.points.Add(3.5 , 12 );

            Load                                    += Form_Load;
            this.modelComboBox.SelectedIndexChanged += modelComboBox_SelectedIndexChanged;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 폼 로드시 처리하기 - Form_Load(sender, e)

        /// <summary>
        /// 폼 로드시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Form_Load(object sender, EventArgs e)
        {
            this.modelComboBox.SelectedIndex = 0;
        }

        #endregion
        #region 모델 콤보 박스 선택 인덱스 변경시 처리하기 - modelComboBox_SelectedIndexChanged(sender, e)

        /// <summary>
        /// 모델 콤보 박스 선택 인덱스 변경시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void modelComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.yHatArray = new double[this.points.XValues.Count];

            this.line.Clear();

            if(FitModel(points, ref this.yHatArray, out this.coefficientArray, this.modelComboBox.SelectedIndex))
            {
                this.line.XValues.Count = this.points.XValues.Count;
                this.line.XValues.Value = this.points.XValues.Value;
                this.line.YValues.Count = this.points.XValues.Count;
                this.line.YValues.Value = this.yHatArray;

                switch(this.modelComboBox.SelectedIndex)
                {
                    case 0 :

                        this.tChart.Header.Text = "y = a * Exp(b * x)\r\na = " + this.coefficientArray[0].ToString("0.00")+"  b = "+this.coefficientArray[1].ToString("0.00");

                        break;

                    case 1 :

                        this.tChart.Header.Text = "y = a x ^ b\r\na = " + this.coefficientArray[0].ToString("0.00") + "  b = " + this.coefficientArray[1].ToString("0.00");

                        break;

                    case 2 :

                        this.tChart.Header.Text = "y = b * ln(x) + a\r\na  =" + this.coefficientArray[0].ToString("0.00") + "  b = " + this.coefficientArray[1].ToString("0.00");

                        break;
                }
            }

            this.line.Repaint();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 모델 맞추기 - FitModel(source, yHatArray, coeffientArray, modelIndex)

        /// <summary>
        /// 모델 맞추기
        /// </summary>
        /// <param name="source">소스 시리즈</param>
        /// <param name="yHatArray">Y 예측값 배열</param>
        /// <param name="coeffientArray">계수 배열</param>
        /// <param name="modelIndex">모델 인덱스</param>
        /// <returns>처리 결과</returns>
        private bool FitModel(Series source, ref double[] yHatArray, out double[] coeffientArray, int modelIndex)
        {
            double[] yArray = new double[source.Count];
            double[] xArray = new double[source.Count];
            double[] wArray = new double[source.Count];

            bool validModel = true;

            switch(modelIndex)
            {
                case 0 :
                    // y(x) = a * Exp(b * x)
                    // linear model : ln(y) = b * x + ln(a)
                    for(int i = 0; i < source.Count; i++)
                    {
                        xArray[i] = source.notMandatory[i];
                        yArray[i] = Math.Log(source.mandatory[i]);
                        wArray[i] = source.mandatory[i] * source.mandatory[i];
                    }

                    Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

                    coeffientArray[0] = Math.Exp(coeffientArray[0]);

                    for(int i = 0; i < source.Count; i++)
                    {
                        yHatArray[i] = coeffientArray[0] * Math.Exp(coeffientArray[1] * xArray[i]);
                    }

                    break;

                case 1 :
                    // Power model y = a * x ^ b
                    // linear model : ln(y) = b * ln(x) + ln(a)
                    for(int i = 0; i < source.Count; i++)
                    {
                        xArray[i] = Math.Log(source.notMandatory[i]);
                        yArray[i] = Math.Log(source.mandatory[i]);
                        wArray[i] = source.mandatory[i] * source.mandatory[i];
                    }

                    Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

                    coeffientArray[0] = Math.Exp(coeffientArray[0]);

                    for(int i = 0; i < source.Count; i++)
                    {
                        yHatArray[i] = coeffientArray[0] * Math.Pow(source.notMandatory[i], coeffientArray[1]);
                    }

                    break;

                case 2 :
                    // Logarithmic model y = b * ln(x) + a
                    for(int i = 0; i < source.Count; i++)
                    {
                        xArray[i] = Math.Log(source.notMandatory[i]);
                        yArray[i] = source.mandatory[i];
                        wArray[i] = source.mandatory[i] * source.mandatory[i];
                    }

                    Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

                    for(int i = 0; i < source.Count; i++)
                    {
                        yHatArray[i] = coeffientArray[1] * Math.Log(source.notMandatory[i]) + coeffientArray[0];
                    }

                    break;

                default :

                    coeffientArray = new double[0];

                    break;
            }

            return validModel;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

using System;

using System.Drawing;

using System.Windows.Forms;

using Steema.TeeChart.Functions;

using Steema.TeeChart.Styles;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 포인트 시리즈

/// </summary>

private Points points;

/// <summary>

/// Y 예측값 배열

/// </summary>

private double[] yHatArray;

/// <summary>

/// 계수 배열

/// </summary>

private double[] coefficientArray;

/// <summary>

/// 라인 시리즈

/// </summary>

private Line line;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

#region 포인트 시리즈를 생성한다.

this.points = new Points();

this.points.Title = "Source";

this.points.Pointer.Brush.Color = Color.FromArgb(115, 141, 192);

this.points.Pointer.Pen.Color = Color.FromArgb(69, 85, 115);

this.points.Pointer.Style = PointerStyles.Rectangle;

#endregion

#region 라인 시리즈를 생성한다.

this.line = new Line();

this.line.Title = "Fitted";

this.line.Color = Color.Orange;

#endregion

#region 티차트를 설정한다.

this.tChart.Series.Add(this.points);

this.tChart.Series.Add(this.line);

#endregion

this.points.Add(1.1 , 1 );

this.points.Add(1.2 , 2.5);

this.points.Add(1.25, 4 );

this.points.Add(1.3 , 3 );

this.points.Add(1.9 , 5.5);

this.points.Add(2.1 , 6.2);

this.points.Add(2.2 , 6.6);

this.points.Add(2.4 , 7.2);

this.points.Add(3 , 8 );

this.points.Add(3.5 , 12 );

Load += Form_Load;

this.modelComboBox.SelectedIndexChanged += modelComboBox_SelectedIndexChanged;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 폼 로드시 처리하기 - Form_Load(sender, e)

/// <summary>

/// 폼 로드시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Form_Load(object sender, EventArgs e)

{

this.modelComboBox.SelectedIndex = 0;

}

#endregion

#region 모델 콤보 박스 선택 인덱스 변경시 처리하기 - modelComboBox_SelectedIndexChanged(sender, e)

/// <summary>

/// 모델 콤보 박스 선택 인덱스 변경시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void modelComboBox_SelectedIndexChanged(object sender, EventArgs e)

{

this.yHatArray = new double[this.points.XValues.Count];

this.line.Clear();

if(FitModel(points, ref this.yHatArray, out this.coefficientArray, this.modelComboBox.SelectedIndex))

{

this.line.XValues.Count = this.points.XValues.Count;

this.line.XValues.Value = this.points.XValues.Value;

this.line.YValues.Count = this.points.XValues.Count;

this.line.YValues.Value = this.yHatArray;

switch(this.modelComboBox.SelectedIndex)

{

case 0 :

this.tChart.Header.Text = "y = a * Exp(b * x)\r\na = " + this.coefficientArray[0].ToString("0.00")+" b = "+this.coefficientArray[1].ToString("0.00");

break;

case 1 :

this.tChart.Header.Text = "y = a x ^ b\r\na = " + this.coefficientArray[0].ToString("0.00") + " b = " + this.coefficientArray[1].ToString("0.00");

break;

case 2 :

this.tChart.Header.Text = "y = b * ln(x) + a\r\na =" + this.coefficientArray[0].ToString("0.00") + " b = " + this.coefficientArray[1].ToString("0.00");

break;

}

this.line.Repaint();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 모델 맞추기 - FitModel(source, yHatArray, coeffientArray, modelIndex)

/// <summary>

/// 모델 맞추기

/// </summary>

/// <param name="source">소스 시리즈</param>

/// <param name="yHatArray">Y 예측값 배열</param>

/// <param name="coeffientArray">계수 배열</param>

/// <param name="modelIndex">모델 인덱스</param>

/// <returns>처리 결과</returns>

private bool FitModel(Series source, ref double[] yHatArray, out double[] coeffientArray, int modelIndex)

{

double[] yArray = new double[source.Count];

double[] xArray = new double[source.Count];

double[] wArray = new double[source.Count];

bool validModel = true;

switch(modelIndex)

{

case 0 :

// y(x) = a * Exp(b * x)

// linear model : ln(y) = b * x + ln(a)

for(int i = 0; i < source.Count; i++)

{

xArray[i] = source.notMandatory[i];

yArray[i] = Math.Log(source.mandatory[i]);

wArray[i] = source.mandatory[i] * source.mandatory[i];

}

Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

coeffientArray[0] = Math.Exp(coeffientArray[0]);

for(int i = 0; i < source.Count; i++)

{

yHatArray[i] = coeffientArray[0] * Math.Exp(coeffientArray[1] * xArray[i]);

}

break;

case 1 :

// Power model y = a * x ^ b

// linear model : ln(y) = b * ln(x) + ln(a)

for(int i = 0; i < source.Count; i++)

{

xArray[i] = Math.Log(source.notMandatory[i]);

yArray[i] = Math.Log(source.mandatory[i]);

wArray[i] = source.mandatory[i] * source.mandatory[i];

}

Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

coeffientArray[0] = Math.Exp(coeffientArray[0]);

for(int i = 0; i < source.Count; i++)

{

yHatArray[i] = coeffientArray[0] * Math.Pow(source.notMandatory[i], coeffientArray[1]);

}

break;

case 2 :

// Logarithmic model y = b * ln(x) + a

for(int i = 0; i < source.Count; i++)

{

xArray[i] = Math.Log(source.notMandatory[i]);

yArray[i] = source.mandatory[i];

wArray[i] = source.mandatory[i] * source.mandatory[i];

}

Regression.LinearRegression(source.Count, xArray, yArray, wArray, out coeffientArray);

for(int i = 0; i < source.Count; i++)

{

yHatArray[i] = coeffientArray[1] * Math.Log(source.notMandatory[i]) + coeffientArray[0];

}

break;

default :

coeffientArray = new double[0];

break;

}

return validModel;

}

#endregion

}

TestProject.zip

[RUST/RAND] ThreadRng 구조체 : gen_range 메소드를 사용해 숫자 맞추기 게임 만들기

■ ThreadRng 구조체의 gen_range 메소드를 사용해 임의의 난수를 생성하고 숫자를 맞추는 게임을 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

rand = "0.8.0"

▶ src/main.rs


use std::cmp;
use std::io;

use rand;
use rand::rngs;
use rand::Rng;

fn main()
{
    println!("Guess the number!");

    let mut thread_rng: rngs::ThreadRng = rand::thread_rng();

    let secret_number : u32 = thread_rng.gen_range(1..=100);

    loop
    {
        println!("Please input your guess.");

        let mut guess_string : String = String::new();

        io::stdin().read_line(&mut guess_string).expect("Failed to read line");

        let guess_number : u32 = match guess_string.trim().parse()
        {
            Ok(number) => number,
            Err(_)          => continue
        };

        println!("You guessed : {}", guess_number);

        match guess_number.cmp(&secret_number)
        {
            cmp::Ordering::Less    => println!("Too small!"),
            cmp::Ordering::Greater => println!("Too big!"),
            cmp::Ordering::Equal   =>
            {
                println!("You win!");

                break;
            }
        }
    }
}

use std::cmp;

use std::io;

use rand;

use rand::rngs;

use rand::Rng;

fn main()

{

println!("Guess the number!");

let mut thread_rng: rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

loop

{

println!("Please input your guess.");

let mut guess_string : String = String::new();

io::stdin().read_line(&mut guess_string).expect("Failed to read line");

let guess_number : u32 = match guess_string.trim().parse()

{

Ok(number) => number,

Err(_) => continue

};

println!("You guessed : {}", guess_number);

match guess_number.cmp(&secret_number)

{

cmp::Ordering::Less => println!("Too small!"),

cmp::Ordering::Greater => println!("Too big!"),

cmp::Ordering::Equal =>

{

println!("You win!");

break;

}

test_project.zip

[RUST/COMMON] Ord 트레잇 : cmp 메소드를 사용해 숫자 비교하기

■ Ord 트레잇의 cmp 메소드를 사용해 숫자를 비교하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::cmp;

let a : u32 = 10;
let b : u32 = 20;

match a.cmp(&b)
{
    cmp::Ordering::Less    => println!("A가 B보다 작다."),
    cmp::Ordering::Greater => println!("A가 B보다 크다."),
    cmp::Ordering::Equal   => println!("A와 B가 같다.")
}

use std::cmp;

let a : u32 = 10;

let b : u32 = 20;

match a.cmp(&b)

{

cmp::Ordering::Less => println!("A가 B보다 작다."),

cmp::Ordering::Greater => println!("A가 B보다 크다."),

cmp::Ordering::Equal => println!("A와 B가 같다.")

}

[RUST/RAND] ThreadRng 구조체 : gen_range 메소드를 사용해 임의의 난수 구하기

■ ThreadRng 구조체의 gen_range 메소드를 사용해 임의의 난수를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use rand::rngs;
use rand::Rng;

let mut thread_rng : rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

use rand::rngs;

use rand::Rng;

let mut thread_rng : rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

[RUST/COMMON] 크레이트 설치 : getrandom

■ getrandom 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
getrandom = "0.2.3"

...

[dependencies]

getrandom = "0.2.3"

[RUST/COMMON] 역 폴란드 표기법(RPN ; Reverse Polish Notation) 수식 계산하기

■ 역 폴란드 표기법(RPN ; Reverse Polish Notation)의 수식을 계산하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::io;
use std::str;

fn main()
{
    let mut vector : Vec<f64> = vec![];

    println!("역 폴란드 표기법으로 수식을 입력해 주시기 바랍니다 : ");

    let mut input_string : String = String::new();

    io::stdin().read_line(&mut input_string).expect("입력 문자열에서 에러가 발생했습니다.");

    let token_split_whitespace : str::SplitWhitespace = input_string.split_whitespace();

    for token in token_split_whitespace
    {
        let token_trimmed : &str = token.trim();

        match token_trimmed.parse::<f64>()
        {
            Ok(value) =>
            {
                vector.push(value);

                continue;
            },
            Err(_) => 0.0,
        };

        let value2 : f64 = vector.pop().unwrap();
        let value1 : f64 = vector.pop().unwrap();

        match token_trimmed
        {
            "+" => vector.push(value1 + value2),
            "-" => vector.push(value1 - value2),
            "*" => vector.push(value1 * value2),
            "/" => vector.push(value1 / value2),
            _   => panic!("계산 불가 연산자 : {}", token_trimmed)
        }
    }

    println!("{}", vector.pop().unwrap());
}

use std::io;

use std::str;

fn main()

{

let mut vector : Vec<f64> = vec![];

println!("역 폴란드 표기법으로 수식을 입력해 주시기 바랍니다 : ");

let mut input_string : String = String::new();

io::stdin().read_line(&mut input_string).expect("입력 문자열에서 에러가 발생했습니다.");

let token_split_whitespace : str::SplitWhitespace = input_string.split_whitespace();

for token in token_split_whitespace

{

let token_trimmed : &str = token.trim();

match token_trimmed.parse::<f64>()

{

Ok(value) =>

{

vector.push(value);

continue;

Err(_) => 0.0,

};

let value2 : f64 = vector.pop().unwrap();

let value1 : f64 = vector.pop().unwrap();

match token_trimmed

{

"+" => vector.push(value1 + value2),

"-" => vector.push(value1 - value2),

"*" => vector.push(value1 * value2),

"/" => vector.push(value1 / value2),

_ => panic!("계산 불가 연산자 : {}", token_trimmed)

}

println!("{}", vector.pop().unwrap());

}

[RUST/COMMON] 선형 합동법 알고리즘을 사용해 난수 생성하기

■ 선형 합동법 알고리즘을 사용해 난수를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::num::Wrapping;

fn get_seed(seed : &mut u32) -> u32
{
    let (a, c) = (134775813u32, 12345u32);

    *seed = (Wrapping(*seed) * Wrapping(a) + Wrapping(c)).0;

    return *seed;
}

fn get_random_value(seed : &mut u32, minimum_value : u32, maximum_value : u32) -> u32
{
    let random_value : u32 = get_seed(seed) % (maximum_value - minimum_value + 1) + minimum_value;

    return random_value;
}

fn main()
{
    let mut seed : u32 = 12345u32;

    for i in 0..10
    {
        let random_value : u32 = get_random_value(&mut seed, 1, 10);

        println!("{}, {}", i + 1, random_value);
    }
}

/*
1, 9
2, 2
3, 1
4, 2
5, 5
6, 2
7, 9
8, 6
9, 7
10, 4
*/

use std::num::Wrapping;

fn get_seed(seed : &mut u32) -> u32

{

let (a, c) = (134775813u32, 12345u32);

*seed = (Wrapping(*seed) * Wrapping(a) + Wrapping(c)).0;

return *seed;

}

fn get_random_value(seed : &mut u32, minimum_value : u32, maximum_value : u32) -> u32

{

let random_value : u32 = get_seed(seed) % (maximum_value - minimum_value + 1) + minimum_value;

return random_value;

}

fn main()

{

let mut seed : u32 = 12345u32;

for i in 0..10

{

let random_value : u32 = get_random_value(&mut seed, 1, 10);

println!("{}, {}", i + 1, random_value);

}

1, 9

2, 2

3, 1

4, 2

5, 5

6, 2

7, 9

8, 6

9, 7

10, 4

[RUST/COMMON] Iterator 트레잇 : 피보나치 수열을 구하는 반복자 만들기

■ Iterator 트레잇을 사용해 피보나치 수열을 구하는 반복자를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


struct FibonacciIterator
{
    a : usize,
    b : usize
}

impl FibonacciIterator
{
    fn new() -> Self
    {
        return FibonacciIterator { a : 1, b : 1 };
    }
}

impl Iterator for FibonacciIterator
{
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item>
    {
        let temporary_value : usize = self.a;

        self.a = self.b;

        self.b += temporary_value;

        return Some(self.a);
    }
}

fn main()
{
    let fibonacci_iterator1 : FibonacciIterator = FibonacciIterator::new();

    for (index, value) in fibonacci_iterator1.enumerate()
    {
        if index >= 10
        {
            break;
        }

        print!("{},", value);
    }

    println!("");

    let fibonacci_iterator2 : FibonacciIterator = FibonacciIterator::new();

    fibonacci_iterator2.take(10).for_each(|value : usize| print!("{},", value));

    print!("\n")
}

struct FibonacciIterator

{

a : usize,

b : usize

}

impl FibonacciIterator

{

fn new() -> Self

{

return FibonacciIterator { a : 1, b : 1 };

}

impl Iterator for FibonacciIterator

{

type Item = usize;

fn next(&mut self) -> Option<Self::Item>

{

let temporary_value : usize = self.a;

self.a = self.b;

self.b += temporary_value;

return Some(self.a);

}

fn main()

{

let fibonacci_iterator1 : FibonacciIterator = FibonacciIterator::new();

for (index, value) in fibonacci_iterator1.enumerate()

{

if index >= 10

{

break;

}

print!("{},", value);

}

println!("");

let fibonacci_iterator2 : FibonacciIterator = FibonacciIterator::new();

fibonacci_iterator2.take(10).for_each(|value : usize| print!("{},", value));

print!("\n")

}

[RUST/COMMON] Iterator 트레잇 : 소수를 구하는 반복자 만들기

■ Iterator 트레잇을 구현해 소수를 구하는 반복자를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


struct PrimeIterator
{
    n : u8
}

impl PrimeIterator
{
    fn new() -> Self
    {
        return PrimeIterator { n : 1 };
    }

    fn is_prime(&self) -> bool
    {
        for i in 2..self.n
        {
            if self.n % i == 0
            {
                return false;
            }
        }

        return true;
    }
}

impl Iterator for PrimeIterator
{
    type Item = u8;

    fn next(&mut self) -> Option<Self::Item>
    {
        loop
        {
            self.n += 1;

            if std::u8::MAX == self.n
            {
                return None
            }

            if self.is_prime()
            {
                return Some(self.n);
            }
        }
    }
}

fn main()
{
    let prime_iterator : PrimeIterator = PrimeIterator::new();

    for n in prime_iterator
    {
        print!("{},", n);
    }
}

struct PrimeIterator

{

n : u8

}

impl PrimeIterator

{

fn new() -> Self

{

return PrimeIterator { n : 1 };

}

fn is_prime(&self) -> bool

{

for i in 2..self.n

{

if self.n % i == 0

{

return false;

}

return true;

}

impl Iterator for PrimeIterator

{

type Item = u8;

fn next(&mut self) -> Option<Self::Item>

{

loop

{

self.n += 1;

if std::u8::MAX == self.n

{

return None

}

if self.is_prime()

{

return Some(self.n);

}

fn main()

{

let prime_iterator : PrimeIterator = PrimeIterator::new();

for n in prime_iterator

{

print!("{},", n);

}

[RUST/COMMON] struct 키워드 : BMI 판정표를 만들고 체질량 지수(Body Mass Index) 판정하기 (구조 개선)

■ struct 키워드를 사용하고 BMI 판정표를 만들고 체질량 지수(Body Mass Index)를 판정하는 방법을 보여준다. ▶ 예제 코드 (RS)


fn main()
{
    let body : Body = Body::new(163.0, 75.2, "영희");

    body.print_result();

    let body: Body = Body::new(158.2, 55.0, "진희");

    body.print_result();

    let body: Body = Body::new(174.2, 54.2, "문희");

    body.print_result();
}

struct BMIRange
{
    minimum : f64,
    maximum : f64,
    label   : String
}

impl BMIRange
{
    fn new(minmum : f64, maximum : f64, label : &str) -> Self
    {
        return BMIRange
        {
            minimum : minmum,
            maximum : maximum,
            label   : label.to_string()
        };
    }

    fn test(&self, value : f64) -> bool
    {
        return (self.minimum <= value) && (value < self.maximum);
    }
}

struct Body
{
    height : f64,
    weight : f64,
    name   : String
}

impl Body
{
    fn new(height : f64, weight : f64, name : &str) -> Self
    {
        return Body
        {
            height : height,
            weight : weight,
            name   : name.to_string()
        };
    }

    fn calculate_bmi(&self) -> f64
    {
        return self.weight / (self.height / 100.0).powf(2.0);
    }

    fn print_result(&self)
    {
        let bmi : f64 = self.calculate_bmi();

        let bmi_range_array : [BMIRange; 6] =
        [
            BMIRange::new( 0.0, 18.5, "저체중"    ),
            BMIRange::new(18.5, 23.0, "정상"      ),
            BMIRange::new(23.0, 25.0, "비만전단계"),
            BMIRange::new(25.0, 30.0, "1단계 비만"),
            BMIRange::new(30.0, 35.0, "2단계 비만"),
            BMIRange::new(35.0, 99.9, "3단계 비만")
        ];

        let mut result : String = String::from("계산 불가");

        for range in bmi_range_array
        {
            if range.test(bmi)
            {
                result = range.label.clone();

                break;
            }
        }

        println!("성명 : {}, BMI : {:.1}, 결과 : {}", self.name, bmi, result);
    }
}

fn main()

{

let body : Body = Body::new(163.0, 75.2, "영희");

body.print_result();

let body: Body = Body::new(158.2, 55.0, "진희");

body.print_result();

let body: Body = Body::new(174.2, 54.2, "문희");

body.print_result();

}

struct BMIRange

{

minimum : f64,

maximum : f64,

label : String

}

impl BMIRange

{

fn new(minmum : f64, maximum : f64, label : &str) -> Self

{

return BMIRange

{

minimum : minmum,

maximum : maximum,

label : label.to_string()

};

}

fn test(&self, value : f64) -> bool

{

return (self.minimum <= value) && (value < self.maximum);

}

struct Body

{

height : f64,

weight : f64,

name : String

}

impl Body

{

fn new(height : f64, weight : f64, name : &str) -> Self

{

return Body

{

height : height,

weight : weight,

name : name.to_string()

};

}

fn calculate_bmi(&self) -> f64

{

return self.weight / (self.height / 100.0).powf(2.0);

}

fn print_result(&self)

{

let bmi : f64 = self.calculate_bmi();

let bmi_range_array : [BMIRange; 6] =

[

BMIRange::new( 0.0, 18.5, "저체중" ),

BMIRange::new(18.5, 23.0, "정상" ),

BMIRange::new(23.0, 25.0, "비만전단계"),

BMIRange::new(25.0, 30.0, "1단계 비만"),

BMIRange::new(30.0, 35.0, "2단계 비만"),

BMIRange::new(35.0, 99.9, "3단계 비만")

];

let mut result : String = String::from("계산 불가");

for range in bmi_range_array

{

if range.test(bmi)

{

result = range.label.clone();

break;

}

println!("성명 : {}, BMI : {:.1}, 결과 : {}", self.name, bmi, result);

}

[RUST/COMMON] Xorshift 알고리즘을 사용해 난수 생성하기 (unsafe 미사용)

■ Xorshift 알고리즘을 사용해 난수를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::time;

fn main()
{
    let mut seed : u32 = get_seed();

    for _ in 0..100
    {
        let random_value : u32 = get_random_value(&mut seed, 1, 6);

        println!("{}", random_value);
    }
}

fn get_seed() -> u32
{
    return time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap().as_millis() as u32;
}

fn get_random_value(seed: &mut u32, start: u32, end: u32) -> u32
{
    *seed ^= *seed << 13;
    *seed ^= *seed >> 17;
    *seed ^= *seed << 5;

    return *seed % (end - start + 1) + start;
}

use std::time;

fn main()

{

let mut seed : u32 = get_seed();

for _ in 0..100

{

let random_value : u32 = get_random_value(&mut seed, 1, 6);

println!("{}", random_value);

}

fn get_seed() -> u32

{

return time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap().as_millis() as u32;

}

fn get_random_value(seed: &mut u32, start: u32, end: u32) -> u32

{

*seed ^= *seed << 13;

*seed ^= *seed >> 17;

*seed ^= *seed << 5;

return *seed % (end - start + 1) + start;

}

[RUST/COMMON] Xorshift 알고리즘을 사용해 난수 생성하기

■ Xorshift 알고리즘을 사용해 난수를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::time;

static mut SEED : u32 = 0;

unsafe fn get_random_value(start : u32, end : u32) -> u32
{
    if SEED == 0
    {
        let epoc : time::Duration = time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap();

        SEED = epoc.as_millis() as u32;
    }

    SEED ^= SEED << 13;
    SEED ^= SEED >> 17;
    SEED ^= SEED << 5;

    return SEED % (end - start + 1) + start;
}

fn main()
{
    for _ in 0..100
    {
        unsafe
        {
            let random_value : u32 = get_random_value(1, 6);

            println!("{}", random_value);
        }
    }
}

use std::time;

static mut SEED : u32 = 0;

unsafe fn get_random_value(start : u32, end : u32) -> u32

{

if SEED == 0

{

let epoc : time::Duration = time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap();

SEED = epoc.as_millis() as u32;

}

SEED ^= SEED << 13;

SEED ^= SEED >> 17;

SEED ^= SEED << 5;

return SEED % (end - start + 1) + start;

}

fn main()

{

for _ in 0..100

{

unsafe

{

let random_value : u32 = get_random_value(1, 6);

println!("{}", random_value);

}

[RUST/COMMON] struct 키워드 : 체질량 지수(Body Mass Index) 구하기

■ struct 키워드로 구조체를 사용해 체질량 지수(Body Mass Index)를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


struct Body
{
    weight : f64,
    height : f64
}

fn calculate_bmi(body : &Body) -> f64
{
    let height : f64 = body.height / 100.0;

    return body.weight / height.powf(2.0);
}

fn main()
{
    let person1: Body  = Body
    {
        weight : 80.0,
        height : 165.0
    };

    let person2: Body = Body
    {
        weight : 65.0,
        height : 170.0
    };

    println!("사람 1 = {:.1}", calculate_bmi(&person1));
    println!("사람 2 = {:.1}", calculate_bmi(&person2));
}

struct Body

{

weight : f64,

height : f64

}

fn calculate_bmi(body : &Body) -> f64

{

let height : f64 = body.height / 100.0;

return body.weight / height.powf(2.0);

}

fn main()

{

let person1: Body = Body

{

weight : 80.0,

height : 165.0

};

let person2: Body = Body

{

weight : 65.0,

height : 170.0

};

println!("사람 1 = {:.1}", calculate_bmi(&person1));

println!("사람 2 = {:.1}", calculate_bmi(&person2));

}

[RUST/COMMON] struct 키워드 : BMI 판정표를 만들고 체질량 지수(Body Mass Index) 판정하기

■ struct 키워드를 사용해 BMI 판정표를 만들고 체질량 지수(Body Mass Index)를 판정하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::io;

struct BMIRange
{
    minimum : f64,
    maximum : f64,
    label   : &'static str
}

fn input(prompt : &str) -> f64
{
    println!("{}", prompt);

    let mut source: String = String::new();

    io::stdin().read_line(&mut source).expect("입력 에러");

    return source.trim().parse().expect("숫자 변환 에러");
}

fn main()
{
    let height_cm : f64 = input("키(cm) : ");
    let weight    : f64 = input("몸무게(kg) : ");

    let height : f64 = height_cm / 100.0;
    let bmi    : f64 = weight / height.powf(2.0);

    let bmi_range_list : Vec<BMIRange> = vec!
    [
        BMIRange
        {
            minimum : 0.0,
            maximum : 18.5,
            label   : "저체중"
        },
        BMIRange
        {
            minimum : 18.5,
            maximum : 23.0,
            label   : "정상"
        },
        BMIRange
        {
            minimum : 23.0,
            maximum : 25.0,
            label   : "비만전단계"
        },
        BMIRange
        {
            minimum : 25.0,
            maximum : 30.0,
            label   : "1단계 비만"
        },
        BMIRange
        {
            minimum : 30.0,
            maximum : 35.0,
            label   : "2단계 비만"
        },
        BMIRange
        {
            minimum : 35.0,
            maximum : 99.0,
            label   : "3단계 비만"
        }
    ];

    let mut result: &str = "계산 불가";

    for range in bmi_range_list
    {
        if range.minimum <= bmi && bmi < range.maximum
        {
            result = range.label;

            break;
        }
    }

    println!("BMI = {:.1}, 비만도 = {}", bmi, result);
}

use std::io;

struct BMIRange

{

minimum : f64,

maximum : f64,

label : &'static str

}

fn input(prompt : &str) -> f64

{

println!("{}", prompt);

let mut source: String = String::new();

io::stdin().read_line(&mut source).expect("입력 에러");

return source.trim().parse().expect("숫자 변환 에러");

}

fn main()

{

let height_cm : f64 = input("키(cm) : ");

let weight : f64 = input("몸무게(kg) : ");

let height : f64 = height_cm / 100.0;

let bmi : f64 = weight / height.powf(2.0);

let bmi_range_list : Vec<BMIRange> = vec!

[

BMIRange

{

minimum : 0.0,

maximum : 18.5,

label : "저체중"

BMIRange

{

minimum : 18.5,

maximum : 23.0,

label : "정상"

BMIRange

{

minimum : 23.0,

maximum : 25.0,

label : "비만전단계"

BMIRange

{

minimum : 25.0,

maximum : 30.0,

label : "1단계 비만"

BMIRange

{

minimum : 30.0,

maximum : 35.0,

label : "2단계 비만"

BMIRange

{

minimum : 35.0,

maximum : 99.0,

label : "3단계 비만"

}

];

let mut result: &str = "계산 불가";

for range in bmi_range_list

{

if range.minimum <= bmi && bmi < range.maximum

{

result = range.label;

break;

}

println!("BMI = {:.1}, 비만도 = {}", bmi, result);

}

[RUST/COMMON] 재귀적 함수 호출을 사용해 피보나치 수열 출력하기

■ 재귀적 함수 호출을 사용해 피보나치 수열을 출력하는 방법을 보여준다. ▶ 예제 코드 (RS)


fn main()
{
    for i in 2..=20
    {
        println!("{}", calculate_fibonacci_sequence(i));
    }
}

fn calculate_fibonacci_sequence(index : i64) -> i64
{
    if index == 1
    {
        return 0;
    }

    if index == 2
    {
        return 1;
    }

    return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);
}

/*
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
*/

fn main()

{

for i in 2..=20

{

println!("{}", calculate_fibonacci_sequence(i));

}

fn calculate_fibonacci_sequence(index : i64) -> i64

{

if index == 1

{

return 0;

}

if index == 2

{

return 1;

}

return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);

}

144

233

377

610

987

1597

2584

4181

[RUST/COMMON] 체질량 지수(Body Mass Index) 구하기

■ 체질량 지수(Body Mass Index)를 구하는 방법을 보여준다. ▶ main.rs


fn main()
{
    let height_cm = input("키(cm) : ");
    let weight_kg = input("몸무게(kg) : ");

    let height = height_cm / 100.0;
    let bmi    = weight_kg / height.powf(2.0);

    println!("BMI = {:.1}", bmi);

    if bmi < 18.5
    {
        println!("저체중");
    }
    else if bmi < 23.0
    {
        println!("정상");
    }
    else if bmi < 25.0
    {
        println!("비만전단계");
    }
    else if bmi < 30.0
    {
        println!("1단계 비만");
    }
    else if bmi < 35.0
    {
        println!("2단계 비만");
    }
    else
    {
        println!("3단계 비만");
    }
}

fn input(prompt: &str) -> f64
{
    println!("{}", prompt);

    let mut source = String::new();

    std::io::stdin().read_line(&mut source).expect("입력 에러");

    return source.trim().parse().expect("숫자가 아닙니다.");
}

/*
키(cm) :
169
몸무게(kg) :
86
BMI = 30.1
2단계 비만
*/

fn main()

{

let height_cm = input("키(cm) : ");

let weight_kg = input("몸무게(kg) : ");

let height = height_cm / 100.0;

let bmi = weight_kg / height.powf(2.0);

println!("BMI = {:.1}", bmi);

if bmi < 18.5

{

println!("저체중");

}

else if bmi < 23.0

{

println!("정상");

}

else if bmi < 25.0

{

println!("비만전단계");

}

else if bmi < 30.0

{

println!("1단계 비만");

}

else if bmi < 35.0

{

println!("2단계 비만");

}

else

{

println!("3단계 비만");

}

fn input(prompt: &str) -> f64

{

println!("{}", prompt);

let mut source = String::new();

std::io::stdin().read_line(&mut source).expect("입력 에러");

return source.trim().parse().expect("숫자가 아닙니다.");

}

키(cm) :

169

몸무게(kg) :

BMI = 30.1

2단계 비만