Занадто швидкий, занадто фур'є: Код FFT Golf


48

Реалізуйте Швидке перетворення Фур'є у найменших можливих символах.

Правила:

  • Найкоротше рішення виграє
  • Можна припустити, що вхід - це 1D масив, довжина якого - потужність двох.
  • Ви можете використовувати алгоритм, обраний вами, але рішення має бути фактично швидким перетворенням Фур'є, а не лише наївним дискретним перетворенням Фур'є (тобто воно повинно мати асимптотичну обчислювальну вартість )O(NlogN)

Редагувати:

  • код повинен реалізовувати стандартну швидку швидку перетворення Фур'є, форму якої можна побачити в рівнянні (3) цієї статті Вольфрама ,

    введіть тут опис зображення

  • Використання функції FFT з попередньо існуючої стандартної бібліотеки або пакету статистики заборонено. Завдання полягає в тому, щоб швидко реалізувати сам алгоритм FFT.

3
Це не визначено. По крайней мере, вам потрібно визначити фактори нормалізації, і ви також повинні знати, що будь-яка неоднозначність буде навмисно витлумачена. Наприклад, "Реалізація" задоволена відповіддю " FFT(3 символи): це в стандартній бібліотеці"? Деякі тестові випадки теж були б непоганими.
Пітер Тейлор

Чи важливо це щодо порядку вихідних елементів, тобто чи потрібно реалізовувати біт, перевернутий розбортування, чи ми можемо залишити вихід у зашифрованому порядку?
Пол Р.

Див. Правки до правил. Вихід повинен бути списком / масивом зі значеннями, упорядкованими відповідно до індексів у стандартному вираженні DFT, на яке посилалося вище.
jakevdp

2
Чи можете ви розмістити деякі приклади входів і виходів, щоб ми могли перевірити наші реалізації?
FUZxxl

2
Заголовок повинен був бути "Швидкий і Фур'є" (Швидкий і лютий).
клісмік

Відповіді:


12

Математика, 95 байт

Ще одна реалізація FFT Cooley – Tukey за допомогою @ chyaong .

