types.hpp

Go to the documentation of this file.

// Copyright 2025 Eric Hermosis
//
// This file is part of the Tannic Tensor Library.
//
// 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 TYPES_HPP
#define TYPES_HPP
 
#include <iostream>
#include <cstdint>  
#include <string>   
#include <complex>
#include "runtime/types.h"
 
namespace tannic {
 
constexpr inline std::size_t dsizeof(type type) {
    switch (type) { 
        case boolean:   return 0;
        case int8:      return sizeof(int8_t);
        case int16:     return sizeof(int16_t);
        case int32:     return sizeof(int32_t);
        case int64:     return sizeof(int64_t);
        case float16:   return sizeof(float) / 2;
        case float32:   return sizeof(float);
        case float64:   return 2 * sizeof(float);
        case complex64: return 2 * sizeof(float);     
        case complex128:return 2 * sizeof(double);  
        default:        return 0;
    }
} 
 
constexpr inline std::size_t nbytesof(type dtype, std::size_t nelements) {
    if (dtype == boolean) {
        return (nelements + 7) / 8; 
    }
    return dsizeof(dtype) * nelements;
}
 
 
constexpr inline std::string dnameof(type type) {
    switch (type) { 
        case boolean:    return "boolean";
        case int8:       return "int8";
        case int16:      return "int16";
        case int32:      return "int32";
        case int64:      return "int64";
        case float16:    return "float16";
        case float32:    return "float32";
        case float64:    return "float64";
        case complex64:  return "complex64";
        case complex128: return "complex128";
        default:         return "none";
    }
} 
 
constexpr inline uint8_t dcodeof(type type) {
    switch (type) { 
        case boolean:   return 1;
        case int8:      return 12;
        case int16:     return 13;
        case int32:     return 14;
        case int64:     return 15;
        case float16:   return 23;
        case float32:   return 24;
        case float64:   return 25;
        case complex64: return 35;     
        case complex128:return 36;  
        default:        return 0;
    }
}
 
constexpr inline type dtypeof(uint8_t code) {
    switch (code) {
        case 1 : return boolean;
        case 12: return int8;
        case 13: return int16;
        case 14: return int32;
        case 15: return int64;
        case 23: return float16;
        case 24: return float32;
        case 25: return float64;
        case 35: return complex64;
        case 36: return complex128;
        default: return unknown;
    }
} 
  
template <typename T>
constexpr inline type dtypeof() {
    if constexpr (std::is_same_v<T, bool>) return boolean;
    else if constexpr (std::is_same_v<T, int8_t>)  return int8;
    else if constexpr (std::is_same_v<T, int16_t>) return int16;
    else if constexpr (std::is_same_v<T, int32_t>) return int32;
    else if constexpr (std::is_same_v<T, int64_t>) return int64;
    else if constexpr (std::is_same_v<T, float16_t>)   return float16;
    else if constexpr (std::is_same_v<T, float>)   return float32;
    else if constexpr (std::is_same_v<T, double>)  return float64;
    else if constexpr (std::is_same_v<T, std::complex<float>>)  return complex64;
    else if constexpr (std::is_same_v<T, std::complex<double>>) return complex128;
    else                                           return unknown;
}
 
inline std::ostream& operator<<(std::ostream& ostream, type type) {
    return ostream << dnameof(type);
} 
 
} // namespace tannic
 
#endif // TYPES_HPP