field.h

Go to the documentation of this file.

 
#ifndef OAKFIELD_FIELD_H
#define OAKFIELD_FIELD_H
 
#include <complex.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef OAKFIELD_SIM_RESULT_DEFINED
#define OAKFIELD_SIM_RESULT_DEFINED
typedef enum SimResult {
    SIM_RESULT_OK = 0,           
    SIM_RESULT_INVALID_ARGUMENT, 
    SIM_RESULT_INVALID_STATE,    
    SIM_RESULT_OUT_OF_MEMORY,    
    SIM_RESULT_NOT_FOUND,        
    SIM_RESULT_NOT_SUPPORTED,    
    SIM_RESULT_DEPENDENCY_ERROR, 
    SIM_RESULT_TYPE_MISMATCH     
} SimResult;
#endif /* OAKFIELD_SIM_RESULT_DEFINED */
 
typedef enum SimFieldStorage {
    SIM_FIELD_STORAGE_ROW_MAJOR = 0 
} SimFieldStorage;
 
typedef enum SimFieldDomain {
    SIM_FIELD_DOMAIN_UNKNOWN = 0, 
    SIM_FIELD_DOMAIN_PHYSICAL,    
    SIM_FIELD_DOMAIN_SPECTRAL,    
    SIM_FIELD_DOMAIN_HYBRID       
} SimFieldDomain;
 
typedef enum SimFieldValueKind {
    SIM_FIELD_VALUE_REAL_SCALAR = 0,         
    SIM_FIELD_VALUE_COMPLEX_SCALAR,          
    SIM_FIELD_VALUE_COMPLEX_REAL_CONSTRAINT, 
    SIM_FIELD_VALUE_COMPLEX_IMAG_ZERO_CONSTRAINT, 
    SIM_FIELD_VALUE_UNKNOWN                       
} SimFieldValueKind;
 
typedef struct SimFieldRepresentation {
    SimFieldDomain domain;        
    SimFieldValueKind value_kind; 
} SimFieldRepresentation;
 
typedef enum SimScalarDomainKind {
    SIM_SCALAR_DOMAIN_UNKNOWN = 0, 
    SIM_SCALAR_DOMAIN_REAL,        
    SIM_SCALAR_DOMAIN_COMPLEX,     
    SIM_SCALAR_DOMAIN_INTEGER,     
    SIM_SCALAR_DOMAIN_MODULAR      
} SimScalarDomainKind;
 
typedef enum SimScalarCapability {
    SIM_SCALAR_CAP_NONE = 0u,                           
    SIM_SCALAR_CAP_ADDITIVE_ARITHMETIC = 1u << 0,       
    SIM_SCALAR_CAP_MULTIPLICATIVE_ARITHMETIC = 1u << 1, 
    SIM_SCALAR_CAP_DIVISION = 1u << 2,                  
    SIM_SCALAR_CAP_ORDERING = 1u << 3,                  
    SIM_SCALAR_CAP_FLOOR = 1u << 4,                     
    SIM_SCALAR_CAP_MODULO = 1u << 5,           
    SIM_SCALAR_CAP_ANALYTIC_CALL = 1u << 6,    
    SIM_SCALAR_CAP_CONJUGATION = 1u << 7,      
    SIM_SCALAR_CAP_COMPLEX_ROTATION = 1u << 8, 
    SIM_SCALAR_CAP_POWER = 1u << 9             
} SimScalarCapability;
 
typedef struct SimScalarDomain {
    SimScalarDomainKind kind; 
    uint16_t bit_width;       
    bool is_signed;           
    uint64_t modulus;         
} SimScalarDomain;
 
struct SimField;
 
typedef void *(*SimFieldAllocFn)(void *userdata, size_t size);
 
typedef void (*SimFieldFreeFn)(void *userdata, void *ptr);
 
typedef struct SimFieldAllocator {
    SimFieldAllocFn allocate; 
    SimFieldFreeFn release;   
    void *userdata;           
} SimFieldAllocator;
 
typedef struct SimFieldLayout {
    size_t rank;     
    size_t *shape;   
    size_t *strides; 
    bool contiguous; 
} SimFieldLayout;
 
typedef struct SimField {
    SimFieldLayout layout;       
    size_t element_size;         
    void *data;                  
    SimFieldStorage storage;     
    SimFieldAllocator allocator; 
    bool owns_data;              
    bool complex_mode; 
    SimFieldRepresentation repr;   
    SimScalarDomain scalar_domain; 
    uint64_t magic;                
} SimField;
 
typedef struct SimComplexDouble {
    double re; 
    double im; 
} SimComplexDouble;
 
#ifndef SIM_HAVE_SIMCOMPLEXDOUBLE
#define SIM_HAVE_SIMCOMPLEXDOUBLE 1
#endif
 
SimResult sim_field_allocator_default(SimFieldAllocator *allocator);
 
SimResult sim_field_init(SimField *field, size_t rank, const size_t *shape, size_t element_size,
                         SimFieldStorage storage, const SimFieldAllocator *allocator);
 
SimResult sim_field_init_typed(SimField *field, size_t rank, const size_t *shape,
                               SimScalarDomain scalar_domain, SimFieldStorage storage,
                               const SimFieldAllocator *allocator);
 
SimResult sim_field_wrap(SimField *field, const SimFieldLayout *layout, size_t element_size,
                         SimFieldStorage storage, void *data);
 
SimResult sim_field_wrap_typed(SimField *field, const SimFieldLayout *layout,
                               SimScalarDomain scalar_domain, SimFieldStorage storage, void *data);
 
