```python
import sympy
from sympy import I, conjugate, pi, oo
from sympy.functions import exp
from sympy.matrices import Identity, MatrixSymbol
import numpy as np
```

# \#3

## Fourier matrix with $\omega$


```python
ω = sympy.Symbol("omega")

def omegaPow(idx):
    return ω**(idx) 

def fourierGenerator(N):
    return sympy.Matrix(N, N, lambda m, n: omegaPow(m * n))

assert fourierGenerator(2) == sympy.Matrix([[1, 1], [1, ω]])

fourierGenerator(4)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & \omega & \omega^{2} & \omega^{3}\\1 & \omega^{2} & \omega^{4} & \omega^{6}\\1 & \omega^{3} & \omega^{6} & \omega^{9}\end{matrix}\right]$




```python
fourierGenerator(4)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & \omega & \omega^{2} & \omega^{3}\\1 & \omega^{2} & \omega^{4} & \omega^{6}\\1 & \omega^{3} & \omega^{6} & \omega^{9}\end{matrix}\right]$



## Complex conjugate F


```python
conjugate(fourierGenerator(4))
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & \overline{\omega} & \overline{\omega}^{2} & \overline{\omega}^{3}\\1 & \overline{\omega}^{2} & \overline{\omega}^{4} & \overline{\omega}^{6}\\1 & \overline{\omega}^{3} & \overline{\omega}^{6} & \overline{\omega}^{9}\end{matrix}\right]$



## Substitute $\omega=e^\frac{i2{\pi}mn}{N}$


```python
def omegaSubstirution(idx, N):
    return sympy.exp((I * 2 * pi * idx) / N)


assert omegaSubstirution(1, 4) == I
assert omegaSubstirution(8, 8) == 1
assert omegaSubstirution(3, 6) == -1
```

## Generate Fourier matrix with values


```python
def fourierGeneratorWithExp(N):
    return sympy.Matrix(N, N, lambda m, n: omegaSubstirution(m * n, N))


assert fourierGeneratorWithExp(2) == sympy.Matrix([[1, 1], [1, -1]])

F4 = fourierGeneratorWithExp(4)

F4
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & i & -1 & - i\\1 & -1 & 1 & -1\\1 & - i & -1 & i\end{matrix}\right]$



## Matrix conjugate


```python
F4Conj = conjugate(F4)

assert Identity(4).as_explicit() == (1 / 4) * F4 * F4Conj

F4Conj
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & - i & -1 & i\\1 & -1 & 1 & -1\\1 & i & -1 & - i\end{matrix}\right]$



## Conjugate generator with $\omega$


```python
def fourierConjGenerator(N):
    return sympy.Matrix(N, N, lambda m, n: omegaPow(0 if m == 0 else (N - m) * n))


fourierConjGenerator(4)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & \omega^{3} & \omega^{6} & \omega^{9}\\1 & \omega^{2} & \omega^{4} & \omega^{6}\\1 & \omega & \omega^{2} & \omega^{3}\end{matrix}\right]$



## Conjugate generator with values


```python
def fourierConjGeneratorWithExp(N):
    return sympy.Matrix(
        N, N, lambda m, n: omegaSubstirution(0 if m == 0 else (N - m) * n, N))


F4ConjWithExp = fourierConjGeneratorWithExp(4)

assert F4Conj == F4ConjWithExp

F4ConjWithExp
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & - i & -1 & i\\1 & -1 & 1 & -1\\1 & i & -1 & - i\end{matrix}\right]$



## Permutation Generator


```python
def generatePermutationMatrix(N):
    return np.vstack((np.hstack((np.array([1]), np.zeros(
        N - 1, dtype=int))), np.zeros((N - 1, N), dtype=int))) + np.fliplr(
            np.diagflat(np.ones(N - 1, dtype=int), -1))


assert np.all(
    generatePermutationMatrix(4) == np.array([[1, 0, 0, 0], [0, 0, 0, 1],
                                              [0, 0, 1, 0], [0, 1, 0, 0]]))

generatePermutationMatrix(4)
```




    array([[1, 0, 0, 0],
           [0, 0, 0, 1],
           [0, 0, 1, 0],
           [0, 1, 0, 0]])



## $$F=P{\cdot}\overline{F}$$


```python
P4 = generatePermutationMatrix(4)

assert F4 == P4 * F4Conj

