5. 階層ＣＤＦＤとモジュール

階層ＣＤＦＤとモジュールの動機:複雑なシステム開発には、一つのレベルCDFDで全ての機能を定義することが非常に困難である。大規模システムの開発には、何人の開発者が必要である。開発の効率を向上させるため、開発者らは、開発仕事を分担して開発するのが、普通である。高いレベルCDFDのプロセスを分解することによって、開発者らは、分担した開発の仕事を並行で行うことができる。

プロセスの分解プロセスの分解は、そのプロセスの機能を細かく表現する低いレベルのCDFDを作成する作業である。

例えば、

sel

pass

account1

account2

account_file1

card_id

Check_Password

pr_meg

このプロセスは、次のページにあるCDFDへ分解することができる。

Confirm_Account

card_idpass

account

pr_meg

Transfer_Account

account1

account2

account_file1

sel

図２

このCDFDに対応するモジュールは、次のページにあるものである。

module Check_Password_decom / SYSTEM_ATM;type Account = SYSTEM_ATM.Account;var ext account_file: set of SYSTEM_ATM.Address;behav CDFD_2;

process Init()end_process;

process Confirm_Account(card_id: nat0, pass: nat0) account: Account | pr_meg: string

...end_process;

process Transfer_Account(sel: bool, account: Account) account1: Account | account2: Account

...end_process; end_module;

定義 プロセスAは、CDFD Gへ分解されたなら、

GがプロセスAの分解と呼び、AがGの高いレベル

プロセスと呼ぶ。

プロセスの分解はいつ止まるべきか？

全ての一番低いレベルのプロセスは、十分に簡単

であるとき、プロセスの分解は、止まるべきである。

A 3 1

A 3 2

A 3 3

A 1

A 2

A 3

A 4x 1x 2

x 3

x 4

x 5x 6

A 1 1 A 1 3

s 11

s 11

x 7

A 3 3 1

A 3 3 2

s 22

x 1 x 2

x 3y2 x 3

x 5

x 7

z 1

z 2

z 2

z 3d 1

A 1 2y1

A 3 3 2d 2

1

2 3

4

この階層的CDFDに対応する階層的モジュールは、次のようなものである。module SYSTEM_Example;...

var s1: Type1;behav CDFD_1;process Init;process A1 decom: A1_decom; /*Module A1_decom は、A1の分解。*/end_process; process A2;process A3 decom: A3_decom; /*Module A3_decom は、A3の分解。*/end_process; process A4; end_module;

module A1_decom / SYSTEM_Example;...var ext s1: Type1;behav CDFD_2;process Init;process A11;process A12;process A13;end_module;

module A3_decom;...

behav CDFD_3;process Init;process A31;process A32;process A33 decom: A33_decom; /*Module A33_decom は、A33の分解である。*/end_process; end_module;

module A33_decom / A3_decom;...

var s2: Type1;behav CDFD_4;process Init;process A331;process A332;process A333;

end_module.

データストアの対応

一般には、高いレベルのプロセスにアクセスされ

たデータストアが、そのプロセスの分解にも同じ

ように使われるべきである。

定義 CDFDのローカルデータストアは、本CDFDに初めて導入されたデータストアである。

定義 CDFDの外部データストアとは、そのCDFDの高いレベルのCDFDに使われるデータストアである。

外部データストアは、2種類がある。

(1) 高いレベルのCDFDのローカルストア。本CDFDに対応するモジュールに extを使って宣言する。

(2) 既存のデータストア。こういうストアは、階層CDFDの中で、全てのCDFDに使われるグローバルデータストアである。本CDFDに対応するモジュールに次のように宣言する。

ext #file: int

入力と出力データフロー定義 CDFDの入力データフローとは、そのCDFDの開始

プロセスの入力データフローのことである。CDFDの出力データフローとは、そのCDFDの終結プロセスの出力データフローのことである。

定義 もしプロセスAとAの分解Gは以下の三つの条件が満たせば、AとGが、構造的な矛盾がない。

(1) Gの全ての入力と出力データフローは、Aの入力と出力データフローである。

(2) プロセスAの入力と出力データフローは、Gに使われている。

(3) プロセスAにアクセスされている全てのデータストアは、Gに同じように使われている。

事例:

W

x 1x 2

y 1

y 2

W 2

W 3

d 1

d 2

x 1

x 2

y 1y 2

H i g h l e v e l p r o c e s s

T h e d e c o m p o s i t i o n o f p r o c e s s W

W 1

s1

s1

データストアに関するルール:(1) rd s ：高いレベルプロセスà rd s：分解されたCDFD。(2) wr s ：高いレベルプロセスà rd とwr s ：分解されたCDFD.

モジュールの部品の有効範囲

M

M1 M2 M3

M11 M12 M13

M122 M123M121

高いレベルモジュールMに定義された型、データストア変数、および関数の有効範囲は、Mのプロセスの分解によって得た全てのモジュールのことである。

モジュールの部品の参照

M

M1 M2 M3

M11 M12 M13

