diff --git a/d1/de0/namespacenumerical__methods.html b/d1/de0/namespacenumerical__methods.html index e8b3a60de..c57f22985 100644 --- a/d1/de0/namespacenumerical__methods.html +++ b/d1/de0/namespacenumerical__methods.html @@ -104,6 +104,9 @@ Functions std::complex< double > * FastFourierTransform (std::complex< double > *p, uint8_t n)  FastFourierTransform is a recursive function which returns list of complex numbers. More...
  +std::complex< double > * InverseFastFourierTransform (std::complex< double > *p, uint8_t n) + InverseFastFourierTransform is a recursive function which returns list of complex numbers. More...
+ 

Detailed Description

for std::map container

@@ -232,6 +235,128 @@ Here is the call graph for this function:
+ + + +

◆ InverseFastFourierTransform()

+ +
+
+ + + + + + + + + + + + + + + + + + +
std::complex< double > * numerical_methods::InverseFastFourierTransform (std::complex< double > * p,
uint8_t n 
)
+
+ +

InverseFastFourierTransform is a recursive function which returns list of complex numbers.

+
Parameters
+ + + +
pList of Coefficents in form of complex numbers
nCount of elements in list p
+
+
+
Returns
p if n==1
+
+y if n!=1
+

Base Case To return

+

Declaring value of pi

+

Calculating value of omega

+

One change in comparison with DFT

+

One change in comparison with DFT

+

Coefficients of even power

+

Coefficients of odd power

+

Assigning values of even Coefficients

+

Assigning value of odd Coefficients

+

Recursive Call

+

Recursive Call

+

Final value representation list

+

Updating the first n/2 elements

+

Updating the last n/2 elements

+

Deleting dynamic array ye

+

Deleting dynamic array yo

