Core.h

Go to the documentation of this file.

/*
 * Copyright (c) The Shogun Machine Learning Toolbox
 * Written (w) 2014 Soumyajit De
 * Written (w) 2014 Khaled Nasr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those
 * of the authors and should not be interpreted as representing official policies,
 * either expressed or implied, of the Shogun Development Team.
 */

#ifndef CORE_H_
#define CORE_H_

#include <shogun/mathematics/linalg/internal/implementation/ElementwiseSquare.h>
#include <shogun/mathematics/linalg/internal/implementation/MatrixProduct.h>
#include <shogun/mathematics/linalg/internal/implementation/Add.h>
#include <shogun/mathematics/linalg/internal/implementation/Apply.h>
#include <shogun/mathematics/linalg/internal/implementation/ElementwiseProduct.h>
#include <shogun/mathematics/linalg/internal/implementation/Scale.h>
#include <shogun/mathematics/linalg/internal/implementation/Convolve.h>
#include <shogun/mathematics/linalg/internal/implementation/RangeFill.h>

namespace shogun
{

namespace linalg
{

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void add(Matrix A, Matrix B, Matrix C, typename Matrix::Scalar alpha=1.0,
        typename Matrix::Scalar beta=1.0)
{
    implementation::add<backend, Matrix>::compute(A, B, C, alpha, beta);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
Matrix add(Matrix A, Matrix B, typename Matrix::Scalar alpha=1.0,
        typename Matrix::Scalar beta=1.0)
{
    return implementation::add<backend, Matrix>::compute(A, B, alpha, beta);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void scale(Matrix A, Matrix B, typename Matrix::Scalar alpha)
{
    implementation::scale<backend, Matrix>::compute(A, B, alpha);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void scale(Matrix A, typename Matrix::Scalar alpha)
{
    implementation::scale<backend, Matrix>::compute(A, A, alpha);
}

template <Backend backend=linalg_traits<Core>::backend, class Matrix>
void range_fill(Matrix A, typename Matrix::Scalar start=0.0)
{
    implementation::range_fill<backend, Matrix>::compute(A, start);
}

template <Backend backend=linalg_traits<Core>::backend, class Matrix>
void range_fill(Matrix A, index_t len, typename Matrix::Scalar start=0.0)
{
    implementation::range_fill<backend, Matrix>::compute(A, len, start);
}

#ifdef HAVE_LINALG_LIB

template <Backend backend=linalg_traits<Core>::backend,class Matrix,class Vector>
void apply(Matrix A, Vector b, Vector x, bool transpose=false)
{
    implementation::apply<backend,Matrix,Vector>::compute(A, b, x, transpose);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix,class Vector>
Vector apply(Matrix A, Vector b, bool transpose=false)
{
    return implementation::apply<backend,Matrix,Vector>::compute(A, b, transpose);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void matrix_product(Matrix A, Matrix B, Matrix C,
    bool transpose_A=false, bool transpose_B=false, bool overwrite=true)
{
    implementation::matrix_product<backend, Matrix>::compute(A, B, C, transpose_A, transpose_B, overwrite);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
typename implementation::matrix_product<backend,Matrix>::ReturnType matrix_product(Matrix A, Matrix B,
    bool transpose_A=false, bool transpose_B=false)
{
    return implementation::matrix_product<backend, Matrix>::compute(A, B, transpose_A, transpose_B);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void subtract(Matrix A, Matrix B, Matrix C,
    typename Matrix::Scalar alpha=1.0, typename Matrix::Scalar beta=1.0)
{
    implementation::add<backend, Matrix>::compute(A, B, C, alpha, -1*beta);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void elementwise_product(Matrix A, Matrix B, Matrix C)
{
    implementation::elementwise_product<backend, Matrix>::compute(A, B, C);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
typename implementation::elementwise_product<backend,Matrix>::ReturnType elementwise_product(Matrix A, Matrix B)
{
    return implementation::elementwise_product<backend,Matrix>::compute(A, B);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
typename implementation::elementwise_square<backend,Matrix>::ReturnType elementwise_square(Matrix m)
{
    return implementation::elementwise_square<backend,Matrix>::compute(m);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix, class ResultMatrix>
void elementwise_square(Matrix m, ResultMatrix result)
{
    implementation::elementwise_square<backend,Matrix>::compute(m,result);
}

template <Backend backend=linalg_traits<Core>::backend,class Matrix>
void convolve(Matrix X, Matrix W, Matrix Y, bool flip = false,
    bool overwrite=true, int32_t stride_x=1, int32_t stride_y=1)
{
    implementation::convolve<backend, Matrix>::compute(X, W, Y, flip, overwrite, stride_x, stride_y);
}
#endif // HAVE_LINALG_LIB

}

}
#endif // CORE_H_