M122 M123M121

例えば:(1) M2に次の型と関数を定義した

。typeAccount = composed of

name: stringno: nat0balance: nat0end

…function Fact(n: nat): nat== if n = 1

then nelse n * Fact(n – 1)

end_functionend_module;

M

M1 M2 M3

M11 M12 M13

M122 M123M121

事例：M11に次のような定義ができる。

MyAccount = M2.Account;

MyOp(n: nat) r: natpre truepost r = M2.Fact(n)end_process;

しかし、M１１は、M１２であれば、上の定義は、次のように書ける。

MyAccount = Account;

MyOp(n: nat) r: natpre truepost r = Fact(n)end_process;

６. 基本型

６．１ 基本型の分類

数字型（The numeric types）文字型（The character type）列挙型（The enumeration types）

Boolean型（The boolean type）

数字型

型名 値の集合

nat {1, 2, 3, …} 自然数nat0 {0, 1, 2, 3, …} 0を含む自然数int {…, -2, -1, 0, 1, 2, …} 整数

real {…, -2.5, -1.4, 0.0, 1.4, 2.5, …} 実数

ここで real ＞ int ＞ nat0 ＞ nat

演算子 名前 型

- x Unary minus real --> realabs(x) Absolute value real --> realfloor(x) Floor real --> intx + y Sum real * real --> realx - y Difference real * real --> realx * y Product real * real --> realx / y Division real * real --> realx div y Integer division int * int --> intx rem y Remainder int * int --> natx mod y Modulus nat * nat --> natx ** y Power real * real --> real

例えば、x = 9, y = 4.5, z = 3.14, a = - 4, b = 3とする。

- z = - 3.14 abs(a) = 4 floor(y) = 4 x + z = 12.14 x - y = 4.5 a * b = - 12 x / y = 2.0 a div b = -1 a rem b = 1 x mod b = 0 x ** b = 729

関係演算子 名前 型x < y Less than real * real --> boolx > y Greater than real * real -->

boolx <= y Less or equal real * real -->

boolx >= y Greater or equal real * real -->

boolx = y Equal real * real -->

boolx <> y Not equal real * real -->

bool

文字型

型名： char

文字型の値の表示: 'x'

事例:

'a' 'B' '|' ')' ':' '@' '7'

関係演算子 名前 型c1 = c2 Equal real * real -> boolc1 <> c2 Not equal real * real -> bool

事例：

'a' = 'B' <=> false'a' <> ‘B' <=> true

列挙型

型の宣言： T = {<V1>, <V2>, …, <Vn>}ここで、Tは、宣言された列挙型名で、Vi (i = 1,….,n) は、型Ｔの値である。

事例：Week = {<Monday>, <Tuesday>,

<Wednesday>, <Thursday>, <Friday>, <Saturday>, <Sunday>}

関係演算子 名前 型v1 = v2 Equal T * T -> boolv1 <> v2 Not equal T * T -> bool

ここでＴは、列挙型である。

事例：

<Monday> <> <Tuesday> <=> true<Wednesday> = <Friday> <=> false

Boolean型型名 値の集合bool {true, false, nil}

演算子 名前 型

and and bool * bool -> boolor or bool * bool -> boolnot not bool -> bool=> implies bool * bool -> bool<=> if and only if bool * bool -> bool

６．２ 応用事例電車の切符の料金を計算する操作。

T = {<STUDENT>, <ORDINARY>, <PENSIONER>}

process Tell_Fare(passenger: T) fare: realext rd normal_fare: real post fare = case passenger of <STUDENT> --> normal_fare - 0.25 * normal_fare; <ORDINARY> --> normal_fare; <PENSIONER> --> normal_fare - 0.30 * normal_fare

end_caseend_process

クラス練習

曜日を入力して、その日にある授業の名前

を教えるプロセスの仕様を作成しましょう。

月曜日に「ソフトウェア工学」の授業があり、火曜日に「プログラム設計」の授業があり、

水曜日に「離散数学」の授業があり、

木曜日に「プログラミング言語」の授業があり、金曜日に「形式手法」の授業があり、

