%====================================================%
%                                                    %
%                 Basic programming                  %
%          A.Paoluzzi & M. Vicentino, 1997           %
%                                                    %
%====================================================%

%----------------------------------------------------%
%-- Sequence Length ---------------------------------%
%----------------------------------------------------%

DEF Length = + ~ AA:(K:1);
Length:< 84, 'ab', <>, 1, <11,12,13>>;

%----------------------------------------------------%
%-- Factorial function ------------------------------%
%----------------------------------------------------%

DEF myFact = * ~ INTSTO;
Fact:5;

DEF myFACT = IF:<C:EQ:0,k:1,FACT~-~[ID,K:1]>;
FACT:5;

%----------------------------------------------------%
%-- Cartesian product of two sets -------------------%
%----------------------------------------------------%

<1,2,3> DISTR <22,23,24,25>;
<1,2,3> DISTR <'a','b','c','d'>;
DISTL:< 1 , < 22 , 23 , 24 , 25 > >;
DISTL:< 1 , < 'a' , 'b' , 'c' , 'd' > >;
<1,2,3> (AA:DISTL ~ DISTR) <22,23,24,25>;

DEF CartMatrix=AA:DISTL ~ DISTR;

<1,2> CartMatrix <'a','b'>;
<1,2,3,4,5> CartMatrix <'a','b','c','d'>;


DEF Cart2 = CAT ~ AA:DISTL ~ DISTR;
<1,2> Cart2 <'a','b'>;
<1,2,3> Cart2 <22,23,24,25>;
<1,2,3> Cart2 <'a','b','c','d'>;

DEF CartPazz = AA:CAT ~ AA:DISTL ~ DISTR;
<1,2> CartPazz <'a','b'>;
<1,2,3> CartPazz <22,23,24,25>;
<1,2,3> CartPazz <'a','b','c','d'>;



%----------------------------------------------------%
%-- Cartesian product of any numer of sets ----------%
%----------------------------------------------------%
DEF Val=<<'a','b','c'>, <1,2,3>, <0.1,0.2,0.3>>;
Val;
DEF Val2=<<'a','b','c'>, <1,2,3>, <0.1,0.2,0.3>,<10,20,30>,<100,200,300>,<1000,2000,3000>>;
Val2;


CART2:<<'a','b','c'>, <1,2,3>>;
DEF cartm = INSL:CART2;
cartm:Val;
cartm:Val2;

DEF f2 = AA:CAT ~ cart2;

DEF cartm = INSL:f2;
cartm:Val;
cartm:Val2;

ID:3;
[ID]:3;
AA:[ID]:<1,2,3,4,5,6>;
AA:(AA:[ID]):<<1,2,3>,<4,2,1>,<3,2>>;
AA:(AA:[ID]):Val;
DEF f1 = AA:(AA:[ID]);
f1:Val;
f1:Val2;

DEF cartm = INSL:CART2 ~ f1;
cartm:Val;

DEF cartm = INSL:f2 ~ f1;
cartm:Val;

DEF cartm = INSR:f2 ~ f1;
cartm:Val;

DEF cartm = TREE:f2 ~ f1;
cartm:Val;

TREE:ID:<1,2,3,4,5>;
TREE:ID:(1..20);


%----------------------------------------------------%
%-- Power set ---------------------------------------%
%----------------------------------------------------%
CAT:<1,2,< >>;
DEF Val=<1,'a',0.1,10>;
[ID,K:<>]:1;
AA:[ID,K:<>]:Val;
(CARTM~AA:[ID,K:<>]):Val;
(CARTM~AA:[[ID],K:<>]):Val;
DEF PowerSet2 = AA:CAT ~ cartm ~ AA:[ID,K:<>];
PowerSet:Val;

%----------------------------------------------------%
%-- Chose     ---------------------------------------%
%----------------------------------------------------%

DEF GES(a,b::TT)=GE:b:a;
DEF GTS(a,b::TT)=GT:b:a;
DEF LES(a,b::TT)=LE:b:a;
DEF LTS(a,b::TT)=LT:b:a;

GES:<1,2>;
GES:<2,1>;


DEF CHOSE(n,k::IsNat)=
					      FACT:n / (FACT:k * FACT:(n - k));
CHOSE:<-5,1>;
CHOSE:<5,0>;
CHOSE:<1,1>;
CHOSE:<2,3>;
CHOSE:<6,4>;
CHOSE:<7,1>;
CHOSE:<7,7>;

DEF CHOSE(n,k::IsNat)=IF:< GES,
                            FACT~S1 / (FACT~S2 * FACT~-~[S1,S2]),
                           RAISE:[K:'CHOSE',ID]>:<n,k>;

DEF CHOSE(n::IsNat)(k::AND~[Isnat,LE:n])=
          FACT:n / (FACT:k * FACT:(n - k));
CHOSE:5:0;
CHOSE:1:1;
CHOSE:2:3;
CHOSE:6:4;
CHOSE:7:1;
CHOSE:7:7;

DEF CHOSE=FACT~S1 / (FACT~S2 * FACT~-);

DEF CHOSE=IF:< AND~[IsNat~S1,IsNat~S2,GES],
               FACT~S1 / (FACT~S2 * FACT~-~[S1,S2]),
               RAISE:[K:'CHOSE',ID]>;
