'프로그래밍' 카테고리의 글 목록 (56 Page)

조립제법(Horner의 방법) 예제 for Lua

프로그래밍/Lua 2008. 3. 14. 12:21

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Java 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
* 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표
* 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

아래의 소스파일은 Ruby용 소스파일 testSyntheticDivision.rb 를 Lua용으로 수정한 것이다.

--[[
Filename: testSyntheticDivision.lua
Purpose: Find the quotient and remainder when some polynomial is
divided by a monic polynomial of the first degree.
Execute: lua testSyntheticDivision.lua -2 1 3 3 1
--]]
-- 사용법 표시
function printUsage()
print("사용법: lua testSyntheticDivision.lua [수] [피제식의 계수들]")
print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
end
-- 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
-- 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
function simplify(v, width)
t = "" .. v
tlen = string.len(t)
if string.sub(t, tlen-2) == ".0" then
t = string.sub(t, 0, tlen-2)
end
if width ~= nil then
if tlen < width then
t = string.sub(" ", 0, width - tlen) .. t
end
end
return t
end
-- 다항식을 내림차순의 스트링 표현으로 반환
function toPolyString(c)
local t = ""
sc0 = simplify(c[1], null)
if #c > 2 then
if sc0 == "1" then
t = t .. "x^" .. (#c-1)
elseif sc0 == "-1" then
t = t .. "-x^" .. (#c-1)
else
t = t .. sc0 .. " x^" .. (#c-1)
end
elseif #c == 2 then
if sc0 == "1" then
t = t .. "x"
elseif sc0 == "-1" then
t = t .. "-x"
else
t = t .. sc0 .. " x"
end
elseif #c == 1 then
t = t .. sc0
end
for i = 2, #c do
k = #c - i
sc = simplify(c[i], nil)
if k > 1 then
if c[i] > 0.0 then
if sc == "1" then
t = t .. " + " .. "x^" .. k
else
t = t .. " + " .. sc .. " x^" .. k
end
elseif c[i] < 0.0 then
if sc == "-1" then
t = t .. " - " .. "x^" .. k
else
t = t .. " - " .. simplify(math.abs(c[i]), nil) .. " x^" .. k
end
end
elseif k == 1 then
if c[i] > 0.0 then
if sc == "1" then
t = t .. " + " .. "x"
else
t = t .. " + " .. sc .. " x"
end
elseif c[i] < 0.0 then
if sc == "-1" then
t = t .. " - " .. "x"
else
t = t .. " - " .. simplify(math.abs(c[i]), null) .. " x"
end
end
elseif k == 0 then
if c[i] > 0.0 then
t = t .. " + " .. sc
elseif c[i] < 0.0 then
t = t .. " - " .. simplify(math.abs(c[i]), null)
end
end
end
return t
end
-- 다향식 나눗셈 결과를
-- (피제식) = (제식)(몫) + (나마지)
-- 형태로 출력
function printDivisionResult(a, c, b)
local strLine = " " .. toPolyString(c)
io.write( strLine .. "\n")
strLine = " = ( " .. toPolyString( { 1.0, -a } ) .. " )"
tmp = { }
for i = 1, #b - 1 do
tmp[i] = b[i]
end
strLine = strLine .. "( " .. toPolyString(tmp) .. " )"
r = b[#b]
if r > 0.0 then
strLine = strLine .. " + " .. simplify(r, nil)
elseif r < 0.0 then
strLine = strLine .. " - " .. simplify(math.abs(r), nil)
end
io.write( strLine .. "\n" )
end
-- 조립제법 계산표 출력 함수
function printSyntheticTable(a, c, s, q)
strLine = " | "
strLine = strLine .. simplify(c[1], 6)
for i = 2, #c do
strLine = strLine .. " " .. simplify(c[i], 6)
end
io.write( strLine .. "\n" )
strLine = simplify(a, 6) .. " |"
strLine = strLine .. " "
strLine = strLine .. simplify(s[2], 6)
for i = 3, #s do
strLine = strLine .. " " .. simplify(s[i], 6)
end
io.write( strLine .. "\n" )
strLine = " |"
for i = 1, #q do
strLine = strLine .. "--------"
end
io.write( strLine .. "\n" )
strLine = " "
strLine = strLine .. simplify(q[1], 6)
for i = 2, #q do
strLine = strLine .. " " .. simplify(q[i], 6)
end
io.write( strLine .. "\n" )
end
-- 실행 시작 지점
if #arg < 3 then
printUsage()
os.exit(1)
end
-- 피제식은 c_0 x^n + c_1 x^(n -1) + ... + c_n
-- 제식은 x - a
a = arg[1]
c = { }
s = { }
b = { }
for i = 1, #arg-1 do
c[i] = tonumber(arg[i + 1])
end
-- 조립제법의 주요 부분
s[1] = 0.0
b[1] = c[1]
for i = 2, #c do
s[i] = b[i-1]*a
b[i] = c[i] + s[i]
end
-- 몫의 계수와 나머지를 출력한다.
io.write("몫의 계수는 ")
for i = 1, #b-1 do
io.write(simplify(b[i], nil) .. ", ");
end
io.write(simplify(b[#b], nil) .. " ")
io.write("이고, 나머지는 " .. simplify(b[#b], nil) .. " 이다." .. "\n")
io.write("\n")
-- 조립제법 표를 출력한다.
printSyntheticTable(a, c, s, b)
io.write("\n")
-- (피제식) = (제식) x (몫) + (나머지)
printDivisionResult(a, c, b)

실행> lua testSyntheticDivision.lua 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

   |    2 3 4 5
   1 |    2 5 9
   |---------------------------------
2 5 9    14

2 x^3 + 3 x^2 + 4 x + 5
= ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

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

'프로그래밍 > Lua' 카테고리의 다른 글

황금비율(golden ratio) 구하기 with Lua (0)	2008.03.24
현재 시각 알아내기 for Lua (0)	2008.03.24
80컬럼 컨솔에 19단표 출력하기 예제 for Lua (0)	2008.03.03
(최대공약수 구하기) while... 반복문 예제 for Lua (0)	2008.02.21
if...else... 조건문 사용 예제 for Lua (0)	2008.02.19

Posted by Scripter

,

조립제법(Horner의 방법) 예제 for Ruby

프로그래밍/Ruby 2008. 3. 14. 11:49

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Ruby 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
* 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표
* 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

아래의 소스파일은 Python용 소스파일 testSyntheticDivision.py 를 Ruby용으로 수정한 것이다.

ruby 대신 jruby 로도 수정 없이 그대로 실행된다.

=begin
Filename: testSyntheticDivision.rb
Purpose: Find the quotient and remainder when some polynomial is
divided by a monic polynomial of the first degree.
Execute: ruby testSyntheticDivision.rb -2 1 3 3 1
Or jruby testSyntheticDivision.rb -2 1 3 3 1
=end
# 사용법 표시
def printUsage()
print("사용법: ruby testSyntheticDivision.rb [수] [피제식의 계수들]" + "\n")
print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다." + "\n")
end
# 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
# 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
def simplify(v, width)
t = "%d" % v
tlen = t.length
if t[(tlen-2)..(tlen-1)] == ".0"
t = t[0..(tlen-2)]
end
if width != nil
if tlen < width
t = " "[0...(width - tlen)] + t
end
end
return t
end
# 다항식을 내림차순의 스트링 표현으로 반환
def toPolyString(c)
t = ""
sc0 = simplify(c[0], nil)
if c.length > 2
if sc0 == "1"
t += "x^%d" % (c.length-1)
elsif sc0 == "-1"
t += "-x^%d" % (c.length-1)
else
t += sc0 + " x^%d" % (c.length-1)
end
elsif c.length == 2
if sc0 == "1"
t += "x"
elsif sc0 == "-1"
t += "-x"
else
t += sc0 + " x"
end
elsif c.length == 1
t += sc0
end
for i in 1...c.length do
k = c.length - 1 - i
sc = simplify(c[i], nil)
if k > 1
if c[i] > 0.0
if sc == "1"
t += " + " + "x^" + k
else
t += " + " + sc + " x^%d" % k
end
elsif c[i] < 0.0
if sc == "-1"
t += " - " + "x^" + k
else
t += " - " + simplify(c[i].abs, nil) + " x^%d" % k
end
end
elsif k == 1
if c[i] > 0.0
if sc == "1"
t += " + " + "x"
else
t += " + " + sc + " x"
end
elsif c[i] < 0.0
if sc == "-1"
t += " - " + "x"
else
t += " - " + simplify(c[i].abs, nil) + " x"
end
end
elsif k == 0
if c[i] > 0.0
t += " + " + sc
elsif c[i] < 0.0
t += " - " + simplify(c[i].abs, nil)
end
end
end
return t
end
# 다향식 나눗셈 결과를
# (피제식) = (제식)(몫) + (나마지)
# 형태로 출력
def printDivisionResult(a, c, b)
strLine = " " + toPolyString(c)
print( strLine + "\n")
strLine = " = ( " + toPolyString( [1.0, -a] ) + " )"
tmp = [0.0] * (b.length - 1)
for i in 0...tmp.length do
tmp[i] = b[i]
end
strLine += "( " + toPolyString(tmp) + " )"
r = b[b.length - 1]
if r > 0.0
strLine += " + " + simplify(r, nil)
elsif r < 0.0
strLine += " - " + simplify(r.abs, nil)
end
print( strLine + "\n" )
end
# 조립제법 계산표 출력 함수
def printSyntheticTable(a, c, s, q)
strLine = " | "
strLine += simplify(c[0], 6)
for i in 1...c.length do
strLine += " " + simplify(c[i], 6)
end
print( strLine + "\n" )
strLine = simplify(a, 6) + " |"
strLine += " "
strLine += simplify(s[1], 6)
for i in 2...s.length do
strLine += " " + simplify(s[i], 6)
end
print( strLine + "\n" )
strLine = " |"
for i in 0...q.length do
strLine += "--------"
end
print( strLine + "\n" )
strLine = " "
strLine += simplify(q[0], 6)
for i in 1...q.length do
strLine += " " + simplify(q[i], 6)
end
print( strLine + "\n" )
end
# 실행 시작 지점
if ARGV.length < 2
printUsage()
exit(1)
end
######################################################
# 피제식은 c_0 x^n + c_1 x^(n -1) + ... + c_n
# 제식은 x - a
a = ARGV[0].to_f
c = [0.0]*(ARGV.length - 1)
s = [0.0]*(+ARGV.length - 1)
b = [0.0]*(ARGV.length - 1)
for i in 0...c.length do
c[i] = ARGV[i + 1].to_f
end
######################################################
# 조립제법의 주요 부분
s[0] = 0.0
b[0] = c[0]
for i in 1...c.length do
s[i] = b[i-1]*a
b[i] = c[i] + s[i]
end
######################################################
# 몫의 계수와 나머지를 출력한다.
print("몫의 계수는 ")
for i in 0...(b.length - 2) do
print(simplify(b[i], nil) + ", " )
end
print(simplify(b[b.length - 2], nil) + " ")
print("이고, 나머지는 " + simplify(b[b.length - 1], nil) + " 이다." + "\n")
print("\n")
######################################################
# 조립제법 표를 출력한다.
printSyntheticTable(a, c, s, b)
print("\n")
######################################################
# (피제식) = (제식) x (몫) + (나머지)
printDivisionResult(a, c, b)

실행> ruby testSyntheticDivision.rb 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

   |    2 3 4 5
   1 |    2 5 9
   |---------------------------------
2 5 9    14

2 x^3 + 3 x^2 + 4 x + 5
= ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

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

'프로그래밍 > Ruby' 카테고리의 다른 글

황금비율(golden ratio) 구하기 with Ruby or JRuby (0)	2008.03.24
현재 시각 알아내기 for Ruby and JRuby (0)	2008.03.24
80컬럼 컨솔에 19단표 출력하기 예제 for Ruby (0)	2008.03.03
(최대공약수 구하기) while... 반복문 예제 for Ruby (0)	2008.02.21
if...else... 조건문 사용 예제 for Ruby (0)	2008.02.19

Posted by Scripter

,

조립제법(Horner의 방법) 예제 for Python

프로그래밍/Python 2008. 3. 14. 11:11

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Python 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
* 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표
* 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

아래의 소스파일은 Groovy용 소스파일 testSyntheticDivision.groovy 를 Python용으로 수정한 것이다.

python 대신 jython이나 IronPython 으로도 수정 없이 그대로 실행된다.

# Filename: testSyntheticDivision.py
#
# Purpose: Find the quotient and remainder when some polynomial is
# divided by a monic polynomial of the first degree.
#
# Execute: python testSyntheticDivision.py -2 1 3 3 1
# Or jython testSyntheticDivision.py -2 1 3 3 1
import sys
# 사용법 표시
def printUsage():
print("사용법: python testSyntheticDivision.py [수] [피제식의 계수들]")
print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
# 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
# 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
def simplify(v, width=None):
t = "%d" % v
tlen = len(t)
if t[tlen-2:tlen-1] == ".0":
t = t[0, -2]
if width != None:
if tlen < width:
t = " "[0: width - tlen] + t
return t
# 다항식을 내림차순의 스트링 표현으로 반환
def toPolyString(c):
t = ""
sc0 = simplify(c[0])
if len(c) > 2:
if sc0 == "1":
t += "x^%d" % (len(c)-1)
elif sc0 == "-1":
t += "-x^%d" % (len(c)-1)
else:
t += sc0 + " x^%d" % (len(c)-1)
elif len(c) == 2:
if sc0 == "1":
t += "x"
elif sc0 == "-1":
t += "-x"
else:
t += sc0 + " x"
elif len(c) == 1:
t += sc0
for i in range(1, len(c)):
k = len(c) - 1 - i
sc = simplify(c[i])
if k > 1:
if c[i] > 0.0:
if sc == "1":
t += " + " + "x^%d" % k
else:
t += " + " + sc + " x^%d" % k
elif c[i] < 0.0:
if sc == "-1":
t += " - " + "x^%d" % k
else:
t += " - " + simplify(abs(c[i])) + " x^%d" % k
elif k == 1:
if c[i] > 0.0:
if sc == "1":
t += " + " + "x"
else:
t += " + " + sc + " x"
elif c[i] < 0.0:
if sc == "-1":
t += " - " + "x"
else:
t += " - " + simplify(abs(c[i])) + " x"
elif k == 0:
if c[i] > 0.0:
t += " + " + sc
elif c[i] < 0.0:
t += " - " + simplify(abs(c[i]))
return t
# 다항식 나눗셈 결과를
# (피제식) = (제식)(몫) + (나머지)
# 형태로 출력
def printDivisionResult(a, c, b):
strLine = " " + toPolyString(c)
print( strLine )
strLine = " = ( " + toPolyString( [1.0, -a] ) + " )"
tmp = [0.0] * (len(b) - 1)
for i in range(0, len(tmp)):
tmp[i] = b[i]
strLine += "( " + toPolyString(tmp) + " )"
r = b[len(b) - 1]
if r > 0.0:
strLine += " + " + simplify(r)
elif r < 0.0:
strLine += " - " + simplify(abs(r))
print( strLine )
# 조립제법 계산표 출력 함수
def printSyntheticTable(a, c, s, q):
strLine = " | "
strLine += simplify(c[0], 6)
for i in range(1, len(c)):
strLine += " " + simplify(c[i], 6)
print( strLine )
strLine = simplify(a, 6) + " |"
strLine += " "
strLine += simplify(s[1], 6)
for i in range(2, len(s)):
strLine += " " + simplify(s[i], 6)
print( strLine )
strLine = " |"
for i in range(0, len(q)):
strLine += "--------"
print( strLine )
strLine = " "
strLine += simplify(q[0], 6)
for i in range(1, len(q)):
strLine += " " + simplify(q[i], 6)
print( strLine )
# 실행 시작 지점
if len(sys.argv) < 3:
printUsage()
sys.exit(1)
######################################################
# 피제식은 c_0 x^n + c_1 x^(n -1) + ... + c_n
# 제식은 x - a
a = float(sys.argv[1])
c = [0.0]*(len(sys.argv) - 2)
s = [0.0]*(len(sys.argv) - 2)
b = [0.0]*(len(sys.argv) - 2)
for i in range(0, len(c)):
c[i] = float(sys.argv[i + 2])
######################################################
# 조립제법의 주요 부분
s[0] = 0.0
b[0] = c[0]
for i in range(1, len(c)):
s[i] = b[i-1]*a
b[i] = c[i] + s[i]
######################################################
# 몫의 계수와 나머지를 출력한다.
print("몫의 계수는"),
for i in range(0, len(b) - 2):
print(simplify(b[i], None) + ", " ),
print(simplify(b[len(b) - 2], None)),
print("이고, 나머지는 " + simplify(b[len(b) - 1], None) + " 이다.")
print
######################################################
# 조립제법 표를 출력한다.
printSyntheticTable(a, c, s, b)
print
######################################################
# (피제식) = (제식) x (몫) + (나머지)
printDivisionResult(a, c, b)

실행> python testSyntheticDivision.py 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

   |    2 3 4 5
   1 |    2 5 9
   |---------------------------------
2 5 9    14

2 x^3 + 3 x^2 + 4 x + 5
= ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

'프로그래밍 > Python' 카테고리의 다른 글

황금비율(golden ratio) 구하기 with Python or Jython (0)	2008.03.24
현재 시각 알아내기 for Python, Jython, and IronPython (0)	2008.03.24
80컬럼 컨솔에 19단표 출력하기 예제 for Python (0)	2008.03.03
(최대공약수 구하기) while... 반복문 예제 for Python (0)	2008.02.21
if...else... 조건문 사용 예제 for Python (0)	2008.02.19

Posted by Scripter

,

조립제법(Horner의 방법) 예제 (2) for Groovy

프로그래밍/Groovy 2008. 3. 14. 10:27

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Groovy 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
* 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표
* 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

/*
* Filename: testSyntheticDivision.groovy
*
* Purpose: Find the quotient and remainder when some polynomial is
* divided by a monic polynomial of the first degree.
* 이 소스는 자바 소스 TestSyntheticMethod.java 와 내용이 거의 같은
* 그루비 소스 TestSyntheticMethod.groovy 를 더욱 그루비 소스 코드 답게 수정한 것이다.
*
* Execute: groovy testSyntheticDivision.groovy -2 1 3 3 1
*
*/
// 사용법 표시
def printUsage() {
println("사용법: groovy testSyntheticDivision.groovy [수] [피제식의 계수들]")
println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
String simplify(double v) {
String t = "" + v
if (t.endsWith(".0"))
t = t[0..<(t.length() - 2)]
return t
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
// 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
String simplify(double v, int width) {
String t = "" + v
if (t.endsWith(".0"))
t = t[0..<(t.length() - 2)]
int len = t.length()
if (len < width)
t = " ".substring(0, width - len) + t
return t;
}
// 다항식을 내림차순의 스트링 표현으로 반환
String toPolyString(double[] c) {
String t = ""
def sc0 = simplify(c[0])
if (c.length > 2) {
if (sc0 == "1")
t += "x^" + (c.length-1)
else if (sc0 == "-1")
t += "-x^" + (c.length-1)
else
t += sc0 + " x^" + (c.length-1)
}
else if (c.length == 2) {
if (sc0 == "1")
t += "x"
else if (sc0 == "-1")
t += "-x"
else
t += sc0 + " x"
}
else if (c.length == 1) {
t += sc0
}
for (i in 1..< c.length) {
def k = c.length - 1 - i
def sc = simplify(c[i])
if (k > 1) {
if (c[i] > 0.0) {
if (sc == "1")
t += " + " + "x^" + k
else
t += " + " + sc + " x^" + k
}
else if (c[i] < 0.0) {
if (sc == "-1")
t += " - " + "x^" + k
else
t += " - " + simplify(Math.abs(c[i])) + " x^" + k
}
}
else if (k == 1) {
if (c[i] > 0.0) {
if (sc == "1")
t += " + " + "x"
else
t += " + " + sc + " x"
}
else if (c[i] < 0.0) {
if (sc == "-1")
t += " - " + "x"
else
t += " - " + simplify(Math.abs(c[i])) + " x"
}
}
else if (k == 0) {
if (c[i] > 0.0) {
t += " + " + sc
}
else if (c[i] < 0.0)
t += " - " + simplify(Math.abs(c[i]))
}
}
return t
}
// 다항식 나눗셈 결과를
// (피제식) = (제식)(몫) + (나마지)
// 형태로 출력
def printDivisionResult(double a, double[] c, double[] b) {
print(" " + toPolyString(c))
println()
print(" = ( " + toPolyString( [1.0, -a] as double[] ) + " )")
double[] tmp = new double[b.length - 1]
for (i in 0..<tmp.length) {
tmp[i] = b[i]
}
print("( " + toPolyString(tmp) + " )")
double r = b[b.length - 1]
if (r > 0.0)
print(" + " + simplify(r))
else if (r < 0.0)
print(" - " + simplify(Math.abs(r)))
println()
}
// 조립제법 계산표 출력 함수
def printSyntheticTable(double a, double[] c, double[] s, double[] q) {
print(" | ")
print(simplify(c[0], 6))
for (i in 1..< c.length) {
print(" " + simplify(c[i], 6))
}
println()
print(simplify(a, 6) + " | ")
print(" ")
print(simplify(s[1], 6))
for (i in 2..< s.length) {
print(" " + simplify(s[i], 6))
}
println()
print(" |-")
for (i in 0..< q.length) {
print("--------")
}
println()
print(" ")
print(simplify(q[0], 6))
for (i in 1..< q.length) {
print(" " + simplify(q[i], 6))
}
println()
}
// 실행 시작 지점
if (args.length < 3) {
printUsage()
System.exit(1);
}
double a = Double.parseDouble(args[0])
double[] c = new double[args.length - 1]
double[] s = new double[c.length]
double[] b = new double[c.length]
for (i in 0..<c.length) {
c[i] = Double.parseDouble(args[i + 1])
}
s[0] = 0.0;
b[0] = c[0];
for (i in 1..<c.length) {
s[i] = b[i-1]*a
b[i] = c[i] + s[i]
}
print("몫의 계수는 ");
for (i in 0..<(b.length - 2)) {
print(simplify(b[i]) + ", " )
}
print(simplify(b[b.length - 2]))
println(" 이고, 나머지는 " + simplify(b[b.length - 1]) + " 이다.")
println()
printSyntheticTable(a, c, s, b)
println()
printDivisionResult(a, c, b)

groovy 명령으로 아래와 같이 실행하여 보았다.

실행> groovy testSyntheticDivision.groovy 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

   |    2 3 4 5
   1 |    2 5 9
   |---------------------------------
2 5 9    14

2 x^3 + 3 x^2 + 4 x + 5
= ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

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

'프로그래밍 > Groovy' 카테고리의 다른 글

황금비율(golden ratio) 구하기 with Groovy (0)	2008.03.24
현재 시각 알아내기 for Groovy (0)	2008.03.24
조립제법(Horner의 방법) 예제 (1) for Groovy (0)	2008.03.14
80컬럼 컨솔에 19단표 출력하기 예제 (2) for Groovy (0)	2008.03.03
80컬럼 컨솔에 19단표 출력하기 예제 (1) for Groovy (0)	2008.03.03

Posted by Scripter

,

조립제법(Horner의 방법) 예제 (1) for Groovy

프로그래밍/Groovy 2008. 3. 14. 10:13

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Groovy 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

/*
* Filename: TestSyntheticMethod.groovy
*
* Purpose: Find the quotient and remainder when some polynomial is
* divided by a monic polynomial of the first degree.
* 이 소스는 자바소스 TestSyntheticMethod.java 에서 배열 생성 부분
* new double[] {1.0, -a} 을 [1.0, -a] as double[] 로 변경한 것만 다르다.
*
* Execute: groovy TestSyntheticMethod.groovy -2 1 3 3 1
*/
import java.lang.Math;
public class TestSyntheticMethod {
// 사용법 표시
public static void printUsage() {
System.out.println("사용법: java TestSyntheticMethod [수] [피제식의 계수들]");
System.out.println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
public static String simplify(double v) {
String t = "" + v;
if (t.endsWith(".0"))
t = t.substring(0, t.length() - 2);
return t;
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
// 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
public static String simplify(double v, int width) {
String t = "" + v;
if (t.endsWith(".0"))
t = t.substring(0, t.length() - 2);
int len = t.length();
if (len < width)
t = " ".substring(0, width - len) + t;
return t;
}
// 다항식을 내림차순의 스트링 표현으로 반환
public static String toPolyString(double[] c) {
String t = "";
if (c.length > 2) {
if (simplify(c[0]).equals("1"))
t += "x^" + (c.length-1);
else if (simplify(c[0]).equals("-1"))
t += "-x^" + (c.length-1);
else
t += simplify(c[0]) + " x^" + (c.length-1);
}
else if (c.length == 2) {
if (simplify(c[0]).equals("1"))
t += "x";
else if (simplify(c[0]).equals("-1"))
t += "-x";
else
t += simplify(c[0]) + " x";
}
else if (c.length == 1) {
t += simplify(c[0]);
}
for (int i = 1; i < c.length; i++) {
if (c.length - 1 - i > 1) {
if (c[i] > 0.0) {
if (simplify(c[i]).equals("1"))
t += " + " + "x^" + (c.length - 1 - i);
else
t += " + " + simplify(c[i]) + " x^" + (c.length - 1 - i);
}
else if (c[i] < 0.0) {
if (simplify(c[i]).equals("-1"))
t += " - " + "x^" + (c.length - 1 - i);
else
t += " - " + simplify(Math.abs(c[i])) + " x^" + (c.length - 1 - i);
}
}
else if (c.length - 1 - i == 1) {
if (c[i] > 0.0) {
if (simplify(c[i]).equals("1"))
t += " + " + "x";
else
t += " + " + simplify(c[i]) + " x";
}
else if (c[i] < 0.0) {
if (simplify(c[i]).equals("-1"))
t += " - " + "x";
else
t += " - " + simplify(Math.abs(c[i])) + " x";
}
}
else if (c.length - 1 - i == 0) {
if (c[i] > 0.0) {
t += " + " + simplify(c[i]);
}
else if (c[i] < 0.0)
t += " - " + simplify(Math.abs(c[i]));
}
}
return t;
}
// 다항식 나눗셈 결과를
// (피제식) = (제식)(몫) + (나마지)
// 형태로 출력
public static void printDivisionResult(double a, double[] c, double[] b) {
System.out.print(" " + toPolyString(c));
System.out.println();
System.out.print(" = ( " + toPolyString( [1.0, -a] as double[] ) + " )");
double[] tmp = new double[b.length - 1];
for (int i = 0; i < tmp.length; i++) {
tmp[i] = b[i];
}
System.out.print("( " + toPolyString(tmp) + " )");
double r = b[b.length - 1];
if (r > 0.0)
System.out.print(" + " + simplify(r));
else if (r < 0.0)
System.out.print(" - " + simplify(Math.abs(r)));
System.out.println();
}
// 조립제법 계산표 출력 메소드
public static void printSyntheticTable(double a, double[] c, double[] s, double[] q) {
System.out.print(" | ");
System.out.print(simplify(c[0], 6));
for (int i = 1; i < c.length; i++) {
System.out.print(" " + simplify(c[i], 6));
}
System.out.println();
System.out.print(simplify(a, 6) + " | ");
System.out.print(" ");
System.out.print(simplify(s[1], 6));
for (int i = 2; i < s.length; i++) {
System.out.print(" " + simplify(s[i], 6));
}
System.out.println();
System.out.print(" |-");
for (int i = 0; i < q.length; i++) {
System.out.print("--------");
}
System.out.println("");
System.out.print(" ");
System.out.print(simplify(q[0], 6));
for (int i = 1; i < q.length; i++) {
System.out.print(" " + simplify(q[i], 6));
}
System.out.println();
}
// Java 애플리케이션의 실행 시작 시점 main 메소드
// (C 언어의 main 함수에 해당)
public static void main(String[] args) {
if (args.length < 3) {
printUsage();
System.exit(1);
}
//////////////////////////////////////////////////////
// 피제식은 c_0 x^n + c_1 x^(n -1) + ... + c_n
// 제식은 x - a
double a = Double.parseDouble(args[0]);
double[] c = new double[args.length - 1];
double[] s = new double[c.length];
double[] b = new double[c.length];
for (int i = 0; i < c.length; i++) {
c[i] = Double.parseDouble(args[i + 1]);
}
//////////////////////////////////////////////////////
// 조립제법의 주요 부분
s[0] = 0.0;
b[0] = c[0];
for (int i = 1; i < c.length; i++) {
s[i] = b[i-1]*a;
b[i] = c[i] + s[i];
}
//////////////////////////////////////////////////////
// 몫의 계수와 나머지를 출력한다.
System.out.print("몫의 계수는 ");
for (int i = 0; i < b.length - 2; i++) {
System.out.print(simplify(b[i]) + ", " );
}
System.out.print(simplify(b[b.length - 2]));
System.out.println(" 이고, 나머지는 " + simplify(b[b.length - 1]) + " 이다.");
System.out.println();
//////////////////////////////////////////////////////
// 조립제법 표를 출력한다.
printSyntheticTable(a, c, s, b);
System.out.println();
//////////////////////////////////////////////////////
// (피제식) = (제식) x (몫) + (나머지)
printDivisionResult(a, c, b);
}
}

Groovy 언어로 작성된 소스파일은 groovyc 명형으로 컴파일한 후 , 컴파일된 .class 파일을 java 명령으로 실행해도 되지만, groovy 명령을 사용하여 (아래에서 처험) 컴파일 과정 없이 직접 소스파일을 실행시킬 수 있다.

실행> groovy TestSyntheticMethod.groovy 1 2 3 4 5

몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

       |      2       3       4       5
     1 |              2       5       9
       |---------------------------------
              2       5       9      14

  2 x^3 + 3 x^2 + 4 x + 5
    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

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

'프로그래밍 > Groovy' 카테고리의 다른 글

현재 시각 알아내기 for Groovy (0)	2008.03.24
조립제법(Horner의 방법) 예제 (2) for Groovy (0)	2008.03.14
80컬럼 컨솔에 19단표 출력하기 예제 (2) for Groovy (0)	2008.03.03
80컬럼 컨솔에 19단표 출력하기 예제 (1) for Groovy (0)	2008.03.03
Groovy 언어의 특징을 잘 나타내는 몇 가지 예제들 (0)	2008.02.21

Posted by Scripter

,

조립제법(Horner의 방법) 예제 for Java

프로그래밍/Java 2008. 3. 13. 22:25

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Java 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
* 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표
* 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

/*
* Filename: TestSyntheticMethod.java
*
* Purpose: Find the quotient and remainder when some polynomial is
* divided by a monic polynomial of the first degree.
*
* Compile: javac -d . TestSyntheticMethod.java
*
* Execute: java TestSyntheticMethod -2 1 3 3 1
*/
import java.lang.Math;
public class TestSyntheticMethod {
// 사용법 표시
public static void printUsage() {
System.out.println("사용법: java TestSyntheticMethod [수] [피제식의 계수들]");
System.out.println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
public static String simplify(double v) {
String t = "" + v;
if (t.endsWith(".0"))
t = t.substring(0, t.length() - 2);
return t;
}
// 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
// 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
public static String simplify(double v, int width) {
String t = "" + v;
if (t.endsWith(".0"))
t = t.substring(0, t.length() - 2);
int len = t.length();
if (len < width)
t = " ".substring(0, width - len) + t;
return t;
}
// 다항식을 내림차순의 스트링 표현으로 반환
public static String toPolyString(double[] c) {
String t = "";
if (c.length > 2) {
if (simplify(c[0]).equals("1"))
t += "x^" + (c.length-1);
else if (simplify(c[0]).equals("-1"))
t += "-x^" + (c.length-1);
else
t += simplify(c[0]) + " x^" + (c.length-1);
}
else if (c.length == 2) {
if (simplify(c[0]).equals("1"))
t += "x";
else if (simplify(c[0]).equals("-1"))
t += "-x";
else
t += simplify(c[0]) + " x";
}
else if (c.length == 1) {
t += simplify(c[0]);
}
for (int i = 1; i < c.length; i++) {
if (c.length - 1 - i > 1) {
if (c[i] > 0.0) {
if (simplify(c[i]).equals("1"))
t += " + " + "x^" + (c.length - 1 - i);
else
t += " + " + simplify(c[i]) + " x^" + (c.length - 1 - i);
}
else if (c[i] < 0.0) {
if (simplify(c[i]).equals("-1"))
t += " - " + "x^" + (c.length - 1 - i);
else
t += " - " + simplify(Math.abs(c[i])) + " x^" + (c.length - 1 - i);
}
}
else if (c.length - 1 - i == 1) {
if (c[i] > 0.0) {
if (simplify(c[i]).equals("1"))
t += " + " + "x";
else
t += " + " + simplify(c[i]) + " x";
}
else if (c[i] < 0.0) {
if (simplify(c[i]).equals("-1"))
t += " - " + "x";
else
t += " - " + simplify(Math.abs(c[i])) + " x";
}
}
else if (c.length - 1 - i == 0) {
if (c[i] > 0.0) {
t += " + " + simplify(c[i]);
}
else if (c[i] < 0.0)
t += " - " + simplify(Math.abs(c[i]));
}
}
return t;
}
// 다항식 나눗셈 결과를
// (피제식) = (제식)(몫) + (나마지)
// 형태로 출력
public static void printDivisionResult(double a, double[] c, double[] b) {
System.out.print(" " + toPolyString(c));
System.out.println();
System.out.print(" = ( " + toPolyString( new double[] {1.0, -a} ) + " )");
double[] tmp = new double[b.length - 1];
for (int i = 0; i < tmp.length; i++) {
tmp[i] = b[i];
}
System.out.print("( " + toPolyString(tmp) + " )");
double r = b[b.length - 1];
if (r > 0.0)
System.out.print(" + " + simplify(r));
else if (r < 0.0)
System.out.print(" - " + simplify(Math.abs(r)));
System.out.println();
}
// 조립제법 계산표 출력 메소드
public static void printSyntheticTable(double a, double[] c, double[] s, double[] q) {
System.out.print(" | ");
System.out.print(simplify(c[0], 6));
for (int i = 1; i < c.length; i++) {
System.out.print(" " + simplify(c[i], 6));
}
System.out.println();
System.out.print(simplify(a, 6) + " | ");
System.out.print(" ");
System.out.print(simplify(s[1], 6));
for (int i = 2; i < s.length; i++) {
System.out.print(" " + simplify(s[i], 6));
}
System.out.println();
System.out.print(" |-");
for (int i = 0; i < q.length; i++) {
System.out.print("--------");
}
System.out.println("");
System.out.print(" ");
System.out.print(simplify(q[0], 6));
for (int i = 1; i < q.length; i++) {
System.out.print(" " + simplify(q[i], 6));
}
System.out.println();
}
// Java 애플리케이션의 실행 시작 시점 main 메소드
// (C 언어의 main 함수에 해당)
public static void main(String[] args) {
if (args.length < 3) {
printUsage();
System.exit(1);
}
//////////////////////////////////////////////////////
// 피제식은 c_0 x^n + c_1 x^(n -1) + ... + c_n
// 제식은 x - a
double a = Double.parseDouble(args[0]);
double[] c = new double[args.length - 1];
double[] s = new double[c.length];
double[] b = new double[c.length];
for (int i = 0; i < c.length; i++) {
c[i] = Double.parseDouble(args[i + 1]);
}
//////////////////////////////////////////////////////
// 조립제법의 주요 부분
s[0] = 0.0;
b[0] = c[0];
for (int i = 1; i < c.length; i++) {
s[i] = b[i-1]*a;
b[i] = c[i] + s[i];
}
//////////////////////////////////////////////////////
// 몫의 계수와 나머지를 출력한다.
System.out.print("몫의 계수는 ");
for (int i = 0; i < b.length - 2; i++) {
System.out.print(simplify(b[i]) + ", " );
}
System.out.print(simplify(b[b.length - 2]));
System.out.println(" 이고, 나머지는 " + simplify(b[b.length - 1]) + " 이다.");
System.out.println();
//////////////////////////////////////////////////////
// 조립제법 표를 출력한다.
printSyntheticTable(a, c, s, b);
System.out.println();
//////////////////////////////////////////////////////
// (피제식) = (제식) x (몫) + (나머지)
printDivisionResult(a, c, b);
}
}

컴파일> javac -d . TestSyntheticMethod.java
실행> java TestSyntheticMethod 1 2 3 4 5

몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.       |      2       3       4       5     1 |              2       5       9       |---------------------------------              2       5       9      14  2 x^3 + 3 x^2 + 4 x + 5    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

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

'프로그래밍 > Java' 카테고리의 다른 글

황금비율(golden ratio) 구하기 with Java (0)	2008.03.24
현재 시각 알아내기 for Java (0)	2008.03.24
80컬럼 컨솔에 19단표 출력하기 예제 for Java (0)	2008.03.03
(최대공약수 구하기) while... 반복문 예제 for Java (0)	2008.02.20
if...else... 조건문 사용 예제 for Java (0)	2008.02.19

Posted by Scripter

,

if ... else ... 조건문 사용 예제 for D

프로그래밍/D 2008. 3. 8. 17:35

D 언어의 if ... else ... 조건문 구문은 C/C++/Java/Groovy 의 것과 같다.
단, 한글이 포함된 소스파일은 UTF-8 인코딩으로 저장해야 한다.
또 C/C++ 언어에서 쓰이는 exit() 함수를 D 언어에서 쓰기 위해서는

import std.c.stdlib;

구문을 소스의 앞부분에 미리 써 놓아야 한다.

소스 파일명: testIfD.d

import std.c.stdio; // printf 함수 사용을 위해
import std.c.stdlib; // exit 함수 사용을 위해
import std.conv; // to! 변환함수 사용을 위해
// 사용법을 컨솔에 보여주는 함수
void printUsing() {
printf("Using: testIfD [number]\n");
printf("This determines whether the number is positive or not.\n");
}
int main (string[] args) {
float val;
if (args.length != 2) {
printUsing();
exit(1);
return 1;
}
// 명령행 인자의 스트링을 가져와서
// 배정밀도 부동소수점수로 변환하여
// 변수 val에 저장한다.
val = to!(float)(args[1]);
// 변수 val에 저장된 값이 양수인지 음수인지 0인지를
// 판단하는 if...else... 조건문
if (val > 0.0)
printf("%g is a positive number.\n", val);
else if (val < 0.0)
printf("%g is a negative number.\n", val);
else
printf("%g is zero.\n", val);
return 0;
}

컴파일> dmd testIfD.d

실행> testIfD
Using: testIfD [number]
This determines whether the number is positive or not.

실행> testIfD 1.234
1.234 is a positive number.

실행> testIfD 1.234
-1.234 is a negative number.

실행> testIfD 0
0 is zero.

'프로그래밍 > D' 카테고리의 다른 글

D 언어로 역삼각함수, 역쌍곡선함수 값을 구하는 예제 (0)	2013.01.04
명령행 인자 처리 예제 for D (0)	2008.03.08
for 반복문 예제 For D (0)	2008.03.08
Hello 예제 for D (0)	2008.03.08

Posted by Scripter

,

명령행 인자 처리 예제 for D

프로그래밍/D 2008. 3. 8. 17:18

소스에 한글이 포함된 경우에는 파일을 UTF-8 인코딩으로 저장해야 한다.
반복문은 for( ; ; ) 구문을 써도 되지만, 여기서는 foreach 구문을 사용하였다.

소스 파일명: testArgumentsD.d

import std.c.stdio; // prinf 함수의사용을 위해
import std.conv; // to! 변환함수 사용을 위해
int main (string[] args) {
double sum = 0.0; // 초기화
// 명령행 인자(command-line argument) 개수 출력
printf("Count of arguments: %d\n", args.length);
foreach (string arg; args[1 .. args.length]) {
// 스트링을 배정밀도 부동소수점수로 변환하여 누적
// sum += std.conv.to!(double)(arg);
sum += to!(double)(arg);
}
// 누적된 배정밀도 값을 출력
printf("The sum of arguments is %g\n", sum);
return 0;
}

컴파일> dmd testArgumentsD.d

실행> testArgumentsD 1 2 3 4
Count of arguments: 5
The sum of arguments is 10

실행> testArgumentsD 1 2 3 4.1
Count of arguments: 5
The sum of arguments is 10.1

'프로그래밍 > D' 카테고리의 다른 글

D 언어로 역삼각함수, 역쌍곡선함수 값을 구하는 예제 (0)	2013.01.04
if ... else ... 조건문 사용 예제 for D (0)	2008.03.08
for 반복문 예제 For D (0)	2008.03.08
Hello 예제 for D (0)	2008.03.08

Posted by Scripter

,

for 반복문 예제 For D

프로그래밍/D 2008. 3. 8. 16:53

D 언어에는 froeach를 사영하는 반목문도 있지만,
C/C++/Java 언어에서 쓰인 보총의 for ( ; ;) 을 그대로 써도 된다.

소스 파일명: testForLoopD.d
------------------------------[소스 시작]
import std.c.stdio;

int main (string[] args) {
int x;
x = 2;
for (int i = 1; i < 10; i++) {
printf("%d x %d = %d\n", x, i, x*i);
}
return 0;
}
------------------------------[소스 끝]

컴파일> dmd testForLoop.d

실행> testForLoop
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18

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

'프로그래밍 > D' 카테고리의 다른 글

D 언어로 역삼각함수, 역쌍곡선함수 값을 구하는 예제 (0)	2013.01.04
if ... else ... 조건문 사용 예제 for D (0)	2008.03.08
명령행 인자 처리 예제 for D (0)	2008.03.08
Hello 예제 for D (0)	2008.03.08

Posted by Scripter

,

Hello 예제 for D

프로그래밍/D 2008. 3. 8. 16:32

D 언어 홈페이지는 http://www.digitalmars.com/d/index.html 이다.

컨솔에 문자 출력하는 D 언어 구문은 C 언어의 것과 같다.

printf(format, ...);

소스 파일명: hello.d
------------------------------[소스 시작]
import std.c.stdio;

int main (string[] args) {
printf("Hello, world!\n");
return 0;
}
------------------------------[소스 끝]

컴파일> dmd hello.d

실행> hello
Hello, world!

'프로그래밍 > D' 카테고리의 다른 글

D 언어로 역삼각함수, 역쌍곡선함수 값을 구하는 예제 (0)	2013.01.04
if ... else ... 조건문 사용 예제 for D (0)	2008.03.08
명령행 인자 처리 예제 for D (0)	2008.03.08
for 반복문 예제 For D (0)	2008.03.08

Posted by Scripter

,

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

'프로그래밍'에 해당되는 글 605건

조립제법(Horner의 방법) 예제 for Lua

'프로그래밍 > Lua' 카테고리의 다른 글

조립제법(Horner의 방법) 예제 for Ruby

'프로그래밍 > Ruby' 카테고리의 다른 글

조립제법(Horner의 방법) 예제 for Python

'프로그래밍 > Python' 카테고리의 다른 글

조립제법(Horner의 방법) 예제 (2) for Groovy

'프로그래밍 > Groovy' 카테고리의 다른 글

조립제법(Horner의 방법) 예제 (1) for Groovy

'프로그래밍 > Groovy' 카테고리의 다른 글

조립제법(Horner의 방법) 예제 for Java

'프로그래밍 > Java' 카테고리의 다른 글

if ... else ... 조건문 사용 예제 for D

'프로그래밍 > D' 카테고리의 다른 글

명령행 인자 처리 예제 for D

'프로그래밍 > D' 카테고리의 다른 글

for 반복문 예제 For D

'프로그래밍 > D' 카테고리의 다른 글

Hello 예제 for D

'프로그래밍 > D' 카테고리의 다른 글

카테고리

태그목록

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

글 보관함

달력

링크

티스토리툴바