そして土曜日と日曜日には、授業がない。(提示：曜日と授業と共に列挙型として定義する。）

7. 集合型

７．１ 集合型の定義

定義２「集合」：集合は、同じ性質を持つオブジェク

トの集まりである。

集合のオブジェクトは、集合の「要素」とも呼ばれる。

集合の特徴（不変性質）：

（１）集合の要素は、全て違う。

（２）集合の要素の書く順番が重要でない。

集合の事例：

(1) クラスは、学生の集合である。

(2) 駐車場は、車の集合である。

全ての要素が明確である集合は、次のように書く。

(1) {5, 9, 10} (2) {“中村”, “中田”, “川口”, “高原"} (3) {"Java", "Pascal", "C", "C++", "Fortran"}

注意: {a, a, b} 正しい集合でない。

集合型の定義：

T が一つの型とすれば、この型から作られた集合方Aは、次のように宣言される。

typeA = set of T

Aは、Tの全ての「部分集合（subset）」の集合である。或いは、AがTのパワー集合とも言う。

集合型の事例：

型Tは、次の列挙型として定義されてある。

T = {<DOG>, <CAT>, <COW>}

Tによって形成された集合型Aは、次のように定義される。

A = set of T

そうすると、型Aは、次の集合になる。

A = {{ }, {<DOG>}, {<CAT>}, {<COW>},{<DOG>, <CAT>}, {<DOG>, <COW>}, {<CAT>, <COW>}, {<DOG>, <CAT>, <COW>}}

集合型で変数を定義する。

例えば、

s: A;

又は

s: set of T

そうすると、変数sは、次のような値を取ることができる。

s = { } (空集合)s = {<DOG>} s = {<CAT>}s = {<COW>}s = {<DOG>, <CAT>}s = {<DOG>, <COW>}s = {<CAT>, <COW>} s = {<DOG>, <CAT>, <COW>}

７．２ コンストラクタ

集合型のコンストラクタは、指定された要素から一つの集合を生成する演算子である。

集合型には、二つのコンストラクタが使われる。

集合の列挙表記 （set enumeration)および

集合の内包表記（set comprehension）.

集合の列挙表記は、次のように書く。

{e_1, e_2, ..., e_n}

ここで e_i (I = 1, …, n) らは、集合

{e_1, e_2, ..., e_n}の要素である。

例えば: {5, 9, 10, 50}{‘a’, ‘t’, ‘l’}

集合の内包表記は、次のように書く。

{e(x_1, x_2, ..., x_n) | bd1, bd2, ..., bdn & P(x_1, x_2, ..., x_n)}

ここで、bdi (i = 1, ..., n)は、bindingである。

上述の集合の内包表記は、bd1, bd2, ..., bdn および述語論理式Pを満たす変数x_1, x_2, ...,x_nによって定義された全てのeの集まりである。

事例:

{x | x: nat & 1 < x < 5} = {2, 3, 4}

{y | y: nat0 & y <= 5} = {0, 1, 2, 3, 4, 5}

{x + y | x: nat0, y: nat0 & 1 < x + y < 8} = {2, 3, 4, 5, 6, 7}

{i | i inset {1, 3, 5, 7}} = {1, 3, 5, 7}

７．３ 演算子

(1) 要素 (inset)

inset: T * set of T --> bool

事例: 7 inset {4, 5, 7, 9} <=> true 3 inset {4, 5, 7, 9} <=> false

(2) 非要素 (notin)

notin: T * set of T --> bool

事例:7 notin {4, 5, 7, 9} <=> false 3 notin {4, 5, 7, 9} <=> true

(3) 濃度 (card)

card: set of T --> nat

事例:

card({5, 7, 9}) = 3 card({'h', 'o', 's', 'e', 'i'}) = 5

(4) 和集合(union)

union: set of T * set of T --> set of T union(s1,s2) ==

{x | x inset s1 or x inset s2}

事例:union({5, 15, 25}, {15, 20, 25, 30}) =

{5, 15, 25, 20, 30} union({15, 20, 25, 30}, {5, 15, 25}) =

{5, 15, 25, 20, 30}

(5) 共通集合(inter)

inter: set of T * set of T --> set of T inter(s1, s2) ==

{x | x inset s1 and x inset s2}

例えば, s1 = {5, 7, 9}, s2 = {7, 10, 9, 15}, s3 = {8, 5, 20} とすれば、

inter(s1, s2) = {7, 9} inter(s1, s3) = {5} inter(s2, s3) = { }

(6) 差集合 (diff)

diff: set of T * set of T --> set of T diff(s1, s2) == {x | x inset s1 and x notin s2}

例えば, s1 = {5, 7, 9} s2 = {7, 10, 9, 15}s3 = {8, 12}とすれば、

diff(s1, s2) = {5} diff(s1, s3) = {5, 7, 9} diff(s1, { }) = s1

（７）部分集合 (subset)subset: set of T * set of T --> bool subset(s1, s2) == forall [x: s1] | x inset s2

事例: s1 = {5, 15, 25}, s2 = {5, 10, 15, 20, 25, 30}とすれば、

subset(s1, s2) <=> true subset(s2, s1) <=> false subset({ }, s1) <=> true subset(s1, s1) <=> true

(8) 真部分集合 (psubset）

psubset: set of T * set of T --> bool psubset(s1, s2) == subset(s1, s2) and s1 <> s2

事例:s1 = {5, 15, 25}, s2 = {5, 10, 15, 25, 30}とすれば、

psubset(s1,s2) <=> true psubset(s1, s1) <=> false psubset(s2, s1) <=> false psubset({ }, s1) <=> true

(9) 集合の同異 (=, <>)

=: set of T * set of T --> bool s1 = s2 == forall[x: s1] | x inset s2 and

card(s1) = card(s2)

<>: set of T * set of T --> bool s1 <> s2 == (exists[x: s1] | x notin s2) or

(exists[x: s2] | x notin s1)

事例:{5, 15, 25} = { 25, 15, 5} <=> true {5, 15, 25} <> {5, 20, 30} <=> true

(10) パワー集合 (power)

power: set of T --> set of set of T power(s) == { s1 | subset(s1, s)}

事例: s = {5, 15, 25}とすれば、

power(s) = {{ }, {5}, {15}, {25}, {5, 15}, {15, 25}, {5, 25}, {5, 15, 25}}

７．４ 応用事例

An Email_Address_Bookシステム

module EmailBook;var

email_book: set of Email;

ここで、Emailは以前に既に定義された型である。

Find Add

Delete

email_book1

e

r e

e

Figure 1

process Find(e: Email) r: bool ext rd email_bookpost r = (e inset email_book)end_process;

process Add(e: Email)ext wr email_bookpost email_book = union(~email_book, {e})end_process;

process Delete(e: Email)ext wr email_bookpost email_book = diff(~email_book, {e})end_process;

クラス練習1. s1 = {5, 15, 25}, s2 = {15, 30, 50}, s3 = {30, 2, 8}とする。次の式を評価しましょう。

card(s1)card(s2)union(s1, s2)diff(s2, s3)inter(union(s2, s3), s1)inter(union(s1, s3), diff(s2, union(s1, s3)))

2. 電話番号帳システムを定義しましょう。このシステムには、次のプロセスを定義しましょう：Add, Find, Delete, およびUpdate. プロセスAddでは、一つの新しい電話番号を電話番号帳に加える。プロセスFindでは、指定された電話番号を電話番号帳に探して、存在しているかどうかを教える。プロセスDeleteでは、指定された電話番号を電話番号帳から削除する。プロセスUpdateでは、指定された電話番号帳にすでにある古い電話番号を指定された新しい電話番号に置き換える。

８．列型

８．１ 列型の定義

定義３「列」：列は要素を順番に並べるもので

ある。

列の特徴（不変性質）：

（１）列に同じ要素は含まれることが可能である。（２）列に要素の出現順番が重要である。

事例：

(1) [5, 15, 15, 5, 35]

(2) ['u', 'n', 'i', 'v', 'e', 'r', 's', 'i', 't', 'y']

(3) [20.5, 40.5, 85.5]

注意： [3, 5, 9] <> [5, 3, 9][3, 5, 9] <> [3, 3, 5, 9]

列型の定義:

T を一つの型とすれば、この型から作られた列型Aは、次のように宣言される。

typeA = seq of T

例えば、type

Ages = seq of nat;

String = seq of char

変数の宣言：

studentAges: Ages;

studentName: String

８．２ コンストラクタ

列型には、二つのコンストラクタが使われる。

列の列挙表記（sequence enumeration)列の内包表記（sequence comprehension）

(1)列の列挙表記

[a_1, a_2, ..., a_n]

ここで、a_i (i=1, …, n) は、この列の要素である。

例えば:[5, 9, 8, 9, 5]

(2)列の内包表記

[e(x) | x: S & P(x)]

ここで、Sは数字の集合である。

この列の内包表記は、Pを満たすSの要素の小さい順番で並べた列を表している。

例えば、[x | x: {1, 20, 2, 6, 9} & x mod 2 = 0] =[2, 6, 20]

８．３ 演算子

（１）先頭要素 (hd)hd: seq of T à T

事例：s1 = [4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 25] とすれば、

hd(s1) = 4 hd(s2) = {3, 9} hd(s3) = 10

(2)尾部(tl)

tl: seq of T à seq of T

事例： s1 = [4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 25] とすれば、

tl(s1) = [9, 10] tl(s2) = [{6}] tl(s3) = [9, 4, 25]

(3)長さ(len)

len: seq of T --> natlen(s) == 列sの要素の数

例えば: s1 = [4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 25] とすれば、

len(s1) = 3 len(s2) = 2 len(s3) = 4

（４）要素集合 (elems)

elems: seq of T --> set of T

事例： s1 = [4, 9, 4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 10, 25] とすれば、

elems(s1) = {4, 9, 10} elems(s2) = {{3, 9}, {6}} elems(s3) = {10, 9, 4, 25} elems [ ] = { }.

（５）インデックス集合（inds)