void sim_field_destroy(SimField *field);
 
SimResult sim_field_index_offset(const SimField *field, const size_t *indices, size_t *out_offset);
 
SimResult sim_field_element_index(const SimField *field, const size_t *indices, size_t rank,
                                  size_t *out_index);
 
void *sim_field_data(SimField *field);
 
const void *sim_field_data_const(const SimField *field);
 
size_t sim_field_element_count(const SimFieldLayout *layout);
 
size_t sim_field_bytes(const SimField *field);
 
size_t sim_field_rank(const SimField *field);
 
const size_t *sim_field_shape(const SimField *field);
 
const size_t *sim_field_strides(const SimField *field);
 
size_t sim_field_width(const SimField *field);
 
size_t sim_field_height(const SimField *field);
 
SimResult sim_field_index_to_xy(const SimField *field, size_t index, size_t *out_x, size_t *out_y);
 
SimResult sim_field_xy_to_index(const SimField *field, size_t x, size_t y, size_t *out_index);
 
bool sim_field_complex_mode(const SimField *field);
 
bool sim_field_storage_is_complex(const SimField *field);
 
bool sim_field_domain_is_complex(const SimField *field);
 
bool sim_field_is_complex(const SimField *field);
 
size_t sim_field_components(const SimField *field);
 
double *sim_field_real_data(SimField *field);
const double *sim_field_real_data_const(const SimField *field);
int8_t *sim_field_i8_data(SimField *field);
const int8_t *sim_field_i8_data_const(const SimField *field);
int32_t *sim_field_i32_data(SimField *field);
const int32_t *sim_field_i32_data_const(const SimField *field);
int64_t *sim_field_i64_data(SimField *field);
const int64_t *sim_field_i64_data_const(const SimField *field);
uint8_t *sim_field_u8_data(SimField *field);
const uint8_t *sim_field_u8_data_const(const SimField *field);
uint32_t *sim_field_u32_data(SimField *field);
const uint32_t *sim_field_u32_data_const(const SimField *field);
uint64_t *sim_field_u64_data(SimField *field);
const uint64_t *sim_field_u64_data_const(const SimField *field);
 
SimComplexDouble *sim_field_complex_data(SimField *field);
const SimComplexDouble *sim_field_complex_data_const(const SimField *field);
 
SimResult sim_field_promote_inplace_to_complex(SimField *field);
 
SimResult sim_field_require_complex(SimField *field);
SimFieldRepresentation sim_field_representation(const SimField *field);
SimScalarDomain sim_field_scalar_domain(const SimField *field);
SimResult sim_field_set_scalar_domain(SimField *field, SimScalarDomain domain);
bool sim_field_storage_matches_scalar_domain(size_t element_size, SimScalarDomain domain);
SimScalarDomain sim_scalar_domain_unknown(void);
SimScalarDomain sim_scalar_domain_f64(void);
SimScalarDomain sim_scalar_domain_c64(void);
SimScalarDomain sim_scalar_domain_i8(void);
SimScalarDomain sim_scalar_domain_i32(void);
SimScalarDomain sim_scalar_domain_i64(void);
SimScalarDomain sim_scalar_domain_u8(void);
SimScalarDomain sim_scalar_domain_u32(void);
SimScalarDomain sim_scalar_domain_u64(void);
SimScalarDomain sim_scalar_domain_from_legacy_complex_flag(bool is_complex);
SimScalarDomain sim_scalar_domain_from_field_representation(SimFieldRepresentation repr);
SimScalarDomain sim_scalar_domain_from_field(const SimField *field);
const char *sim_scalar_domain_kind_name(SimScalarDomainKind kind);
bool sim_scalar_domain_kind_from_name(const char *text, SimScalarDomainKind *out_kind);
const char *sim_scalar_domain_name(SimScalarDomain domain);
bool sim_scalar_domain_from_name(const char *text, SimScalarDomain *out_domain);
bool sim_scalar_domain_equal(SimScalarDomain lhs, SimScalarDomain rhs);
bool sim_scalar_domain_validate(SimScalarDomain domain);
bool sim_scalar_domain_is_complex(SimScalarDomain domain);
bool sim_scalar_domain_is_integer(SimScalarDomain domain);
uint32_t sim_scalar_domain_capabilities(SimScalarDomain domain);
bool sim_scalar_domain_supports(SimScalarDomain domain, uint32_t capability_mask);
const char *sim_field_domain_name(SimFieldDomain domain);
const char *sim_field_value_kind_name(SimFieldValueKind kind);
bool sim_field_domain_from_name(const char *text, SimFieldDomain *out_domain);
bool sim_field_value_kind_from_name(const char *text, SimFieldValueKind *out_kind);
bool sim_field_value_kind_is_complex_valued(SimFieldValueKind kind);
bool sim_field_value_kind_has_imag_zero_constraint(SimFieldValueKind kind);
bool sim_field_value_kind_has_spectral_real_constraint(SimFieldValueKind kind);
bool sim_field_representation_requires_complex_storage(SimFieldRepresentation repr);
bool sim_field_representation_has_imag_zero_constraint(SimFieldRepresentation repr);
bool sim_field_representation_has_spectral_real_constraint(SimFieldRepresentation repr);
SimResult sim_field_validate_representation(const SimField *field, SimFieldRepresentation repr);
SimResult sim_field_set_representation(SimField *field, SimFieldRepresentation repr);
#ifdef __cplusplus
}
#endif
 
#endif /* OAKFIELD_FIELD_H */