このディレクトリの索引

http://pc12.2ch.net/test/read.cgi/tech/1255709298/55 
#  [1] 授業単元:プログラム言語論 
#  [2] 問題文(含コード&リンク): 
# 
#  設問1.C言語、またはC++言語で、割り算を計算するdev(int x,int y)関数(*)を作成しなさい。 
# ただし、不変表明(assert)を使って、0で除算を実行した場合にエラーを出力するようにすること。 
# (*)関数devは、int型の返値を持ち、x/yを計算するものとする。
:- op(700,xfx,は).

関数定義(div(X,Y),Z) :- div(X,Y,Z).

div(X,Y,Z) :-
    length(L1,X),
    length(L2,Y),
    div(L1,L2,DIV,MOD),
    length(DIV,Z).

div(_,[],_,_) :- write('0除算エラー\n'),!.
div(L1,L2,[_|D],MOD) :-
    append(L2,L3,L1),
    div(L3,L2,D,MOD).
div(L1,L2,[],L1) :- \+(append(L2,L3,L1)).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

findavg(_集約項,_項,_算術平均) :-
    findall(_集約項,_項,_値ならび),
    '加算'(_値ならび,_合計値),
    length(_値ならび,_ならびの長さ),
    _算術平均 is _合計値 / _ならびの長さ,!.

加算(trunc(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A is trunc(B)),SL),!.
加算(四捨五入(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 四捨五入(B)),SL),!.
加算(切捨て(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 切捨て(B)),SL),!.
加算(切り上げ(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 切り上げ(B)),SL),!.
加算([],L) :-
    var(L),
    L = 0.0e+00,!.
加算([],L) :-
    \+(var(L)),
    加算の変数に零をおく(L),!.
加算([L|R],SL) :-
    ならび(L),
    行列の転置([L|R],L1),
    加算_2(L1,SL),!.
加算(X,S) :-
    加算_1(X,0.0e+00,S) .

加算_1([],S,S) :- !.
加算_1([A|R],Y,S) :-
    ならび(A),
    ならび(Y),
    !,
    ならび加算(A,Y,Z),
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    atom_number(A,I),
    integer(I),
    Z is I + Y,
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    atom_number(A,F),
    real(F),
    Z is F + Y,
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    加算_1(R,Y,S),!.
加算_1([A|R],Y,S) :-
    A1 は A,
    Z is A1 + Y,
    加算_1(R,Z,S).
加算_1(A,Y,S) :-
    とからりすと(A,L),
    !,
    加算_1(L,Y,S) .

加算_2([],[]) :- !.
加算_2([L|R],[S|R2]) :-
    加算(L,S),
    加算_2(R,R2).

加算の変数に零をおく([]) :- !.
加算の変数に零をおく([A|R]) :-
    変数(A),
    A = 0.0e+00,
    加算の変数に零をおく(R),!.

とからりすと(A,[A]) :-
    atomic(A),!.
とからりすと(A と B,C) :-
    とからりすと(A,A1),
    とからりすと(B,B1),
    append(A1,B1,C).

変数(_変数) :- var(_変数).

ならび([_|_]).


_項 は (_ネットワーク :: _式) :-
    _ネットワーク :: _項 は _式,
    ! .
_評価項 は N : L :-
    M は N,
    L1 は L,
    list_nth(M,L1,_評価項),
    ! .
_評価項 は prolog(_評価項) :-
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    !,
    error_protect(_評価項,fail) .
_評価値 は [X|{P}] :-
    findall(X,P,_評価値),
    ! .
_評価項 は ` _値 :-
    !,
    _評価項 = _値,
    ! .
_項 は _式 :-
    var(_式),
    _項 = _式,
    ! .
_項 は _式 :-
    error_protect(一時関数定義(_式,_項),fail) .
_項 は _式 :-
    atom(_式),
    member(_式,[minint,maxint,cputtime,time,csize,cused,dbsize,dbused,gsize,gused,noptrs,ptrsued,ssize,sused,tsize,tused]),
    !,
    _項 is _式,
    ! .
_項 は _式 :-
    二項組込み関数(_式),
    二項組込み関数の評価(_式,_項) .
_項 は _式 :-
    二項組込み関数(_式),
    !,
    fail .
_項 は _式 :-
    functor(_式,Functor,1),
    arg(1,_式,Arg),
    Y は Arg,
    functor(_式_1,Functor,1),
    arg(1,_式_1,Y),
    member(Functor,[atom,real,integer,var,float,list]),
    !,
    error_protect(_式_1,fail),
    _項 = Y,
    ! .
_項 は _式 :-
    atom(_式),
    error_protect(get_global(_式,_項),fail),
    ! .
_項 は _式 :-
    real(_式),
    _項 = _式,
    ! .
_項 は _式 :-
    real(_式),
    !,
    fail .
_項 は _式 :-
    list(_式),
    findall(X,(member(U,_式) , X は U),_項) .
_項 は _式 :-
    list(_式),
    !,
    fail.
_項 は _erlang_module : _erlang関数 :-
    erlang関数評価(_erlang_module : _erlang関数,_項),!.
_項 は _式 :-
    関数定義(_式,_項),!.
_項 は _式 :-
    functor(_式,_関数,_次数),
    function(_関数,_次数),
    findall(Arg,(for(1,N,_次数) , arg(N,_式,Arg)),L),
    関数評価に於いて引数部分の関数評価(L,L2),
    _式の二 =.. [_関数|L2],
    error_protect(_項 is _式の二,fail) .
_項 は _評価関数 :-
    error_protect(_項 is _評価関数,fail),!.
_評価項 は prolog(_評価項) :-
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    !,
    error_protect(_評価項,fail),!.
_項 は _評価項 :-
    述語評価が可能(_評価項,_関数,_次数,_次数足す一),
    _評価項 =.. _評価項の項分解ならび,
    findall(Arg,(for(1,N,_次数) , arg(N,_評価項,Arg)),L),
    関数評価に於いて引数部分の関数評価(L,L2),
    append(L2,[_],_変数を付加した引数ならび),
    _解付き評価項 =.. [_関数|_変数を付加した引数ならび],
    error_protect(_解付き評価項,fail),
    arg(_次数足す一,_解付き評価項,_項) .
_項 は _評価項 :-
    \+(述語評価が可能(_評価項,_関数,_次数,_次数足す一)),
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    error_protect(_評価項,fail),
    arg(Arg,_評価項,_項) .
_項 は _評価項 :-
    \+(述語評価が可能(_評価項,_関数,_次数,_次数足す一)),
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    \+(error_protect(_評価項,fail)),
    _評価項 = _項,!.
_項 は _式 :-
    atomic(_式),
    \+(述語評価が可能(_式,_関数,_次数,_次数足す一)),
    _項 = _式,!.

述語評価が可能(_評価項,_関数,_次数,_次数足す一) :-
    functor(_評価項,_関数,_次数),
    _次数足す一 is _次数 + 1,
    \+(predicate_type(_関数,_次数足す一,undefined)),!.

関数評価に於いて引数部分の関数評価([],[]).
関数評価に於いて引数部分の関数評価([L|R1],[L2|R2]) :-
    list(L),
    !,
    関数評価に於いて引数部分の関数評価(L,L2),
    関数評価に於いて引数部分の関数評価(R1,R2),
    ! .
関数評価に於いて引数部分の関数評価([F|R1],[F|R2]) :-
    \+(error_protect(F2 は F,fail)),
    !,
    関数評価に於いて引数部分の関数評価(R1,R2) .
関数評価に於いて引数部分の関数評価([F|R1],[F2|R2]) :-
    error_protect(F2 は F,fail),
    関数評価に於いて引数部分の関数評価(R1,R2) .

erlang関数評価(os : cmd(Command),_項) :-
    erlang :: (os : cmd(Command) -> _項_1),
    _項 は string2atom(_項_1),!.
erlang関数評価(_erlang_module : _erlang関数,_項) :-
    erlang :: (_erlang_module : _erlang関数 -> _項),!.

関数定義(_項の一 + _項の二,_値) :-
    _値の一 は _項の一,
    number(_値の一),
    _値の二 は _項の二,
    number(_値の二),
    _値 is _値の一 + _値の二,
    !.
関数定義(_項の一 + _項の二,_値) :-
    _値の一 は _項の一,
    atomic(_値の一),
    _値の二 は _項の二,
    atomic(_値の二),
    concat_atom([_値の一,_値の二],_値),
    !.
関数定義(_ならびの一 + _ならびの二,_値) :-
    (
        変数(_ならびの一)
    ;
        _ならびの一 == []
    ;
        list(_ならびの一)
    ;
        変数(_ならびの二)
    ;
        _ならびの二 == []
    ;
        list(_ならびの二)
    ),
    !,
    append(_ならびの一,_ならびの二,_値) .
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    list(_値の一),
    _値の二 は _項の二,
    integer(_値の二),
    findall(_値の一,for(1,_,_値の二),LY),
    concat_list(LY,_値),
    !.
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    atom(_値の一),
    _値の二 は _項の二,
    integer(_値の二),
    findall(_値の一,for(1,_,_値の二),L),
    concat_atom(L,_値),
    !.
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    atomic(_値の一),
    _値の二 は _項の二,
    atomic(_値の二),
    concat_atom([_値の一,_値の二],_値),
    !.
関数定義(_ならびの一 * _ならびの二,_値) :-
    (
        変数(_ならびの一)
    ;
        _ならびの一 == []
    ;
        list(_ならびの一)
    ;
        変数(_ならびの二)
    ;
        _ならびの二 == []
    ;
        list(_ならびの二)
    ),
    !,
    append(_ならびの一,_ならびの二,_値) .
関数定義(` _値,_値) :-
    !.
関数定義(@ _式,_値) :-
    _値 は _式,!.
関数定義(四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _値の二 >= 0.0e+00,
    _四捨五入後の値 is floor(_値の二 + 0.5) * 1.0,!.
関数定義(四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 is ceil(_値の二 - 0.5),!.
関数定義(切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は floor(_値の二) * 1.0,!.
関数定義(切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二),!.
関数定義(十円未満四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 は floor(_値の二 / 10 + 0.5) * 10,!.
関数定義(十円未満切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は trunc(_値の二 / 10) * 10,!.
関数定義(十円未満切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二 / 10) * 10,!.
関数定義(百円未満四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 は floor(_値の二 / 100 + 0.5) * 100,!.
関数定義(百円未満切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二 / 100) * 100,!.
関数定義(百円未満切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は floor(_値の二 / 100) * 100,!.
関数定義(整数化(_値),_整数化された値) :-
    _値の二 は _値,
    _整数化された値 is trunc(_値の二),!.
関数定義(char_code(_項),_値) :-
    (
        atom(_項),
        atomic_length(_項,1),
        char_code(_項,_値)
    ;
        integer(_項),
        char_code(_値,_項)
    ;
        複合項(_項),
        _項の一 は _項,
        _値 は char_code(_項の一)
    ),
    !.
関数定義($ _大域変数名,_値) :-
    atom(_大域変数名),
    get_global(_大域変数名,_値の一),
    _値 は _値の一,!.
関数定義(S,E) :-
    functor(S,select,1),
    to(S,E),!.
関数定義(setq(A,B),E) :-
    atom(A),
    B1 は B,
    set_global(A,B1),
    E = B1,!.
関数定義(++ A,X) :-
    A1 は A,
    list(A1),
    加算(A1,X),!.
関数定義(A ++ B,X) :-
    C is B / A,
    X = A + C + B,!.
関数定義(car(A),E) :-
    A1 は A,
    A1 = [E|_],!.
関数定義(cdr(A),E) :-
    A1 は A,
    A1 = [_|E],!.
関数定義(cons(A,B),E) :-
    A1 は A,
    B1 は B,
    E = [A1|B1],!.
関数定義(length(A),E) :-
    A1 は A,
    list(A1),
    length(A1,E),!.
関数定義(decode(A,B,C,D),E) :-
    A1 は A,
    B1 は B,
    A1 = B1,
    E は C,!.
関数定義(decode(A,B,C,D),E) :-
    E は D,!.
関数定義(decompcons(A),E) :-
    A1 は A,
    decompcons(A1,E),!.
関数定義(substr(A,B,C),E) :-
    関数定義(subatomic(A,B,C),E),!.
関数定義(subatomic(A,B,C),E) :-
    A1 は A,
    B1 は B,
    C1 は C,
    subatomic(A1,B1,C1,E),!.
関数定義(concat(A),E) :-
    A1 は A,
    concat(A1,E),!.
関数定義(concat(A,B),E) :-
    A1 は A,
    B1 は B,
    concat(A1,B1,E),!.
関数定義(append(A,B),E) :-
    A1 は A,
    B1 は B,
    append(A1,B1,E),!.
関数定義(reverse(A),E) :-
    A1 は A,
    reverse(A1,E),!.
関数定義(string2atom(A),E) :-
    A2 は A,
    flat(A2,B),
    atom_codes(E,B),!.
関数定義(P,E) :-
    functor(P,greatest,Arg),
    P =.. [greatest|L],
    findall(B,(member(A,L) , B は A),L2),
    max(L2,E),!.
関数定義(P,E) :-
    functor(P,least,Arg),
    P =.. [least|L],
    findall(B,(member(A,L) , B は A),L2),
    min(L2,E),!.
関数定義(cel(_列数,_行数,_行列),_解) :-
    _関数評価された行数 は _行数,
    _関数評価された列数 は _列数,
    list_nth(_関数評価された行数,_行列,_行),
    list_nth(_関数評価された列数,_行,_解),!.