inds: seq of T --> set of nat1

事例：s1 = [4, 9, 4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 10, 25] とすれば、

inds(s1) = {1, 2, 3, 4, 5}inds(s2) = {1, 2}inds(s3) = {1, 2, 3, 4, 5}

（6）適用

s(i)

列sのi番目の要素を返す。

事例： s1 = [4, 9, 4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 10, 25] とすれば、

s1(1) = 4 s1(4) = 9 s2(1) = {3, 9} s3(4) = 10

（７）連結（conc）

conc: seq of T * seq of T à seq of T

事例：s1 = [4, 9, 4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 10, 25] とすれば、

conc(s1, s3) = [4, 9, 4, 9, 10, 10, 9, 4, 10, 25]conc(s2, s2) = [{3, 9}, {6}, {3, 9}, {6}]

（８）列の同異(=, <>)

= : seq of T * seq of T à bool<>: seq of T * seq of T à bool

事例: s1 = [4, 9, 4, 9, 10], s2 = [{3, 9}, {6}], s3 = [10, 9, 4, 10, 25] とすれば、

s1 = s1 <=> true s1 <> s2 <=> true s2 = s3 <=> false

８．４ 応用事例: 学生成績の管理

例えば、 [90, 82, 93, 71, 60, 54, 82, 71, 90]