P4 * F4Conj
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & i & -1 & - i\\1 & -1 & 1 & -1\\1 & - i & -1 & i\end{matrix}\right]$



## $$P^2 = I$$


```python
assert np.all(np.linalg.matrix_power(P4, 2) == np.identity(4, dtype=int))
```

## $$\frac{1}{N}{\cdot}F^2 = P$$


```python
assert np.all(((1 / 4) * np.linalg.matrix_power(F4, 2)).astype(int) == P4)
```

# \#4


```python
ID = sympy.Matrix(
    np.hstack((np.vstack((np.identity(2, dtype=int), np.identity(2,
                                                                 dtype=int))),
               np.vstack((np.identity(2, dtype=int) * np.diag(F4)[0:2],
                          -np.identity(2, dtype=int) * np.diag(F4)[0:2])))))

ID
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 0\\0 & 1 & 0 & i\\1 & 0 & -1 & 0\\0 & 1 & 0 & - i\end{matrix}\right]$




```python
ID.inv()
```




$\displaystyle \left[\begin{matrix}\frac{1}{2} & 0 & \frac{1}{2} & 0\\0 & \frac{1}{2} & 0 & \frac{1}{2}\\\frac{1}{2} & 0 & - \frac{1}{2} & 0\\0 & - \frac{i}{2} & 0 & \frac{i}{2}\end{matrix}\right]$




```python
F2 = fourierGeneratorWithExp(2)
Zeros2 = np.zeros((2, 2), dtype=int)

F22 = sympy.Matrix(
    np.array(np.vstack((np.hstack((F2, Zeros2)), np.hstack((Zeros2, F2))))))

F22
```




$\displaystyle \left[\begin{matrix}1 & 1 & 0 & 0\\1 & -1 & 0 & 0\\0 & 0 & 1 & 1\\0 & 0 & 1 & -1\end{matrix}\right]$




```python
F22.inv()
```




$\displaystyle \left[\begin{matrix}\frac{1}{2} & \frac{1}{2} & 0 & 0\\\frac{1}{2} & - \frac{1}{2} & 0 & 0\\0 & 0 & \frac{1}{2} & \frac{1}{2}\\0 & 0 & \frac{1}{2} & - \frac{1}{2}\end{matrix}\right]$




```python
EvenOddP = sympy.Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0],
                         [0, 0, 0, 1]])
EvenOddP
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0\\0 & 0 & 1 & 0\\0 & 1 & 0 & 0\\0 & 0 & 0 & 1\end{matrix}\right]$




```python
assert ID * F22 * EvenOddP == F4

ID * F22 * EvenOddP
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & i & -1 & - i\\1 & -1 & 1 & -1\\1 & - i & -1 & i\end{matrix}\right]$




```python
F4
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & i & -1 & - i\\1 & -1 & 1 & -1\\1 & - i & -1 & i\end{matrix}\right]$



# \#5

$$
 F^{T}_{N} = 
\left(
    \begin{bmatrix}
       I_{N/2} & D_{N/2}  \\[0.3em]
       I_{N/2} & -D_{N/2} \\[0.3em]
     \end{bmatrix}
     \cdot
     \begin{bmatrix}
       F_{N/2} &   \\[0.3em]
        & F_{N/2} \\[0.3em]
     \end{bmatrix}
     \cdot
     \begin{bmatrix}
       even_{N/2} & even_{N/2}  \\[0.3em]
       odd_{N/2} & odd_{N/2} \\[0.3em]
     \end{bmatrix}
 \right)^T
     =
    \begin{bmatrix}
       even_{N/2} & odd_{N/2}  \\[0.3em]
       even_{N/2} & odd_{N/2} \\[0.3em]
     \end{bmatrix}
    \cdot
    \begin{bmatrix}
        F_{N/2} &   \\[0.3em]
        & F_{N/2} \\[0.3em]
    \end{bmatrix}
    \cdot
    \begin{bmatrix}
        I_{N/2} & I_{N/2} \\[0.3em]
        D_{N/2} & -D_{N/2} \\[0.3em]
    \end{bmatrix}
 $$


```python
EvenOddP * F22 * sympy.Matrix.transpose(ID)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & i & -1 & - i\\1 & -1 & 1 & -1\\1 & - i & -1 & i\end{matrix}\right]$




```python
EvenOddP * F22 * sympy.Matrix.transpose(ID) == F4
```




    True



# \#6

### Based on Permutation Matrix for the Conjugate Matrix - even / odd Permutation


```python
N = 6

