第6回　OCamlの「モジュール・システム」

(* 対話環境で #load "graphics.cma" ;; としてから実行する *)

Graphics.open_graph "" ; (* Caml graphicsウィンドウを開く *)

(* nはループ回数，
   (cx, cy)は複素数cの実部と虚部，
   (zx, xy)は複素数zの実部と虚部 *)
let rec converge n (cx, cy) (zx, zy) =
  (* n <= 0になったら収束と判定 *)
  if n <= 0 then true else
  (* |z| >= 2となったら発散と判定 *)
  if zx *. zx +. zy *. zy >= 2.0 then false else
  (* z = z * z + cとしてループ（末尾再帰） *)
  converge (n - 1) (cx, cy) 
    (cx +. zx *. zx -. zy *. zy,
     cy +. 2.0 *. zx *. zy) in

(* 左下座標(-1.5, -1.5)から右上座標(1.5, 1.5)までの
   Mandelbrot集合を300×300ドットで描画 *)
for x = 0 to 299 do
  for y = 0 to 299 do
    let conv =
      converge 100
        (float x /. 100.0 -. 1.5,
         float y /. 100.0 -. 1.5)
        (0.0, 0.0) in
    if conv then Graphics.plot x y;
  done
done ;;

Graphics.open_graph "" ;

(* デカルト座標から極座標への変換 *)
let c2p (x, y) = (sqrt (x *. x +. y *. y), atan2 y x) in
(* 極座標からデカルト座標への変換 *)
let p2c (r, t) = (r *. cos t, r *. sin t) in

(* 極座標で表現された複素数p1とp2の和を極座標で返す *)
let add p1 p2 =
  let (x1, y1) = p2c p1 in
  let (x2, y2) = p2c p2 in
  c2p (x1 +. x2, y1 +. y2) in

let rec converge n c (zr, zt) =
  if n <= 0 then true else
  if zr >= 2.0 then false else
  converge (n - 1) c (add c (zr *. zr, zt +. zt)) in

for x = 0 to 299 do
  for y = 0 to 299 do
    let cx = float x /. 100.0 -. 1.5 in
    let cy = float y /. 100.0 -. 1.5 in
    let conv = converge 100 (c2p (cx, cy)) (0.0, 0.0) in
    if conv then Graphics.plot x y;
  done
done ;;

# module type Complex =
    sig
      type t (* 複素数の型 *)
      val make : float * float -> t (* 実部と虚部から複素数を作って返す *)
      val add : t -> t -> t (* 複素数の足し算 *)
      val mul : t -> t -> t (* 複素数の掛け算 *)
      val abs : t -> float (* 複素数の絶対値 *)
    end ;;
# module type Complex =
  sig
    type t
    val make : float * float -> t
    val add : t -> t -> t
    val mul : t -> t -> t
    val abs : t -> float
  end ;;

# module Cartesian : Complex = (* CartesianはComplexインタフェースを実装 *)
  struct
    type t = float * float
    let make (x, y) = (x, y)
    let add (x1, y1) (x2, y2) = (x1 +. x2, y1 +. y2)
    let mul (x1, y1) (x2, y2) =
      (x1 *. x2 -. y1 *. y2,
       x1 *. y2 +. x2 *. y1)
    let abs (x, y) = sqrt (x *. x +. y *. y)
  end ;;
module Cartesian : Complex
# module Polar : Complex = (* PolarはComplexインタフェースを実装 *)
  struct
    type t = float * float
    let c2p (x, y) = (sqrt (x *. x +. y *. y), atan2 y x)
    let p2c (r, t) = (r *. cos t, r *. sin t)
    let make (x, y) = c2p (x, y)
    let add p1 p2 =
      let (x1, y1) = p2c p1 in
      let (x2, y2) = p2c p2 in
      c2p (x1 +. x2, y1 +. y2)
    let mul (r1, t1) (r2, t2) = (r1 *. r2, t1 +. t2)
    let abs (r, t) = r
  end ;;
module Polar : Complex

# let p1 = Polar.make (1.0, 1.0) (* p1は複素数1+iを表す *) ;;
val p1 : Polar.t = <abstr>
# let p2 = Polar.mul p1 p1 (* p1の2乗をp2とする *) ;;
val p2 : Polar.t = <abstr>
# Polar.abs p2 (* p2の絶対値は2になる *) ;;
- : float = 2.00000000000000044

# (* 「複素数p2の絶対値と偏角を足す」というナンセンスな計算 *)
  let (x, y) = p2 in x +. y ;;
Characters 74-76:
  let (x, y) = p2 in x +. y ;;
               ^^
This expression has type Polar.t but is here used with type 'a * 'b

# Polar.p2c p2 ;;
Characters 0-9:
  Polar.p2c p2 ;;
  ^^^^^^^^^
Unbound value Polar.p2c

# #load "graphics.cma";;
# module Mandelbrot (C : Complex) =
  struct
    let f () = (* 実際にマンデルブロ集合を描画する関数 *)
      let rec converge n c z =
	if n <= 0 then true else
	if C.abs z >= 2.0 then false else
	converge (n - 1) c (C.add c (C.mul z z)) in
      for x = 0 to 299 do
	for y = 0 to 299 do
	  let cx = float x /. 100.0 -. 1.5 in
	  let cy = float y /. 100.0 -. 1.5 in
	  let conv = converge 100 (C.make (cx, cy)) (C.make (0.0, 0.0)) in
	  if conv then Graphics.plot x y;
	done
      done
  end ;;
module Mandelbrot : functor (C : Complex) -> sig val f : unit -> unit end

# module CartesianMandelbrot = Mandelbrot(Cartesian) ;;
module CartesianMandelbrot : sig val f : unit -> unit end
# module PolarMandelbrot = Mandelbrot(Polar) ;;
module PolarMandelbrot : sig val f : unit -> unit end

# Graphics.open_graph "" ;;
- : unit = ()
# CartesianMandelbrot.f () ;;
- : unit = ()
# Graphics.clear_graph () ;;
- : unit = ()
# PolarMandelbrot.f () ;;
- : unit = ()