module StudentsScores;varstudent_scores: seq of nat;

process Search(s: nat) number: natext rd student_scorespre truepost number =

card({i | i: inds(student_scores) & student_scores(i) = s})

操作Searchは、列student_scoresに存在している入力自然数sの数を教える。

process Modify(s: nat, i: nat1) ext wr student_scorespre len(student_scores) >= ipost forall[ j: inds(student_scores)] |

if j <> ithen

student_scores[j] = ~student_scores[j])elsestudent_scores[j] = s

end_process;

この操作は、列student_scoresのi番目の要素をsに置き換える。

process Add(s: nat)ext wr student_scorespre true

post student_scores = conc(~student_scores, [s])

end_process;

この操作は、列student_scoresの末尾に入力自然数sを加える。

process Sort()ext wr student_scorespost Is_Permutation(~student_scores,

student_scores) and Is_Ordered(student_scores)

end_process;

この操作は、列student_scoresの要素を小さい順

番で並べる列に変換する。

function Is_Permutation(l1, l2: seq of int): bool== forall[e: union(elems(l1), elems(l2))] |

card({i | i: inds(l1) & l1(i) = e}) = card({i | i: inds(l2) & l2(i) = e})

end_function;

この関数では、l1の全ての要素はl2の全ての要素と同じかどうかを判断する。また、同じ要素がl1に使われた回数は、l2に使われた回数と同じかどうかも判断する。

例えば、 l1 = [90, 82, 93, 71, 60, 54, 82, 71, 90]l2 = [54, 60, 71, 71, 82, 82, 90, 90, 93]

function Is_Ordered(l: seq of int): bool== forall[i,j: inds(l)] | i < j => l(i) <= l(j)end_function;

この関数は、列lの要素を小さい順番で並べる

かどうかを判断する。

例えば、l = [54, 60, 71, 71, 82, 82, 90, 90, 93]

クラス練習

整数のqueueというデータ構造を列として定義し、そのデータ構造に次の操作を定義しましょう。Append, Eliminate, Read, and Count. 操作Appendは、指定された要素を列queueの末尾に加える。操作 Eliminate は、列queueの先頭要素を削除する。操作Read は、列queueの先頭要素を教える。操作Count は、列queueの要素の数を教える。

９．複合型（composite type)９．１ 複合型の定義複合型Aを次のように定義する。

A = composed of f_1: 型１f_2: 型2

... f_n: 型ｎ

end

このように定義された複合型Aは、n個のフィールドを持つオブジェクトの集まりである。

事例：Account = composed of

account_no: natpassword: natbalance: int

end

変数の宣言:account: Account;

９．２ コンストラクタ（make-function)

複合型Aのフィールドの値v_1, v_2, ..., v_nを用いて、次のように型Aの一つのオブジェクトを生成

する。mk_A(v_1, v_2, ..., v_n)

例えば、

account = mk_Account(1073548, 1234, 5000)

９．３ 演算子

（１）フィールドの選択（Field select）変数coを次のように宣言する。

co: A

coのフィールドf_iを選択（参照）する表現は、次の通りである。

co.f_i

例えば、account.passwordaccount.balance

(2) フィールド値更新（Field modification）

変数coは複合型Aの一つのオブジェクトを表すとしたら、

modify(co, f_1 -> v_1, f_2 -> v_2, ..., f_k -> v_k)

ここで 1 <= k <= nである。

例えば、account = mk_Account(1073548, 1234, 5000)

とすれば、

account1 = modify(account, password -> 4321)= mk_Account(1073548, 4321, 5000)

(3) 値の比べ(=, <>)二つの複合型の値は、同じかどうかを比べること

ができる。

事例:mk_Account(1073548, 1234, 5000) =

mk_Account(1073548, 1234, 5000)

mk_Account(1073548, 1234, 5000) <> mk_Account(1073548, 4321, 5000)

９．４ 応用事例

学生成績管理データベースの一つの表を次のよう

な内容を含める。

名前 学生番号 グループ C１ C2 Total中村, 0001, A3 2 2 4中田, 0002, A2 0 2 2... ... ... ...

ここで、C1 = Course1, C2 = Course2.

この表は複合型のオブジェクトの列として見られる。

module StudentScoreManagement;type

OneStudent = composed ofname: string st_no: natgroup: seq of char c1: natc2: nattotal: nat

end;

StudentsTable = seq of OneStudent;

varext #students_table: StudentsTable;

process Search(student_no: nat) info:OneStudent | error: string

ext rd students_tablepre truepost let is_member =