P = generatePermutationMatrix(N)

EvenOddP = sympy.Matrix(
    np.vstack((
        P[0],
        P[np.arange(N-2, 1, -2)],
        P[np.arange(N-1, 0, -2)]
    ))
)

EvenOddP
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 1 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 1 & 0\\0 & 1 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 1 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 1\end{matrix}\right]$




```python
def generatePermutationFourierMatrix(N):
    P = generatePermutationMatrix(N)
    return sympy.Matrix(
        np.vstack((
            P[0],
            P[np.arange(N-2, 1, -2)],
            P[np.arange(N-1, 0, -2)]
        ))
    )

assert np.all(generatePermutationFourierMatrix(4) == sympy.Matrix([
    [1, 0, 0, 0],
    [0, 0, 1, 0],
    [0, 1, 0, 0],
    [0, 0, 0, 1]
]))
```

### Shape of the Permutation Matrix
$$
\begin{bmatrix}
    even_{N/2} & even_{N/2}  \\[0.3em]
    odd_{N/2} & odd_{N/2} \\[0.3em]
\end{bmatrix}
$$

### N = 8 Fourier Permutation Matrix


```python
generatePermutationFourierMatrix(8)
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\end{matrix}\right]$




```python
generatePermutationFourierMatrix(6)
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 1 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 1 & 0\\0 & 1 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 1 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 1\end{matrix}\right]$



## Generate Fourier Matrices

### Generate Fourier Blocks for basic Matrix:

#### Half Eye: $I_{N/2}$
#### Half Fourier Diagonal: $D_{N/2}$
#### Half Fourier: $F_{N/2}$


```python
def generateFourierBlocks(N, fourierGenerator):
    half = int(N/2)
    quarterEye = sympy.Matrix.eye(half, half)
    quarterZeroes = sympy.Matrix.zeros(half, half)
    halfDiagFourier = sympy.Matrix.diag(
        np.diagonal(fourierGenerator(N))
    )[:half, :half]
    halfFourier = fourierGenerator(half)
    return (quarterEye, quarterZeroes, halfDiagFourier, halfFourier)
```


```python
Blocks4 = generateFourierBlocks(4, fourierGenerator)

assert Blocks4 == (
    sympy.Matrix([
        [1, 0],
        [0, 1]
    ]),
    sympy.Matrix([
        [0, 0],
        [0, 0]
    ]),
    sympy.Matrix([
        [1, 0],
        [0, ω]
    ]),
    sympy.Matrix([
        [1, 1],
        [1, ω]
    ])
)
```


```python
Blocks4Complex = generateFourierBlocks(4, fourierGeneratorWithExp)

assert Blocks4Complex == (
    sympy.Matrix([
        [1, 0],
        [0, 1]
    ]),
    sympy.Matrix([
        [0, 0],
        [0, 0]
    ]),
    sympy.Matrix([
        [1, 0],
        [0, I]
    ]),
    sympy.Matrix([
        [1, 1],
        [1, -1]
    ])
)
```


```python
def composeFourierMatricesFromBlocks(N, quarterEye, quarterZeroes, halfDiagFourier, halfFourier):
    return (
        sympy.Matrix.vstack(
            sympy.Matrix.hstack(
                quarterEye,
                halfDiagFourier
            ),
            sympy.Matrix.hstack(
                quarterEye,
                -halfDiagFourier
            )
        ),
        sympy.Matrix.vstack(
            sympy.Matrix.hstack(
                halfFourier,
                quarterZeroes
            ),
            sympy.Matrix.hstack(
                quarterZeroes,
                halfFourier
            )
        ),
        generatePermutationFourierMatrix(N)
    )
```


```python
def createFourierMatrices(N, fourierGenerator):
    (quarterEye, quarterZeroes, halfDiagFourier, halfFourier) = generateFourierBlocks(N, fourierGenerator)
    return composeFourierMatricesFromBlocks(N, quarterEye, quarterZeroes, halfDiagFourier, halfFourier)
```

## Generate Fourier Matrices 

### IdentityAndDiagonal: $
\begin{bmatrix}
   I_{N/2} & D_{N/2}  \\[0.3em]
   I_{N/2} & -D_{N/2} \\[0.3em]
 \end{bmatrix}
