Example #1
0
void ChebyshevDiffMatrix(int N, elem::Matrix<T>& D, double a = -1, double b = 1) {

    elem::Matrix<T> X;
    ChebyshevPoints(N, X);
    double *x = X.Buffer();

    const double s = 2.0 / (b - a);

    D.Resize(N+1, N+1);
    for(int j = 0; j <= N; j++)
        for(int i = 0; i <= N; i++) {
            int d = i - j;
            double v = 2.0 / (b - a);

            if (i == 0 && j == 0)
                v *= (2.0 * N * N + 1.0) / 6.0;
            else if (i == N && j == N)
                v *= -(2.0 * N * N + 1.0) / 6.0;
            else {
                if (i == 0 || i == N)
                    v *= 2.0;
                if (j ==0 || j == N)
                    v /= 2.0;

                if (d == 0)
                    v *= -x[j] / (2.0 * (1 - x[j] * x[j]));
                else if (d % 2 == 0)
                    v *= 1.0 / (x[i] - x[j]);
                else
                    v *= -1.0 / (x[i] - x[j]);
            }

            D.Set(i, j, v);
        }
}
Example #2
0
void ChebyshevPoints(int N, elem::Matrix<T>& X, double a = -1, double b = 1) {
    const double s = (b - a) / 2.0;
    const double pi = boost::math::constants::pi<double>();

    X.Resize(N+1, 1);
    for(int j = 0; j <= N; j++)
        X.Set(j, 0,
            (std::cos(j * pi / N) + a + 1) * s);

    if (N % 2 == 0)
        X.Set(N / 2, 0, 0.0);
}
    void realize_matrix_view(elem::Matrix<value_type>& A,
        int i, int j, int height, int width,
        int col_stride, int row_stride) const {

        A.Resize(height, width);
        value_type *data = A.Buffer();

#ifdef SKYLARK_HAVE_OPENMP
#pragma omp parallel for
#endif
        for(size_t j_loc = 0; j_loc < width; j_loc++) {
            size_t j_glob = j + j_loc * row_stride;
            for (size_t i_loc = 0; i_loc < height; i_loc++) {
                size_t i_glob = i + i_loc * col_stride;
                size_t tmp = j_glob * _S;
                tmp += i_glob;
                value_type sample = entries[tmp];
                tmp = j_loc * height;
                data[tmp + i_loc] = scale * sample;
            }
        }
    }