exists1[i: inds(students_table)] | students_table(i).st_no = student_no

in if is_memberthen info = students_table(i)else error = “The student does not exist.”

end_process;

process Update(one_student: OneStudent, credit1, credit2: nat)

ext wr students_tablepre truepost len(students_table) = len(~students_table) and

forall[i: inds(~students_table）] | if ~students_table(i) = one_studentthen students_table(i) =

modify(~students_table(i), c1 -> credit1, c2 -> credit2, total -> credit1 + credit2)

else ~students_table(i) = students_table(i)

クラス練習複合型Student を定義しましょう。この型のオブジェクトは、

次のフィールドを含む：name, date_of_birth, college, and grade。複合型Student によって、列student_listを

外部変数として定義する。以上のデータ構造に基づく次の操作を定義しなさい：Register, Change_Name, Get_Info。操作Register は、指定されたStudent型の

オブジェクトを列student_listの末尾に加える。操作

Change_Name は、指定された古い名前を指定された新

しい名前に置き換える。操作Get_Infoは、指定された

学生の全てのフィールドを教える。

１０．総合応用事例

会議参加登録システム

考え方：

（１）登録するデータ項目は何。（２）登録するために、どんな操作が必要で

あるのか。

以上のことを考えた上で、次の仕様を作成する。

module Conference_Registration;typePersonal_Info = composed of

name: seq of charemail: seq of charaddress: seq of chartel: Telephoneend;

varregistration_book: set of Personal_Info

process Register(participant: Personal_Info)ext wr registration_bookpost registration_book =

union({participant}, ~registration_book)end_process;

process Cancel(participant: Personal_Info)ext wr registration_bookpost registration_book =

diff(~registration_book, {participant})end_process;

process Count() no: nat0ext rd registration_bookpost no = card(registration_book)end_process;

end_module

１１．写像型

写像（map)とは、集合Xと集合Yにおいて、集合Xの各要素を集合Yの要素に対応づける特別な関係である。

X Y

劉

高橋

林

中島

日本信号

法政大学

国立情報学研究所

定義域（domain)

値域 （range)

写像の特徴：（１）定義域Xの任意な要素に対して、地域Yに対応づけ

る要素は、一つしかない。これは、写像と一般の関係との違いである。

（２）写像の定義域と値域は、有限である。これは、一般の関数との違いである。

X Y

劉

高橋

林

中島

日本信号

法政大学

国立情報学研究所

定義域（domain)

値域 （range)

具体的な写像は、次のように表す。

{a_1 -> b_1, a_2 -> b_2, ..., a_n -> b_n}

ここで、a_i -> b_i (i=1,…,n) 写像の要素であり、定義域の要素a_iは、値域の要素b_i に対応づけるという意味をする。

例えば、

{<中島> -> <国立情報学研究所>, <劉> -> <法政大学>, <高橋> -> <日本信号>, <林> -> <日本信号>}

空写像は、次のように表す。

{->}

11.1 写像型の定義

写像型Tは、次のように定義する。

T = map T1 to T2

ここで、T1は、定義域型と呼ぶ。T2は、値域型と

呼ぶ。

例えば、写像型Aを次のように定義する。

A = map nat to char

Aは、定義域型natから値域型charへの写像である。

写像型Aの要素（写像或いは写像値）の事例：

{1 -> 'a', 2 -> 'b', 3 -> 'c', 4 -> 'd'}

{5 -> 'u', 15 -> 'v', 25 -> 'w'}

{10 -> 'x', 20 -> 'y'}

{50 -> 'r'}

{->}

11.2 コンストラクタ

写像型には、写像値を定義するために、二つのコンストラクタが使われる。

写像の列挙表記 (map enumeration) 写像の内包表記 (map comprehension)

(1) 写像の列挙表記

一般式：

{a_1 -> b_1, a_2 -> b_2, ..., a_n -> b_n}

事例:

{3 -> 'a', 8 -> 'b', 10 -> 'c'}

{<中島> -> <国立情報学研究所>, <劉> -> <法政大学>, <高橋> -> <日本信号>, <林> -> <日本信号>}

(2)写像の内包表記

{ed -> er | bd1, ..., bdn & P(x1, x2, ..., xn)}

ここで、edとerは、式であり、bd1, ..., bdnは、bindingであり、x1, x2, ..., xn は束縛変数である。

上述の写像の内包表記は、bd1, bd2, ..., bdn および述語論理式Pを満たす変数x_1, x_2, ...,x_nによって定義された全てのed -> erの集まりである。

例えば、次の写像の内包表記で合格の写像を定義した。

{x -> y | x: {5, 10, 15}, y: {10, 20, 30} & y = 2 * x} = {5 -> 10, 10 -> 20, 15 -> 30}

しかし、次の写像の内包表記で不合格の写像を定義した。

{x -> y | x: {1, 2, 3}, y: {5, 10, 15, 20} & y > x * 5} =

{1 -> 10, 1 -> 15, 1 -> 20, 2 -> 15, 2 -> 20, 3 -> 20}何故でしょうか?

