Trait DivArray2 

pub trait DivArray2<RHS> {
    type Output;

    // Required method
    fn div_array2(self, rhs: Array2<RHS>) -> Result<Self::Output, String>;
}

Required Associated Types

type Output

Required Methods

fn div_array2(self, rhs: Array2<RHS>) -> Result<Self::Output, String>

Implementations on Foreign Types

impl DivArray2<Acceleration> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Mass>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Acceleration>) -> Result<Array2<Mass>, String>

impl DivArray2<Acceleration> for Array2<ForcePerVolume>

type Output = ArrayBase<OwnedRepr<Density>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Acceleration>, ) -> Result<Array2<Density>, String>

impl DivArray2<Acceleration> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<MassPerDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Acceleration>, ) -> Result<Array2<MassPerDistance>, String>

impl DivArray2<Acceleration> for Array2<Velocity>

type Output = ArrayBase<OwnedRepr<Time>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Acceleration>) -> Result<Array2<Time>, String>

impl DivArray2<Angle> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<RotationalStiffness>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Angle>, ) -> Result<Array2<RotationalStiffness>, String>

impl DivArray2<AngularAcceleration> for Array2<AngularVelocity>

type Output = ArrayBase<OwnedRepr<Time>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<AngularAcceleration>, ) -> Result<Array2<Time>, String>

impl DivArray2<AngularVelocity> for Array2<Angle>

type Output = ArrayBase<OwnedRepr<Time>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<AngularVelocity>, ) -> Result<Array2<Time>, String>

impl DivArray2<AngularVelocity> for Array2<Velocity>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<AngularVelocity>, ) -> Result<Array2<Distance>, String>

impl DivArray2<Area> for Array2<AreaOfMoment>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<Area>, String>

impl DivArray2<Area> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Area>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<Area> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<Stress>, String>

impl DivArray2<Area> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<Force>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<Force>, String>

impl DivArray2<Area> for Array2<ForceStress>

type Output = ArrayBase<OwnedRepr<StressSquared>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<StressSquared>, String>

impl DivArray2<Area> for Array2<MassPerDistance>

type Output = ArrayBase<OwnedRepr<Density>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<Density>, String>

impl DivArray2<Area> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<ForcePerVolume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<ForcePerVolume>, String>

impl DivArray2<Area> for Array2<Volume>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Area>) -> Result<Array2<Distance>, String>

impl DivArray2<AreaOfMoment> for Array2<Area>

type Output = ArrayBase<OwnedRepr<InverseArea>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<AreaOfMoment>, ) -> Result<Array2<InverseArea>, String>

impl DivArray2<AreaOfMoment> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<AreaOfMoment>) -> Result<Array2<Stress>, String>

impl DivArray2<AreaOfMoment> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<Stiffness>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<AreaOfMoment>, ) -> Result<Array2<Stiffness>, String>

impl DivArray2<Charge> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Voltage>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Charge>) -> Result<Array2<Voltage>, String>

impl DivArray2<Compliance> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Force>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Compliance>) -> Result<Array2<Force>, String>

impl DivArray2<Compliance> for Array2<Volume>

type Output = ArrayBase<OwnedRepr<ForceArea>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Compliance>, ) -> Result<Array2<ForceArea>, String>

impl DivArray2<Density> for Array2<ForcePerVolume>

type Output = ArrayBase<OwnedRepr<Acceleration>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Density>, ) -> Result<Array2<Acceleration>, String>

impl DivArray2<Density> for Array2<Mass>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Density>) -> Result<Array2<Volume>, String>

impl DivArray2<Density> for Array2<MassPerDistance>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Density>) -> Result<Array2<Area>, String>

impl DivArray2<Distance> for Array2<Area>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Distance>, String>

impl DivArray2<Distance> for Array2<AreaOfMoment>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Volume>, String>

impl DivArray2<Distance> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Stiffness>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Stiffness>, String>

impl DivArray2<Distance> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<ForceDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Distance>, ) -> Result<Array2<ForceDistance>, String>

impl DivArray2<Distance> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Force>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Force>, String>

impl DivArray2<Distance> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<ForceArea>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<ForceArea>, String>

impl DivArray2<Distance> for Array2<InverseDistance>

