functions.hpp

Go to the documentation of this file.

// Copyright 2025 Eric Hermosis
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
#ifndef FUNCTIONS_HPP
#define FUNCTIONS_HPP
 
#include "concepts.hpp"
#include "traits.hpp" 
#include "shape.hpp"
#include "strides.hpp"
#include "tensor.hpp" 
 
namespace tannic::function {  
template<Functional Functor, Expression Argument>
class Function {
public:
    Functor functor;
    typename Trait<Argument>::Reference argument;
 
    constexpr Function(Functor functor, typename Trait<Argument>::Reference argument)
    :   functor(functor)
    ,   argument(argument)
    {}
 
    constexpr type dtype() const {
        return argument.dtype();
    }
 
    constexpr Shape const& shape() const {
        return argument.shape();
    }  
 
    constexpr Strides const& strides() const {
        return argument.strides();
    }
 
    auto offset() const {
        return argument.offset();
    }
 
    Tensor forward() const {
        Tensor source = argument.forward();
        Tensor target(dtype(), shape(), strides(), offset());
        functor(source, target);
        return target;
    } 
};
 
 
struct Log {
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Exp {
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Sqrt { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Rsqrt { 
    float epsilon = 0.0f;
    void operator()(Tensor const&, Tensor&) const;
};
 
 
struct Abs { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Sin {
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Cos { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Tan { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Sinh { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Cosh { 
    void operator()(Tensor const&, Tensor&) const;
};
 
struct Tanh { 
    void operator()(Tensor const&, Tensor&) const;
};
 
template<Expression Operand>
constexpr auto log(Operand&& operand) {
    return Function<Log, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto exp(Operand&& operand) {
    return Function<Exp, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto sqrt(Operand&& operand) {
    return Function<Sqrt, Operand>({}, std::forward<Operand>(operand));
}  
 
template<Expression Operand>
constexpr auto rsqrt(Operand&& operand, float epsilon = 0.0f) {
    return Function<Rsqrt, Operand>({epsilon}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto abs(Operand&& operand) {
    return Function<Abs, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto sin(Operand&& operand) {
    return Function<Sin, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto cos(Operand&& operand) {
    return Function<Cos, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto tan(Operand&& operand) {
    return Function<Tan, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto sinh(Operand&& operand) {
    return Function<Sinh, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto cosh(Operand&& operand) {
    return Function<Cosh, Operand>({}, std::forward<Operand>(operand));
}
 
template<Expression Operand>
constexpr auto tanh(Operand&& operand) {
    return Function<Tanh, Operand>({}, std::forward<Operand>(operand));
}
 
} namespace tannic {
    
using function::log;
using function::exp;
using function::sqrt;
using function::rsqrt;
using function::abs;
using function::sin;
using function::cos;
using function::tan;
using function::sinh;
using function::cosh;
using function::tanh;
 
} //namespace tannic
 
#endif // FUNCTIONS_HPP