11.3 演算子

(1) 適用

写像mの定義： m: map T1 to T2;

写像mの適用： m(a)

m(a)は、写像mにおけるaに対応する値を返す。

事例：

写像m1は、次の値である。m1 = {5 -> 10, 10 -> 20, 15 -> 30}

写像m1の適応：

m1(5) = 10 m1(10) = 20 m1(15) = 30

(2) 定義域 (dom)

写像m は、次のように定義されるとする。

m: map T1 to T2;

写像mの定義域は、定義域型T1の部分集合である。

dom: map T1 to T2 ー> set of T1

事例：

m1 = {5 -> 10, 10 -> 20, 15 -> 30}

dom(m1) = {5, 10, 15}

(3) 値域（rng）

写像m は、次のように定義されるとする。

m: map T1 to T2;

写像mの値域は、値域型T2の部分集合である。

rng: map T1 to T2 ー> set of T2

事例：

m1 = {5 -> 10, 10 -> 20, 15 -> 30}

rng(m1) = {10, 20, 30}

(4) 上書き （override）

m1とm2は、二つの写像である。m1とm2の上書き

演算は、次のように書く。

override(m1, m2)

写像m1に写像m2を上書きして結合させた写像を

返す。つまり、m1とm2の定義域に共通して含まれる要素に対する対応付けはm2の対応付けとなる。

事例：

写像m1とm2は、次の値である。

m1 = {5 -> 10, 10 -> 20, 15 -> 30}, m2 = {10 -> 5, 15 -> 50, 4 -> 20}.

写像m1に写像m2を上書きして結合させた写像は、次の通りである。

override(m1, m2) = {10 -> 5, 15 -> 50, 4 -> 20, 5 -> 10}

override(m2, m1) = {5 -> 10, 10 -> 20, 15 -> 30, 4 -> 20}

注意： 上書き演算子overrideは、交換性を持っていない。つまり、override(m1, m2) <> override(m2, m1)

(５) 定義域限定（domrt）

写像mの定義域が集合sに限定することによる得た部分写像は、次のように表現する。

domrt(s, m)

写像mのうち、定義域を集合sに所属する要素に限定した写像を返す。

例えば、m = {10 -> 5, 15 -> 50, 4 -> 20, 5 -> 10},s = {10, 5, 50, 30}とすれば、

domrt(s, m) = {10 -> 5, 5 -> 10}

(6) 値域限定（rngrt）

写像mの値域が集合sに限定することによる得た部分写像は、次のように表現する。

rngrt(m, s)

写像mのうち、値域を集合sに所属する要素に限定した写像を返す。

例えば、m = {10 -> 5, 15 -> 50, 4 -> 20, 5 -> 10},s = {10, 5, 50, 30}とすれば、

rngrt(m, s) = {5 -> 10, 10 -> 5, 15 -> 50}

(7) 定義域非限定（domrb）

写像mの定義域が集合sに属さない要素に限定することによる得た子写像は、次のように表現する。

domrb(s, m)

写像mのうち、定義域を集合sに属さない要素に限定した写像を返す。

例えば、m = {10 -> 5, 15 -> 50, 4 -> 20, 5 -> 10},s = {10, 5, 50, 30}とすれば、

domrb(s, m) = {15 -> 50, 4 -> 20}

(8) 地域非限定（rngrb）

写像mの値域が集合sに属さない要素に限定することによる得た子写像は、次のように表現する。

rngrb(m, s)

写像mのうち、値域を集合sに属さない要素に限定した写像を返す。

例えば、m = {10 -> 5, 15 -> 50, 4 -> 20, 5 -> 10},s = {10, 5, 50, 30}とすれば、

rngrb(m, s) = {4 -> 20}

(9) 写像の合成 (comp) 写像m1とm2は、次のように宣言すれば、

m1: map A to B （事例：m1 = {a1 -> b1, a2 -> b2}）m2: map B to C （事例：m2 = {b1 -> c1, b2 -> c2}）

写像m1とm2の合成が、次のような写像になる。comp(m1, m2): map A to C （事例：comp(m1, m2) = {a1 -> c1, a2 -> c2}）

A B C

a1

a2

b1

b2

c1

c2

(10)値の比較(=, <>)

写像m1とm2は同じか違うかを次のように表す。

m1 = m2 （同じ）m1とm2の全ての要素は同じ。

m1 <> m2 （違う）m1とm2のある要素が違う。

例えば、m1 = {5 -> 10, 10 -> 20, 15 -> 30}, m2 = {10 -> 5, 15 -> 50, 4 -> 20}とすれば、m1 <> m2, m1 = m1

学生成績管理：

学生成績管理データベースの一つの表を次のような内容を含める。

名前 学生番号 グループ C１ C2 Total中村, 0001, A3 2 2 4中田, 0002, A2 0 2 2... ... ... ...

ここで、C1 = Course1, C2 = Course2.

特徴：一人の学生に対し、学生番号は唯一である。

11.4 応用事例