$
 
### FourierHalfNSize: $
\begin{bmatrix}
   F_{N/2} &   \\[0.3em]
    & F_{N/2} \\[0.3em]
 \end{bmatrix}
$

### EvenOddPermutation: $
\begin{bmatrix}
    even_{N/2} & even_{N/2}  \\[0.3em]
    odd_{N/2} & odd_{N/2} \\[0.3em]
\end{bmatrix}
$

### Full picture
$$
F_{N}=\begin{bmatrix}
   I_{N/2} & D_{N/2}  \\[0.3em]
   I_{N/2} & -D_{N/2} \\[0.3em]
 \end{bmatrix}
 \cdot
 \begin{bmatrix}
   F_{N/2} &   \\[0.3em]
    & F_{N/2} \\[0.3em]
 \end{bmatrix}
 \cdot
 \begin{bmatrix}
   even_{N/2} & even_{N/2}  \\[0.3em]
   odd_{N/2} & odd_{N/2} \\[0.3em]
 \end{bmatrix}
 $$


```python
def generateFourierMatricesWithOmega(N):
    return createFourierMatrices(N, fourierGenerator)
```


```python
IdentityAndDiagonal, FHalfNSize, EvenOddPermutation = generateFourierMatricesWithOmega(4)
```


```python
assert sympy.Matrix([
    [1, 0, 1, 0],
    [0, 1, 0, ω],
    [1, 0, -1, 0],
    [0, 1, 0, -ω],
]) == IdentityAndDiagonal

IdentityAndDiagonal
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 0\\0 & 1 & 0 & \omega\\1 & 0 & -1 & 0\\0 & 1 & 0 & - \omega\end{matrix}\right]$




```python
assert sympy.Matrix([
    [1, 1, 0, 0],
    [1, ω, 0, 0],
    [0, 0, 1, 1],
    [0, 0, 1, ω]
]) == FHalfNSize

FHalfNSize
```




$\displaystyle \left[\begin{matrix}1 & 1 & 0 & 0\\1 & \omega & 0 & 0\\0 & 0 & 1 & 1\\0 & 0 & 1 & \omega\end{matrix}\right]$




```python
FHalfNSize = sympy
```


```python
assert sympy.Matrix([
    [1, 0, 0, 0],
    [0, 0, 1, 0],
    [0, 1, 0, 0],
    [0, 0, 0, 1]
]) == EvenOddPermutation

EvenOddPermutation
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0\\0 & 0 & 1 & 0\\0 & 1 & 0 & 0\\0 & 0 & 0 & 1\end{matrix}\right]$




```python
def generateFourierMatricesWithExp(N):
    return createFourierMatrices(N, fourierGeneratorWithExp)
```


```python
IdentityAndDiagonal, FourierHalfNSize, EvenOddPermutation = generateFourierMatricesWithExp(4)
```


```python
assert sympy.Matrix([
    [1, 0, 1, 0],
    [0, 1, 0, I],
    [1, 0, -1, 0],
    [0, 1, 0, -I]
]) == IdentityAndDiagonal

IdentityAndDiagonal
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 0\\0 & 1 & 0 & i\\1 & 0 & -1 & 0\\0 & 1 & 0 & - i\end{matrix}\right]$




```python
assert sympy.Matrix([
    [1, 1, 0, 0],
    [1, -1, 0, 0],
    [0, 0, 1, 1],
    [0, 0, 1, -1]
]) == FourierHalfNSize

FourierHalfNSize
```




$\displaystyle \left[\begin{matrix}1 & 1 & 0 & 0\\1 & -1 & 0 & 0\\0 & 0 & 1 & 1\\0 & 0 & 1 & -1\end{matrix}\right]$




```python
assert sympy.Matrix([
    [1, 0, 0, 0],
    [0, 0, 1, 0],
    [0, 1, 0, 0],
    [0, 0, 0, 1]
]) == EvenOddPermutation

EvenOddPermutation
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0\\0 & 0 & 1 & 0\\0 & 1 & 0 & 0\\0 & 0 & 0 & 1\end{matrix}\right]$



## Solution for \#6