type Output = ArrayBase<OwnedRepr<InverseArea>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Distance>, ) -> Result<Array2<InverseArea>, String>

impl DivArray2<Distance> for Array2<Mass>

type Output = ArrayBase<OwnedRepr<MassPerDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Distance>, ) -> Result<Array2<MassPerDistance>, String>

impl DivArray2<Distance> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Stress>, String>

impl DivArray2<Distance> for Array2<Strain>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Distance>, String>

impl DivArray2<Distance> for Array2<Stress>

type Output = ArrayBase<OwnedRepr<ForcePerVolume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Distance>, ) -> Result<Array2<ForcePerVolume>, String>

impl DivArray2<Distance> for Array2<Time>

type Output = ArrayBase<OwnedRepr<Velocity>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Velocity>, String>

impl DivArray2<Distance> for Array2<Velocity>

type Output = ArrayBase<OwnedRepr<AngularVelocity>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Distance>, ) -> Result<Array2<AngularVelocity>, String>

impl DivArray2<Distance> for Array2<Volume>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Distance>) -> Result<Array2<Area>, String>

impl DivArray2<Force> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Compliance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Force>) -> Result<Array2<Compliance>, String>

impl DivArray2<Force> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Force>) -> Result<Array2<Area>, String>

impl DivArray2<Force> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Force>) -> Result<Array2<Distance>, String>

impl DivArray2<Force> for Array2<ForceStress>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Force>) -> Result<Array2<Stress>, String>

impl DivArray2<Force> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Force>) -> Result<Array2<Volume>, String>

impl DivArray2<ForceArea> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<ForceArea>) -> Result<Array2<Distance>, String>

impl DivArray2<ForceArea> for Array2<Volume>

type Output = ArrayBase<OwnedRepr<Compliance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForceArea>, ) -> Result<Array2<Compliance>, String>

impl DivArray2<ForceDistance> for Array2<Force>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForceDistance>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<ForceDistance> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForceDistance>, ) -> Result<Array2<Distance>, String>

impl DivArray2<ForcePerDistancePowerFour> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForcePerDistancePowerFour>, ) -> Result<Array2<Volume>, String>

impl DivArray2<ForcePerVolume> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForcePerVolume>, ) -> Result<Array2<Volume>, String>

impl DivArray2<ForcePerVolume> for Array2<ForcePerDistancePowerFour>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForcePerVolume>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<ForcePerVolume> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<ForcePerVolume>) -> Result<Array2<Area>, String>

impl DivArray2<ForcePerVolume> for Array2<Stress>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<ForcePerVolume>, ) -> Result<Array2<Distance>, String>

impl DivArray2<InverseArea> for Array2<Area>

type Output = ArrayBase<OwnedRepr<AreaOfMoment>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseArea>, ) -> Result<Array2<AreaOfMoment>, String>

impl DivArray2<InverseArea> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<InverseArea>) -> Result<Array2<Volume>, String>

impl DivArray2<InverseArea> for Array2<InverseDistance>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseArea>, ) -> Result<Array2<Distance>, String>

impl DivArray2<InverseDistance> for Array2<Area>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<Volume>, String>

impl DivArray2<InverseDistance> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<Area>, String>

impl DivArray2<InverseDistance> for Array2<Force>

type Output = ArrayBase<OwnedRepr<ForceDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<ForceDistance>, String>

impl DivArray2<InverseDistance> for Array2<ForcePerDistancePowerFour>

type Output = ArrayBase<OwnedRepr<ForcePerVolume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<ForcePerVolume>, String>

impl DivArray2<InverseDistance> for Array2<ForcePerVolume>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<Stress>, String>

impl DivArray2<InverseDistance> for Array2<InverseArea>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<InverseDistance>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<Mass> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Acceleration>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Mass>) -> Result<Array2<Acceleration>, String>

impl DivArray2<Mass> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<VelocitySquared>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Mass>, ) -> Result<Array2<VelocitySquared>, String>

impl DivArray2<MassPerDistance> for Array2<Mass>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<MassPerDistance>, ) -> Result<Array2<Distance>, String>

impl DivArray2<MassPerDistance> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<Acceleration>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<MassPerDistance>, ) -> Result<Array2<Acceleration>, String>