CHOSE:<5,0>;
CHOSE:<1,1>;
CHOSE:<2,3>;
CHOSE:<6,4>;
CHOSE:<7,1>;
CHOSE:<7,7>;

DEF CHOSE= IF:< AND~[IsNat~S1,IsNat~S2,GES],
               CHOSEAUX,
               RAISE:[K:'CHOSE',ID]>
WHERE
	CHOSEAUX=IF:<OR~[EQ~[S1,S2],(C:EQ:0)~S2],
	             K:1,
	             CHOSEAUX~[S1 - K:1, S2 - K:1] + CHOSEAUX~[S1 - K:1, S2 ]>
END;
CHOSE:<9,0>;
CHOSE:<1,1>;
CHOSE:<2,3>;
CHOSE:<6,4>;
CHOSE:<7,1>;
CHOSE:<7,7>;

!Sbagliata!! 
!DEF CHOSE(n,k::IsNat) = 
!	IF:<EQ:<n,k> OR EQ:<k,1>,
!        1,
!	    CHOSE:<n - 1, k - 1> + CHOSE:<n - 1, k >>;



DEF CHOSE(n::NOT~ISINTNEG)(k::AND~[NOT~ISINTNEG,LE:n]) = 
	IF:<EQ,
        K:1,
	    IF:<(C:EQ:1)~S2,
	                 S1,
	                 CHOSE~[S1 - K:1, S2 - K:1] + CHOSE~[S1 - K:1, S2 ]>>:<n,k>;

CHOSE:2:0;
CHOSE:1:1;
CHOSE:2:3;
CHOSE:6:4;
CHOSE:7:1;
CHOSE:7:7;	         

DEF CHOSE= IF:< AND~[NOT~ISINTNEG~S1,NOT~ISINTNEG~S2,GES],
               CHOSEAUX,
               RAISE:[K:'CHOSE',ID]>
WHERE
	CHOSEAUX=IF:<EQ,
				 K:1,
	             IF:<(C:EQ:0)~S2,
	                 K:1,
	                 CHOSEAUX~[S1 - K:1, S2 - K:1] * S1 / S2>>
END;
CHOSE:<7,0>;
CHOSE:<1,1>;
CHOSE:<2,3>;
CHOSE:<6,4>;
CHOSE:<7,1>;
CHOSE:<7,7>;

DEF RIGATARTAGLIA(n::IsNat) = AA : (CHOSE~[K:n,ID]) : (0..n);
RIGATARTAGLIA:1;
RIGATARTAGLIA:2;
RIGATARTAGLIA:5;

DEF TARTAGLIATRI(n_max::IsIntPos) = AA:RIGATARTAGLIA:(0..n_max);
TARTAGLIATRI:10;

(AL~[K:0,ID]):(RIGATARTAGLIA:3);

TRANS:<<1,2,3>,<'a','b','c'>>;
TRANS:< < 0 , 1 , 4 , 6 , 4 , 1 > , < 1 , 4 , 6 , 4 , 1 , 0 > >;
TRANS~[AL~[K:0,ID],AR~[ID,K:0]]:(RIGATARTAGLIA:4);

DEF STEP=AA:+~TRANS~[AL~[K:0,ID],AR~[ID,K:0]];
STEP:<1>;
STEP:(RIGATARTAGLIA:0);
STEP:(RIGATARTAGLIA:1);
STEP:(RIGATARTAGLIA:2);
STEP:(RIGATARTAGLIA:3);
STEP:(RIGATARTAGLIA:4);



DEF TARTAGLIATRI(n_max::IsIntPos) = IF:<EQ~[ID,K:0],
	      							    K:<<1>>,
	      							    AL~[STEP~S1,ID]~TARTAGLIATRI>:(n_max - 1);
TARTAGLIATRI:5;

LAST:<1>;

DEF TARTAGLIATRI(n_max::IsIntPos) = IF:<EQ~[ID,K:0],
	      							    K:<<1>>,
	      							    AR~[ID,STEP~LAST]~TARTAGLIATRI>:(n_max - 1);
TARTAGLIATRI:10;
	      							  


DEF TARTAGLIATRI(n_max::IsIntPos)= COMP:(#:n_max:addrow):<<1>>
WHERE
	addrow= AR ~ [ID,STEP ~ LAST]
END;
TARTAGLIATRI:10;

DEF TARTAGLIATRI(n_max::IsIntPos)= (REVERSE ~ COMP:(#:n_max:addrow)):<<1>>
WHERE
	addrow= AL ~ [row ~ S1,ID],
	row = vectsum ~ [ID,REVERSE] ~ C:AL:0
END;
TARTAGLIATRI:10;

DEF progressiveS (input::IsSeqOf:isNum) = (fin~pipe):<input,<0>>
WHERE
	n=len:input,
	block=[TAIL~S1, AL ~ [ S1~S1 + S1~S2, S2 ]],
	pipe=(COMP ~ #:n):block,
	fin = TAIL ~ REVERSE ~ S2
END;
progressiveS:(1..10);
	
DEF block=[TAIL~S1, AL ~ [ FIRST~S1 + FIRST~S2, S2 ]];
Def Val=<1..10, <0>>;
Val;
block:Val;
(block~block):Val;