{n=Length@#}~With~If[n>1,Join[+##,#-#2]&[#0@#[[;;;;2]],#0@#[[2;;;;2]]I^Array[-4#/n&,n/2,0]],#]&

Безумовно

FFT[x_] := With[{N = Length[x]},
  If[N > 1,
    With[{a = FFT[ x[[1 ;; N ;; 2]] ], 
          b = FFT[ x[[2 ;; N ;; 2]] ] * Table[E^(-2*I*Pi*k/N), {k, 0, N/2 - 1}]},
      Join[a + b, a - b]],
    x]]

1
Я думаю #[[;;;;2]]==#[[1;;N;;2]]і [[2;;;;2]]==[[2;;N;;2]].
chyanog

1
101 символ:With[{L=Length@#},If[L>1,Join[+##,#-#2]&[#0@#[[;;;;2]],#0@#[[2;;;;2]]E^(-2I*Pi(Range[L/2]-1)/L)],#]]&
chyanog

Приємно, ви можете конденсувати ще одну анонімну функцію всередині неї, не конфліктуючи з рекурсивною. Також дізнався, що Частина заповнює пропущені індекси. Ми можемо взяти його далі за допомогою Unicode.
милі

9

J, 37 байт

_2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#

Поліпшення через кілька років. Ще використовується алгоритм FFT Cooley-Tukey.

Збережено 4 байти за допомогою e πi = -1, завдяки @ Leaky Nun .

Спробуйте в Інтернеті!

Використання

   f =: _2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#
   f 1 1 1 1
4 0 0 0
   f 1 2 3 4
10 _2j2 _2 _2j_2
   f 5.24626 3.90746 3.72335 5.74429 4.7983 8.34171 4.46785 0.760139
36.9894 _6.21186j0.355661 1.85336j_5.74474 7.10778j_1.13334 _0.517839 7.10778j1.13334 1.85336j5.74474 _6.21186j_0.355661

Пояснення

_2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#  Input: array A
                                    #  Length
                                  1<   Greater than one?
_2&(                            )~     Execute this if true, else return A
_2                            ]\         Get non-overlapping sublists of size 2
    0                       |:           Move axis 0 to the end, equivalent to transpose
                          /@             Reduce [even-indexed, odd-indexed]
                       &$:               Call recursively on each 
                   #                     Get the length of the odd list
                i.@                      Range from 0 to that length exclusive
                    %#                   Divide each by the odd length
             _1^                         Compute (-1)^x for each x
           ]                             Get the odd list
            %                            Divide each in that by the previous
       +                                 Add the even values and modified odd values
         -                               Subtract the even values and modified odd values
        ,                                Join the two lists and return

1
Дивіться також це: blog.ndpar.com/2014/10/11/dft-j
FUZxxl

9

Пітон, 166 151 150 символів

Для цього використовується алгоритм FFT Radi-2 Cooley-Tukey

from math import*
def F(x):N=len(x);t=N<2or(F(x[::2]),F(x[1::2]));return N<2and x or[
a+s*b/e**(2j*pi*n/N)for s in[1,-1]for(n,a,b)in zip(range(N),*t)]

Тестування результату

>>> import numpy as np
>>> x = np.random.random(512)
>>> np.allclose(F(x), np.fft.fft(x))
True

1
2 речі: зазвичай найкраще використовувати from x import*та sum(([x for x in y] for y in z),[])довше, ніж [x for y in z for x in y].
кабінка

1
Спасибі - це економить 15 символів! Ще 11, і це твіт.
jakevdp

О, це однозначно можливо. Часто коли ви знайдете одне поліпшення, старе стає каменем спотикання.
виставка

5

Пітон 3: 140 134 113 символів

Коротка версія - коротка і солодка, вписується в твіт (з подякою миль ):

from math import*
def f(v):
 n=len(v)
 if n<2:return v
 a,b=f(v[::2])*2,f(v[1::2])*2;return[a[i]+b[i]/1j**(i*4/n)for i in range(n)]

(У Python 2 - /це обрізний поділ, коли обидві сторони є цілими числами. Отже, ми замінюємо (i*4/n)їх (i*4.0/n), який стикає довжину до 115 символів.)

Довга версія - більше чіткості у внутрішніх умовах класичного FFT Cooley-Tukey:

import cmath
def transform_radix2(vector):
    n = len(vector)
    if n <= 1:  # Base case
        return vector
    elif n % 2 != 0:
        raise ValueError("Length is not a power of 2")
    else:
        k = n // 2
        even = transform_radix2(vector[0 : : 2])
        odd  = transform_radix2(vector[1 : : 2])
        return [even[i % k] + odd[i % k] * cmath.exp(i * -2j * cmath.pi / n) for i in range(n)]

1
Скорочений до 113 байт з використаннямe^(-2j * pi * i / n) = (-1)^(2 * i / n) = (1j)^(4 * i / n)
миль

@miles Дуже вражаюче спостереження, дякую! Неодноразово впроваджуючи DFT протягом більше десятиліття, я одержимий sin / cos / exp і забув, що можна використовувати прості повноваження i. Я відредагував свою відповідь, щоб включити нове розуміння і зачитати вас.
Наюкі

5

R: 142 133 99 95 байт

Дякуємо @Giuseppe за те, що він допомагав мені голити 32 36 байт!

f=function(x,n=sum(x|1),y=1:(n/2)*2)`if`(n>1,f(x[-y])+c(b<-f(x[y]),-b)*exp(-2i*(y/2-1)*pi/n),x)

Додатковий трюк тут полягає у використанні аргументів основної функції за замовчуванням для інстанціювання деяких змінних.
Використання все одно таке:

x = c(1,1,1,1)
f(x)
[1] 4+0i 0+0i 0+0i 0+0i

4-річна версія в 133 байтах:

f=function(x){n=length(x);if(n>1){a=Recall(x[seq(1,n,2)]);b=Recall(x[seq(2,n,2)]);t=exp(-2i*(1:(n/2)-1)*pi/n);c(a+b*t,a-b*t)}else{x}}

З відступами:

f=function(x){
    n=length(x)
    if(n>1){
        a=Recall(x[seq(1,n,2)])
        b=Recall(x[seq(2,n,2)])
        t=exp(-2i*(1:(n/2)-1)*pi/n)
        c(a+b*t,a-b*t)
        }else{x}
    }

Він також використовує алгоритм Cooley-Tukey. Єдиними хитрощами є використання функції, Recallяка дозволяє рекурсивність та використання векторизації R, що значно скорочує фактичні обчислення.

Використання:

x = c(1,1,1,1)
f(x)
[1] 4+0i 0+0i 0+0i 0+0i

1
Через чотири роки, і ми знижуємо його до 101 байта . Не на 100% впевнений, чому ви вже використовували Recallяк названу функцію, але ей, гольф легко заднім ходом! :) +1, дуже приємно.
Джузеппе