impl DivArray2<RotationalStiffness> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Angle>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<RotationalStiffness>, ) -> Result<Array2<Angle>, String>

impl DivArray2<Stiffness> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stiffness>) -> Result<Array2<Distance>, String>

impl DivArray2<Stiffness> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<AreaOfMoment>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Stiffness>, ) -> Result<Array2<AreaOfMoment>, String>

impl DivArray2<Strain> for Array2<Stress>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Strain>) -> Result<Array2<Stress>, String>

impl DivArray2<Stress> for Array2<Force>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<Area>, String>

impl DivArray2<Stress> for Array2<ForceArea>

type Output = ArrayBase<OwnedRepr<AreaOfMoment>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<AreaOfMoment>, String>

impl DivArray2<Stress> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Volume>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<Volume>, String>

impl DivArray2<Stress> for Array2<ForcePerVolume>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Stress>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<Stress> for Array2<ForceStress>

type Output = ArrayBase<OwnedRepr<Force>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<Force>, String>

impl DivArray2<Stress> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<Distance>, String>

impl DivArray2<Stress> for Array2<StressSquared>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Stress>) -> Result<Array2<Stress>, String>

impl DivArray2<StressSquared> for Array2<ForceStress>

type Output = ArrayBase<OwnedRepr<Area>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<StressSquared>) -> Result<Array2<Area>, String>

impl DivArray2<Time> for Array2<Angle>

type Output = ArrayBase<OwnedRepr<AngularVelocity>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Time>, ) -> Result<Array2<AngularVelocity>, String>

impl DivArray2<Time> for Array2<AngularVelocity>

type Output = ArrayBase<OwnedRepr<AngularAcceleration>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Time>, ) -> Result<Array2<AngularAcceleration>, String>

impl DivArray2<Time> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Velocity>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Time>) -> Result<Array2<Velocity>, String>

impl DivArray2<Time> for Array2<Velocity>

type Output = ArrayBase<OwnedRepr<Acceleration>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Time>) -> Result<Array2<Acceleration>, String>

impl DivArray2<Velocity> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<Time>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Velocity>) -> Result<Array2<Time>, String>

impl DivArray2<Velocity> for Array2<Time>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Velocity>) -> Result<Array2<Distance>, String>

impl DivArray2<VelocitySquared> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Mass>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<VelocitySquared>, ) -> Result<Array2<Mass>, String>

impl DivArray2<Voltage> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Charge>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Voltage>) -> Result<Array2<Charge>, String>

impl DivArray2<Volume> for Array2<Area>

type Output = ArrayBase<OwnedRepr<InverseDistance>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Volume>, ) -> Result<Array2<InverseDistance>, String>

impl DivArray2<Volume> for Array2<AreaOfMoment>

type Output = ArrayBase<OwnedRepr<Distance>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Volume>) -> Result<Array2<Distance>, String>

impl DivArray2<Volume> for Array2<Distance>

type Output = ArrayBase<OwnedRepr<InverseArea>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Volume>) -> Result<Array2<InverseArea>, String>

impl DivArray2<Volume> for Array2<Force>

type Output = ArrayBase<OwnedRepr<ForcePerVolume>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Volume>, ) -> Result<Array2<ForcePerVolume>, String>

impl DivArray2<Volume> for Array2<ForceDistance>

type Output = ArrayBase<OwnedRepr<Stress>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Volume>) -> Result<Array2<Stress>, String>

impl DivArray2<Volume> for Array2<ForceVolume>

type Output = ArrayBase<OwnedRepr<Force>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Volume>) -> Result<Array2<Force>, String>

impl DivArray2<Volume> for Array2<Mass>

type Output = ArrayBase<OwnedRepr<Density>, Dim<[usize; 2]>>

fn div_array2(self, rhs: Array2<Volume>) -> Result<Array2<Density>, String>

impl DivArray2<Volume> for Array2<Stiffness>

type Output = ArrayBase<OwnedRepr<ForcePerDistancePowerFour>, Dim<[usize; 2]>>

fn div_array2( self, rhs: Array2<Volume>, ) -> Result<Array2<ForcePerDistancePowerFour>, String>

Implementors