Script Programming(스크립트 프로그래밍)

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 자바 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Integer 클래스와 Long 클래스의 정적 메소드

         Integer.parseInt(String, int);
         Long.toString(long, int);

을 이용하였으며, 지원되는 진법은 2진법부터 36진법까지이다.

1. /*
2.  *  Filename: ConvertRadixApp.java
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Compile: javac -d . ConvertRadixApp.java
6.  *  Execute: java ConvertRadixApp
7.  *
8.  *      Date:  2008/03/25
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. import java.io.*;
13. import java.util.*;
15. public class ConvertRadixApp {
17.     public static void printUsage() {
18.         System.out.println("Usage: java ConvertRadixApp");
19.         System.out.println("Convert radix in a interactive mode, where the maximum radix is 36.");
20.     }
22.     public void printAbout() {
23.         System.out.println("    About: Convert radix in a interactive mode.");
24.     }
26.     public void printMainMenu() {
27.         System.out.println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it");
28.     }
30.     public void printMainPrompt() {
31.         System.out.print("  Prompt> ");
32.     }
34.     public void printSubMenu(int srcRadix, int destRadix) {
35.         System.out.println("    Convert Radix_" + srcRadix + " to Radix_" + destRadix);
36.         System.out.println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
37.     }
39.     public void printSubPrompt() {
40.         System.out.print("    Input Value>> ");
41.     }
43.     public String convertRadix(String s,  int srcRdx, int destRdx) {
44.         long val;
45.         String ret = "";
46.         try {
47.             val = Integer.parseInt(s, srcRdx);
48.             ret = Long.toString(val, destRdx);
49.             return ret.toUpperCase();
50.         }
51.         catch (NumberFormatException nfx) {
52.             System.out.println("    Error: " + nfx.getMessage() + " cantains some invalid character.");
53.             ret = "????";
54.         }
55.         finally {
56.             return ret.toUpperCase();
57.         }
58.     }
60.     public void doConvert(BufferedReader r, int srcRadix, int destRadix) {
61.         String line;
62.         String cmd;
63.         String srcStr = "", destStr = "";
64.         System.out.println();
65.         printSubMenu(srcRadix, destRadix);
66.         try {
67.             do {
68.                 printSubPrompt();
69.                 while ((cmd = r.readLine()) == null) {
70.                 }
71.                 if ("main()".equals(cmd)) {
72.                     return;
73.                 }
74.                 else if ("exit()".equals(cmd) || "quit()".equals(cmd)) {
75.                     System.exit(0);
76.                 }
78.                 try {
79.                     Integer.parseInt(cmd, srcRadix);
80.                     srcStr = cmd;
81.                     destStr = convertRadix(srcStr, srcRadix, destRadix);
82.                     System.out.println("        ( " + srcStr + " )_" + srcRadix +  "   --->   ( " + destStr + " )_" + destRadix);
83.                     System.out.println();
84.                 }
85.                 catch (NumberFormatException nfx) {
86.                 }
87.              } while (true);
88.         }
89.         catch (IOException ex) {
90.             ex.printStackTrace();
91.         }
92.     }
94.     public void doStart() {
95.         String line;
96.         String cmd;
97.         int srcRadix = 10, destRadix = 10;
98.         String srcStr = "", destStr = "";
99.         boolean onlyOnce = true;
100.         BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
101.         try {
102.             do {
103.                 System.out.println();
104.                 if (onlyOnce) {
105.                     System.out.println("  The supported maximum radix is 36.");
106.                     onlyOnce = false;
107.                 }
108.                 printMainMenu();
109.                 printMainPrompt();
110.                 while ((cmd = r.readLine()) == null) {
111.                 }
112.                 if ("qQxX".contains(cmd) && cmd.length() == 1) {
113.                     System.exit(0);
114.                 }
115.                 else if ("aA".contains(cmd) && cmd.length() == 1) {
116.                     printAbout();
117.                 }
118.                 else if ("sS".contains(cmd) && cmd.length() == 1) {
119.                     System.out.print("  Input the source and target radices (say, 16 2): ");
120.                     line = r.readLine();
121.                     StringTokenizer st = new StringTokenizer(line, " ,\t");
122.                     while (st.countTokens() < 2) {
123.                         System.out.print("  Input the source and target radices (say, 16 2): ");
124.                         line = r.readLine();
125.                         st = new StringTokenizer(line, " ,\t");
126.                     }
127.                     srcRadix = Integer.parseInt(st.nextToken());
128.                     destRadix = Integer.parseInt(st.nextToken());
129.                     doConvert(r, srcRadix, destRadix);
130.                 }
131.             } while (true);
132.         }
133.         catch (IOException ex) {
134.             ex.printStackTrace();
135.         }
136.     }
138.     public static void main(String[] args) {
139.         if (args.length > 0 && "-h".equals(args[0])) {
140.             printUsage();
141.             System.exit(1);
142.         }
143.         ConvertRadixApp app = new ConvertRadixApp();
144.         app.doStart();
145.     }
146. }

컴파일> javac -d . ConvertRadixApp.java

실행> java ConvertRadixApp

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 10 16

    Convert Radix_10 to Radix_16
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 256
        ( 256 )_10   --->   ( 100 )_16

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 16 10

    Convert Radix_16 to Radix_10
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> FFFF
        ( FFFF )_16   --->   ( 65535 )_10

    Input Value>> exit()

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 C++ 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  Golden ratio - Sajun.org

1. /*
2.  *  Filename: testGoldenRatioCPP.cpp
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Compile: cl -GX testGoldenRatioCPP.cpp
6.  *
7.  *   Execute: testGoldenRatioCPP
8.  *
9.  *      Date:  2008/03/24
10.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
11.  */
13. #include <iostream>
14. #include <string>
15. #include <cmath>
17. using namespace std;
19. typedef struct _PAIR {
20.     double x1;
21.     double x2;
22. } PAIR;
24. void printUsing() {
25.     cout << "Using: testGoldenRatioCPP [-h|-help]" << endl;
26.     cout << "This calculates the value of the golden ratio." << endl;
27. }
29. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
30. PAIR *findQuadraticRoot(double a, double b, double c) {
31.     static PAIR zeros;
32.     if (a == 0.0) {
33.         cerr << "Since the highest coefficient is zero, the given equation is not a quadratic equation." << endl;
34.         exit(1);
35.     }
36.     else if (b*b - 4*a*c < 0.0) {
37.         cerr << "Since the discriminant " << (b*b - 4*a*c) << " is negative, the given equation has no real root." << endl;
38.         exit(1);
39.     }
41.     zeros.x1 = (-b + sqrt(b*b - 4*a*c)) / (2.0 * a);
42.     zeros.x2 = (-b - sqrt(b*b - 4*a*c)) / (2.0 * a);
43.     return (PAIR *) &zeros;
44. }
46. void main(int argc, char *argv[]) {
47.     double x1, x2;
48.     PAIR *values = (PAIR *) findQuadraticRoot(1.0, -1.0, -1.0);
49.     if (argc > 1 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0)) {
50.         printUsing();
51.         exit(1);
52.     }
54.     values = findQuadraticRoot(1.0, -1.0, -1.0);
55.     x1 = values->x1;
56.     x2 = values->x2;
57.     if (x1 >= x2) {
58.         cout << "The bigger root is " << x1 << endl;
59.         cout << "and the less root is " << x2 << endl;
60.     }
61.     else {
62.         cout << "The bigger root is " << x2 << endl;
63.         cout << "and the less root is " << x1 << endl;
64.     }
65. }

