object Scala0101 {
def main(args:Array[String]) {
println(3 + 5)
println(3 - 5)
println(3 * 5)
println(Math.pow(3, 5))
println(5 / 3)
println(5.0 / 3)
println(5 / 3.0)
println(5 % 3)
printf("%d\n", 3 * 5)
print(3 * 5 + "\n")
println("%3d".format(3 * 5))
println("%23.20f".format(5 / 3.0))
}
}
/*
Z:\>scala Scala0101.scala
8
-2
15
243.0
1
1.6666666666666667
1.6666666666666667
2
15
15
15
1.66666666666666670000
*/
object Scala0102 {
def main(args:Array[String]) {
val i = 3 * 5;
printf("3 * 5 = %d\n", i);
}
}
object Scala0103 {
def main(args:Array[String]) {
for (i <- 1 to 9) {
print(i + ", ")
}
println()
}
}
object Scala0104 {
def main(args:Array[String]) {
for (i <- 1 to 9) {
if (i % 3 == 0) {
print(i + ", ")
}
}
println()
for (i <- 1 to 9 if i % 3 == 0) {
print(i + ", ")
}
println()
}
}
object Scala0105 {
def main(args:Array[String]) {
var sm = 0
for (i <- 1 to 99) {
if (i % 3 == 0) {
sm += i
}
}
println(sm)
}
}
(1 to 9)
(1 to 9).filter(n => n % 3 == 0)
(1 to 99).filter(n => n % 3 == 0).reduce((x, n) => x + n)
(1 to 99).filter(n => n % 3 == 0).sum
// 初項:a, 公差:a で, 上限:lim の数列の総和を返す関数
def sn(a:Int, lim:Int) = {
val n = lim / a // 項数:n = 上限:lim / 公差:a
val l = n * a // 末項:l = 項数:n * 公差:a
(a + l) * n / 2 // 総和:sn = (初項:a + 末項:l) * 項数:n / 2
}
// 3 の倍数の合計
sn(3,999)
val n = 10000
n * (n + 1) / 2
val n = 5000
n * (n + 1)
val n = 5000
(Math.pow(n, 2)).toInt
val n = 1000
n * (n + 1) * (2 * n + 1) / 6
val n = 100
(Math.pow(n, 2) * Math.pow((n + 1), 2) / 4).toInt
val n = 10
val a = 2
val r = 3
a * (Math.pow(r, n).toInt - 1) / (r -1)
(0 to 9)
(0 to 9).map(n => n * 3 + 5)
(0l to 9l).map(n => n * 3 + 5).product
// 等差数列の積
def prod(m: Long, d: Int, n: Int): Long = {
n match {
case 0 => 1
case _ => m * prod(m + d, d, n - 1)
}
}
// 初項 5, 公差 3, 項数 10 の数列の積
prod(5, 3, 10)
// 階乗を求める関数
def Fact(n: Int): Int = {
n match {
case 0 => 1
case _ => n * Fact(n - 1)
}
}
// 10の階乗
Fact(10)
// 下降階乗冪
def FallingFact(x: Int, n: Int): Int = {
n match {
case 1 => x
case _ => x * FallingFact(x - 1, n - 1)
}
}
// 10 から 6 までの 総乗
FallingFact(10, 5)
// 上昇階乗冪
def RisingFact(x: Int, n: Int): Int = {
n match {
case 1 => x
case _ => x * RisingFact(x + 1, n - 1)
}
}
// 10 から 14 までの 総乗
RisingFact(10, 5)
// 階乗
def Fact(n: Int): Int = {
n match {
case 0 => 1
case _ => n * Fact(n - 1)
}
}
// 順列 (異なる 10 個のものから 5 個取ってできる順列の総数)
val n = 10
val r = 5
Fact(n) / Fact(n - r)
// 下降階乗冪
def FallingFact(x: Int, n: Int): Int = {
n match {
case 1 => x
case _ => x * FallingFact(x - 1, n - 1)
}
}
// 順列 (異なる 10 個のものから 5 個取ってできる順列の総数)
val n = 10
val r = 5
FallingFact(n, r)
// 重複順列 (異なる 10 個のものから重複を許して 5 個取ってできる順列の総数)
val n = 10
val r = 5
Math.pow(n, r)
// 組合せ
def Comb(n: Int, r: Int): Int = {
(n, r) match {
case (_, 0) => 1
case (_, 1) => n
case (_, _) if n == r => 1
case (_, _) => Comb(n - 1, r - 1) + Comb(n - 1, r)
}
}
// 異なる 10 個のものから 5 個取ってできる組合せの総数
val n = 10
val r = 5
Comb(n, r)
// 組合せ
def Comb(n: Int, r: Int): Int = {
(n, r) match {
case (_, 0) => 1
case (_, 1) => n
case (_, _) if n == r => 1
case (_, _) => Comb(n - 1, r - 1) + Comb(n - 1, r)
}
}
// 異なる 10 個のものから重複を許して 5 個とる組合せの総数
val n = 10
val r = 5
Comb(n + r - 1, r)
// 自作の正弦関数
def mySin(x:Double, n:Int, nega:Boolean, numerator:Double, denominator:Double, y:Double):Double = {
val m = 2 * n
val denom = denominator * (m + 1) * m
val num = numerator * x * x
val a = num / denom
// 十分な精度になったら処理を抜ける
if (a <= 0.00000000001)
y
else
y + mySin(x, n + 1, !nega, num, denom, if (nega) a else -a)
}
(0 to 24).
map(_ * 15).
// 0° ～ 360° のうち 30°, 45° の倍数
filter(n => (n % 30 == 0) || (n % 45 == 0)).
// ラジアン
map(degree => (degree, Math.toRadians(degree))).
// 標準の正弦関数 と 自作の正弦関数
map(t => (t._1, Math.sin(t._2), mySin(t._2, 1, false, t._2, 1.0, t._2))).
// 標準関数との差異
foreach {t => t
match {
case (degree, d1, d2) => println("%3d : %13.10f - %13.10f = %13.10f".format(degree, d1, d2, d1 - d2))
}
}
(0 to 24).
map(_ * 15).
filter(n => (n % 30 == 0) || (n % 45 == 0)).
foreach { degree =>
val radian = Math.toRadians(degree)
// 自作の正弦関数
val d1 = mySin(radian, 1, false, radian, 1.0, radian)
// 標準の正弦関数
val d2 = Math.sin(radian)
// 標準関数との差異
println("%3d : %13.10f - %13.10f = %13.10f".format(degree, d1, d2, d1 - d2));
}
// 自作の余弦関数
def myCos(x:Double, n:Int, nega:Boolean, numerator:Double, denominator:Double, y:Double):Double = {
val m = 2 * n
val denom = denominator * m * (m - 1)
val num = numerator * x * x
val a = num / denom
// 十分な精度になったら処理を抜ける
if (a <= 0.00000000001)
y
else
y + myCos(x, n + 1, !nega, num, denom, if (nega) a else -a)
}
(0 to 24).
map(_ * 15).
filter(n => (n % 30 == 0) || (n % 45 == 0)).
foreach { degree =>
val radian = Math.toRadians(degree)
// 自作の余弦関数
val d1 = myCos(radian, 1, false, 1.0, 1.0, 1.0)
// 標準の余弦関数
val d2 = Math.cos(radian)
// 標準関数との差異
System.out.println("%3d : %13.10f - %13.10f = %13.10f".format(degree, d1, d2, d1 - d2));
}
// 自作の正接関数
def myTan(x:Double, x2:Double, n:Int, t:Double):Double = {
val denom = x2 / (n - t)
val num = n - 2
if (num <= 1)
x / (1 - denom)
else
myTan(x, x2, num, denom)
}
(0 to 12).
map(_ * 15).
filter(n => n % 180 != 0).
map(_ - 90).
foreach { degree =>
val radian = Math.toRadians(degree)
val x2 = radian * radian
// 自作の正接関数
val d1 = myTan(radian, x2, 15, 0.0) // 15:必要な精度が得られる十分大きな奇数
// 標準の正接関数
val d2 = Math.tan(radian)
// 標準関数との差異
System.out.println("%3d : %13.10f - %13.10f = %13.10f".format(degree, d1, d2, d1 - d2));
}
// 自作の指数関数
def myExp(x:Double, n:Int, numerator:Double, denominator:Double, y:Double):Double = {
val denom = denominator * n
val num = numerator * x
val a = num / denom
// 十分な精度になったら処理を抜ける
if (Math.abs(a) <= 0.00000000001)
y
else
y + myExp(x, n + 1, num, denom, a)
}
(0 to 20).
map(n => (n - 10) / 4.0).
foreach { x =>
// 標準の指数関数
val d1 = Math.exp(x)
// 自作の指数関数
val d2 = myExp(x, 1, 1.0, 1.0, 1.0)
// 標準関数との差異
System.out.println("%5.2f : %13.10f - %13.10f = %13.10f".format(x, d1, d2, d1 - d2));
}
// 自作の指数関数
def myExp(x:Double, x2:Double, n:Int, t:Double):Double = {
val denom = x2 / (n + t)
val num = n - 4
if (num < 6)
1 + ((2 * x) / (2 - x + denom))
else
myExp(x, x2, num, denom)
}
(0 to 20).
map(n => (n - 10) / 4.0).
foreach { x =>
// 標準の指数関数
val d1 = Math.exp(x)
// 自作の指数関数
val x2 = x * x
val d2 = myExp(x, x2, 30, 0.0) // 30:必要な精度が得られるよう, 6から始めて4ずつ増加させる
// 標準関数との差異
System.out.println("%5.2f : %13.10f - %13.10f = %13.10f".format(x, d1, d2, d1 - d2))
}
// 自作の対数関数
def myLog(x2:Double, numerator:Double, denominator:Double, y:Double):Double = {
val denom = denominator + 2
val num = numerator * x2 * x2
val a = num / denom
// 十分な精度になったら処理を抜ける
if (Math.abs(a) <= 0.00000000001)
y
else
y + myLog(x2, num, denom, a)
}
(1 to 20).
map(_ / 5.0).
foreach { x =>
// 標準の対数関数
val d1 = Math.log(x)
// 自作の対数関数
val x2 = (x - 1) / (x + 1)
val d2 = 2 * myLog(x2, x2, 1.0, x2)
// 標準関数との差異
System.out.println("%5.2f : %13.10f - %13.10f = %13.10f".format(x, d1, d2, d1 - d2))
}
// 自作の対数関数
def myLog(x:Double, n:Int, t:Double):Double = {
var n2 = n
var x2 = x
if (n > 3) {
if (n % 2 == 0)
n2 = 2
x2 = x * (n / 2)
}
val t2 = x2 / (n2 + t)
if (n <= 2)
x / (1 + t2)
else
myLog(x, n - 1, t2)
}
(1 to 20).
map(_ / 5.0).
foreach { x =>
// 標準の対数関数
val d1 = Math.log(x)
// 自作の対数関数
val d2 = myLog(x - 1, 27, 0.0) // 27:必要な精度が得られる十分大きな奇数
// 標準関数との差異
System.out.println("%5.2f : %13.10f - %13.10f = %13.10f".format(x, d1, d2, d1 - d2))
}
// 自作の双曲線正弦関数
def mySinh(x:Double, n:Int, numerator:Double, denominator:Double, y:Double):Double = {
val m = 2 * n
val denom = denominator * (m + 1) * m
val num = numerator * x * x
val a = num / denom
// 十分な精度になったら処理を抜ける
if (Math.abs(a) <= 0.00000000001)
y
else
y + mySinh(x, n + 1, num, denom, a)
}
(0 to 20).
map(_ - 10).
foreach { x =>
// 自作の双曲線正弦関数
val d1 = mySinh(x, 1, x, 1.0, x)
// 標準の双曲線正弦関数
val d2 = Math.sinh(x)
// 標準関数との差異
System.out.println("%3d : %17.10f - %17.10f = %13.10f".format(x, d1, d2, d1 - d2));
}
// 自作の双曲線余弦関数
def myCosh(x:Double, n:Int, numerator:Double, denominator:Double, y:Double):Double = {
val m = 2 * n
val denom = denominator * m * (m - 1)
val num = numerator * x * x
val a = num / denom
// 十分な精度になったら処理を抜ける
if (Math.abs(a) <= 0.00000000001)
y
else
y + myCosh(x, n + 1, num, denom, a)
}
(0 to 20).
map(_ - 10).
foreach { x =>
// 自作の双曲線余弦関数
val d1 = myCosh(x, 1, 1.0, 1.0, 1.0)
// 標準の双曲線余弦関数
val d2 = Math.cosh(x)
// 標準関数との差異
System.out.println("%3d : %17.10f - %17.10f = %13.10f".format(x, d1, d2, d1 - d2));
}
object Scala0601 {
def main(args: Array[String]) {
val a:Double = 0
val b:Double = 1
// 蜿ｰ蠖｢蜑・〒遨榊・
var n:Int = 2
for (j <- 1 to 10) {
var h:Double = (b - a) / n
var s:Double = 0
var x:Double = a
for (i <- 1 to (n - 1)) {
x += h
s += f(x)
}
s = h * ((f(a) + f(b)) / 2 + s)
n *= 2
// 邨先棡繧・ﾏ 縺ｨ豈碑ｼ・
println("%3d : %13.10f, %13.10f".format(j, s, s - Math.PI))
}
}
def f(x:Double):Double = {
4 / (1 + x * x)
}
}
object Scala0602 {
def main(args: Array[String]) {
val a:Double = 0
val b:Double = 1
// 荳ｭ轤ｹ蜑・〒遨榊・
var n:Int = 2
for (j <- 1 to 10) {
var h:Double = (b - a) / n
var s:Double = 0
var x:Double = a + (h / 2)
for (i <- 1 to n) {
s += f(x)
x += h
}
s *= h
n *= 2
// 邨先棡繧・ﾏ 縺ｨ豈碑ｼ・
println("%3d : %13.10f, %13.10f".format(j, s, s - Math.PI))
}
}
def f(x:Double):Double = {
4 / (1 + x * x)
}
}
object Scala0603 {
def main(args: Array[String]) {
val a:Double = 0
val b:Double = 1
// Simpson蜑・〒遨榊・
var n:Int = 2
for (j <- 1 to 5) {
var h:Double = (b - a) / n
var s2:Double = 0
var s4:Double = 0
var x:Double = a + h
for (i <- 1 to (n / 2)) {
s4 += f(x)
x += h
s2 += f(x)
x += h
}
s2 = (s2 - f(b)) * 2 + f(a) + f(b)
s4 *= 4
var s:Double = (s2 + s4) * h / 3
n *= 2
// 邨先棡繧・ﾏ 縺ｨ豈碑ｼ・
println("%3d : %13.10f, %13.10f".format(j, s, s - Math.PI))
}
}
def f(x:Double):Double = {
4 / (1 + x * x)
}
}
object Scala0604 {
def main(args: Array[String]) {
val a:Double = 0
val b:Double = 1
val t = Array.ofDim[Double](7, 7)
// 蜿ｰ蠖｢蜑・〒遨榊・
var n:Int = 2
for (i <- 1 to 6) {
var h:Double = (b - a) / n
var s:Double = 0
var x:Double = a
for (j <- 1 to (n - 1)) {
x += h
s += f(x)
}
// 邨先棡繧剃ｿ晏ｭ・
t(i)(1) = h * ((f(a) + f(b)) / 2 + s)
n *= 2
}
// Richardson縺ｮ陬懷､匁ｳ・
n = 4
for (j <- 2 to 6) {
for (i <- j to 6) {
t(i)(j) = t(i)(j - 1) + (t(i)(j - 1) - t(i - 1)(j - 1)) / (n - 1)
if (i == j) {
// 邨先棡繧・ﾏ 縺ｨ豈碑ｼ・
println("%3d : %13.10f, %13.10f".format(j, t(i)(j), t(i)(j) - Math.PI))
}
}
n *= 4
}
}
def f(x:Double):Double = {
4 / (1 + x * x)
}
}
object Scala0701 {
// 繝・・繧ｿ轤ｹ縺ｮ謨ｰ - 1
val N = 6
def main(args: Array[String]) {
// 1.5蛻ｻ縺ｿ縺ｧ -4.5・・.5 縺ｾ縺ｧ, ・礼せ縺縺大､繧偵そ繝・ヨ
val x = (0 to N).map(_ * 1.5 - 4.5)
val y = x.map(f)
// 0.5蛻ｻ縺ｿ縺ｧ 荳弱∴繧峨ｌ縺ｦ縺・↑縺・､繧定｣憺俣
val d1 = (0 to 18).map(_ * 0.5 - 4.5)
val d2 = d1.map(f)
val d3 = d1.map(lagrange(_, x, y))
(d1 zip d2 zip d3).foreach {
case ((d1, d2), d3) =>
println("%5.2f\t%8.5f\t%8.5f\t%8.5f".format(d1, d2, d3, d2 - d3))
}
}
// 蜈・・髢｢謨ｰ
def f(x:Double) = {
x - Math.pow(x,3) / (3 * 2) + Math.pow(x,5) / (5 * 4 * 3 * 2)
}
// Lagrange (繝ｩ繧ｰ繝ｩ繝ｳ繧ｸ繝･) 陬憺俣
def lagrange(d:Double, x:IndexedSeq[Double], y:IndexedSeq[Double]) = {
var sum_list = List[Double](0)
for (i <- 0 to N) {
var prod_list = List(y(i))
for (j <- 0 to N) {
if (i != j) {
prod_list = ((d - x(j)) / (x(i) - x(j)))::prod_list
}
}
sum_list = prod_list.product::sum_list
}
sum_list.sum
}
}
object Scala0702 {
// 繝・・繧ｿ轤ｹ縺ｮ謨ｰ - 1
val N = 6
def main(args: Array[String]) {
// 1.5蛻ｻ縺ｿ縺ｧ -4.5・・.5 縺ｾ縺ｧ, ・礼せ縺縺大､繧偵そ繝・ヨ
val x = (0 to N).map(_ * 1.5 - 4.5)
val y = x.map(f)
// 0.5蛻ｻ縺ｿ縺ｧ 荳弱∴繧峨ｌ縺ｦ縺・↑縺・､繧定｣憺俣
val d1 = (0 to 18).map(_ * 0.5 - 4.5)
val d2 = d1.map(f)
val d3 = d1.map(neville(_, x, y))
(d1 zip d2 zip d3).foreach {
case ((d1, d2), d3) =>
println("%5.2f\t%8.5f\t%8.5f\t%8.5f".format(d1, d2, d3, d2 - d3))
}
}
// 蜈・・髢｢謨ｰ
def f(x:Double) = {
x - Math.pow(x,3) / (3 * 2) + Math.pow(x,5) / (5 * 4 * 3 * 2)
}
// Neville (繝阪Χ繧｣繝ｫ) 陬憺俣
def neville(d:Double, x:IndexedSeq[Double], y:IndexedSeq[Double]) = {
val w = Array.ofDim[Double](N + 1, N + 1)
for (i <- 0 to N)
w(0)(i) = y(i)
for (j <- 1 to N) {
for (i <- 0 to N - j)
w(j)(i) = w(j-1)(i+1) + (w(j-1)(i+1) - w(j-1)(i)) * (d - x(i+j)) / (x(i+j) - x(i))
}
w(N)(0)
}
}
object Scala0703 {
// 繝・・繧ｿ轤ｹ縺ｮ謨ｰ - 1
val N = 6
def main(args: Array[String]) {
// 1.5蛻ｻ縺ｿ縺ｧ -4.5・・.5 縺ｾ縺ｧ, ・礼せ縺縺大､繧偵そ繝・ヨ
val x = (0 to N).map(_ * 1.5 - 4.5)
val y = x.map(f)
// 蟾ｮ蛻・膚縺ｮ陦ｨ繧剃ｽ懊ｋ
val d = Array.ofDim[Double](N + 1, N + 1)
for (j <- 0 to N)
d(0)(j) = y(j)
for (i <- 1 to N) {
for (j <- 0 to N - i)
d(i)(j) = (d(i-1)(j+1) - d(i-1)(j)) / (x(j+i) - x(j))
}
// ・朱嚴蟾ｮ蛻・膚
val a = (0 to N).map(d(_)(0))
// 0.5蛻ｻ縺ｿ縺ｧ 荳弱∴繧峨ｌ縺ｦ縺・↑縺・､繧定｣憺俣
val d1 = (0 to 18).map(_ * 0.5 - 4.5)
val d2 = d1.map(f)
val d3 = d1.map(newton(_, x, a))
(d1 zip d2 zip d3).foreach {
case ((d1, d2), d3) =>
println("%5.2f\t%8.5f\t%8.5f\t%8.5f".format(d1, d2, d3, d2 - d3))
}
}
// 蜈・・髢｢謨ｰ
def f(x:Double) = {
x - Math.pow(x,3) / (3 * 2) + Math.pow(x,5) / (5 * 4 * 3 * 2)
}
// Newton (繝九Η繝ｼ繝医Φ) 陬憺俣
def newton(d:Double, x:IndexedSeq[Double], a:IndexedSeq[Double]) = {
var sum_list = List(a(0))
for (i <- 1 to N) {
var prod_list = List(a(i))
for (j <- 0 to i - 1) {
prod_list = (d - x(j))::prod_list
}
sum_list = (prod_list.product)::sum_list
}
sum_list.sum
}
}
object Scala0704 {
// 繝・・繧ｿ轤ｹ縺ｮ謨ｰ - 1
val N = 6
val Nx2 = 13
def main(args: Array[String]) {
// 1.5蛻ｻ縺ｿ縺ｧ -4.5・・.5 縺ｾ縺ｧ, ・礼せ縺縺大､繧偵そ繝・ヨ
val x = (0 to N).map(_ * 1.5 - 4.5)
val y = x.map(f)
val yd = x.map(fd)
// 蟾ｮ蛻・膚縺ｮ陦ｨ繧剃ｽ懊ｋ
val z = (0 to Nx2).map(_ / 2).map(x(_))
val d = Array.ofDim[Double](Nx2 + 1, Nx2 + 1)
for (i <- 0 to Nx2)
d(0)(i) = y(i / 2)
for (i <- 1 to Nx2) {
for (j <- 0 to Nx2 - i)
if (i == 1 && j % 2 == 0)
d(i)(j) = yd(j / 2)
else
d(i)(j) = (d(i-1)(j+1) - d(i-1)(j)) / (z(j+i) - z(j))
}
// ・朱嚴蟾ｮ蛻・膚
val a = (0 to Nx2).map(d(_)(0))
// 0.5蛻ｻ縺ｿ縺ｧ 荳弱∴繧峨ｌ縺ｦ縺・↑縺・､繧定｣憺俣
val d1 = (0 to 18).map(_ * 0.5 - 4.5)
val d2 = d1.map(f)
val d3 = d1.map(hermite(_, z, a))
(d1 zip d2 zip d3).foreach {
case ((d1, d2), d3) =>
println("%5.2f\t%8.5f\t%8.5f\t%8.5f".format(d1, d2, d3, d2 - d3))
}
}
// 蜈・・髢｢謨ｰ
def f(x:Double) = {
x - Math.pow(x,3) / (3 * 2) + Math.pow(x,5) / (5 * 4 * 3 * 2)
}
// 蟆朱未謨ｰ
def fd(x:Double) = {
1 - Math.pow(x,2) / 2 + Math.pow(x,4) / (4 * 3 * 2)
}
// Hermite (繧ｨ繝ｫ繝溘・繝・ 陬憺俣
def hermite(d:Double, z:IndexedSeq[Double], a:IndexedSeq[Double]) = {
var sum_list = List(a(0))
for (i <- 1 to Nx2) {
var prod_list = List(a(i))
for (j <- 0 to i - 1) {
prod_list = (d - z(j))::prod_list
}
sum_list = (prod_list.product)::sum_list
}
sum_list.sum
}
}
object Scala0705 {
// 繝・・繧ｿ轤ｹ縺ｮ謨ｰ - 1
val N = 6
def main(args: Array[String]) {
// 1.5蛻ｻ縺ｿ縺ｧ -4.5・・.5 縺ｾ縺ｧ, ・礼せ縺縺大､繧偵そ繝・ヨ
val x = (0 to N).map(_ * 1.5 - 4.5)
val y = x.map(f)
// ・馴・婿遞句ｼ上・菫よ焚縺ｮ陦ｨ繧剃ｽ懊ｋ
val a = Array.ofDim[Double](N)
val b = Array.ofDim[Double](N)
val c = Array.ofDim[Double](N)
val d = Array.ofDim[Double](N)
for (i <- 1 to N - 1) {
a(i) = x(i) - x(i-1)
b(i) = 2.0 * (x(i+1) - x(i-1))
c(i) = x(i+1) - x(i)
d(i) = 6.0 * ((y(i+1) - y(i)) / (x(i+1) - x(i)) - (y(i) - y(i-1)) / (x(i) - x(i-1)))
}
// ・馴・婿遞句ｼ上ｒ隗｣縺・(繝茨ｼ阪・繧ｹ豕・
val g = Array.ofDim[Double](N)
val s = Array.ofDim[Double](N)
g(1) = b(1)
s(1) = d(1)
for (i <- 2 to N - 1) {
g(i) = b(i) - a(i) * c(i-1) / g(i-1)
s(i) = d(i) - a(i) * s(i-1) / g(i-1)
}
val z = Array.ofDim[Double](N + 1)
z(0) = 0
z(N) = 0
z(N-1) = s(N-1) / g(N-1)
for (i <- N - 2 to 1 by -1)
z(i) = (s(i) - c(i) * z(i+1)) / g(i)
// 0.5蛻ｻ縺ｿ縺ｧ 荳弱∴繧峨ｌ縺ｦ縺・↑縺・､繧定｣憺俣
val d1 = (0 to 18).map(_ * 0.5 - 4.5)
val d2 = d1.map(f)
val d3 = d1.map(spline(_, x, y, z))
(d1 zip d2 zip d3).foreach {
case ((d1, d2), d3) =>
println("%5.2f\t%8.5f\t%8.5f\t%8.5f".format(d1, d2, d3, d2 - d3))
}
}
// 蜈・・髢｢謨ｰ
def f(x:Double) = {
x - Math.pow(x,3) / (3 * 2) + Math.pow(x,5) / (5 * 4 * 3 * 2)
}
// Spline (繧ｹ繝励Λ繧､繝ｳ) 陬憺俣
def spline(d:Double, x:IndexedSeq[Double], y:IndexedSeq[Double], z:IndexedSeq[Double]) = {
// 陬憺俣髢｢謨ｰ蛟､縺後←縺ｮ蛹ｺ髢薙↓縺ゅｋ縺・
var k = -1
for (i <- N to 1 by -1) {
if (d <= x(i)) k = i - 1
}
if (k < 0) k = N
val d1 = x(k+1) - d
val d2 = d - x(k)
val d3 = x(k+1) - x(k)
(z(k) * Math.pow(d1,3) + z(k+1) * Math.pow(d2,3)) / (6.0 * d3) +
(y(k) / d3 - z(k) * d3 / 6.0) * d1 +
(y(k+1) / d3 - z(k+1) * d3 / 6.0) * d2
}
}
object Scala0801 {
// 驥榊鴨蜉騾溷ｺｦ
val g = -9.8
// 遨ｺ豌玲慣謚嶺ｿよ焚
val k = -0.01
// 譎る俣髢馴囈(遘・
val h = 0.01
def main(args: Array[String]) {
// 隗貞ｺｦ
val degree = 45
val radian = degree * Math.PI / 180.0
// 蛻晞・250 km/h -> 遘帝溘↓螟画鋤
val v = 250 * 1000 / 3600
// 豌ｴ蟷ｳ譁ｹ蜷代・騾溷ｺｦ
val vx = v * Math.cos(radian)
// 驩帷峩譁ｹ蜷代・騾溷ｺｦ
val vy = v * Math.sin(radian)
// 菴咲ｽｮ
val x = 0.0
val y = 0.0
// Euler豕・
euler(1, vx, vy, x, y)
}
def euler(i:Int, vx:Double, vy:Double, x:Double, y:Double):Unit = {
// 邨碁℃遘呈焚
val t = i * h
// 菴咲ｽｮ
val wx = x + h * vx
val wy = y + h * vy
println("%4.2f\t%8.5f\t%9.5f\t%9.5f\t%8.5f".format(t, vx, vy, wx, wy))
// 騾溷ｺｦ
val wvx = vx + h * fx(vx, vy)
val wvy = vy + h * fy(vx, vy)
if (wy >= 0.0)
euler(i+1, wvx, wvy, wx, wy)
else
()
}
// 遨ｺ豌玲慣謚励↓繧医ｋ豌ｴ蟷ｳ譁ｹ蜷代・貂幃溷・
def fx(vx:Double, vy:Double) = {
k * Math.sqrt(vx * vx + vy * vy) * vx
}
// 驥榊鴨縺ｨ遨ｺ豌玲慣謚励↓繧医ｋ驩帷峩譁ｹ蜷代・貂幃溷・
def fy(vx:Double, vy:Double) = {
g + (k * Math.sqrt(vx * vx + vy * vy) * vy)
}
}
object Scala0802 {
// 驥榊鴨蜉騾溷ｺｦ
val g = -9.8
// 遨ｺ豌玲慣謚嶺ｿよ焚
val k = -0.01
// 譎る俣髢馴囈(遘・
val h = 0.01
def main(args: Array[String]) {
// 隗貞ｺｦ
val degree = 45
val radian = degree * Math.PI / 180.0
// 蛻晞・250 km/h -> 遘帝溘↓螟画鋤
val v = 250 * 1000 / 3600
// 豌ｴ蟷ｳ譁ｹ蜷代・騾溷ｺｦ
val vx = v * Math.cos(radian)
// 驩帷峩譁ｹ蜷代・騾溷ｺｦ
val vy = v * Math.sin(radian)
// 菴咲ｽｮ
val x = 0.0
val y = 0.0
// Heun豕・
heun(1, vx, vy, x, y)
}
// Heun豕・
def heun(i:Int, vx:Double, vy:Double, x:Double, y:Double):Unit = {
// 邨碁℃遘呈焚
val t = i * h
// 菴咲ｽｮ繝ｻ騾溷ｺｦ
val wx2 = x + h * vx
val wy2 = y + h * vy
val wvx2 = vx + h * fx(vx, vy)
val wvy2 = vy + h * fy(vx, vy)
val wx = x + h * ( vx + wvx2 ) / 2
val wy = y + h * ( vy + wvy2 ) / 2
val wvx = vx + h * (fx(vx, vy) + fx(wvx2, wvy2)) / 2
val wvy = vy + h * (fy(vx, vy) + fy(wvx2, wvy2)) / 2
println("%4.2f\t%8.5f\t%9.5f\t%9.5f\t%8.5f".format(t, wvx, wvy, wx, wy))
if (wy >= 0.0)
heun(i+1, wvx, wvy, wx, wy)
else
()
}
// 遨ｺ豌玲慣謚励↓繧医ｋ豌ｴ蟷ｳ譁ｹ蜷代・貂幃溷・
def fx(vx:Double, vy:Double) = {
k * Math.sqrt(vx * vx + vy * vy) * vx
}
// 驥榊鴨縺ｨ遨ｺ豌玲慣謚励↓繧医ｋ驩帷峩譁ｹ蜷代・貂幃溷・
def fy(vx:Double, vy:Double) = {
g + (k * Math.sqrt(vx * vx + vy * vy) * vy)
}
}
object Scala0803 {
// 驥榊鴨蜉騾溷ｺｦ
val g = -9.8
// 遨ｺ豌玲慣謚嶺ｿよ焚
val k = -0.01
// 譎る俣髢馴囈(遘・
val h = 0.01
def main(args: Array[String]) {
// 隗貞ｺｦ
val degree = 45
val radian = degree * Math.PI / 180.0
// 蛻晞・250 km/h -> 遘帝溘↓螟画鋤
val v = 250 * 1000 / 3600
// 豌ｴ蟷ｳ譁ｹ蜷代・騾溷ｺｦ
val vx = v * Math.cos(radian)
// 驩帷峩譁ｹ蜷代・騾溷ｺｦ
val vy = v * Math.sin(radian)
// 菴咲ｽｮ
val x = 0.0
val y = 0.0
// 荳ｭ轤ｹ豕・
midpoint(1, vx, vy, x, y)
}
def midpoint(i:Int, vx:Double, vy:Double, x:Double, y:Double):Unit = {
// 邨碁℃遘呈焚
val t = i * h
// 菴咲ｽｮ繝ｻ騾溷ｺｦ
val wvx1 = h * fx(vx, vy)
val wvy1 = h * fy(vx, vy)
val wvx2 = vx + wvx1 / 2
val wvy2 = vy + wvy1 / 2
val wvx = vx + h * fx(wvx2, wvy2)
val wvy = vy + h * fy(wvx2, wvy2)
val wx = x + h * wvx2
val wy = y + h * wvy2
println("%4.2f\t%8.5f\t%9.5f\t%9.5f\t%8.5f".format(t, wvx, wvy, wx, wy))
if (wy >= 0.0)
midpoint(i+1, wvx, wvy, wx, wy)
else
()
}
// 遨ｺ豌玲慣謚励↓繧医ｋ豌ｴ蟷ｳ譁ｹ蜷代・貂幃溷・
def fx(vx:Double, vy:Double) = {
k * Math.sqrt(vx * vx + vy * vy) * vx
}
// 驥榊鴨縺ｨ遨ｺ豌玲慣謚励↓繧医ｋ驩帷峩譁ｹ蜷代・貂幃溷・
def fy(vx:Double, vy:Double) = {
g + (k * Math.sqrt(vx * vx + vy * vy) * vy)
}
}
object Scala0804 {
// 驥榊鴨蜉騾溷ｺｦ
val g = -9.8
// 遨ｺ豌玲慣謚嶺ｿよ焚
val k = -0.01
// 譎る俣髢馴囈(遘・
val h = 0.01
def main(args: Array[String]) {
// 隗貞ｺｦ
val degree = 45
val radian = degree * Math.PI / 180.0
// 蛻晞・250 km/h -> 遘帝溘↓螟画鋤
val v = 250 * 1000 / 3600
// 豌ｴ蟷ｳ譁ｹ蜷代・騾溷ｺｦ
val vx = v * Math.cos(radian)
// 驩帷峩譁ｹ蜷代・騾溷ｺｦ
val vy = v * Math.sin(radian)
// 菴咲ｽｮ
val x = 0.0
val y = 0.0
// Runge-Kutta豕・
rungekutta(1, vx, vy, x, y)
}
def rungekutta(i:Int, vx:Double, vy:Double, x:Double, y:Double):Unit = {
// 邨碁℃遘呈焚
val t = i * h
// 菴咲ｽｮ繝ｻ騾溷ｺｦ
val wx1 = h * vx
val wy1 = h * vy
val wvx1 = h * fx(vx, vy)
val wvy1 = h * fy(vx, vy)
val wvx5 = vx + wvx1 / 2
val wvy5 = vy + wvy1 / 2
val wx2 = h * wvx5
val wy2 = h * wvy5
val wvx2 = h * fx(wvx5, wvy5)
val wvy2 = h * fy(wvx5, wvy5)
val wvx6 = vx + wvx2 / 2
val wvy6 = vy + wvy2 / 2
val wx3 = h * wvx6
val wy3 = h * wvy6
val wvx3 = h * fx(wvx6, wvy6)
val wvy3 = h * fy(wvx6, wvy6)
val wvx7 = vx + wvx3
val wvy7 = vy + wvy3
val wx4 = h * wvx7
val wy4 = h * wvy7
val wvx4 = h * fx(wvx7, wvy7)
val wvy4 = h * fy(wvx7, wvy7)
val wx = x + ( wx1 + wx2 * 2 + wx3 * 2 + wx4) / 6
val wy = y + ( wy1 + wy2 * 2 + wy3 * 2 + wy4) / 6
val wvx = vx + (wvx1 + wvx2 * 2 + wvx3 * 2 + wvx4) / 6
val wvy = vy + (wvy1 + wvy2 * 2 + wvy3 * 2 + wvy4) / 6
println("%4.2f\t%8.5f\t%9.5f\t%9.5f\t%8.5f".format(t, wvx, wvy, wx, wy))
if (wy >= 0.0)
rungekutta(i+1, wvx, wvy, wx, wy)
else
()
}
// 遨ｺ豌玲慣謚励↓繧医ｋ豌ｴ蟷ｳ譁ｹ蜷代・貂幃溷・
def fx(vx:Double, vy:Double) = {
k * Math.sqrt(vx * vx + vy * vy) * vx
}
// 驥榊鴨縺ｨ遨ｺ豌玲慣謚励↓繧医ｋ驩帷峩譁ｹ蜷代・貂幃溷・
def fy(vx:Double, vy:Double) = {
g + (k * Math.sqrt(vx * vx + vy * vy) * vy)
}
}
object Scala0804 {
// 驥榊鴨蜉騾溷ｺｦ
val g = -9.8
// 遨ｺ豌玲慣謚嶺ｿよ焚
val k = -0.01
// 譎る俣髢馴囈(遘・
val h = 0.01
def main(args: Array[String]) {
// 隗貞ｺｦ
val degree = 45
val radian = degree * Math.PI / 180.0
// 蛻晞・250 km/h -> 遘帝溘↓螟画鋤
val v = 250 * 1000 / 3600
// 豌ｴ蟷ｳ譁ｹ蜷代・騾溷ｺｦ
val vx = v * Math.cos(radian)
// 驩帷峩譁ｹ蜷代・騾溷ｺｦ
val vy = v * Math.sin(radian)
// 菴咲ｽｮ
val x = 0.0
val y = 0.0
// Runge-Kutta-Gill豕・
rungekuttagill(1, vx, vy, x, y)
}
def rungekuttagill(i:Int, vx:Double, vy:Double, x:Double, y:Double):Unit = {
// 邨碁℃遘呈焚
val t = i * h
// 菴咲ｽｮ繝ｻ騾溷ｺｦ
val wx1 = h * vx
val wy1 = h * vy
val wvx1 = h * fx(vx, vy)
val wvy1 = h * fy(vx, vy)
val wvx5 = vx + wvx1 / 2
val wvy5 = vy + wvy1 / 2
val wx2 = h * wvx5
val wy2 = h * wvy5
val wvx2 = h * fx(wvx5, wvy5)
val wvy2 = h * fy(wvx5, wvy5)
val wvx6 = vx + wvx1 * ((Math.sqrt(2.0) - 1) / 2) + wvx2 * (1 - 1 / Math.sqrt(2.0))
val wvy6 = vy + wvy1 * ((Math.sqrt(2.0) - 1) / 2) + wvy2 * (1 - 1 / Math.sqrt(2.0))
val wx3 = h * wvx6
val wy3 = h * wvy6
val wvx3 = h * fx(wvx6, wvy6)
val wvy3 = h * fy(wvx6, wvy6)
val wvx7 = vx - wvx2 / Math.sqrt(2.0) + wvx3 * (1 + 1 / Math.sqrt(2.0))
val wvy7 = vy - wvy2 / Math.sqrt(2.0) + wvy3 * (1 + 1 / Math.sqrt(2.0))
val wx4 = h * wvx7
val wy4 = h * wvy7
val wvx4 = h * fx(wvx7, wvy7)
val wvy4 = h * fy(wvx7, wvy7)
val wx = x + ( wx1 + wx2 * (2 - Math.sqrt(2.0)) + wx3 * (2 + Math.sqrt(2.0)) + wx4) / 6
val wy = y + ( wy1 + wy2 * (2 - Math.sqrt(2.0)) + wy3 * (2 + Math.sqrt(2.0)) + wy4) / 6
val wvx = vx + (wvx1 + wvx2 * (2 - Math.sqrt(2.0)) + wvx3 * (2 + Math.sqrt(2.0)) + wvx4) / 6
val wvy = vy + (wvy1 + wvy2 * (2 - Math.sqrt(2.0)) + wvy3 * (2 + Math.sqrt(2.0)) + wvy4) / 6
println("%4.2f\t%8.5f\t%9.5f\t%9.5f\t%8.5f".format(t, wvx, wvy, wx, wy))
if (wy >= 0.0)
rungekuttagill(i+1, wvx, wvy, wx, wy)
else
()
}
// 遨ｺ豌玲慣謚励↓繧医ｋ豌ｴ蟷ｳ譁ｹ蜷代・貂幃溷・
def fx(vx:Double, vy:Double) = {
k * Math.sqrt(vx * vx + vy * vy) * vx
}
// 驥榊鴨縺ｨ遨ｺ豌玲慣謚励↓繧医ｋ驩帷峩譁ｹ蜷代・貂幃溷・
def fy(vx:Double, vy:Double) = {
g + (k * Math.sqrt(vx * vx + vy * vy) * vy)
}
}
object Scala0901 {
def main(args: Array[String]) {
val a = 1.0
val b = 2.0
println("%12.10f".format(bisection(a, b)))
}
def bisection(a:Double, b:Double):Double = {
// 蛹ｺ髢・(a, b) 縺ｮ荳ｭ轤ｹ c = (a + b) / 2
val c = (a + b) / 2
println("%12.10f\t%13.10f".format(c, c - Math.sqrt(2)))
val fc = f(c)
if (Math.abs(fc) < 0.0000000001)
c
else {
if (fc < 0) {
// f(c) < 0 縺ｧ縺ゅｌ縺ｰ, 隗｣縺ｯ蛹ｺ髢・(c, b) 縺ｮ荳ｭ縺ｫ蟄伜惠
bisection(c, b)
} else {
// f(c) > 0 縺ｧ縺ゅｌ縺ｰ, 隗｣縺ｯ蛹ｺ髢・(a, c) 縺ｮ荳ｭ縺ｫ蟄伜惠
bisection(a, c)
}
}
}
def f(x:Double) = {
x * x - 2
}
}
object Scala0902 {
def main(args: Array[String]) {
val a = 1.0
val b = 2.0
println("%12.10f".format(falseposition(a, b)))
}
def falseposition(a:Double, b:Double):Double = {
// 轤ｹ (a,f(a)) 縺ｨ 轤ｹ (b,f(b)) 繧堤ｵ舌・逶ｴ邱壹→ x霆ｸ縺ｮ莠､轤ｹ
val c = (a * f(b) - b * f(a)) / (f(b) - f(a))
println("%12.10f\t%13.10f".format(c, c - Math.sqrt(2)))
val fc = f(c)
if (Math.abs(fc) < 0.0000000001)
c
else {
if (fc < 0) {
// f(c) < 0 縺ｧ縺ゅｌ縺ｰ, 隗｣縺ｯ蛹ｺ髢・(c, b) 縺ｮ荳ｭ縺ｫ蟄伜惠
falseposition(c, b)
} else {
// f(c) > 0 縺ｧ縺ゅｌ縺ｰ, 隗｣縺ｯ蛹ｺ髢・(a, c) 縺ｮ荳ｭ縺ｫ蟄伜惠
falseposition(a, c)
}
}
}
def f(x:Double) = {
x * x - 2
}
}
object Scala0903 {
def main(args: Array[String]) {
val x = 1.0
println("%12.10f".format(iterative(x)))
}
def iterative(x0:Double):Double = {
val x1 = g(x0)
println("%12.10f\t%13.10f".format(x1, x1 - Math.sqrt(2)))
if (Math.abs(x1 - x0) < 0.0000000001)
x1
else
iterative(x1)
}
def g(x:Double) = {
(x / 2) + (1 / x)
}
}
object Scala0904 {
def main(args: Array[String]) {
val x = 2.0
println("%12.10f".format(newton(x)))
}
def newton(x0:Double):Double = {
val x1 = x0 - (f0(x0) / f1(x0))
println("%12.10f\t%13.10f".format(x1, x1 - Math.sqrt(2)))
if (Math.abs(x1 - x0) < 0.0000000001)
x1
else
newton(x1)
}
def f0(x:Double) = {
x * x - 2
}
def f1(x:Double) = {
2 * x
}
}
object Scala0905 {
def main(args: Array[String]) {
val x = 2.0
println("%12.10f".format(bailey(x)))
}
def bailey(x0:Double):Double = {
val x1 = x0 - (f0(x0) / (f1(x0) - (f0(x0) * f2(x0) / (2 * f1(x0)))))
println("%12.10f\t%13.10f".format(x1, x1 - Math.sqrt(2)))
if (Math.abs(x1 - x0) < 0.0000000001)
x1
else
bailey(x1)
}
def f0(x:Double) = {
x * x - 2
}
def f1(x:Double) = {
2 * x
}
def f2(x:Double) = {
2
}
}
object Scala0906 {
def main(args: Array[String]) {
val x0 = 1.0
val x1 = 2.0
println("%12.10f".format(secant(x0, x1)))
}
def secant(x0:Double, x1:Double):Double = {
val x2 = x1 - f(x1) * (x1 - x0) / (f(x1) - f(x0))
println("%12.10f\t%13.10f".format(x2, x2 - Math.sqrt(2)))
if (Math.abs(x2 - x1) < 0.0000000001)
x2
else
secant(x1, x2)
}
def f(x:Double) = {
x * x - 2
}
}
|