Так Recall, тепер справді непотрібно. Я помітив, що кілька місяців тому, але був лінивий, щоб змінити його :) Я його модифікую.
планнапус

Дуже хороша! Я вичавив ще 4 байти! , що ставить це нарівні з Mathematica.
Джузеппе

Дякую! Я думав про те, щоб поставити yтам, але не помітив, що це може бути також корисним для exp(...)частини.
планнапус

4

Пітона, 134

Це значною мірою запозичує рішення jakevdp, тому я встановив цю вікі для спільноти.

from math import*
F=lambda x:x*(len(x)<2)or[a+s*b/e**(2j*pi*n/len(x))for s in(1,-1)for n,(a,b)in
enumerate(zip(F(x[::2]),F(x[1::2])))]

Зміни:

-12 знаків: вбити t.

def F(x):N=len(x);t=N<2or(F(x[::2]),F(x[1::2]));return ... in zip(range(N),*t)]
def F(x):N=len(x);return ... in zip(range(N),F(x[::2]),F(x[1::2]))]

-1 char: показник трюку, x*y**-z == x/y**z (це може допомогти деяким іншим)

...[a+s*b*e**(-2j*pi*n/N)...
...[a+s*b/e**(2j*pi*n/N)...

-2 char: замінити andна*

...return N<2and x or[
...return x*(N<2)or[

+1 char: lambdaize, вбивствоN

def F(x):N=len(x);return x*(N<2)or[a+s*b/e**(2j*pi*n/N) ... zip(range(N) ...
F=lambda x:x*(len(x)<2)or[a+s*b/e**(2j*pi*n/len(x)) ... zip(range(len(x)) ...

-2 char: використовувати enumerateзамістьzip(range(len(

...for(n,a,b)in zip(range(len(x)),F(x[::2]),F(x[1::2]))]
...for n,(a,b)in enumerate(zip(F(x[::2]),F(x[1::2])))]

Я думаю, що це вже не швидка трансформація фур'є, хоча ... "вбивство t" ви додали в деякі непотрібні обчислення, які переміщують його з O [N log (N)] в O [N ^ 2]
jakevdp

Здається, я не можу подати заявку на власне повідомлення. Ви маєте рацію, я обмінявся циклом замовлення і вбив виконання. Я покину це питання поки що, якщо знайду спосіб виправити це.
кабінка

101 байт зf=lambda x:x*(len(x)<2)or[u+v/1j**(4*i/len(x))for i,(u,v)in enumerate(zip(f(x[::2])*2,f(x[1::2])*2))]
миль

Ви можете замінити for s in(1,-1)forз for s in 1,-1forабо навіть, якщо порядок не має значення, for s in-1,1for.
Джонатан Фрех

4

С, 259

typedef double complex cplx;
void fft(cplx buf[],cplx out[],int n,int step){
if(step < n){
fft(out, buf,n, step * 2);
fft(out+step,buf+step,n,step*2);
for(int i=0;i<n;i+=2*step){
cplx t=cexp(-I*M_PI*i/n)*out[i+step];
buf[i/2]=out[i]+t;
buf[(i+n)/2]=out[i]-t;
}}}

Проблема полягає в тому, що такі реалізації марні, а прямий алгоритм МНОГО швидше.


2
Ви можете видалити ще кілька пробілів, щоб отримати менший проміжок символів, наприклад, step < nможна змінити step<nі step * 2змінити на step*2.
ProgramFOX

2
всі змінні та функції та typedefs повинні мати

2
У вас хтось запропонував купу вдосконалень для цього. Подивіться на них тут: codegolf.stackexchange.com/review/sugges-edits/17119
Джастін

1
Ви можете видалити всі нові рядки, нові рядки марні в C
TuxCrafting

@ TùxCräftîñg Не всі новинки є марними. Вони потрібні для таких директив, як #include, #define, #if тощо
Nayuki

3

Матлаб, 128 118 107 102 101 94 93 байт

EDIT6: дякую @algmyr за ще один байт!

function Y=f(Y);
n=numel(Y);
k=2:2:n;
if k;
   c=f(Y(k-1));
   d=f(Y(k)).*i.^(2*(2-k)/n);
   Y=[c+d;c-d];
end

EDIT5: Ще коротше :) завдяки @sanchises

function Y=f(Y)
n=numel(Y);
k=2:2:n;
if k;
   c=f(Y(k-1));
   d=f(Y(k)).*(-1).^((2-k)/n);
   Y=[c+d;c-d];
end

EDIT4: Так, на -1 символ більше (можна було б і без цього k):

function Y=f(Y)
n=numel(Y);
if n>1;
   k=2:2:n;
   c=f(Y(k-1));
   d=f(Y(k)).*(-1).^((k/2-1)*2/n)';
   Y=[c+d;c-d];
end

EDIT2 / 3: Дякуємо @sanchises за подальші вдосконалення!

function Y=f(Y)
n=numel(Y);  
if n>1;
   c=f(Y(1:2:n));
   d=f(Y(2:2:n)).*(-1).^(-(0:n/2-1)*2/n).';
   Y=[c+d;c-d]; 
end

EDIT: Можна було вдосконалити, і помітили, що константа масштабування не потрібна.

Це розширена версія, кількість символів дійсна, якщо ви видалите нові рядки / пробіли. (Працює лише для векторів стовпців.)

function y=f(Y)
n=numel(Y);  
y=Y;
if n>1;
   c=f(Y(1:2:n));
   d=f(Y(2:2:n));
   n=n/2;
   d=d.*exp(-pi*i*(0:n-1)/n).';
   y=[c+d;c-d]; 
end

Порада: Ви можете об'єднати дві d=рядки в одну: m=n/2;d=f(Y(2:2:n)).*exp(-pi*i*(0:m-1)/m).';. Крім того, подумайте про те, y=f(Y)щоб змінити Y=f(Y)та видалити рядок 3 (і обіцяйте, що ви ніколи цього не зробите поза кодом-гольфу)
Sanchises

О, дякую! Чи function Y = f(Y)є якісь недоліки, окрім нечитабельності?
недолік

Ну, MATLAB ніколи не скаржиться на значення повернення, навіть якщо Y ніколи не змінюється. Хоча це трохи швидше, тому я думаю, що це не так вже й погано для деяких цілей (тобто функція, яка майже ніколи не змінює вхідну змінну)
Sanchises

Тепер, голять більше: m=n/2може бути видалений, і замість того, щоб mзамінити на n/2і n*2відповідно. І тоді, я переконаний, програма така коротка, як це могло бути в MATLAB.
Санчіз

1
І тоді, я переконаний, програма така коротка, як це могло бути в MATLAB. - Санчіз 8 березня 15.15 о 21:05 Знамениті останні слова ...
Санчіз

2

Желе, 31 30 28 26 байт , не конкуруючий

LḶ÷$N-*×,N$+ḷF
s2Z߀ç/µ¹Ṗ?

Желе було створено після цього виклику, тому воно є неконкурентним.

Для цього використовується рекурсивний алгоритм Cooley-Tukey radix-2. Щодо версії без гольфу, дивіться мою відповідь у Mathematica.

Спробуйте в Інтернеті або Перевірте кілька тестових випадків .

Пояснення

LḶ÷$N-*×,N$+ḷF  Helper link. Input: lists A and B
L               Get the length of A
   $            Operate on that length
 Ḷ                Make a range [0, 1, ..., length-1]
  ÷               Divide each by length
    N           Negate each
     -          The constant -1
      *         Compute -1^(x) for each x in that range
       ×        Multiply elementwise between that range and B, call it B'  
          $     Operate on that B'
         N        Negate each
        ,         Make a list [B', -B']
            ḷ   Get A
           +    Add vectorized, [B', -B'] + A = [A+B', A-B']
             F  Flatten that and return

s2Z߀ç/µ¹Ṗ?  Main link. Input: list X
         Ṗ   Curtail - Make a copy of X with the last value removed
          ?  If that list is truthy (empty lists are falsey)
       µ       Parse to the left as a monad
s2             Split X into sublists of length 2
  Z            Transpose them to get [even-index, odd-index]
   ߀          Call the main link recursively on each sublist
     ç/        Call the helper link as a dyad on the sublists and return
             Else
        ¹      Identity function on X and return

2

C (gcc) , 188 186 184 183 байт

#define d(a,b,c)f(a,b,c,1,0)
f(a,b,c,n,k)_Complex*a,*b;{_Complex z[c];*b=*a;if(n<c)for(f(a,z,c,n*2),f(a+n,z+n,c,n*2);k<c;k+=n*2)b[k+c>>1]=z[k]*2-(b[k/2]=z[k]+z[k+n]/cpow(1i,2.*k/c));}

Спробуйте в Інтернеті!

Трохи гольф менше

#define d(a,b,c)f(a,b,c,1,0)
f(a,b,c,n,k)_Complex*a,*b;{
  _Complex z[c];
  *b=*a;
  if(n<c)
    for(f(a,z,c,n*2),f(a+n,z+n,c,n*2);k<c;k+=n*2)
      b[k+c>>1]=z[k]*2-(b[k/2]=z[k]+z[k+n]/cpow(1i,2.*k/c));
}

1

Пари / GP, 76 символів

X(v)=my(t=-2*Pi*I/#v,s);vector(#v,k,s=t*(k-1);sum(n=0,#v-1,v[n+1]*exp(s*n)))

Використання

X([1,1,1,1])
%2 = [4.000000000000000000000000000, 0.E-27 + 0.E-28*I, 0.E-28 + 0.E-27*I, 0.E-27 + 0.E-28*I]

3
Хіба це не наївний DFT? (тобто тета (N ^ 2))
милі

1

Октава , 109 103 101 100 байт

f(f=@(f)@(x,n=rows(x)){@(d=f(f)(x(k=2:2:n)).*i.^((k*2-4)/n)')[d+(c=f(f)(x(k-1)));c-d],x}{1+(n<2)}())

Спробуйте в Інтернеті!

Оооо, чи мої очі кровоточать від цієї рекурсивної проклятої лямбда. Значна частина цього питання була знята з відповіді @ flawr.

f(                                          % lambda function
  f=@(f)                                    % defined in its own argument list, 
                                            % accepts itself as parameter (for recursion)
    @(x,n=rows(x)){                         % calls another lambda,
                                            % 2nd parameter is just to define a variable
      @(d=f(f)(x(k=2:2:n)).*i.^((k*2-4)/n)')% 1/4 of FFT (argument just defines a variable)
        [d+(c=f(f)(x(k-1)));                % 2/4 of FFT
         c-d                                % 4/4 of FFT
        ],                                  % This is in a @()[] to inhibit evaluation
                                            % unless actually called
      x                                     % FFT of length 1
    }{1+(n<2)}                              % if len(x)==1, return x
                                            % else return [d+c;c-d]
  ()                                        % this is probably important too
)

Я не розумію, що ти робив, але мені це дуже подобається.
недолік

0

Аксіома, 259 , 193 , 181 , 179 байт

L(g,n,f)==>[g for i in 1..n|f]
h(a)==(n:=#a;n=1=>a;c:=h(L(a.i,n,odd? i));d:=h(L(a.i,n,even? i));n:=n/2;t:=1>0;v:=L(d.i*%i^(-2*(i-1)/n),n,t);append(L(c.i+v.i,n,t),L(c.i-v.i,n,t)))

Навіть якщо h (a) міг би пройти весь тест і було б нормально як запис для цього 'змагання', потрібно перевірити аргументи h () або hlp () через fft () нижче, щоб перевірити аргументи . Я не знаю, чи може це програмне забезпечення гаразд, тому що я бачив лише те, що писав інший, і шукаю спосіб, яким він міг би працювати в Аксіомі, щоб повернути якийсь можливий правильний результат. Нижче невпізнаний код з кількома коментарями:

-- L(g,n,f)==>[g for i in 1..n|f]
-- this macro L, build one List from other list, where in g, there is the generic element of index i
-- (as a.i, or a.i*b.i or a.i*4), n build 1..n that is the range of i, f is the condition 
-- for insert the element in the list result.

hlp(a)==
    n:=#a;n=1=>a
    -- L(a.i,n,odd? i)  it means build a list getting "even indices i of a.i as starting from index 0" [so even is odd and odd is even]
    -- L(a.i,n,even? i) it means build a list getting "odd  indices i of a.i as starting from index 0"
    c:=hlp(L(a.i,n,odd? i));d:=hlp(L(a.i,n,even? i))
    n:=n/2;t:=1>0
    v:=L(d.i*%i^(-2*(i-1)/n),n,t)
    append(L(c.i+v.i,n,t),L(c.i-v.i,n,t))

-- Return Fast Fourier transform of list a, in the case #a=2^n
fft(a)==(n:=#a;n=0 or gcd(n,2^30)~=n=>[];hlp(a))

(5) -> h([1,1,1,1])
   (5)  [4,0,0,0]
                                    Type: List Expression Complex Integer
(6) -> h([1,2,3,4])
   (6)  [10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(7) -> h([5.24626,3.90746,3.72335,5.74429,4.7983,8.34171,4.46785,0.760139])
   (7)
   [36.989359, - 6.2118552150 341603904 + 0.3556612739 187363298 %i,
    1.85336 - 5.744741 %i, 7.1077752150 341603904 - 1.1333387260 812636702 %i,
    - 0.517839, 7.1077752150 341603904 + 1.1333387260 812636702 %i,
    1.85336 + 5.744741 %i,
    - 6.2118552150 341603904 - 0.3556612739 187363298 %i]
                                      Type: List Expression Complex Float
(8) -> h([%i+1,2,%i-2,9])
   (8)  [10 + 2%i,3 + 7%i,- 12 + 2%i,3 - 7%i]
                                    Type: List Expression Complex Integer

в декількох я бачив h () або fft () повертає точне рішення, але якщо спрощення не добре, як у:

(13) -> h([1,2,3,4,5,6,7,8])
   (13)
                    +--+                                   +--+
        (- 4 + 4%i)\|%i  - 4 + 4%i             (- 4 - 4%i)\|%i  - 4 + 4%i
   [36, --------------------------, - 4 + 4%i, --------------------------, - 4,
                    +--+                                   +--+
                   \|%i                                   \|%i
            +--+                                   +--+
    (- 4 + 4%i)\|%i  + 4 - 4%i             (- 4 - 4%i)\|%i  + 4 - 4%i
    --------------------------, - 4 - 4%i, --------------------------]
                +--+                                   +--+
               \|%i                                   \|%i
                                    Type: List Expression Complex Integer

ніж потрібно, щоб змінити тип лише одного елемента списку, як написано нижче. 8. (Float) для пошуку приблизного рішення:

(14) -> h([1,2,3,4,5,6,7,8.])
   (14)
   [36.0, - 4.0000000000 000000001 + 9.6568542494 923801953 %i, - 4.0 + 4.0 %i,
    - 4.0 + 1.6568542494 92380195 %i, - 4.0, - 4.0 - 1.6568542494 92380195 %i,
    - 4.0 - 4.0 %i, - 4.0 - 9.6568542494 923801953 %i]
                                      Type: List Expression Complex Float

Я написав це, побачив усі інші відповіді, тому що за посиланням на сторінці це було занадто важко, тому я не знаю, чи може цей код бути правильним. Я не один експерт з ффта, тому все це може (можливо) помилятися.


0

APL (NARS), 58 символів, 116 байт

{1≥k←≢⍵:⍵⋄(∇⍵[y∼⍨⍳k])(+,-)(∇⍵[y←2×⍳t])×0J1*t÷⍨2-2×⍳t←⌊k÷2}

тест

  f←{1≥k←≢⍵:⍵⋄(∇⍵[y∼⍨⍳k])(+,-)(∇⍵[y←2×⍳t])×0J1*t÷⍨2-2×⍳t←⌊k÷2}
  f 1 1 1 1
4J0 0J0 0J0 0J0 
  f 1 2 3 4
10J0 ¯2J2 ¯2J0 ¯2J¯2 
  f 1J1 2 ¯2J1  9
10J2 3J7 ¯12J2 3J¯7 
  f 5.24626,3.90746,3.72335,5.74429,4.7983,8.34171,4.46785,0.760139
36.989359J0 ¯6.211855215J0.3556612739 1.85336J¯5.744741 7.107775215J¯1.133338726 ¯0.517839J0 
  7.107775215J1.133338726 1.85336J5.744741 ¯6.211855215J¯0.3556612739 
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.