컴파일> cl -GX testGoldenRatioCPP.cpp

실행> testGoldenRatioCPP
The bigger root is 1.618034,
and the less root is -0.618034.




이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 C 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  Golden ratio - Sajun.org

1. /*
2.  *  Filename: testGoldenRatio.c
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Compile: cl testGoldenRatio.c
6.  *
7.  *   Execute: testGoldenRatio
8.  *
9.  *      Date:  2008/03/24
10.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
11.  */
13. #include <stdio.h>
14. #include <string.h>
15. #include <math.h>
17. typedef struct _PAIR {
18.     double x1;
19.     double x2;
20. } PAIR;
22. void printUsing() {
23.     printf("Using: testGoldenRatio [-h|-help]\n");
24.     printf("This calculates the value of the golden ratio.\n");
25. }
27. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
28. PAIR *findQuadraticRoot(double a, double b, double c) {
29.     static PAIR zeros;
30.     if (a == 0.0) {
31.         fprintf(stderr, "Since the highest coefficient is zero, the given equation is not a quadratic equation.\n");
32.         exit(1);
33.     }
34.     else if (b*b - 4*a*c < 0.0) {
35.         fprintf(stderr, "Since the discriminant %f is negative, the given equation has no real root.\b", b*b - 4*a*c);
36.     exit(1);
37.     }
39.     zeros.x1 = (-b + sqrt(b*b - 4*a*c)) / (2.0 * a);
40.     zeros.x2 = (-b - sqrt(b*b - 4*a*c)) / (2.0 * a);
41.     return (PAIR *) &zeros;
42. }
44. void main(int argc, char *argv[]) {
45.     double x1, x2;
46.     PAIR *values = (PAIR *) findQuadraticRoot(1.0, -1.0, -1.0);
47.     if (argc > 1 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0)) {
            printUsing();
48.         exit(1);
49.     }
51.     values = findQuadraticRoot(1.0, -1.0, -1.0);
52.     x1 = values->x1;
53.     x2 = values->x2;
54.     if (x1 >= x2) {
55.         printf("The bigger root is %lf, \n", x1);
56.         printf("and the less root is %lf.\n", x2);
57.     }
58.     else {
59.         printf("The bigger root is %lf, \n", x2);
60.         printf("and the less root is %lf.\n", x1);
61.     }
62. }