```python
IdentityAndDiagonal = sympy.Matrix([
    [1, 0, 0,  1,    0,    0],
    [0, 1, 0,  0,    ω,    0],
    [0, 0, 1,  0,    0,    ω**2],
    [1, 0, 0, -1,    0,    0],
    [0, 1, 0,  0,   -ω,    0],
    [0, 0, 1,  0,    0,   -ω**2],
])
IdentityAndDiagonal
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 1 & 0 & 0\\0 & 1 & 0 & 0 & \omega & 0\\0 & 0 & 1 & 0 & 0 & \omega^{2}\\1 & 0 & 0 & -1 & 0 & 0\\0 & 1 & 0 & 0 & - \omega & 0\\0 & 0 & 1 & 0 & 0 & - \omega^{2}\end{matrix}\right]$




```python
FourierHalfNSize = sympy.Matrix([
    [1, 1,    1,    0,    0,    0],
    [1, ω**2, ω**4, 0,    0,    0],
    [1, ω**4, ω**2, 0,    0,    0],
    [0, 0,    0,    1,    1,    1],
    [0, 0,    0,    1,    ω**2, ω**4],
    [0, 0,    0,    1,    ω**4, ω**2],
])

FourierHalfNSize
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 0 & 0 & 0\\1 & \omega^{2} & \omega^{4} & 0 & 0 & 0\\1 & \omega^{4} & \omega^{2} & 0 & 0 & 0\\0 & 0 & 0 & 1 & 1 & 1\\0 & 0 & 0 & 1 & \omega^{2} & \omega^{4}\\0 & 0 & 0 & 1 & \omega^{4} & \omega^{2}\end{matrix}\right]$




```python
EvenOddPermutation
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 1 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 1 & 0\\0 & 1 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 1 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 1\end{matrix}\right]$




```python
FourierBasedOnMatrices = IdentityAndDiagonal * FourierHalfNSize * EvenOddPermutation
FourierBasedOnMatrices
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1 & 1 & 1\\1 & \omega & \omega^{2} & \omega^{3} & \omega^{4} & \omega^{5}\\1 & \omega^{2} & \omega^{4} & \omega^{6} & \omega^{2} & \omega^{4}\\1 & -1 & 1 & -1 & 1 & -1\\1 & - \omega & \omega^{2} & - \omega^{3} & \omega^{4} & - \omega^{5}\\1 & - \omega^{2} & \omega^{4} & - \omega^{6} & \omega^{2} & - \omega^{4}\end{matrix}\right]$




```python
# assert FourierBasedOnMatrices == fourierGeneratorWithExp(N)

fourierGenerator(N)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1 & 1 & 1\\1 & \omega & \omega^{2} & \omega^{3} & \omega^{4} & \omega^{5}\\1 & \omega^{2} & \omega^{4} & \omega^{6} & \omega^{8} & \omega^{10}\\1 & \omega^{3} & \omega^{6} & \omega^{9} & \omega^{12} & \omega^{15}\\1 & \omega^{4} & \omega^{8} & \omega^{12} & \omega^{16} & \omega^{20}\\1 & \omega^{5} & \omega^{10} & \omega^{15} & \omega^{20} & \omega^{25}\end{matrix}\right]$




```python
N = 4
sympy.Matrix(
    sympy.fft(sympy.Matrix.eye(2, 2), 1)
)
```




$\displaystyle \left[\begin{matrix}2\\1.0 - 1.0 i\\0\\1.0 + 1.0 i\end{matrix}\right]$




```python
N = 16
half = int(N/2)

sympy.fft(sympy.Matrix.eye(2), 1)

```




    [2, 1.0 - 1.0*I, 0, 1.0 + 1.0*I]




```python
sympy.Matrix.eye(half)
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\end{matrix}\right]$



0b369a1e7c5d0d10b2b78e2f98da03912a312891
ipynb
Jupyter Notebook
4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb
nickovchinnikov/Computational-Science-and-Engineering
45620e432c97fce68a24e2ade9210d30b341d2e4
MIT
2021-01-14T08:00:23.000Z
2022-01-31T14:00:11.000Z
4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb
nickovchinnikov/Computational-Science-and-Engineering
45620e432c97fce68a24e2ade9210d30b341d2e4
MIT
4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb
nickovchinnikov/Computational-Science-and-Engineering
45620e432c97fce68a24e2ade9210d30b341d2e4
MIT
2022-01-25T15:21:40.000Z
2022-01-25T15:21:40.000Z
Qwen/Qwen-72B
1. YES
2. YES