Здравствуйте, Сергей Губанов, Вы писали:
СГ>Я честно пытался писать карандашом но "не поймал кайфа", уж какой-то он затхлый. Другое дело писать чернильной ручкой. Она меня сразу зацепила. Её надо самостоятельно заправлять чернилами. Следить чтобы чернила не протекали, и чтобы по неосторожности не получилось кляксы. После написания текста чернильной ручкой, бумагу надо просушить — чернила должны высохнуть. Чернильная ручка — интересная ручка! Не то что какой-то там неинтересный карандаш. Мне интересно писать чернильной ручкой!
Сергей, а чей это (с)? Просто интересно — текст понравился
...
Здравствуйте, Vladimir V Kochetkov, Вы писали:
VVK>Сергей, а чей это (с)? Просто интересно — текст понравился
Мой. Это я так пошутил.
Здравствуйте, sch, Вы писали:
sch>P.S. Покажите пожалуйста реализацию какой-нибудь алгоритмически-сложной задачи на Обероне, будте добры. Хотя бы пузырьковую сортировку. Ей богу, очень интересно.
Быстрое дискретное преобразование Фурье подойдёт?
MODULE SignalsFFT;
IMPORT Math, SignalsMath;
CONST
Pi = SignalsMath.Pi;
chop_const = 1.0E-15;
TYPE
Complex = SignalsMath.Complex;
Array* = ARRAY OF Complex;
ReversIndex = POINTER TO RECORD
p: INTEGER;
index: POINTER TO ARRAY OF INTEGER;
next: ReversIndex
END;
Trig = POINTER TO RECORD
N: INTEGER;
cos, sin: POINTER TO ARRAY OF REAL;
next: Trig
END;
VAR
ReversIndexList: ReversIndex;
trigList, invTrigList: Trig;
PROCEDURE GetReverseIndexTable(p: INTEGER): POINTER TO ARRAY OF INTEGER;
VAR u: ReversIndex; i, n: INTEGER;
BEGIN
u := ReversIndexList;
WHILE (u # NIL) & (u.p # p) DO u := u.next END;
IF u = NIL THEN
NEW(u); NEW(u.index, p); u.p := p;
n := SignalsMath.Log(2*p - 1);
FOR i := 0 TO p-1 DO u.index[i] := ORD( SignalsMath.Reverse(BITS(i), n) ) END;
u.next := ReversIndexList; ReversIndexList := u
END;
RETURN u.index
END GetReverseIndexTable;
PROCEDURE BitReverseCopy (IN input: Array; OUT output: Array);
VAR i, j, p: INTEGER; a,b: Complex; index: POINTER TO ARRAY OF INTEGER;
BEGIN p := LEN(input) DIV 2;
index := GetReverseIndexTable(p);
FOR i := 0 TO p-1 DO
j := index[i]; a := input[i]; b := input[i+p];
output[j].re := a.re + b.re; output[j].im := a.im + b.im;
output[j+1].re := a.re - b.re; output[j+1].im := a.im - b.im;
END
END BitReverseCopy;
PROCEDURE fft4 (direction: BOOLEAN; VAR val: Array);
VAR i0, i1, i2, i3, N: INTEGER; z0, z1, z2, z3: Complex;
BEGIN N := LEN(val); i0 := 0; i1 := 1; i2 := 2; i3 := 3;
IF direction THEN
WHILE i3 < N DO
z0 := val[i0]; z1 := val[i1]; z2 := val[i2]; z3 := val[i3];
val[i0].re := z0.re + z2.re; val[i0].im := z0.im + z2.im;
val[i1].re := z1.re - z3.im; val[i1].im := z1.im + z3.re;
val[i2].re := z0.re - z2.re; val[i2].im := z0.im - z2.im;
val[i3].re := z1.re + z3.im; val[i3].im := z1.im - z3.re;
INC(i0, 4); INC(i1, 4); INC(i2, 4); INC(i3, 4);
END
ELSE
WHILE i3 < N DO
z0 := val[i0]; z1 := val[i1]; z2 := val[i2]; z3 := val[i3];
val[i0].re := z0.re + z2.re; val[i0].im := z0.im + z2.im;
val[i1].re := z1.re + z3.im; val[i1].im := z1.im - z3.re;
val[i2].re := z0.re - z2.re; val[i2].im := z0.im - z2.im;
val[i3].re := z1.re - z3.im; val[i3].im := z1.im + z3.re;
INC(i0, 4); INC(i1, 4); INC(i2, 4); INC(i3, 4);
END
END
END fft4;
PROCEDURE GetCosSin(direction: BOOLEAN; N: INTEGER; OUT cos, sin: POINTER TO ARRAY OF REAL);
VAR n: INTEGER; coeff: REAL; u: Trig;
BEGIN
N := N DIV 2;
IF direction THEN u := trigList ELSE u := invTrigList END;
WHILE (u # NIL) & (u.N # N) DO u := u.next END;
IF u = NIL THEN
IF direction THEN coeff := Pi / N ELSE coeff := - Pi / N END;
NEW(cos, N); NEW(sin, N);
FOR n := 0 TO N-1 DO cos[n] := Math.Cos(coeff*n); sin[n] := Math.Sin(coeff*n) END;
NEW(u); u.N := N; u.cos := cos; u.sin := sin;
IF direction THEN u.next := trigList; trigList := u ELSE u.next := invTrigList; invTrigList := u END;
ELSE
cos := u.cos; sin := u.sin
END
END GetCosSin;
PROCEDURE Mult(VAR array: Array; multiplier: REAL);
VAR i: INTEGER;
BEGIN
FOR i := 0 TO LEN(array)-1 DO
array[i].re := array[i].re * multiplier;
array[i].im := array[i].im * multiplier;
END
END Mult;
PROCEDURE Check(IN input: Array; OUT output: Array);
VAR N: INTEGER;
BEGIN N := LEN(input);
ASSERT(SignalsMath.IsPower2(N), 20);
ASSERT(LEN(output) = N, 21);
END Check;
PROCEDURE FFT (direction: BOOLEAN; IN input: Array; OUT output: Array);
VAR np, d, n, k, m, p2, p, N, f: INTEGER; a, b, t: Complex; cos, sin: REAL;
Cos, Sin: POINTER TO ARRAY OF REAL;
BEGIN
Check(input, output);
N := LEN(input);
BitReverseCopy(input, output);
fft4(direction, output);
GetCosSin(direction, N, Cos, Sin);
p := 4;
WHILE p < N DO
p2 := 2*p; m := 0; d := N DIV p2;
WHILE m < N DO
f := 0;
FOR k := 0 TO p-1 DO
n := m + k; a := output[n]; np := n+p; t := output[np];
cos := Cos[f]; sin := Sin[f]; INC(f, d);
b.re := cos*t.re - sin*t.im; b.im := sin*t.re + cos*t.im;
output[n].re := a.re + b.re; output[n].im := a.im + b.im;
output[np].re := a.re - b.re; output[np].im := a.im - b.im;
END;
INC(m, p2);
END;
p := p2;
END;
Mult(output, 1.0/Math.Sqrt(N))
END FFT;
PROCEDURE Direct* (IN signal: Array; OUT spectrum: Array);
BEGIN FFT(TRUE, signal, spectrum)
END Direct;
PROCEDURE Inverse* (IN spectrum: Array; OUT signal: Array);
BEGIN FFT(FALSE, spectrum, signal)
END Inverse;
END SignalsFFT.
MODULE SignalsMath;
CONST
Pi* = 3.1415926535897932384626433832795028841971693;
Epsilon* = 1.0E-15;
TYPE
Complex* = RECORD
re*, im*: REAL
END;
PROCEDURE ChopReal* (VAR x: REAL);
BEGIN
IF ABS(x) <= Epsilon THEN x := 0.0 END
END ChopReal;
PROCEDURE ChopComplex* (VAR z: Complex);
BEGIN
IF ABS(z.re) <= Epsilon THEN z.re := 0.0 END;
IF ABS(z.im) <= Epsilon THEN z.im := 0.0 END
END ChopComplex;
PROCEDURE ChopComplexArray* (VAR z: ARRAY OF Complex);
VAR n: INTEGER;
BEGIN
FOR n := 0 TO LEN(z)-1 DO
IF ABS(z[n].re) <= Epsilon THEN z[n].re := 0.0 END;
IF ABS(z[n].im) <= Epsilon THEN z[n].im := 0.0 END
END
END ChopComplexArray;
PROCEDURE Log* (n: INTEGER): INTEGER;
VAR i, r: INTEGER;
BEGIN r := 0; WHILE n > 0 DO n := ASH(n, -1); INC(r) END; RETURN r
END Log;
PROCEDURE IsPower2* (N: INTEGER): BOOLEAN;
VAR i, n: INTEGER; s: SET;
BEGIN s := BITS(N); n := 0;
FOR i := 0 TO 31 DO
IF i IN s THEN INC(n) END
END;
RETURN n = 1
END IsPower2;
PROCEDURE RoundToPower2* (N: INTEGER): INTEGER;
BEGIN
RETURN ASH(1, Log(N))
END RoundToPower2;
PROCEDURE Reverse* (s: SET; Count: INTEGER): SET;
VAR i: INTEGER; r: SET;
BEGIN r := {}; DEC(Count);
FOR i := 0 TO Count DO
IF i IN s THEN INCL(r, Count - i) END
END; RETURN r
END Reverse;
END SignalsMath.
Здравствуйте, Сергей Губанов, Вы писали:
СГ>Здравствуйте, sch, Вы писали:
sch>>P.S. Покажите пожалуйста реализацию какой-нибудь алгоритмически-сложной задачи на Обероне, будте добры. Хотя бы пузырьковую сортировку. Ей богу, очень интересно.
СГ>Быстрое дискретное преобразование Фурье подойдёт?
Не флейма ради, а перфоманс тест можно, по сравнению с скажем Intell Performance Primitives и с той же ралазизацией на плюсах в лоб портированой, просто интрересно насколько качественный код генерит компилятор Оберона.
... << RSDN@Home 1.1.4 beta 7 rev. 447>>
Здравствуйте, IO, Вы писали:
IO>Здравствуйте, Сергей Губанов, Вы писали:
СГ>>Здравствуйте!
СГ>>Теперь у оберонщиков, наконец-то, появилась своя "песочница":
СГ>>http://metasystems.ru/blackbox/frm/
СГ>>С уважением,
СГ>>Сергей Губанов
IO>А почему было им не выделить здесь отдельную песочницу?
Дык в чём проблема, если наберётся их критическая маса, будут експерты желающие модерировать и в первое время отвечать на ответы.
Но тогда и я по Python-у хочу, думаю нас даже побольше оберонщиков наберётся.
... << RSDN@Home 1.1.4 beta 7 rev. 447>>
