All posts by kpark

C# operator== vs Equals

http://msdn.microsoft.com/en-us/library/ms173147.aspx

// Operator Overloading
if (x == y) { // 컴파일시 x와 y가 동일한지 확인

// 참조형일 경우
object x = “hello”;
object y = ‘h’ + “ello”; // ensure it’s a different reference
if (x == y) { // 결과 => FALSE
if (x.Equals(y)) { // 결과 => TRUE

// string 형(참조형이긴 하지만)일 경우
// Equals와 equality operators (== and !=) 을 구현하여 string 객체의 값이 동일한지 확인
string x1 = “hello”;
string y1 = ‘h’ + “ello”; // ensure it’s a different reference
if (x1 == y1) { // 결과 => TRUE
if (x1.Equals(y1)) { // 결과 => TRUE

Interface

Interface (인터페이스)
http://dis.dankook.ac.kr/lectures/hci09/entry/Interface

IEnumerable & IEnumerator Interface
-IEnumerable 인터페이스는 foreach를 사용하여 컬랙션을 반복하는 것을 지원하기 위해 구현하여 사용한다.
http://dis.dankook.ac.kr/lectures/hci11/entry/IEnumerable
http://dis.dankook.ac.kr/lectures/hci09/entry/Enumerator

IEquatable Interface
-IEquatable 인터페이스는 두 객체간에 서로 내부 내용이 같은 지 (예: if(a == b))를 비교하기 위해 구현하여 사용한다.
http://dis.dankook.ac.kr/lectures/hci11/entry/IEquatable
http://dis.dankook.ac.kr/lectures/hci10/72
http://dis.dankook.ac.kr/lectures/hci09/entry/Equals

IComparable Interface
-IComparable 인터페이스는 개체에 대한 기본 정렬(sort) 순서를 지정해주기 위해 구현하여 사용한다. 해당 개체를 배열이나 컬랙션에서 정렬하는데 필요하다.
http://dis.dankook.ac.kr/lectures/hci11/entry/IComparable

Method Overloading vs Method Overriding

http://dis.dankook.ac.kr/lectures/hci10/entry/Method-Overloading-vs-Method-Overriding

Method Overloading: 동일한 함수명에 매개변수가 다른 함수를 둘 이상 정의하는 것으로, 동일한 함수 기능을 수행하지만 다른 매개변수의 경우를 처리할 때 사용

Method Overriding: 상속받은 파생 클래스에서 동일한 함수명에 동일한 매개변수로 정의하여 함수를 재정의하는 것으로 상속되어진 함수의 기능을 변경해서 재사용하고 싶을 때 사용

class Point : IEquatable<Point>, IComparable<Point>
{
// static member field
protected static int count = 0;

// instance member field
protected int x, y;


// property
public int X
{
get { return this.x; }
set { this.x = value; }
}


public int Y
{
get { return this.y; }
set { this.y = value; }
}


public static int Count
{
get { return count; } // error: this.count 는 사용할 수 없음
}


// constructor & destructor
public Point() : this(0, 0) { }
public Point(int x, int y) { this.x = x; this.y = y; count++; }
~Point() { count–; }


// method
public void SetPosition(int x, int y) { this.x = x; this.y = y; }
public void Move(int x, int y) { this.x += x; this.y += y; }


// ToString method override
public override string ToString() { return (String.Format(“({0}, {1})”, x, y)); }
// virtual method
public virtual void Print() { Console.WriteLine(“X={0} Y={1}”, x, y); }

// static method
public static int GetCount() { return count; }

// operator++ overload
public static Point operator++(Point p) { ++p.x; ++p.y; return p; }
// operator== overload
public static bool operator==(Point p1, Point p2) { return p1.Equals(p2); }
// operator!= overload
public static bool operator!=(Point p1, Point p2) { return !p1.Equals(p2); }
public override int GetHashCode() { return x ^ y; }
public override bool Equals(object obj)
{
if (!(obj is Point))
return false;
return Equals((Point)obj);
}

// IEquatable
public bool Equals(Point other)
{
if (this.x == other.x && this.y == other.y)
return true;
return false;
}


// IComparable
public int CompareTo(Point other)
{
if (this.x > other.x)
{
return 1;
}
else if (this.x < other.x)
{
return -1;
}
else
{
return 0;
}
}
}




class Point3D : Point, IEquatable<Point3D>
{
// instance member field
protected int z;


// property
public int Z
{
get { return this.z; }
set { this.z = value; }
}


// constructor & destructor
public Point3D() : this(0, 0, 0) { }
public Point3D(int x, int y, int z) : base(x, y) { this.z = z; }
~Point3D() { }


public void SetPosition(int x, int y, int z) { base.SetPosition(x, y); this.z = z; }
public void Move(int x, int y, int z) { base.Move(x, y); this.z += z; }


// override ToString method
public override string ToString() { return (String.Format(“({0}, {1}, {2})”, x, y, z)); }
// overrided method
public override void Print() { Console.WriteLine(“X={0} Y={1} Z={2}”, x, y, z); }
// operator++ overload
public static Point3D operator++(Point3D p) { ++p.x; ++p.y; ++p.z; return p; }
// operator== overload
public static bool operator ==(Point3D p1, Point3D p2) { return p1.Equals(p2); }
// operator!= overload
public static bool operator !=(Point3D p1, Point3D p2) { return !p1.Equals(p2); }
public override int GetHashCode() { return x ^ y ^ z; }
public override bool Equals(object obj)
{
if (!(obj is Point3D))
return false;
return Equals((Point3D)obj);
}


// IEquatable
public bool Equals(Point3D other)
{
if (this.x == other.x && this.y == other.y && this.z == other.z)
return true;
return false;
}
}




class PointTest
{
// pass-by-value (value type)
static void Swap(int p1, int p2)
{
int p;
p = p1;
p1 = p2;
p2 = p;
}


// pass-by-reference (value type)
static void Swap(ref int p1, ref int p2)
{
int p;
p = p1;
p1 = p2;
p2 = p;
}


// pass-by-value (reference type)
static void Swap(int[] p1, int[] p2)
{
int[] p;
p = p1;
p1 = p2;
p2 = p;
}


// pass-by-value (reference type)
static void Swap(ref int[] p1, ref int[] p2)
{
int[] p;
p = p1;
p1 = p2;
p2 = p;
}


static void Swap(ref Point p1, ref Point p2)
{
Point p;
p = p1;
p1 = p2;
p2 = p;
}


static void Swap(ref Point3D p1, ref Point3D p2)
{
Point3D p;
p = p1;
p1 = p2;
p2 = p;
}


static void Main(string[] args)
{
// value type: pass-by-value/pass-by-reference
int i = 5, j = 10;
Console.WriteLine(“Before: i={0}, j={1}”, i, j);


Swap(i, j);
Console.WriteLine(“After integer pass-by-value swap: i={0}, j={1}”, i, j);


Swap(ref i, ref j);
Console.WriteLine(“After integer pass-by-reference Swap: i={0}, j={1}”, i, j);


// reference type: pass-by-value/pass-by-reference
int[] arr1 = { 1, 2, 3 };
int[] arr2 = { 4, 5, 6, 7, 8 };
Console.WriteLine(“Before array pass-by-value swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1)
Console.Write(“{0} “, a);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();


Swap(arr1, arr2);
Console.WriteLine(“After array pass-by-value swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1)
Console.Write(“{0} “, a);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();


Swap(ref arr1, ref arr2);
Console.WriteLine(“After array pass-by-reference swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1)
Console.Write(“{0} “, a);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();


Console.Write(“p1: “);
Point p1 = new Point();
Console.Write(“p2: “);
Point p2 = new Point();


// Point
p1.SetPosition(10, 10); // 변수 값 지정
Console.Write(“p1 SetPosition: “);
p1.Print(); // 현재 좌표 출력
p1.Move(20, 50); // 좌표 변경 (점의 위치 이동)
Console.Write(“p1 Move: “);
p1.Print(); // 현재 좌표 출력
Console.WriteLine(“p1=” + p1);


p2.SetPosition(20, 30); // 변수 값 지정
Console.Write(“p2 SetPosition: “);
p2.Print(); // 현재 좌표 출력


//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p1, ref p2);
Console.WriteLine(“p1: {0}”, p1);
Console.WriteLine(“p2: {0}”, p2);


Console.WriteLine();
Console.WriteLine(“p1.m_nX={0}, p1.m_nY={1}, Point.GetCount()={2}”, p1.X, p1.Y, Point.Count);
Console.WriteLine(“p2.m_nX={0}, p2.m_nY={1}, Point.GetCount()={2}”, p2.X, p2.Y, Point.Count);


// Point3D
Console.Write(“p3: “);
Point3D p3 = new Point3D();
Console.Write(“p4: “);
Point3D p4 = new Point3D();


Console.WriteLine();
p3.SetPosition(10, 20);
Console.Write(“p3 SetPosition: “);
p3.Print(); // 현재 좌표 출력
p3.SetPosition(30, 40, 50);
Console.Write(“p3 SetPosition: “);
p3.Print(); // 현재 좌표 출력
++p3;
Console.Write(“++p3: “);
p3.Print(); // 현재 좌표 출력
p3.Move(20, 30, 40); // 좌표 변경 (점의 위치 이동)
Console.Write(“p3 Move: “);
p3.Print(); // 현재 좌표 출력
p3.Move(10, 10); // 좌표 변경 (점의 위치 이동)
Console.Write(“p3 Move: “);
Console.WriteLine(p3); // p3는 Point클래스의 ToString이 호출


Console.WriteLine();
p4.SetPosition(100, 200, 300);
Console.Write(“p4 SetPosition: “);
p4.Print(); // 현재 좌표 출력
p4.Move(10, 10, 10); // 좌표 변경 (점의 위치 이동)
Console.Write(“p4 Move: “);
p4.Print(); // 현재 좌표 출력


//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p3, ref p4);
Console.WriteLine(“p1: {0}”, p3);
Console.WriteLine(“p2: {0}”, p4);


Console.WriteLine();
Console.WriteLine(“p3.m_nX={0}, p3.m_nY={1}, p3.m_nZ={2}, Point.GetCount()={3}”, p3.X, p3.Y, p3.Z, Point.GetCount());
Console.WriteLine(“p4.m_nX={0}, p4.m_nY={1}, p4.m_nZ={2}, Point.count={3}”, p4.X, p4.Y, p4.Z, Point.Count);


if (p3 == p4)
Console.WriteLine(“p3 == p4”);
if (p3 != p4)
Console.WriteLine(“p3 != p4”);


Console.Write(“p5: “);
Point p5 = p3;
p5.Print(); // 현재 좌표 출력 p5는 Point3D – polymorphism
Console.Write(“p6: “);
Point p6 = new Point3D(110, 210, 310); // p6도 Point3D
p6.Print(); // Point3D의 Print가 호출 (late binding) – polymorphism
Point3D p7 = (Point3D)p5;
Console.WriteLine(p7); // p7는 Point3D클래스의 ToString이 호출
if (p7 == p5)
Console.WriteLine(“p7 == p5”);
if (p7 == p6)
Console.WriteLine(“p7 == p6”);
}
}


 

class indexer, property, abstract, sealed

Indexer (인덱서)
http://dis.dankook.ac.kr/lectures/hci09/entry/Indexer

Property (속성)
http://dis.dankook.ac.kr/lectures/hci09/entry/Property

Abstract Class (추상 클래스)
http://dis.dankook.ac.kr/lectures/hci09/entry/Abstract-class

Sealed Class (봉인 클래스)
http://dis.dankook.ac.kr/lectures/hci09/entry/Sealed-Class

polymorphism (다형성)
– Shape/Circle/Rectangle/Triangle/Square 클래스
– class 및 inheritance
– abstract class 및 polymorphism

String.Substring Method

String.Substring Method

http://msdn.microsoft.com/ko-kr/library/system.string.aspx






Substring(Int32) 이 인스턴스에서 부분 문자열을 검색합니다. 부분 문자열은 지정된 문자 위치에서 시작됩니다.





Substring(Int32, Int32) 이 인스턴스에서 부분 문자열을 검색합니다. 부분 문자열은 지정된 문자 위치에서 시작하고 길이도 지정되어 있습니다.

string str = “Hi, Welcome to HCI Programming II! Hi”;
Console.WriteLine(“str의 substring(3) {0}”, str.Substring(3)); // ” Welcome to HCI Programming II! Hi” 3번째 위치에서 떼어냄

Console.WriteLine(“str의 substring(14, 20) {0}”, str.Substring(14,20)); // ” HCI Programming II!” 14번째 위치에서부터 20개 만큼 떼어냄

WeatherInfo

// 섭씨 기온

public double Temperature
{

     get;

     set;

}

 

// 화씨 기온

public double Fahrenheit

{

     get

     {

          return  (Temperature에서 섭씨 -> 화씨 변환하는 공식으로 화씨값 반환)

     }

     set

     {

           value에서 화씨 -> 섭씨 변환하는 공식으로 Temperature 셋팅

     }

}


// 풍속 (m/s)

public double Wind
{

     get;

     set;

}


// 풍속 (Km/h)  1 m/s = 3.6 Km/h = (1/1000) Km / (1/3600) h

public double WindKmh
{

     get
     {
          return (Wind에서 변환하여 Kmh값 반환)
     }

     set
     {
          value에서 변환하여 Wind 셋팅
     }

}

Inheritance


    class Person
    {
        private string name; // 파상클래스에 상속 안됨
        protected int age; // 파생클래스에 상속 됨


        public Person() : this(“HCI”, 20)
        {
        }


        public Person(string name, int age)
        {
            this.name = name;
            this.age = age;
        }


        protected string GetName() // 파생클래스에 상속 안됨
        {
            return name;
        }


        protected void SetName(string name) // 파생클래스에 상속 안됨
        {
            this.name = name;
        }


        public void Print()
        {
            Console.WriteLine(“Person Name: {0} Age: {1}”, name, age);
        }
    }




    class Student : Person
    {
        int id;


        public Student() // public Student : base()와 같은 의미, 생성자는 상속안됨
        {
            id = 5208;
        }


        public Student(string name, int age, int id) : base(name, age)
        {
            this.id = id;
        }


        public void Print()
        {
            Console.WriteLine(“Student Name: {0} Age: {1} Id: {2}”, GetName(), age, id);
        }
    }




   class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Print();


            Person p1 = new Person(“HCI2~~~~~~~~~~”, 2013);
            p1.Print();

            Student s = new Student();
            s.Print();


            Student s1 = new Student(“학생들~~”, 24, 555);
            s1.Print();
        }
    }

Car class property


    class Car
    {
        // member field
        //string name;
        //int year;
        /*
        public string Name
        {
            get
            {
                return this.name;
            }
            set
            {
                this.name = value;
            }
        }
        public int Year
        {
            get
            {
                return this.year;
            }
            set
            {
                this.year = value;
            }
        }
        */


        // property
        public string Name
        {
            get;
            set;
        }
        public int Year
        {
            get;
            set;
        }


        // constructor
        public Car() : this(“Avante”, 2013)
        {
        }


        public Car(string name, int year)
        {
            this.Name = name;
            this.Year = year;
        }


        // method
        public void Print()
        {
            Console.WriteLine(“자동차 {0} 년도 {1}”, this.Name, this.Year);
        }
    }


 



  class Program
    {
        static void Main(string[] args)
        {
            Car c1 = new Car();
            c1.Print();
            c1.Name = “Accent”;
            c1.Print();
            Console.WriteLine(c1.Name);


            Car c2 = new Car(“Sonata”, 2012);
            c2.Print();
        }


HW2

연습문제 (2)







단원 : C# 기초


목표 : C# 프로그램 기초


주요 연습 내용 : array, 클래스, 추상클래스, 상속, 속성 연습


준비자료 :


 


연습문제 Ex2 (Due by 10/18 24시까지)


-cyber 강의실 (cyber.dku.edu)source code, executable file, solution/project VC# file, 보고서를 학번_이름_Ex2.zip으로 묶어서 낼 것. 보고서 (30%)


 


[연습문제]


1. WeatherInfo 클래스를 정의하라 (WeatherInfo.cs 파일로 저장한다). (10%)


이 클래스는 기온(섭씨), 화씨기온, 풍속(m/s), 풍속(km/h), 습도를 멤버 속성으로 포함한다.


– public double Temperature { get; set;}


– public double Fahrenheit // getset에 대한 내부정의 필요 (섭씨<->화씨 변환)


– public double Wind { get; set;}


– public double WindKmh // getset에 대한 내부정의 필요


// 1 m/s = 3.6 Km/h = (1/1000) Km / (1/3600) h


– public string Humidity { get; set;}


그리고 메소드는 다음을 포함한다.


– public WeatherInfo() // 기본 생성자


– public WeatherInfo(double temperature, double wind, double humidity) // 생성자


– public virtual void Print() // WeatherInfo 모든 속성 값을 출력


– public override string ToString() // Print와 동일하게 string으로 출력


 


2. WeatherIndex 추상 클래스를 정의하라 (WeatherIndex.cs 파일로 저장한다).


이 클래스는 IndexLevel 열거형과 Title, Value, IndexColor, IndexDescription를 멤버 속성으로 포함한다. (10%)


– protected WeatherInfo info = null;


– public abstract string Title { get; }


– public abstract double Value { get; }


– public abstract ConsoleColor IndexColor { get; }


– public abstract string IndexDescription { get; }


그리고 메소드는 다음을 포함한다.


– protected WeatherIndex() { info = new WeatherInfo(); } // protected 생성자


– public abstract void PrintTable(); // 테이블 출력


– public abstract void UserInputCalculate(); // 사용자 입력에 의한 계산


– public override string ToString() { return string.Empty; } // 계산된 결과값 string


 


3. WeatherIndex 추상 클래스를 상속받은 WindChillTemperatureIndex 클래스를 정의하라 (WindChillTemperatureIndex.cs 파일로 저장한다). (10%)


– public enum IndexLevel { DANGER, WARNING, CAUTION, AWARE }


– public override string Title { get { return “체감온도지수“; } }


– public override double Value // get에 대한 내부정의 필요


// 체감온도값(섭씨) = 13.12 + 0.6215T – 11.37 V0.16 +0.3965 V0.16 T [ T: 기온, V : 풍속(km/h) ]


– public override ConsoleColor IndexColor // get에 대한 내부정의 필요 (체감온도지수색상)


– public override string IndexDescription // get에 대한 내부정의 필요 (체감온도지수 주의사항)


– public IndexLevel Index // get에 대한 내부정의 필요 (체감온도지수)


– public override void PrintTable() // 체감온도 산출표 출력 구현


– public override void UserInputCalculate() // 체감온도 사용자 입력에 의한 계산 구현


– public override string ToString() // 사용자입력에 대한 체감온도 결과 값 string 구현


 


4. WeatherIndex 추상 클래스를 상속받은 HeatIndex 클래스를 정의하라 (HeatIndex.cs 파일로 저장한다). (10%)


– public enum IndexLevel { VERYHIGH, HIGH, USUAL, LOW }


– public override string Title { get { return “열지수“; } }


– public override double Value // get에 대한 내부정의 필요


// 열지수값(HI) = -42.379 + (2.04901523*F) + (10.14333127*R) – (0.22475541*F*R) – (0.00683770*F*F) – (0.05481717*R*R) + (0.00122874*F*F*R) + (0.00085282*F*R*R) – (0.00000199*F*F*R*R) [F: 화씨온도, R: 상대습도]


– public override ConsoleColor IndexColor // get에 대한 내부정의 필요 (열지수색상)


– public override string IndexDescription // get에 대한 내부정의 필요 (열지수 주의사항)


– public IndexLevel Index // get에 대한 내부정의 필요 (열지수)


– public override void PrintTable(); // 열지수 산출표 출력 구현


– public override void UserInputCalculate() // 열지수 사용자 입력에 의한 계산 구현


– public override string ToString() // 사용자입력에 대한 열지수 결과 값 string 구현


 


5. WeatherIndexFactory 클래스 (WeatherIndexFactory.cs 파일로 저장한다)는 아래의 메소드를 포함한다. (10%)


// id에 따라서 WindChillTemperatureIndex 또는 HeatIndex 객체 (instance)를 생성


– static public WeatherIndex GetInstance(int id)


 


6. Program 클래스 (Program.cs 파일로 저장한다)는 아래의 메소드를 포함한다. (10%)


// do-while를 사용하여 ESCAPE-키를 누르지 않는 경우, 계속해서 사용자로 하여금 체감온도 또는 열지수를 선택하면, 산출표를 보여주고 사용자 입력된 수치로 계산 할 수 있도록 함.


– WeatherIndex calc = WeatherIndexFactory.GetInstance(value);


calc.PrintTable();


calc.UserInputCalculate();


 


// ArrayList를 사용하여, 사용자가 입력한 수치로 계산된 결과를 리스트에 저장해 두었다가, do-while를 벗어나서 프로그램을 종료할 시 사용자가 테스트한 계산 정보의 전체 리스트를 출력함.


– ArrayList wicList = new ArrayList();


foreach (WeatherIndex wic in wicList) Console.WriteLine(wic.ToString());


 


7. 프로그램에 본인이 더 테스트해보고 싶은 Methodroutine을 추가하라. 그리고 기상청에서 제공하는 체감온도지수 & 열지수 같이 정확히 계산됨을 본인의 프로그램과 비교하여 증명하라. (10%)


 


체감온도 http://www.kma.go.kr/HELP/basic/help_01_07.jsp


체감온도는 외부에 있는 사람이나 동물이 바람과 한기에 노출된 피부로부터 열을 빼앗길 때 느끼는 추운 정도를 나타내는 지수임





















위험


-45 미만


노출된 피부는 몇분내에 얼게 되고, 야외 활동시 저체온 위험이 매우 크므로 방풍·보온기능이 있는 매우 따뜻한 겹옷을 착용해야 함. 또한 노출된 모든 피부를 덮고 모자, 벙어리장갑, 스카프, 목도리, 마스크의 착용이 필요함. 야외환경은 생명에 매우 위험하므로 야외활동은 가급적 짧게 하거나 취소하여 실내에 머무를 수 있도록 할 것.


경고


-45~-25 미만 10~15분이내


동상 위험이 있고, 보호장구 없이 장기간 노출시 저체온에 빠질 위험이 크므로 방풍기능이 있는 겹옷이나 따뜻한 겹옷을 착용해야함. 또한 노출된 모든 피부를 덮고 모자, 벙어리장갑, 스카프, 목도리, 마스크의 착용이 필요함. 피부가 바람에 직접 노출되지 않도록 할 것


주의


-25~-10 미만


노출된 피부에 매우 찬 기운이 느껴지고, 보호장구 없이 장기간 노출시 저체온에 빠질 위험이 있으므로 방풍기능이 있는 겹옷이나 따뜻한 옷을 착용해야함. 또한 모자, 벙어리장갑, 스카프의 착용이 필요함


관심


-10 이상


추위를 느끼는 정도가 증가함. 긴 옷이나 따뜻한 옷의 착용이 필요함


 


열지수 http://www.kma.go.kr/HELP/basic/help_01_04.jsp


열지수는 기온과 습도에 따른 사람이 실제로 느끼는 더위를 지수화한 것임





















매우높음


54 이상


보통사람이 열에 지속적으로 노출될 시 열사·일사병 위험 매우 높음


높음


41~54 미만


보통사람이 열에 지속적으로 노출되면, 신체활동 시 일사병, 열경련, 열피폐 위험 높음


보통


32~41 미만


보통사람이 열에 지속적으로 노출되면, 신체활동 시 열사병, 열경련, 열피폐 가능성 있음


낮음


32 미만


보통사람이 열에 지속적으로 노출되면, 신체활동 시 피로 위험 높음


 


체감온도(Wind Chill Temperature) 산출표


5 0 -5 -10 -15 -20 -25 -30 -35 -40 -45 -50


5 4.08 -1.59 -7.26 -12.93 -18.61 -24.28 -29.95 -35.62 -41.30 -46.97 -52.64 -58.31


10 2.66 -3.31 -9.29 -15.26 -21.23 -27.21 -33.18 -39.15 -45.13 -51.10 -57.07 -63.05


15 1.75 -4.42 -10.58 -16.75 -22.91 -29.08 -35.24 -41.41 -47.57 -53.74 -59.90 -66.07


20 1.07 -5.24 -11.55 -17.86 -24.17 -30.48 -36.79 -43.10 -49.41 -55.72 -62.02 -68.33


25 0.52 -5.91 -12.34 -18.76 -25.19 -31.61 -38.04 -44.46 -50.89 -57.31 -63.74 -70.17


30 0.05 -6.47 -13.00 -19.52 -26.04 -32.57 -39.09 -45.62 -52.14 -58.66 -65.19 -71.71


35 -0.35 -6.96 -13.57 -20.18 -26.79 -33.40 -40.01 -46.62 -53.23 -59.83 -66.44 -73.05


40 -0.71 -7.40 -14.08 -20.77 -27.45 -34.13 -40.82 -47.50 -54.19 -60.87 -67.56 -74.24


45 -1.03 -7.79 -14.54 -21.29 -28.04 -34.80 -41.55 -48.30 -55.06 -61.81 -68.56 -75.31


50 -1.33 -8.14 -14.96 -21.77 -28.59 -35.40 -42.22 -49.03 -55.84 -62.66 -69.47 -76.29


55 -1.60 -8.47 -15.34 -22.21 -29.08 -35.96 -42.83 -49.70 -56.57 -63.44 -70.31 -77.19


60 -1.85 -8.77 -15.70 -22.62 -29.54 -36.47 -43.39 -50.32 -57.24 -64.17 -71.09 -78.02


65 -2.08 -9.05 -16.03 -23.00 -29.97 -36.95 -43.92 -50.90 -57.87 -64.84 -71.82 -78.79


70 -2.30 -9.32 -16.34 -23.36 -30.38 -37.40 -44.42 -51.44 -58.46 -65.48 -72.50 -79.52


75 -2.50 -9.57 -16.63 -23.69 -30.76 -37.82 -44.88 -51.95 -59.01 -66.07 -73.14 -80.20


80 -2.70 -9.80 -16.91 -24.01 -31.11 -38.22 -45.32 -52.43 -59.53 -66.64 -73.74 -80.84


관심 주의 경고 위험


 


열지수(Heat Index) 산출표


27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


40 26.90 27.70 28.60 29.70 30.90 32.30 33.80 35.40 37.20 39.10 41.20 43.40 45.80 48.30 50.90 53.70 56.60


45 27.10 28.00 29.10 30.30 31.70 33.20 34.90 36.80 38.80 41.00 43.40 45.90 48.50 51.30 54.30 57.50 60.80


50 27.40 28.40 29.70 31.00 32.60 34.40 36.30 38.40 40.70 43.10 45.80 48.60 51.60 54.80 58.10 61.70 65.40


55 27.70 28.90 30.30 31.90 33.70 35.60 37.80 40.20 42.70 45.50 48.50 51.60 55.00 58.50 62.30 66.20 70.40


60 28.10 29.50 31.00 32.80 34.80 37.10 39.50 42.20 45.10 48.10 51.40 55.00 58.70 62.60 66.80 71.20 75.80


65 28.50 30.00 31.80 33.90 36.20 38.70 41.40 44.40 47.60 51.00 54.70 58.60 62.70 67.10 71.70 76.50 81.60


70 28.90 30.70 32.70 35.00 37.60 40.40 43.50 46.80 50.30 54.20 58.20 62.50 67.10 71.90 77.00 82.30 87.80


75 29.30 31.40 33.70 36.30 39.20 42.30 45.70 49.40 53.30 57.50 62.00 66.70 71.80 77.00 82.60 88.40 94.50


80 29.70 32.10 34.70 37.70 40.90 44.40 48.10 52.20 56.50 61.20 66.10 71.30 76.80 82.50 88.60 94.90 101.50


85 30.20 32.90 35.90 39.10 42.70 46.60 50.80 55.20 60.00 65.10 70.40 76.10 82.10 88.30 94.90 101.80 108.90


90 31.10 34.00 37.20 40.80 44.70 49.00 53.50 58.40 63.70 69.20 75.10 81.20 87.70 94.50 101.60 109.00 116.80


95 32.00 35.20 38.70 42.50 46.80 51.50 56.50 61.90 67.60 73.60 80.00 86.60 93.70 101.00 108.70 116.70 125.10


100 32.90 36.40 40.20 44.40 49.00 54.20 59.70 65.50 71.70 78.20 85.10 92.40 99.90 107.90 116.10 124.80 133.70


낮음 보통 높음 매우높음