Trait TensorElementwise 

pub trait TensorElementwise {
    // Required methods
    fn add(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn sub(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn mul(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn neg(&mut self, input: &Tensor) -> Result<Tensor>;
    fn conj(&mut self, input: &Tensor) -> Result<Tensor>;
    fn div(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn abs(&mut self, input: &Tensor) -> Result<Tensor>;
    fn sign(&mut self, input: &Tensor) -> Result<Tensor>;
    fn maximum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn minimum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>;
    fn compare(
        &mut self,
        lhs: &Tensor,
        rhs: &Tensor,
        dir: &CompareDir,
    ) -> Result<Tensor>;
    fn select(
        &mut self,
        pred: &Tensor,
        on_true: &Tensor,
        on_false: &Tensor,
    ) -> Result<Tensor>;
    fn clamp(
        &mut self,
        input: &Tensor,
        lower: &Tensor,
        upper: &Tensor,
    ) -> Result<Tensor>;

    // Provided methods
    fn add_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn add_into(
        &mut self,
        lhs: &Tensor,
        rhs: &Tensor,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn add_read_into(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn sub_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn sub_into(
        &mut self,
        lhs: &Tensor,
        rhs: &Tensor,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn sub_read_into(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn mul_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn mul_into(
        &mut self,
        lhs: &Tensor,
        rhs: &Tensor,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn mul_read_into(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn neg_read(&mut self, input: TensorRead<'_>) -> Result<Tensor> { ... }
    fn neg_into(&mut self, input: &Tensor, out: TensorWrite<'_>) -> Result<()> { ... }
    fn neg_read_into(
        &mut self,
        input: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn conj_read(&mut self, input: TensorRead<'_>) -> Result<Tensor> { ... }
    fn conj_into(&mut self, input: &Tensor, out: TensorWrite<'_>) -> Result<()> { ... }
    fn conj_read_into(
        &mut self,
        input: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn div_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn div_into(
        &mut self,
        lhs: &Tensor,
        rhs: &Tensor,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn div_read_into(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
        out: TensorWrite<'_>,
    ) -> Result<()> { ... }
    fn rem(&mut self, lhs: &Tensor, _rhs: &Tensor) -> Result<Tensor> { ... }
    fn rem_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn abs_read(&mut self, input: TensorRead<'_>) -> Result<Tensor> { ... }
    fn sign_read(&mut self, input: TensorRead<'_>) -> Result<Tensor> { ... }
    fn maximum_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn minimum_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn compare_read(
        &mut self,
        lhs: TensorRead<'_>,
        rhs: TensorRead<'_>,
        dir: &CompareDir,
    ) -> Result<Tensor> { ... }
    fn select_read(
        &mut self,
        pred: TensorRead<'_>,
        on_true: TensorRead<'_>,
        on_false: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
    fn clamp_read(
        &mut self,
        input: TensorRead<'_>,
        lower: TensorRead<'_>,
        upper: TensorRead<'_>,
    ) -> Result<Tensor> { ... }
}

Elementwise tensor operations.

Examples

use tenferro_tensor::TensorElementwise;

fn accepts_elementwise<B: TensorElementwise>(_backend: &mut B) {}

Required Methods

fn add(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn sub(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn mul(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn neg(&mut self, input: &Tensor) -> Result<Tensor>

fn conj(&mut self, input: &Tensor) -> Result<Tensor>

fn div(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn abs(&mut self, input: &Tensor) -> Result<Tensor>

fn sign(&mut self, input: &Tensor) -> Result<Tensor>

fn maximum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn minimum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor>

fn compare( &mut self, lhs: &Tensor, rhs: &Tensor, dir: &CompareDir, ) -> Result<Tensor>

fn select( &mut self, pred: &Tensor, on_true: &Tensor, on_false: &Tensor, ) -> Result<Tensor>

fn clamp( &mut self, input: &Tensor, lower: &Tensor, upper: &Tensor, ) -> Result<Tensor>

Provided Methods

fn add_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

Elementwise addition accepting either owned tensors or borrowed views.

Backends that implement this method must not silently move data across devices. A backend that cannot consume views should return an explicit backend error rather than materializing or transferring implicitly.

Examples

use tenferro_tensor::{Tensor, TensorElementwise, TensorRead};

fn add_owned<B: TensorElementwise>(
    backend: &mut B,
    lhs: &Tensor,
    rhs: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    backend.add_read(TensorRead::from_tensor(lhs), TensorRead::from_tensor(rhs))
}

fn add_into( &mut self, lhs: &Tensor, rhs: &Tensor, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise addition.

_into methods never accumulate into the previous output value.

Examples

use tenferro_tensor::{Tensor, TensorElementwise, TensorWrite};

fn add_into<B: TensorElementwise>(
    backend: &mut B,
    lhs: &Tensor,
    rhs: &Tensor,
    mut out: Tensor,
) -> tenferro_tensor::Result<Tensor> {
    backend.add_into(lhs, rhs, TensorWrite::from_tensor(&mut out))?;
    Ok(out)
}

fn add_read_into( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise addition from reads.

Examples

use tenferro_tensor::{TensorElementwise, TensorRead, TensorWrite};

fn add_read_into<B: TensorElementwise>(
    backend: &mut B,
    lhs: TensorRead<'_>,
    rhs: TensorRead<'_>,
    out: TensorWrite<'_>,
) -> tenferro_tensor::Result<()> {
    backend.add_read_into(lhs, rhs, out)
}

fn sub_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

Elementwise subtraction accepting either owned tensors or borrowed views.

Examples

use tenferro_tensor::{Tensor, TensorElementwise, TensorRead};

fn sub_owned<B: TensorElementwise>(
    backend: &mut B,
    lhs: &Tensor,
    rhs: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    backend.sub_read(TensorRead::from_tensor(lhs), TensorRead::from_tensor(rhs))
}

fn sub_into( &mut self, lhs: &Tensor, rhs: &Tensor, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise subtraction.

fn sub_read_into( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise subtraction from reads.

fn mul_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

fn mul_into( &mut self, lhs: &Tensor, rhs: &Tensor, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise multiplication.

fn mul_read_into( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise multiplication from reads.

fn neg_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

fn neg_into(&mut self, input: &Tensor, out: TensorWrite<'_>) -> Result<()>

Overwrite caller-provided output with elementwise negation.

fn neg_read_into( &mut self, input: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise negation from a read.

fn conj_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

fn conj_into(&mut self, input: &Tensor, out: TensorWrite<'_>) -> Result<()>

Overwrite caller-provided output with elementwise conjugation.

fn conj_read_into( &mut self, input: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise conjugation from a read.

fn div_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

fn div_into( &mut self, lhs: &Tensor, rhs: &Tensor, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise division.

fn div_read_into( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, out: TensorWrite<'_>, ) -> Result<()>

Overwrite caller-provided output with elementwise division from reads.

fn rem(&mut self, lhs: &Tensor, _rhs: &Tensor) -> Result<Tensor>

Elementwise remainder.

The default is an explicit unsupported error so backend implementors can opt in without silent fallback.

Examples

use tenferro_tensor::{Tensor, TensorElementwise};

fn rem_owned<B: TensorElementwise>(
    backend: &mut B,
    lhs: &Tensor,
    rhs: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    backend.rem(lhs, rhs)
}

fn rem_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

Elementwise remainder accepting owned tensors or borrowed views.

Examples

use tenferro_tensor::{Tensor, TensorElementwise, TensorRead};

fn rem_read<B: TensorElementwise>(
    backend: &mut B,
    lhs: &Tensor,
    rhs: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    backend.rem_read(TensorRead::from_tensor(lhs), TensorRead::from_tensor(rhs))
}

fn abs_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

fn sign_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

fn maximum_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

fn minimum_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

fn compare_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, dir: &CompareDir, ) -> Result<Tensor>

fn select_read( &mut self, pred: TensorRead<'_>, on_true: TensorRead<'_>, on_false: TensorRead<'_>, ) -> Result<Tensor>

fn clamp_read( &mut self, input: TensorRead<'_>, lower: TensorRead<'_>, upper: TensorRead<'_>, ) -> Result<Tensor>

Implementors