컴파일> cl testGoldenRatio.c

실행> testGoldenRatio
The bigger root is 1.618034,
and the less root is -0.618034.


Ch를 이용하면 C 언어 소스 코드를 (컴파일하지 않고) 직접 실행시킬 수 있다.

실행> ch testGoldenRatio.c
The bigger root is 1.618034,
and the less root is -0.618034.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 Lua 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  http://en.wikipedia.org/wiki/Golden_ratio

1. -- Filename: testGoldenRatio.lua
2. --    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
3. --
4. --  Execute: lua testGoldenRatio.lua
5. --
6. -- Date    24-March-2008
7. -- Author  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. function printUsing()
10.     print("Using: lua testGoldenRatio.lua [-h|-help]");
11.     print("This calculates the value of the golden ratio.");
12. end
14. -- 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
15. function findQuadraticRoot(a, b, c)
16.     if a == 0.0 then
17.         error( "Since the highest coefficient is zero, the given equation is not a quadratic equation." )
18.     elseif b*b - 4*a*c < 0.0 then
19.         error( "Since the discriminant " .. (b*b - 4*a*c) .. " is negative, the given equation has no real root." )
20.     end
22.     x1 = (-b + math.sqrt(b*b - 4*a*c)) / (2.0 * a)
23.     x2 = (-b - math.sqrt(b*b - 4*a*c)) / (2.0 * a)
24.     return {x1, x2}
25. end
27. -- 실행 시작 지점
28. if #arg > 0 and (arg[1] == "-h" or arg[1] == "-help") then
29.     printUsing()
30.     os.exit(1)
31. end
32. values = findQuadraticRoot(1.0, -1.0, -1.0)
33. x1 = values[1]
34. x2 = values[2]
35. if x1 >= x2 then
36.     print("The bigger root is " .. x1 .. ", ")
37.     print("and the less root is " .. x2 .. ".")
38. else
39.     print("The bigger root is " .. x2 .. ", ")
40.     print("and the less root is " .. x1 .. ".")
41. end

실행> lua testGoldenRatio.lua
The bigger root is 1.6180339887499,
and the less root is -0.61803398874989.




이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 Ruby 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  http://en.wikipedia.org/wiki/Golden_ratio