+
33 {
+
34 if (n == 1) {
+
35 return p; /// Base Case To return
+
36 }
+
37
+
38 double pi = 2 * asin(1.0); /// Declaring value of pi
+
39
+
40 std::complex<double> om = std::complex<double>(
+
41 cos(2 * pi / n), sin(2 * pi / n)); /// Calculating value of omega
+
42
+
43 om.real(om.real()/n); /// One change in comparison with DFT
+
44 om.imag(om.imag()/n); /// One change in comparison with DFT
+
45
+
46 auto *pe = new std::complex<double>[n / 2]; /// Coefficients of even power
+
47
+
48 auto *po = new std::complex<double>[n / 2]; /// Coefficients of odd power
+
49
+
50 int k1 = 0, k2 = 0;
+
51 for (int j = 0; j < n; j++) {
+
52 if (j % 2 == 0) {
+
53 pe[k1++] = p[j]; /// Assigning values of even Coefficients
+
54
+
55 } else
+
56 po[k2++] = p[j]; /// Assigning value of odd Coefficients
+
57 }
+
58
+
59 std::complex<double> *ye =
+
60 InverseFastFourierTransform(pe, n / 2); /// Recursive Call
+
61
+
62 std::complex<double> *yo =
+
63 InverseFastFourierTransform(po, n / 2); /// Recursive Call
+
64
+
65 auto *y = new std::complex<double>[n]; /// Final value representation list
+
66
+
67 k1 = 0, k2 = 0;
+
68
+
69 for (int i = 0; i < n / 2; i++) {
+
70 y[i] =
+
71 ye[k1] + pow(om, i) * yo[k2]; /// Updating the first n/2 elements
+
72 y[i + n / 2] =
+
73 ye[k1] - pow(om, i) * yo[k2]; /// Updating the last n/2 elements
+
74
+
75 k1++;
+
76 k2++;
+
77 }
+
78
+
79 if(n!=2){
+
80
+
81 delete[] pe;
+
82 delete[] po;
+
83
+
84 }
+
85
+
86 delete[] ye; /// Deleting dynamic array ye
+
87 delete[] yo; /// Deleting dynamic array yo
+
88 return y;
+
89}
+
std::complex::imag
T imag(T... args)
+
numerical_methods::InverseFastFourierTransform
std::complex< double > * InverseFastFourierTransform(std::complex< double > *p, uint8_t n)
InverseFastFourierTransform is a recursive function which returns list of complex numbers.
Definition: inverse_fast_fourier_transform.cpp:33
+
std::complex::real
T real(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
diff --git a/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.map b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.map new file mode 100644 index 000000000..487b84f55 --- /dev/null +++ b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.map @@ -0,0 +1,5 @@ + + + + + diff --git a/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.md5 b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.md5 new file mode 100644 index 000000000..48d0e25cf --- /dev/null +++ b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.md5 @@ -0,0 +1 @@ +dfcb53ae2d2e3cfb7bc79c9ca6132364 \ No newline at end of file diff --git a/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.svg b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.svg new file mode 100644 index 000000000..ed0a8c593 --- /dev/null +++ b/d1/de0/namespacenumerical__methods_aee56dc85997b8cd42bad71a5d6bd2d93_cgraph.svg @@ -0,0 +1,59 @@ + + + + + + +numerical_methods::InverseFastFourierTransform + + + +Node1 + + +numerical_methods:: +InverseFastFourierTransform + + + + + +Node1->Node1 + + + + + +Node2 + + +std::complex::imag + + + + + +Node1->Node2 + + + + + +Node3 + + +std::complex::real + + + + + +Node1->Node3 + + + + + diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html index 9d7f31890..7ac9538f3 100644 --- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html +++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html @@ -355,6 +355,7 @@ Numerical Methods
  • Fast Fourier Transform
  • Gaussian Elimination
  • Golden Search Extrema
    • +
  • Inverse Fast Fourier Transform
  • Lu Decompose
  • Lu Decomposition
  • Midpoint Integral Method
    • diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp.html b/d9/d37/inverse__fast__fourier__transform_8cpp.html new file mode 100644 index 000000000..25d150e5f --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp.html @@ -0,0 +1,288 @@ + + + + + + + +Algorithms_in_C++: numerical_methods/inverse_fast_fourier_transform.cpp File Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +Namespaces | +Functions
    +
    inverse_fast_fourier_transform.cpp File Reference
    +
    +
    + +

    An inverse fast Fourier transform (IFFT) is an algorithm that computes the inverse fourier transform. +More...

    +
    #include <cassert>
    +#include <cmath>
    +#include <complex>
    +#include <iostream>
    +#include <vector>
    +
    +Include dependency graph for inverse_fast_fourier_transform.cpp:
    +
    +
    +
    +
    +
    + + + + +

    +Namespaces

    namespace  numerical_methods
     for std::map container
     
    + + + + + + + + + + +

    +Functions

    std::complex< double > * numerical_methods::InverseFastFourierTransform (std::complex< double > *p, uint8_t n)
     InverseFastFourierTransform is a recursive function which returns list of complex numbers. More...
     
    static void test ()
     Self-test implementations. More...
     
    int main (int argc, char const *argv[])
     Main function. More...
     
    +

    Detailed Description

    +

    An inverse fast Fourier transform (IFFT) is an algorithm that computes the inverse fourier transform.

    +

    This algorithm has an application in use case scenario where a user wants find coefficients of a function in a short time by just using points generated by DFT. Time complexity this algorithm computes the IDFT in O(nlogn) time in comparison to traditional O(n^2).

    Author
    Ameya Chawla
    +

    Function Documentation

    + +

    ◆ main()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int main (int argc,
    char const * argv[] 
    )
    +
    + +

    Main function.

    +
    Parameters
    + + + +
    argccommandline argument count (ignored)
    argvcommandline array of arguments (ignored) calls automated test function to test the working of fast fourier transform.
    +
    +
    +
    Returns
    0 on exit
    +
    157 {
    +
    158 test(); // run self-test implementations
    +
    159 // with 2 defined test cases
    +
    160 return 0;
    +
    161}
    +
    test
    static void test()
    Self-test implementations.
    Definition: inverse_fast_fourier_transform.cpp:100
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ test()

    + +
    +
    + + + + + +
    + + + + + + + +
    static void test ()
    +     		+static
    +
    + +

    Self-test implementations.

    +

    Declaring two test cases and checking for the error in predicted and true value is less than 0.000000000001.

    Returns
    void
    +

    Test case 1

    +

    Test case 2

    +

    True Answer for test case 1

    +

    True Answer for test case 2

    +

    Comparing for both real and imaginary values for test case 1

    +

    Comparing for both real and imaginary values for test case 2

    +
    100 {
    +
    101 /* descriptions of the following test */
    +
    102
    +
    103 auto *t1 = new std::complex<double>[2]; /// Test case 1
    +
    104 auto *t2 = new std::complex<double>[4]; /// Test case 2
    +
    105
    +
    106 t1[0] = {3, 0};
    +
    107 t1[1] = {-1, 0};
    +
    108 t2[0] = {10, 0};
    +
    109 t2[1] = {-2, -2};
    +
    110 t2[2] = {-2, 0};
    +
    111 t2[3] = {-2, 2};
    +
    112
    +
    113 uint8_t n1 = 2;
    +
    114 uint8_t n2 = 4;
    +
    115 std::vector<std::complex<double>> r1 = {
    +
    116 {1, 0}, {2, 0}}; /// True Answer for test case 1
    +
    117
    +
    118 std::vector<std::complex<double>> r2 = {
    +
    119 {1, 0}, {2, 0}, {3, 0}, {4, 0}}; /// True Answer for test case 2
    +
    120
    +
    121 std::complex<double> *o1 = numerical_methods::InverseFastFourierTransform(t1, n1);
    +
    122
    +
    123 std::complex<double> *o2 = numerical_methods::InverseFastFourierTransform(t2, n2);
    +
    124
    +
    125 for (uint8_t i = 0; i < n1; i++) {
    +
    126 assert((r1[i].real() - o1[i].real() < 0.000000000001) &&
    +
    127 (r1[i].imag() - o1[i].imag() <
    +
    128 0.000000000001)); /// Comparing for both real and imaginary
    +
    129 /// values for test case 1
    +
    130
    +
    131 }
    +
    132
    +
    133 for (uint8_t i = 0; i < n2; i++) {
    +
    134 assert((r2[i].real() - o2[i].real() < 0.000000000001) &&
    +
    135 (r2[i].imag() - o2[i].imag() <
    +
    136 0.000000000001)); /// Comparing for both real and imaginary
    +
    137 /// values for test case 2
    +
    138
    +
    139 }
    +
    140
    +
    141
    +
    142 delete[] t1;
    +
    143 delete[] t2;
    +
    144 delete[] o1;
    +
    145 delete[] o2;
    +
    146 std::cout << "All tests have successfully passed!\n";
    +
    147}
    + + +
    numerical_methods::InverseFastFourierTransform
    std::complex< double > * InverseFastFourierTransform(std::complex< double > *p, uint8_t n)
    InverseFastFourierTransform is a recursive function which returns list of complex numbers.
    Definition: inverse_fast_fourier_transform.cpp:33
    + +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    +
    +
    + + + + diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp.js b/d9/d37/inverse__fast__fourier__transform_8cpp.js new file mode 100644 index 000000000..bf1d8c6fd --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp.js @@ -0,0 +1,6 @@ +var inverse__fast__fourier__transform_8cpp = +[ + [ "InverseFastFourierTransform", "d9/d37/inverse__fast__fourier__transform_8cpp.html#aee56dc85997b8cd42bad71a5d6bd2d93", null ], + [ "main", "d9/d37/inverse__fast__fourier__transform_8cpp.html#abf9e6b7e6f15df4b525a2e7705ba3089", null ], + [ "test", "d9/d37/inverse__fast__fourier__transform_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ] +]; \ No newline at end of file diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map new file mode 100644 index 000000000..2f39bd8fa --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 new file mode 100644 index 000000000..a8307be27 --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 @@ -0,0 +1 @@ +de856a9343e14e8502573294078af2e2 \ No newline at end of file diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg new file mode 100644 index 000000000..0427755e6 --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg @@ -0,0 +1,74 @@ + + + + + + +test + + + +Node1 + + +test + + + + + +Node2 + + +numerical_methods:: +InverseFastFourierTransform + + + + + +Node1->Node2 + + + + + +Node2->Node2 + + + + + +Node3 + + +std::complex::imag + + + + + +Node2->Node3 + + + + + +Node4 + + +std::complex::real + + + + + +Node2->Node4 + + + + + diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.map b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.map new file mode 100644 index 000000000..ae904aa64 --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.md5 b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.md5 new file mode 100644 index 000000000..3dabba732 --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.md5 @@ -0,0 +1 @@ +2936f11d712c89d983afd3b16d238496 \ No newline at end of file diff --git a/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.svg b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.svg new file mode 100644 index 000000000..d6bcf5e56 --- /dev/null +++ b/d9/d37/inverse__fast__fourier__transform_8cpp_abf9e6b7e6f15df4b525a2e7705ba3089_cgraph.svg @@ -0,0 +1,89 @@ + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +test + + + + + +Node1->Node2 + + + + + +Node3 + + +numerical_methods:: +InverseFastFourierTransform + + + + + +Node2->Node3 + + + + + +Node3->Node3 + + + + + +Node4 + + +std::complex::imag + + + + + +Node3->Node4 + + + + + +Node5 + + +std::complex::real + + + + + +Node3->Node5 + + + + + diff --git a/dc/d57/inverse__fast__fourier__transform_8cpp__incl.map b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.map new file mode 100644 index 000000000..96c0ad39c --- /dev/null +++ b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/dc/d57/inverse__fast__fourier__transform_8cpp__incl.md5 b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.md5 new file mode 100644 index 000000000..2caf93c3e --- /dev/null +++ b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.md5 @@ -0,0 +1 @@ +f9f96cbbc1bb3fa353e322a89b14801c \ No newline at end of file diff --git a/dc/d57/inverse__fast__fourier__transform_8cpp__incl.svg b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.svg new file mode 100644 index 000000000..af6eaaee5 --- /dev/null +++ b/dc/d57/inverse__fast__fourier__transform_8cpp__incl.svg @@ -0,0 +1,98 @@ + + + + + + +numerical_methods/inverse_fast_fourier_transform.cpp + + + +Node1 + + +numerical_methods/inverse +_fast_fourier_transform.cpp + + + + + +Node2 + + +cassert + + + + + +Node1->Node2 + + + + + +Node3 + + +cmath + + + + + +Node1->Node3 + + + + + +Node4 + + +complex + + + + + +Node1->Node4 + + + + + +Node5 + + +iostream + + + + + +Node1->Node5 + + + + + +Node6 + + +vector + + + + + +Node1->Node6 + + + + + diff --git a/dir_9c6faab82c22511b50177aa2e38e2780.html b/dir_9c6faab82c22511b50177aa2e38e2780.html index 6fd663b86..8ee696d0f 100644 --- a/dir_9c6faab82c22511b50177aa2e38e2780.html +++ b/dir_9c6faab82c22511b50177aa2e38e2780.html @@ -120,6 +120,9 @@ Files file  golden_search_extrema.cpp  Find extrema of a univariate real function in a given interval using golden section search algorithm.
      +file  inverse_fast_fourier_transform.cpp + An inverse fast Fourier transform (IFFT) is an algorithm that computes the inverse fourier transform.
    +  file  lu_decompose.cpp  LU decomposition of a square matrix
      diff --git a/dir_9c6faab82c22511b50177aa2e38e2780.js b/dir_9c6faab82c22511b50177aa2e38e2780.js index 33d869ffb..6e684e628 100644 --- a/dir_9c6faab82c22511b50177aa2e38e2780.js +++ b/dir_9c6faab82c22511b50177aa2e38e2780.js @@ -8,6 +8,7 @@ var dir_9c6faab82c22511b50177aa2e38e2780 = [ "fast_fourier_transform.cpp", "d8/d9a/fast__fourier__transform_8cpp.html", "d8/d9a/fast__fourier__transform_8cpp" ], [ "gaussian_elimination.cpp", "d0/de2/gaussian__elimination_8cpp.html", "d0/de2/gaussian__elimination_8cpp" ], [ "golden_search_extrema.cpp", "d6/d7a/golden__search__extrema_8cpp.html", "d6/d7a/golden__search__extrema_8cpp" ], + [ "inverse_fast_fourier_transform.cpp", "d9/d37/inverse__fast__fourier__transform_8cpp.html", "d9/d37/inverse__fast__fourier__transform_8cpp" ], [ "lu_decompose.cpp", "dd/d65/lu__decompose_8cpp.html", "dd/d65/lu__decompose_8cpp" ], [ "lu_decomposition.h", "d1/dbe/lu__decomposition_8h.html", "d1/dbe/lu__decomposition_8h" ], [ "midpoint_integral_method.cpp", "df/d11/midpoint__integral__method_8cpp.html", "df/d11/midpoint__integral__method_8cpp" ], diff --git a/files.html b/files.html index b6081235a..8e654dbba 100644 --- a/files.html +++ b/files.html @@ -262,18 +262,19 @@ solve-a-rat-in-a-maze-c-java-pytho/"  fast_fourier_transform.cppA fast Fourier transform (FFT) is an algorithm that computes the discrete Fourier transform (DFT) of a sequence, or its inverse (IDFT)  gaussian_elimination.cppGaussian elimination method  golden_search_extrema.cppFind extrema of a univariate real function in a given interval using golden section search algorithm - lu_decompose.cppLU decomposition of a square matrix - lu_decomposition.hFunctions associated with LU Decomposition of a square matrix - midpoint_integral_method.cppA numerical method for easy approximation of integrals - newton_raphson_method.cppSolve the equation \(f(x)=0\) using Newton-Raphson method for both real and complex solutions - ode_forward_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using forward Euler method - ode_midpoint_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method - ode_semi_implicit_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method - qr_decompose.hLibrary functions to compute QR decomposition of a given matrix - qr_decomposition.cppProgram to compute the QR decomposition of a given matrix - qr_eigen_values.cppCompute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method - rungekutta.cppRunge Kutta fourth order method implementation - successive_approximation.cppMethod of successive approximations using fixed-point iteration method + inverse_fast_fourier_transform.cppAn inverse fast Fourier transform (IFFT) is an algorithm that computes the inverse fourier transform + lu_decompose.cppLU decomposition of a square matrix + lu_decomposition.hFunctions associated with LU Decomposition of a square matrix + midpoint_integral_method.cppA numerical method for easy approximation of integrals + newton_raphson_method.cppSolve the equation \(f(x)=0\) using Newton-Raphson method for both real and complex solutions + ode_forward_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using forward Euler method + ode_midpoint_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method + ode_semi_implicit_euler.cppSolve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method + qr_decompose.hLibrary functions to compute QR decomposition of a given matrix + qr_decomposition.cppProgram to compute the QR decomposition of a given matrix + qr_eigen_values.cppCompute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method + rungekutta.cppRunge Kutta fourth order method implementation + successive_approximation.cppMethod of successive approximations using fixed-point iteration method  ► operations_on_datastructures  array_left_rotation.cppImplementation for the Array Left Rotation algorithm  array_right_rotation.cppImplementation for the Array right Rotation algorithm diff --git a/globals_func_m.html b/globals_func_m.html index 97735f5b5..f648f6290 100644 --- a/globals_func_m.html +++ b/globals_func_m.html @@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl  

    - m -