Другое: Задания по FPTL
Описание
Характеристики учебной работы
Список файлов
- Задания по FPTL
- FPTL Release
- Doc
- JCSSI 6-2005 rus.pdf 198,56 Kb
- PCS 5-2005 rus.ps 7,02 Mb
- Examples
- FFT.txt 2,04 Kb
- Fibonacci.txt 226 b
- Integral.txt 636 b
- Parser.txt 1,09 Kb
- Sort.txt 1,04 Kb
- Tokenizer.txt 369 b
- Tree.txt 657 b
- Readme.docx 18,82 Kb
- Runtime.exe 477,5 Kb
- msvcp100.dll 411,33 Kb
- msvcr100.dll 750,83 Kb
Data List['t]
{
List = c_nil ++ 't * List['t].c_cons;
}
Data Complex
{
Complex = double * double.c_complex;
}
Scheme Fact
{
@ = id.GenSinSignal.FFT;
// Быстрое преобразование Фурье. Входные данные A - список вещественных чисел, длина - степень двойки.
Fun FFT
{
@ = (N * 1).equal -> id,
(OddCoeff.FFT * EvenCoeff.FFT * W * Wn).(Form(Op1, CompMul) * Form(Op2, CompMul)).Concat;
EvenCoeff =
~c_nil -> c_nil,
~c_cons.[2].~c_nil -> c_nil,
~c_cons.[2].~c_cons.([1] * [2].EvenCoeff).c_cons;
OddCoeff =
~c_nil -> c_nil,
~c_cons.[2].~c_nil -> ~c_cons.[1],
~c_cons.([1] * [2].~c_cons.[2].OddCoeff).c_cons;
N = id.Length;
Wn = (0.0 * ((2.0 * 3.141592).mul * N).div).c_complex.CompExp;
W = (1.0 * 0.0).c_complex;
// Входные данные EvenCoeff, OddCoeff, W, Wn
Fun Form[aOperation, aMul]
{
@ = [1].~c_nil -> c_nil,
((Ec * Oc * W).aOperation * ([1].~c_cons.[2] * [2].~c_cons.[2] * NewW * Wn).Form).c_cons;
Ec = [1].~c_cons.[1];
Oc = [2].~c_cons.[1];
W = [3];
Wn = [4];
NewW = (W * Wn).aMul;
}
CompAdd = (([1].Real * [2].Real).add * ([1].Im * [2].Im).add).c_complex;
CompSub = (([1].Real * [2].Real).sub * ([1].Im * [2].Im).sub).c_complex;
CompMul = ( (([1].Real*[2].Real).mul*([1].Im*[2].Im) .mul).sub * (([1].Im*[2].Real).mul * ([1].Real*[2].Im).mul).add).c_complex;
CompExp = ((Real.exp * Im.cos).mul * (Real.exp * Im.sin).mul).c_complex;
Real = ~c_complex.[1];
Im = ~c_complex.[2];
Op1 = ([1] * ([2] * [3]).CompMul).CompAdd;
Op2 = ([1] * ([2] * [3]).CompMul).CompSub;
Length = ~c_nil -> 0, (~c_cons.[2].Length * 1).add;
Concat = [1].~c_nil -> [2],
[2].~c_nil -> [1],
([1].~c_cons.[1] * ([1].~c_cons.[2]*[2]).Concat).c_cons;
}
Fun GenSignal[Generator]
{
@ = (id * 0).equal -> c_nil,
(id.Generator * (id * 1).sub.GenSignal).c_cons;
}
SinSignal = ((id * 1024.0).div * 3.141592).mul.(id * sin).c_complex;
GenSinSignal = GenSignal(SinSignal);
}
Application
% Fact(8192)
Scheme Fibonacci
{
Fib = ([1] * 0).equal -> 1,
([1] * 1).equal -> 1,
((([1] * 2).sub.Fib * ([1] * 1).sub.Fib).add);
@ = Fib.print;
}
Application
% Fibonacci(37)
Scheme Test
{
@ = (0.0 * 30.0 * 0.00001).Integrate(TestFunc);
TestFunc = (((((id*id).mul*id).mul * 0.5).mul.sin * ((id*id).mul * 0.25).mul.sin).mul * (id * 0.125).mul.sin).mul;
// Параметра A*B*Eps - границы отрезка интегрирования и точность.
Fun Integrate[fFunction]
{
@ = (((([1] * Mid).Trp * (Mid * [2]).Trp).add * ([1] * [2]).Trp).sub.abs * [3]).less ->
([1] * [2]).Trp,
((([1] * Mid * ([3] * 2.0).div).@ * (Mid * [2] * ([3] * 2.0).div).@).add);
Mid = (([1] * [2]).add * 2.0).div;
Trp = ((([2] * [1]).sub * ([2].fFunction * [1].fFunction).add).mul * 2.0).div;
}
}
Application
% Test
Data Attr {
Attr = string * string.c_attr;
}
Data AttrList {
AttrList = c_nil ++ Attr * AttrList.c_attrList;
}
Data Tag {
AST = string * AttrList.c_tag;
}
Scheme Parser {
@ = id.Tag.print;
Tag = Seq(Token("<"), Seq(Ident, Seq(AttrList, Token(">"), Action0), Action1), Action2);
Action0 = [1];
Action1 = ([1]*[2]).c_tag;
Action2 = [2];
AttrList = Or(SingleAttr, AttrAttrList);
SingleAttr = Attr.(id -> [1]*([2]*c_nil).c_attrList);
AttrAttrList = Seq(Attr, AttrList, Action4);
Action4 = ([1]*[2]).c_attrList;
Attr = Seq(Ident, Seq(Token("="), StringValue, Action5), Action6);
Action5 = [2];
Action6 = ([1]*[2]).c_attr;
StringValue = Token("\"[^\"]*\"");
Ident = Token("[a-zA-Z][0-9A-Za-z]*");
Fun Seq[Op1, Op2, Action] {
@ = Op1.(id -> ([2]*[1].Op2).(id -> ([2]*([1]*[3]).Action)));
}
Fun Or[Op1, Op2] {
@ = Op1 -> (Op2 -> (Op1*Op2).(([1].length * [3].length).less -> [1]*[2], [3]*[4]), Op1), Op2;
}
Fun Token[ch] {
@ = ([1]*ch).getToken.([2]*[1]);
}
}
Application
% Parser(" <tagName attr1=\"1\" attr2=\"2\" attr3=\"3\"> ")
Data List['t]
{
List = c_nil ++ 't * List['t].c_cons;
}
Scheme Fact
{
@ = 60000.RandomList(-999999,999999).QSort;
Fun RandomList[Max, Min]
{
@ = (id * 0).equal -> c_nil,
((Min * (rand * (Max * Min).sub).mul).add * (id * 1).sub.RandomList).c_cons;
}
Fun QSort
{
@ = ~c_nil -> c_nil,
(((id*Pivot).Filter(less).QSort * (id*Pivot).Filter(equal)).Concat * (id*Pivot).Filter(greater).QSort).Concat ;
Fun Filter[fPredicate]
{
@ = [1].~c_nil -> c_nil,
[1].~c_cons -> Args.(([1]*[3]).fPredicate -> ([1] * ([2]*[3]).Filter).c_cons, ([2]*[3]).Filter);
Args = [1].~c_cons * [2];
}
// Возвращает опорный элемент (первый в списке).
Pivot = id.~c_cons.[1];
Concat = [1].~c_nil -> [2],
[2].~c_nil -> [1],
([1].~c_cons.[1] * ([1].~c_cons.[2]*[2]).Concat).c_cons;
}
}
Application
% Fact
Data List['t]
{
List = c_nil ++ 't * List['t].c_cons;
}
Scheme Tokenize
{
// Разбиение строки на лексемы с последующим формированием списка лексем.
DoTokenize = (([1] * "([\\w]+)[\\s]+([\\w|\\s]*)").match * [1]).(id -> ([1]*[2].DoTokenize).c_cons, ([3]*c_nil).c_cons);
@ = id.DoTokenize.print;
}
Application
% Tokenize("f a b ccc ddd ee f gg")
// Вставка элемента в бинарное дерево поиска (без ребалансировки).
Data Tree['t]
{
Tree = c_leaf ++ Tree['t] * 't * Tree['t].c_node;
}
Scheme BinaryTree
{
// Elem * Tree -> Tree
Fun TreeInsert
{
@ = [2].~c_leaf -> (c_leaf * [1] * c_leaf).c_node,
[2].~c_node -> (([1]*[2].~c_node.[2]).less ->
(([1]*[2].~c_node.[1]).TreeInsert * [2].~c_node.([2]*[3])).c_node,
([2].~c_node.([1]*[2])*([1]*[2].~c_node. [3]).TreeInsert).c_node);
}
@ = (0*(9*(6*(1*(7*(3*(5*c_leaf).TreeInsert) .TreeInsert).TreeInsert).TreeInsert).Tre eInsert).TreeInsert).TreeInsert.print;
}
Application
% BinaryTree
Начать зарабатывать