1. #  Filename: testGoldenRatio.rb
2. #    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
3. #
4. #   Execute: ruby testGoldenRatio.rb
5. #
6. #      Date:  2008/03/24
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. def printUsing()
10.     print("Using: ruby testGoldenRatio.rb [-h|-help]\n")
11.     print("This calculates the value of the golden ratio.\n")
12. end
14. # 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
15. def findQuadraticRoot(a, b, c)
16.     if a == 0.0
17.         raise "Since the highest coefficient is zero, the given equation is not a quadratic equation."
18.     elsif b*b - 4*a*c < 0.0
19.         raise "Since the discriminant " + (b*b - 4*a*c).to_s + " is negative, the given equation has no real root."
20.     end
22.     x1 = (-b + Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
23.     x2 = (-b - Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
24.     return [x1, x2]
25. end
27. # 실행 시작 지점
28. if ARGV.length > 0 && (ARGV[0] == "-h" || ARGV[0] == "-help")
29.     printUsing()
30.     exit(1)
31. end
33. values = findQuadraticRoot(1.0, -1.0, -1.0)
34. x1 = values[0]
35. x2 = values[1]
36. if x1 >= x2 then
37.     print("The bigger root is #{x1}, \n")
38.     print("and the less root is #{x2}.\n")
39. else
40.     print("The bigger root is #{x2}, \n")
41.     print("and the less root is #{x1}.\n")
42. end

실행> ruby testGoldenRatio.rb
The bigger root is 1.61803398874989,
and the less root is -0.618033988749895.


실행> jruby testGoldenRatio.rb
The bigger root is 1.618033988749895,
and the less root is -0.6180339887498949.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 Python 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  http://en.wikipedia.org/wiki/Golden_ratio

1. # -*- encoding: ms949 -*-
3. #  Filename: testGoldenRatio.py
4. #    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
5. #
6. #   Execute: python testGoldenRatio.py
7. #
8. #      Date:  2008/03/24
9. #    Author: PH Kim   [ pkim (AT) scripts.pe.kr ]
11. import sys
12. import math
14. def printUsing():
15.     print("Using: python testGoldenRatio.py [-h|-help]")
16.     print("This calculates the value of the golden ratio.")
18. # 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
19. def findQuadraticRoot(a, b, c):
20.     if a == 0.0:
21.         raise RuntimeError("Since the highest coefficient is zero, the given equation is not a quadratic equation.")
22.     elif b*b - 4*a*c < 0.0:
23.         raise RuntimeError("Since the discriminant " + (b*b - 4*a*c) + " is negative, the given equation has no real root.")
25.     x1 = (-b + math.sqrt(b*b - 4*a*c)) / (2.0 * a)
26.     x2 = (-b - math.sqrt(b*b - 4*a*c)) / (2.0 * a)
27.     return [x1, x2]
30. # 실행 시작 지점
31. if len(sys.argv) > 1 and (sys.argv[1] == "-h" or sys.argv[1] == "-help"):
32.     printUsing()
33.     sys.exit(1)
35. values = findQuadraticRoot(1.0, -1.0, -1.0)
36. x1 = values[0]
37. x2 = values[1]
38. if x1 >= x2:
39.     print("The bigger root is " + str(x1) + ", ")
40.     print("and the less root is " + str(x2) + ".")
41. else:
42.     print("The bigger root is " + str(x2) + ", ")
43.     print("and the less root is " + str(x1) + ".")

실행> python testGoldenRatio.py
The bigger root is 1.61803398875,
and the less root is -0.61803398875.


실행> jython testGoldenRatio.py
The bigger root is 1.618033988749895,
and the less root is -0.6180339887498949.



위의 소스 코드에서 인코딩 선언 부분만

# -*- encoding: cp949 -*-

로 고치면, IronPython에서도 실행된다.


실행> ipy testGoldenRatio.py
The bigger root is 1.61803398875,
and the less root is -0.61803398875.

만일 Jython 2.5.0 이상이면
LookupError: unknown encoding 'ms949'
또는
SyntaxError: Unknown encoding: ms949
와 같은 에러를 만날 수 있다. 이럴 때는

# -*- encoding: iso-8859-1 -*-
또는
# coding: iso-8859-1

로 해야할 것이다. (이는 Jython 2.5.x 의 버그인 것으로 보인다.)




저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 Groovy 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  http://en.wikipedia.org/wiki/Golden_ratio

1. /*
2.  *  Filename: testGoldenRatio.groovy
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Execute: groovy testGoldenRatio.groovy
6.  *
7.  *      Date:  2008/03/24
8.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9.  */
11. import java.util.ArrayList
13. def printUsing() {
14.     println("Using: groovy testGoldenRatio.groovy [-h|-help]")
15.     println("This calculates the value of the golden ratio.")
16. }
18. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
19. def findQuadraticRoot(double a, double b, double c) {
20.     if (a == 0.0) {
21.         throw new RuntimeException("Since the highest coefficient is zero, the given equation is not a quadratic equation.");
22.     }
23.     else if (b*b - 4*a*c < 0.0) {
24.         throw new RuntimeException("Since the discriminant " + (b*b - 4*a*c) + " is negative, the given equation has no real root.")
25.     }
27.     double x1 = (-b + Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
28.     double x2 = (-b - Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
29.     def array = [x1, x2].asImmutable()
30.     return array
31. }
33. // 실행 시작 지점
34. if (args.length > 0 && (args[0].equals("-h") || args[0].equals("-help"))) {
35.     printUsing()
36.     System.exit(1)
37. }
39. def values = findQuadraticRoot(1.0, -1.0, -1.0)
40. def x1 = values[0]
41. def x2 = values[1]
42. if (x1 >= x2) {
43.     println("The bigger root is " + x1 + ", ")
44.     println("and the less root is " + x2 + ".")
45. }
46. else {
47.     println("The bigger root is " + x2 + ", ")
48.     println("and the less root is " + x1 + ".")
49. }

실행> groovy testGoldenRatio.groovy
The bigger root is 1.618033988749895,
and the less root is -0.6180339887498949.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 자바 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  Golden ratio - Sajun.org

1. /*
2.  *  Filename: TestGoldenRatioApp.java
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Compile: javac -d . TestGoldenRatioApp.java
6.  *
7.  *   Execute: java TestGoldenRatioApp
8.  *
9.  *      Date:  2008/03/24
10.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
11.  */
13. import java.util.ArrayList;
15. public class TestGoldenRatioApp {
17.     public static void printUsing() {
18.         System.out.println("Using: java TestGoldenRatioApp [-h|-help]");
19.         System.out.println("This calculates the value of the golden ratio.");
20.     }
22.     // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
23.     public ArrayList<Double> findQuadraticRoot(double a, double b, double c) {
24.         double x1, x2;
25.         if (a == 0.0) {
26.             throw new RuntimeException("Since the highest coefficient is zero, the given equation is not a quadratic equation.");
27.   }
28.         else if (b*b - 4*a*c < 0.0) {
29.             throw new RuntimeException("Since the discriminant " + (b*b - 4*a*c) + " is negative, the given equation has no real root.");
30.   }
32.         x1 = (-b + Math.sqrt(b*b - 4*a*c)) / (2.0 * a);
33.         x2 = (-b - Math.sqrt(b*b - 4*a*c)) / (2.0 * a);
34.         ArrayList<Double> array = new ArrayList<Double>();
35.         array.add(new Double(x1));
36.         array.add(new Double(x2));
37.         return array;
38.     }
40.     public static void main(String[] args) {
41.        TestGoldenRatioApp app = new TestGoldenRatioApp();
42.         if (args.length > 0 && (args[0].equals("-h") || args[0].equals("-help"))) {
43.             app.printUsing();
44.             System.exit(1);
45.         }
46.         ArrayList<Double> values = app.findQuadraticRoot(1.0, -1.0, -1.0);
47.         double x1, x2;
48.         x1 = values.get(0).doubleValue();
49.         x2 = values.get(1).doubleValue();
50.         if (x1 >= x2) {
51.             System.out.println("The bigger root is " + x1 + ", ");
52.             System.out.println("and the less root is " + x2 + ".");
53.         }
54.         else {
55.             System.out.println("The bigger root is " + x2 + ", ");
56.             System.out.println("and the less root is " + x1 + ".");
57.         }
58.     }
59. }

컴파일> javac -d . TestGoldenRatioApp.java

실행> java TestGoldenRatioApp
The bigger root is 1.618033988749895,
and the less root is -0.6180339887498949.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

1. --[[
2.    Filename: testCTime.lua
3.    Execute: lua testCTime.lua
4. --]]
6. -- See http://www.lua.org/manual/5.1/manual.html#pdf-os.clock
8. weekNames = { "일", "월", "화", "수", "목", "금", "토" }
9. cNow = os.date("*t")
11. -- 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
12. print("UTC: " .. os.time(cNow) .. "초")
14. -- 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
15. io.write(cNow["year"] .. "년 " .. cNow["month"] .. "월 " .. cNow["day"] .. "일 ")
16. io.write("(" .. weekNames[cNow["wday"]] .. "요일) ")
17. io.write(cNow["hour"] .. "시 " .. cNow["min"] .. "분 " .. cNow["sec"] .. "초")
18. print()
20. -- 1월 1일은 1, 1월 2일은 2
21. -- Time.now.isdat == false 이면, 서머타임 없음
22. strIsDST = "안함"
23. if cNow["isdst"] then
24.     strIsDST = "함"
25. end
26. print("올해 몇 번째 날: " .. cNow["yday"] .. ", 서머타임 적용 여부: " .. strIsDST)

실행> lau testCTime.lua
UTC: 1206325100초
2008년 3월 24일 (월요일) 11시 18분 20초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

1. =begin
2.    Filename: testCTime.rb
3.    Execute: ruby testCTime.rb
4. =end
6. def println(s)
7.     print("#{s}\n")
8. end
10. weekNames = [ "일", "월", "화", "수", "목", "금", "토" ]
11. cNow = Time.now
13. # 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
14. println("UTC: %d초" % cNow.to_i)
16. # 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
17. println("%d년 %d월 %d일 (%s요일) %d시 %d분 %d초" % [cNow.year, cNow.mon, cNow.day, weekNames[cNow.wday], cNow.hour, cNow.min, cNow.sec] )
19. # 1월 1일은 1, 1월 2일은 2
20. # Time.now.isdat == false 이면, 서머타임 없음
21. println("올해 몇 번째 날: %d, 서머타임 적용 여부: %s" % [cNow.yday, cNow.isdst ? "함" : "안함"])

실행> ruby testCTime.rb
UTC: 1206325100초
2008년 3월 24일 (월요일) 11시 18분 20초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함


실행> jruby testCTime.rb
UTC: 1206325102초
2008년 3월 24일 (월요일) 11시 18분 22초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.