Блоґ одного кібера

Історія хвороби контуженого інформаційним вибухом

Програмування в логіці

with 2 comments

Пролог тобто. Мій імперативний мозок все ще не в’їхав. Тим не менш, я потрохи просунувся, а сьогодні я взагалі молодчина і окрім прологу. Єй!

Вчуся я по двох книжках: Adventure in Prolog, та Вікіпідручник звісно.

На контрольній я дойшов до першої задачі:

Знаходження синуса рядами Тейлора (ой, ця мова явно на таке не розрахована, або я якось не так написав):

% sin рядами тейлора 
% sin(x) = x – x^3/3! + x^5/5! – x^7/7! + …

fak(0,1).
fak(X,F) :- 
        X > 0
        X2 is X-1,
        fak(X2,F2),
        F is F2*X.

pow(X,1,X).
pow(X,N,R) :- 
        N > 1,
        N2 is N – 1,
        pow(X,N2,R2),
        R is R2*X.

sign(1,1).
sign(3,-1).
sign(N,S) :- N2 is N – 4, sign(N2,S).

tayloritem(X,N,I) :- 
        sign(N,Sign), 
        pow(X,N,Pow), 
        fak(N,Fak), 
        I is Sign * Pow / Fak.

good_precision(X,N,E):- tayloritem(X,N,I), I < E, I > -E.

resin(X,1,Res):- tayloritem(X,1,Res).
resin(X,N,Res):-
        N > 0,
        N2 is N – 2,
        tayloritem(X,N,I),
        resin(X,N2,Psin),
        Res is Psin + I.

mysin(X,Sin):- resin(X,101,Sin).

Залишились списки.

Advertisements

Written by bunyk

Травень 16, 2011 at 22:15

Оприлюднено в Кодерство, Конспекти, Нещоденник

Tagged with

Відповідей: 2