types

OneStudent = composed ofname: string group: seq of char c1: natc2: nattotal: nat

end;

StudentNo = nat;

StudentsTable = map StudentNo to OneStudent;

state St of students_table: StudentsTable

end;

process Search(student_no: StudentNo) info: OneStudent

ext rd students_tablepre student_no inset dom(students_table) post info = students_table(student_no)end_process;

process Update(student_no: StudentNo, credit1, credit2: nat)

ext wr students_tablepre truepost if student_no inset dom(students_table)

then students_table = override(~students_table,

{student_no -> modify(~students_table(student_no),

c1 -> credit1, c2 -> credit2, total -> credit1 + credit2)})

else students_table = ~students_tableend_process;

１２．形式仕様作成の3段階技術

質問：どのようにすれば、システムのSOFL仕様を

書けますか？

非形式仕様（日本語）à半形式仕様à形式仕様

事例：誕生日帳システム

誕生日帳とは、法政大学の学生たちの誕生日を記録している本である。誕生日帳システムとは、その誕生日帳に新しい誕生日を記録したり、

誕生日帳から学生の誕生日を探したり、誕生日帳から卒業した学生の誕生日を削除したりするソフトウェアシステムである。

第1段階： 非形式仕様

一. 機能二. 必要なデータ

三. 必要な制限

第1段階： 非形式仕様（事例）

一. 操作機能1. 誕生日の登録2. 誕生日の検索3. 誕生日の更新（間違い誕生日の修正）4. 誕生日の削除

二. データリソース1. 誕生日帳

三. 必要な制限1. 誕生日帳に登録した学生の名前は、全て違う。２．誕生日帳に登録した学生の名前は、最大２０文字で

ある。

第二段階：半形式仕様

１．関連している操作、データリソース、および必要な制限を見つけて、SOFL仕様のモジュールに反映する。

２．必要なデータ型を定義し、データリソースの構造をそれらの型で明確に定義する。

３．操作仕様をpre-postのスタイルで記述する。但し、その中身は、自然言語（例えば、日本語）で記入する。

第二段階：半形式仕様（事例）module SYSTEM_Birthday_Book;typesBirthdayBook = map Name to Birthday;Name = seq of char;Birthday = composed of

year: nat0month: nat0day: nat0end;

varbirthday_book: BirthdayBook; /*制限も考えた*/invbirthday_bookに登録した学生の名前の文字数は、２０以下である。

process Register(name: Name, birthday: Birthday)

ext wr birthday_book: BirthdayBookpost birthday_bookにnameを持っている人の誕生日

birthdayを登録する。end_process;

process Find(name: Name) birthday: Birthdayext rd birthday_bookpre nameは、birthday_bookに既に登録している。post nameを持っている人の誕生日を見つけ、その誕生

日をbirthdayとして出力する。end_process;

process Update(name: Name, birthday: Birthday)ext wr birthday_bookpre nameは、birthday_bookに既に登録している。post birthday_bookにnameを持っている人の

誕生日をbirthdayに更新する。end_process;

process Delete(name: Name)ext wr birthday_bookpre nameは、birthday_bookに既に登録している。post birthday_bookにnameを持っている人の

誕生日を削除する。end_process;

第三段階：形式仕様

１．CDFDでシステムの構造を定義する。

２．全ての不変数を形式に定義する。

３. 全ての操作仕様を形式に表現する。

? ?????????????

????????????

?????? ??????

? ? ? ?

????????

? ? ? ?

????????

????

???????? ? ? ? ?

No. 1

システムのCDFD

第三段階：形式仕様（事例）module SYSTEM_Birthday_Book;typeBirthdayBook = map Name to Birthday;Name = seq of char;Birthday = composed of

year: nat0month: nat0day: nat0end;

varbirthday_book: BirthdayBook;invforall[name: dom(birthday_book)] | len(name) <= 20;

behav: CDFD_No. 1;

process Register(name: Name, birthday: Birthday)

ext wr birthday_book: BirthdayBookpost birthday_book = override(~birthday_book,

{name -> birthday})end_process;

process Find(name: Name) birthday: Birthdayext rd birthday_bookpre name inset dom(birthday_book)post birthday = birthday_book(name)end_process;

process Update(name: Name, birthday: Birthday)

ext wr birthday_bookpre name inset dom(birthday_book)post birthday_book = override(~birthday_book,

{name -> birthday})end_process;process Delete(name: Name)ext wr birthday_bookpre name inset dom(birthday_book)post birthday_book = domrb({name},~birthday_book)end_process; end_module;

総合練習

(1) 前述の「会議参加登録システム」のregistration_bookをPersonal_Infoの列として定義し、それぞれの操作Register, CancelおよびCountの仕様を作成しましょう。

(2) 前述の「会議参加登録システム」のregistration_bookを写像型として定義し、それぞれの操作Register, CancelおよびCountの仕様を作成しましょう。その写像型の定義域の型は、Emailである。値域の型は、emailフィールドを含めっていないPersonal_Infoである。