use crate::err::{FloatToIntPolicy, Result, convert_f64_to_i64};
use crate::exec::capability::Capabilities;
use crate::tensor::device::DeviceId;
use crate::tensor::dtype::DTypeId;
use crate::tensor::dtype::{DType, DTypeDescriptor};
mod execute;
pub use execute::{Execute, ExecuteOutput, ExecutionRequest, StorageBackend, StorageOutput};
mod transfer;
pub use transfer::{StorageTransfer, TransferTo, VariableTransfer};
mod autograd;
pub use autograd::AutogradBackend;
mod variable;
pub use variable::VariableBackend;
mod capability;
pub use capability::{HostInterop, HostReadback, TransferBackend};
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ScalarValue {
Float(f64),
Int(i64),
}
impl ScalarValue {
pub fn to_f64(self) -> f64 {
match self {
ScalarValue::Float(f) => f,
ScalarValue::Int(i) => i as f64,
}
}
pub fn to_i64(self, policy: FloatToIntPolicy) -> Result<i64> {
match self {
ScalarValue::Float(f) => {
convert_f64_to_i64("scalar_value_to_i64", DTypeId::F64.descriptor(), f, policy)
}
ScalarValue::Int(i) => Ok(i),
}
}
}
impl From<f32> for ScalarValue {
fn from(v: f32) -> Self {
ScalarValue::Float(v as f64)
}
}
impl From<f64> for ScalarValue {
fn from(v: f64) -> Self {
ScalarValue::Float(v)
}
}
impl From<i32> for ScalarValue {
fn from(v: i32) -> Self {
ScalarValue::Int(v as i64)
}
}
impl From<i64> for ScalarValue {
fn from(v: i64) -> Self {
ScalarValue::Int(v)
}
}
pub trait SupportsDType<K: DType> {
fn resolve_dtype(field: &K::Field, device: &DeviceId) -> Result<DTypeDescriptor>;
}
pub trait TensorBackend<K: DType>: Backend + SupportsDType<K> {}
impl<B, K> TensorBackend<K> for B
where
B: Backend + SupportsDType<K>,
K: DType,
{
}
pub trait Backend:
StorageBackend + Capabilities + Default + Sized + Clone + Send + Sync + 'static
{
type InnerBackend: Backend;
}
#[cfg(test)]
mod scalar_value_tests {
use super::*;
use crate::err::{ConversionFailure, Error};
#[test]
fn float_to_integer_requires_an_explicit_checked_policy() {
assert_eq!(
ScalarValue::Float(12.0)
.to_i64(FloatToIntPolicy::Exact)
.unwrap(),
12
);
assert!(matches!(
ScalarValue::Float(12.5).to_i64(FloatToIntPolicy::Exact),
Err(Error::InvalidConversion {
reason: ConversionFailure::Fractional,
..
})
));
assert_eq!(
ScalarValue::Float(12.5)
.to_i64(FloatToIntPolicy::Truncate)
.unwrap(),
12
);
}
}