TAKD = (I(2,3)*I(1,3)).ge -> I(3,3),

(

((I(1,3).DECD*I(2,3)*I(3,3)).TAKD *

(I(2,3).DECD*I(3,3)*I(1,3)).TAKD * (I(3,3).DECD*I(1,3)*I(2,3)).TAKD).TAKD

);

}

Application

%gentoo(1)

Вычисление значения N-ого числа Фибоначчи на типе данных Nat – Java

package fptl.decompiler.Generated;

import ComputingBlock.InternalForm.Data.*; import java.util.*;

public class Test implements Runnable

{

public void run()

{

System.out.println("Compiled:" + fib());

}

private int fib()

{

return COUNT(F(CNV(23)));

}

private Nat CNV(int arg0)

{

return CNV_TAILREC(arg0, consBd2);

}

private Nat CNV_TAILREC(int arg0, Nat arg1)

{

while (true)

{

if (arg0 == 0) break; int argTemp0 = arg0 - 1;

Nat argTemp1 = Nat.c_succ(arg1); arg0 = argTemp0;

arg1 = argTemp1;

}

return arg1;

}

private Nat F(Nat arg0)

{

return F_TAILREC(arg0, consBd5);

}

private Nat F_TAILREC(Nat arg0, Nat arg1)

{

while (true)

{

boolean var18;

if (arg0 == null || consBd4 == null) var18 = false;

else

var18 = LE(arg0, consBd4); if (var18) break;

Nat argTemp0 = MINUS(arg0, consBd5);

Nat argTemp1 = PLUS(arg1, F(MINUS(arg0, consBd4)));

arg0 = argTemp0; arg1 = argTemp1;

}

return arg1;

}

private int COUNT(Nat arg0)

{

return COUNT_TAILREC(arg0, 0);

}

private int COUNT_TAILREC(Nat arg0, int arg1)

{

while (true)

{

if (arg0.hasConstructor(0)) break; Nat argTemp0 = arg0.m_fc_succ0; int argTemp1 = arg1 + 1;

arg0 = argTemp0; arg1 = argTemp1;

}

return arg1;

}

private boolean LE(Nat arg0, Nat arg1)

{

return LT(arg0, arg1) | EQ(arg0, arg1);

}

private Nat MINUS(Nat arg0, Nat arg1)

{

while (!(arg1.hasConstructor(0)))

{

Nat argTemp0 = arg0.m_fc_succ0; Nat argTemp1 = arg1.m_fc_succ0; arg0 = argTemp0;

arg1 = argTemp1;

}

return arg0;

}

private Nat PLUS(Nat arg0, Nat arg1)

{

while (!(arg1.hasConstructor(0)))

{

Nat argTemp0 = Nat.c_succ(arg0); Nat argTemp1 = arg1.m_fc_succ0; arg0 = argTemp0;

arg1 = argTemp1;

}

return arg0;

}

private boolean LT(Nat arg0, Nat arg1)

{

if (arg0.hasConstructor(0) && arg1.hasConstructor(1) )

{

return true;

}

else

{

boolean var40;

if (arg0.m_fc_succ0 == null || arg1.m_fc_succ0 == null) var40 = false;

else

var40 = LT(arg0.m_fc_succ0, arg1.m_fc_succ0); return var40;

}

}

private boolean EQ(Nat arg0, Nat arg1)

{

if (arg0.hasConstructor(0) && arg1.hasConstructor(0) )

{

return true;

}

else

{

boolean var43;

if (arg0.m_fc_succ0 == null || arg1.m_fc_succ0 == null) var43 = false;

else

var43 = EQ(arg0.m_fc_succ0, arg1.m_fc_succ0); return var43;

}

}

private static final Nat consBd2; private static final Nat consBd4; private static final Nat consBd5; static

{

consBd2 = Nat.c_null();

consBd4 = Nat.c_succ(Nat.c_succ(Nat.c_null())); consBd5 = Nat.c_succ(Nat.c_null());

}

}

class Nat

{

private int m_consName; public Nat m_fc_succ0; private Nat()

{

}

public static Nat c_null()

{

Nat var = new Nat(); var.m_consName = 0; return var;

}

public static Nat c_succ(final Nat fc_succ0)

{

Nat var = new Nat(); var.m_fc_succ0 = fc_succ0; var.m_consName = 1;

return var;

}

public boolean hasConstructor(int consName)

{

return m_consName == consName;

}

public String toString()

{

Map<Nat, String> m_res = new HashMap<Nat, String>(); Stack<Nat> m_stack = new Stack<Nat>();

m_stack.push(this); while (!m_stack.empty())

{

Nat cur = m_stack.peek(); if (cur.m_consName == 0)

{

m_stack.pop();

m_res.put(cur, "(" + ").c_null");

}

if (cur.m_consName == 1)

{

String res = m_res.get(cur.m_fc_succ0); if (res == null)

m_stack.push(cur.m_fc_succ0);

else

{

m_stack.pop();

m_res.put(cur, "(" + res + ").c_succ");

}

}

if (m_stack.empty())

return m_res.get(cur);

}

return "";

}

}

Вычисление значения N-ого числа Фибоначчи на типе данных Nat – FPTL

Functional Program fib

Data Nat

{

Constructors

{

=>Nat : c_null; Nat=>Nat : c_succ;

}

Nat = c_null ++ (Nat).c_succ;

}

Scheme fib

{

@ = CNV.F.COUNT;

F =

(id*<((c_null).c_succ).c_succ>).LE -> <(c_null).c_succ>,

(

(

(id*<(c_null).c_succ>).MINUS.F * (id*<((c_null).c_succ).c_succ>).MINUS.F

).PLUS

);

///////////////////////////////////////////////////////////////////////////

PLUS =

I(2,2).~c_null -> I(1,2),

(