Subscribe to comments with RSS.

  1. Твоє кунфу сильне, але у мене сильн…
    Інтерпретатор *rainfuck на Пролозі

        domains
           list = byte*
           intlist = long*
           
        predicates
           nondeterm inc_mem(intlist,intlist,integer).
           nondeterm init_mem(intlist).
           nondeterm init_mema(intlist,integer).
           nondeterm dec_mem(intlist,intlist,integer).
           nondeterm get_mem(intlist,integer,integer).
           nondeterm set_mem(intlist,intlist,integer,integer).
           nondeterm skip_forward(list, list, list, list).
           nondeterm skip_forwarda(list, list, list, list, integer).
           nondeterm skip_back(list, list, list, list).
           nondeterm skip_backa(list, list, list, list, integer). 
           
           nondeterm sequence(list, list, intlist, integer).
           nondeterm instruction(list,list,intlist,integer,list,list,intlist,integer).
           nondeterm run(list).
           nondeterm member(byte,list).
        clauses
    
        member(A,[A|_]):-!.
        member(A,[_|X]):-
           member(A,X).
           
        init_mem(Mem) :-
          /* fill list Mem with 0 */   
           init_mema(Mem, 10).
           
        /* fill list Mem with 0 */   
        init_mema([],0) :- !.
        init_mema([0|Tail],Size) :-
           NewSize = Size - 1,
           init_mema(Tail,NewSize).
    
        
        /* inc_mem(List, NewList, Ind) increment element of List with index Ind
           NewList[Ind] = List[Ind] + 1 */
           
        inc_mem([Head|Rest], [NewHead|Rest], 0) :-
           NewHead = (Head + 1), !.
           
        inc_mem([Head|Tail],[Head|NewTail],Ind) :-
           Ind > 0,
           NewInd = Ind - 1,
           inc_mem(Tail,NewTail,NewInd).
           
           
        dec_mem([Head|Rest],[NewHead|Rest],0) :-
           NewHead = (Head - 1), !.
           
        dec_mem([Head|Tail],[Head|NewTail],Ind) :-
          Ind > 0,
           NewInd = Ind - 1,
           dec_mem(Tail, NewTail, NewInd).
    
        /* return value of MemList[Ind] in ResultValue (ResultValue:=MemList[Ind])  */
        get_mem([ResultValue|_],ResultValue,0).
        get_mem([_|Tail],ResultValue,Ind) :-
           Ind > 0,
           NewInd = Ind - 1,
           get_mem(Tail,ResultValue,NewInd).
           
        /*  MemList[Ind]:=SetValue */
        set_mem([_|Tail],[SetValue|Tail], SetValue, 0).
        set_mem([Head|Tail],[Head|NewTail],SetValue, Ind) :-
          Ind > 0,
          NewInd = Ind - 1,
          set_mem(Tail,NewTail,SetValue, NewInd).
          
        
    
        /* Prog - sourse programm list, Rest - remain program after jump */
        skip_back([']'|InstRest], [H|Stack], NewInst, NewStack) :-
        
           skip_backa([H,']'|InstRest], Stack, NewInst, NewStack, 0).  /* 0 - index of internal blocks */
           
        skip_backa(['['|InstRest], Stack, InstRest, ['['|Stack], 0).
        
        skip_backa(['['|InstRest], [H|StackRest], NewInst, NewStack, Num):-
          Num > 0,
          NewNum = Num - 1,
          skip_backa([H,'['|InstRest], StackRest, NewInst, NewStack, NewNum).
          
        skip_backa([']'|InstRest], [H|StackRest], NewInst, NewStack, Num):-
          NewNum = Num + 1,
          skip_backa([H,']'|InstRest], StackRest, NewInst, NewStack, NewNum).
    
        skip_backa([Inst|InstRest], [H|StackRest], NewInst, NewStack, Num):-
          skip_backa([H,Inst|InstRest], StackRest, NewInst, NewStack, Num).
          
           
        
        /* Prog - sourse programm list, Rest - remain program after jump */
        skip_forward(InstList, NewInstList, Stack, NewStack) :-
           skip_forwarda(InstList, NewInstList, Stack, NewStack, 0).  /* 0 - index of internal blocks */
           
        skip_forwarda([']'|Rest], Rest, Stack, [']'|Stack], 0).
        
        skip_forwarda([']'|Rest], NewRest, Stack, NewStack, Num) :-
           Num > 0,
           NewNum = Num - 1,
           skip_forwarda(Rest, NewRest, [']'|Stack], NewStack, NewNum).
           
        skip_forwarda(['['|Rest], NewRest, Stack, NewStack, Num) :-
           NewNum = Num + 1,
           skip_forwarda(Rest, NewRest, ['['|Stack], NewStack, NewNum).
           
        skip_forwarda([Inst|Rest],NewRest, Stack, NewStack, Num) :-
           not(member(Inst,['[',']'])), 
           skip_forwarda(Rest, NewRest, [Inst|Stack], NewStack, Num).
    
    
        /* sequence(InstList, _ , MemList , Ind) */
        sequence([],_,_,_) :- !.
        sequence(Inst,Stack,Mem,Ind) :-
           instruction(Inst, Stack, Mem, Ind,     NewInst, NewStack, NewMem, NewInd),
           sequence(NewInst, NewStack, NewMem, NewInd).
    
    
        instruction(['>'|InstRest], Stack, Mem, MemInd,   InstRest, ['>'|Stack], Mem, NewMemInd) :-
           NewMemInd = MemInd + 1, !.
           
        instruction(['<'|InstRest], Stack, Mem, MemInd,   InstRest, ['<'|Stack], Mem, NewMemInd) :-
           NewMemInd = MemInd - 1, !.
           
        instruction(['+'|InstRest], Stack, Mem, MemInd,   InstRest, ['+'|Stack], NewMem, MemInd) :-
           inc_mem(Mem, NewMem, MemInd), !.
           
        instruction(['-'|InstRest], Stack, Mem, MemInd,   InstRest, ['-'|Stack], NewMem, MemInd) :-
           dec_mem(Mem, NewMem, MemInd), !.
           
        instruction(['.'|InstRest], Stack, Mem, MemInd,   InstRest, ['.'|Stack], Mem, MemInd) :-
          get_mem(Mem, Value, MemInd),
          write("Result = ",Value), nl, !.
          
          
    
        instruction([','|InstRest], Stack, Mem, MemInd,    InstRest,    [','|Stack], NewMem, MemInd) :-
           write("Enter X: "),
           readint(Value),
           nl,
           set_mem(Mem, NewMem, Value, MemInd), !.
           
    
        instruction(['['|InstRest], Stack, Mem, MemInd,    NewInstRest, NewStack, Mem, MemInd) :-
           get_mem(Mem, 0, MemInd),
           skip_forward(InstRest, NewInstRest, ['['|Stack], NewStack), !.
           
        instruction(['['|InstRest], Stack, Mem, MemInd,    InstRest,     ['['|Stack],   Mem, MemInd).
    
    
        instruction([']'|InstRest], Stack, Mem, MemInd,  NewInstList, NewStack, Mem, MemInd) :-
           not(get_mem(Mem,0,MemInd)),
           skip_back([']'|InstRest], Stack, NewInstList, NewStack),!.
           
        instruction([']'|InstRest], Stack, Mem, MemInd,  InstRest, [']'|Stack], Mem, MemInd).
           
     
        instruction([']'|InstRest], [_|NewStack], Mem, MemInd, InstRest, NewStack, Mem, MemInd) :-
           get_mem(Mem, 0, MemInd), !.
           
        instruction([Inst|InstRest], Stack, Mem, Ind,   InstRest, Stack, Mem, Ind) :-
           not(member(Inst,['+','-','','.',',','[',']'])).
    
    
    
        run(Prog) :-
           init_mem(Mem),
           sequence(Prog, [], Mem, 0).
    
          
        
      % copy '[', '>', '+', '>', '+', '<','', '>', '[', '<','', '>', '-',']'
      % Sum  '[', '>', '+', '', '-', '','[','>','+','>','+','<','','>','[','<','','>','-',']','','>','+','<','<','-',']','<',' NN0, point to 0
                '[', '>', '+', '>', '+', '<','', '>', '[', '<','', '>', '-', ']',            
                '<', '','[','>','+','>','+','<','','>','[','<','','>','-',']','','>','+','<','<','-',']','<','','>','>','>',           %   MemInd = 4;
                
                  % Mem[0] = Mem[4], Mem[4] = 0;
                '[','-','<','<','<','','>','>','>',']',                 
                
                '<','<','<','','[','>','+','>','+','<','','>','[','<','','>','-',']','','>','+','<','<','-',']','<','',   %MemInd = 1;
                '[','>','+','+','>','+','+','<','','>',           %MemInd = 3;
                % Mem[4] = Mem[4] - Mem[3]
                '[', '>', '-', '',
                '.'
                ]    
        
             ), 
             
          nl.
    

    danbst

    Травень 17, 2011 at 07:46

    • Visual Prolog? Здається нас надули сказавши що на відміну від Ліспу (який є коммон-, ємакс-, мю-, і ще купу діалектів) Пролог всюди однаковий.

      bunyk

      Травень 19, 2011 at 13:02


Залишити відповідь

Заповніть поля нижче або авторизуйтесь клікнувши по іконці

Лого WordPress.com

Ви коментуєте, використовуючи свій обліковий запис WordPress.com. Log Out / Змінити )

Twitter picture

Ви коментуєте, використовуючи свій обліковий запис Twitter. Log Out / Змінити )

Facebook photo

Ви коментуєте, використовуючи свій обліковий запис Facebook. Log Out / Змінити )

Google+ photo

Ви коментуєте, використовуючи свій обліковий запис Google+. Log Out / Змінити )

З’єднання з %s

%d блогерам подобається це: