Trait MulArray1 

pub trait MulArray1<RHS> {
    type Output;

    // Required method
    fn mul_array1(self, rhs: Array1<RHS>) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn mul_array1(self, rhs: Array1<RHS>) -> Self::Output

Implementations on Foreign Types

impl MulArray1<Acceleration> for Array1<Density>

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

fn mul_array1(self, rhs: Array1<Acceleration>) -> Array1<ForcePerVolume>

impl MulArray1<Acceleration> for Array1<Mass>

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

fn mul_array1(self, rhs: Array1<Acceleration>) -> Array1<Force>

impl MulArray1<Acceleration> for Array1<MassPerDistance>

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

fn mul_array1(self, rhs: Array1<Acceleration>) -> Array1<Stiffness>

impl MulArray1<Acceleration> for Array1<Time>

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

fn mul_array1(self, rhs: Array1<Acceleration>) -> Array1<Velocity>

impl MulArray1<Angle> for Array1<InverseAngle>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Angle>) -> Array1<f64>

impl MulArray1<Angle> for Array1<RotationalStiffness>

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

fn mul_array1(self, rhs: Array1<Angle>) -> Array1<ForceDistance>

impl MulArray1<AngularAcceleration> for Array1<Density>

type Output = ArrayBase<OwnedRepr<MassDivTimeSquaredVolume>, Dim<[usize; 1]>>

fn mul_array1( self, rhs: Array1<AngularAcceleration>, ) -> Array1<MassDivTimeSquaredVolume>

impl MulArray1<AngularAcceleration> for Array1<Time>

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

fn mul_array1(self, rhs: Array1<AngularAcceleration>) -> Array1<AngularVelocity>

impl MulArray1<AngularVelocity> for Array1<AngularVelocity>

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

fn mul_array1(self, rhs: Array1<AngularVelocity>) -> Array1<AngularAcceleration>

impl MulArray1<AngularVelocity> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<AngularVelocity>) -> Array1<Velocity>

impl MulArray1<AngularVelocity> for Array1<Time>

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

fn mul_array1(self, rhs: Array1<AngularVelocity>) -> Array1<Angle>

impl MulArray1<AngularVelocity> for Array1<Velocity>

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

fn mul_array1(self, rhs: Array1<AngularVelocity>) -> Array1<Acceleration>

impl MulArray1<Area> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<AreaOfMoment>

impl MulArray1<Area> for Array1<Density>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<MassPerDistance>

impl MulArray1<Area> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<Volume>

impl MulArray1<Area> for Array1<Force>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<ForceArea>

impl MulArray1<Area> for Array1<ForcePerVolume>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<Stiffness>

impl MulArray1<Area> for Array1<InverseArea>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Area>) -> Array1<f64>

impl MulArray1<Area> for Array1<InverseDistance>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<Distance>

impl MulArray1<Area> for Array1<MassDivTimeSquaredVolume>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<Stress>

impl MulArray1<Area> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<Area>) -> Array1<Force>

impl MulArray1<Area> for Array1<StressSquared>

type Output = ArrayBase<OwnedRepr<ForceStress>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Area>) -> Array1<ForceStress>

impl MulArray1<AreaOfMoment> for Array1<InverseArea>

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

fn mul_array1(self, rhs: Array1<AreaOfMoment>) -> Array1<Area>

impl MulArray1<AreaOfMoment> for Array1<Stiffness>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<AreaOfMoment>) -> Array1<ForceVolume>

impl MulArray1<AreaOfMoment> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<AreaOfMoment>) -> Array1<ForceArea>

impl MulArray1<Charge> for Array1<Voltage>

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

fn mul_array1(self, rhs: Array1<Charge>) -> Array1<ForceDistance>

impl MulArray1<Compliance> for Array1<Force>

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

fn mul_array1(self, rhs: Array1<Compliance>) -> Array1<Distance>

impl MulArray1<Compliance> for Array1<ForceArea>

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

fn mul_array1(self, rhs: Array1<Compliance>) -> Array1<Volume>

impl MulArray1<Density> for Array1<Acceleration>

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

fn mul_array1(self, rhs: Array1<Density>) -> Array1<ForcePerVolume>

impl MulArray1<Density> for Array1<AngularAcceleration>

type Output = ArrayBase<OwnedRepr<MassDivTimeSquaredVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Density>) -> Array1<MassDivTimeSquaredVolume>

impl MulArray1<Density> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<Density>) -> Array1<MassPerDistance>

impl MulArray1<Density> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<Density>) -> Array1<Mass>

impl MulArray1<Distance> for Array1<AngularVelocity>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Velocity>

impl MulArray1<Distance> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Volume>

impl MulArray1<Distance> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Area>

impl MulArray1<Distance> for Array1<Force>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<ForceDistance>

impl MulArray1<Distance> for Array1<ForceArea>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<ForceVolume>

impl MulArray1<Distance> for Array1<ForceDistance>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<ForceArea>

impl MulArray1<Distance> for Array1<ForcePerVolume>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Stress>

impl MulArray1<Distance> for Array1<InverseArea>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<InverseDistance>

impl MulArray1<Distance> for Array1<InverseDistance>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<f64>

impl MulArray1<Distance> for Array1<MassPerDistance>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Mass>

impl MulArray1<Distance> for Array1<Stiffness>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Force>

impl MulArray1<Distance> for Array1<Strain>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Distance>

impl MulArray1<Distance> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Stiffness>

impl MulArray1<Distance> for Array1<Velocity>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<Time>

impl MulArray1<Distance> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<Distance>) -> Array1<AreaOfMoment>

impl MulArray1<Force> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<Force>) -> Array1<ForceArea>

impl MulArray1<Force> for Array1<Compliance>

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

fn mul_array1(self, rhs: Array1<Force>) -> Array1<Distance>

impl MulArray1<Force> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Force>) -> Array1<ForceDistance>

impl MulArray1<Force> for Array1<Stress>

type Output = ArrayBase<OwnedRepr<ForceStress>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Force>) -> Array1<ForceStress>

impl MulArray1<Force> for Array1<Volume>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Force>) -> Array1<ForceVolume>

impl MulArray1<ForceArea> for Array1<Compliance>

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

fn mul_array1(self, rhs: Array1<ForceArea>) -> Array1<Volume>

impl MulArray1<ForceArea> for Array1<Distance>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<ForceArea>) -> Array1<ForceVolume>

impl MulArray1<ForceDistance> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<ForceDistance>) -> Array1<ForceArea>

impl MulArray1<ForceDistance> for Array1<InverseDistance>

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

fn mul_array1(self, rhs: Array1<ForceDistance>) -> Array1<Force>

impl MulArray1<ForcePerDistancePowerFour> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<ForcePerDistancePowerFour>) -> Array1<Stiffness>

impl MulArray1<ForcePerVolume> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<ForcePerVolume>) -> Array1<Stiffness>

impl MulArray1<ForcePerVolume> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<ForcePerVolume>) -> Array1<Stress>

impl MulArray1<ForcePerVolume> for Array1<InverseDistance>

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

fn mul_array1( self, rhs: Array1<ForcePerVolume>, ) -> Array1<ForcePerDistancePowerFour>

impl MulArray1<ForcePerVolume> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<ForcePerVolume>) -> Array1<Force>

impl MulArray1<InverseAngle> for Array1<Angle>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<InverseAngle>) -> Array1<f64>

impl MulArray1<InverseArea> for Array1<Area>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<InverseArea>) -> Array1<f64>

impl MulArray1<InverseArea> for Array1<AreaOfMoment>

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

fn mul_array1(self, rhs: Array1<InverseArea>) -> Array1<Area>

impl MulArray1<InverseArea> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<InverseArea>) -> Array1<InverseDistance>

impl MulArray1<InverseArea> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<InverseArea>) -> Array1<Distance>

impl MulArray1<InverseDistance> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<Distance>

impl MulArray1<InverseDistance> for Array1<Distance>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<f64>

impl MulArray1<InverseDistance> for Array1<ForceDistance>

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

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<Force>

impl MulArray1<InverseDistance> for Array1<ForcePerVolume>

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

fn mul_array1( self, rhs: Array1<InverseDistance>, ) -> Array1<ForcePerDistancePowerFour>

impl MulArray1<InverseDistance> for Array1<InverseDistance>

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

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<InverseArea>

impl MulArray1<InverseDistance> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<ForcePerVolume>

impl MulArray1<InverseDistance> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<InverseDistance>) -> Array1<Area>

impl MulArray1<InverseStress> for Array1<Stress>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<InverseStress>) -> Array1<f64>

impl MulArray1<Mass> for Array1<Acceleration>

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

fn mul_array1(self, rhs: Array1<Mass>) -> Array1<Force>

impl MulArray1<Mass> for Array1<VelocitySquared>

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

fn mul_array1(self, rhs: Array1<Mass>) -> Array1<ForceDistance>

impl MulArray1<MassDivTimeSquaredVolume> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<MassDivTimeSquaredVolume>) -> Array1<Stress>

impl MulArray1<MassPerDistance> for Array1<Acceleration>

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

fn mul_array1(self, rhs: Array1<MassPerDistance>) -> Array1<Stiffness>

impl MulArray1<MassPerDistance> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<MassPerDistance>) -> Array1<Mass>

impl MulArray1<RotationalStiffness> for Array1<Angle>

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

fn mul_array1(self, rhs: Array1<RotationalStiffness>) -> Array1<ForceDistance>

impl MulArray1<Stiffness> for Array1<AreaOfMoment>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Stiffness>) -> Array1<ForceVolume>

impl MulArray1<Stiffness> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Stiffness>) -> Array1<Force>

impl MulArray1<Strain> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Strain>) -> Array1<Distance>

impl MulArray1<Strain> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<Strain>) -> Array1<Stress>

impl MulArray1<Stress> for Array1<Area>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<Force>

impl MulArray1<Stress> for Array1<AreaOfMoment>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<ForceArea>

impl MulArray1<Stress> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<Stiffness>

impl MulArray1<Stress> for Array1<Force>

type Output = ArrayBase<OwnedRepr<ForceStress>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<ForceStress>

impl MulArray1<Stress> for Array1<InverseDistance>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<ForcePerVolume>

impl MulArray1<Stress> for Array1<InverseStress>

type Output = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<f64>

impl MulArray1<Stress> for Array1<Strain>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<Stress>

impl MulArray1<Stress> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<StressSquared>

impl MulArray1<Stress> for Array1<Volume>

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

fn mul_array1(self, rhs: Array1<Stress>) -> Array1<ForceDistance>

impl MulArray1<StressSquared> for Array1<Area>

type Output = ArrayBase<OwnedRepr<ForceStress>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<StressSquared>) -> Array1<ForceStress>

impl MulArray1<Time> for Array1<Acceleration>

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

fn mul_array1(self, rhs: Array1<Time>) -> Array1<Velocity>

impl MulArray1<Time> for Array1<AngularAcceleration>

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

fn mul_array1(self, rhs: Array1<Time>) -> Array1<AngularVelocity>

impl MulArray1<Time> for Array1<AngularVelocity>

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

fn mul_array1(self, rhs: Array1<Time>) -> Array1<Angle>

impl MulArray1<Time> for Array1<Velocity>

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

fn mul_array1(self, rhs: Array1<Time>) -> Array1<Distance>

impl MulArray1<Velocity> for Array1<AngularVelocity>

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

fn mul_array1(self, rhs: Array1<Velocity>) -> Array1<Acceleration>

impl MulArray1<Velocity> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Velocity>) -> Array1<Time>

impl MulArray1<Velocity> for Array1<Time>

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

fn mul_array1(self, rhs: Array1<Velocity>) -> Array1<Distance>

impl MulArray1<Velocity> for Array1<Velocity>

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

fn mul_array1(self, rhs: Array1<Velocity>) -> Array1<VelocitySquared>

impl MulArray1<VelocitySquared> for Array1<Mass>

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

fn mul_array1(self, rhs: Array1<VelocitySquared>) -> Array1<ForceDistance>

impl MulArray1<Voltage> for Array1<Charge>

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

fn mul_array1(self, rhs: Array1<Voltage>) -> Array1<ForceDistance>

impl MulArray1<Volume> for Array1<Density>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<Mass>

impl MulArray1<Volume> for Array1<Distance>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<AreaOfMoment>

impl MulArray1<Volume> for Array1<Force>

type Output = ArrayBase<OwnedRepr<ForceVolume>, Dim<[usize; 1]>>

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<ForceVolume>

impl MulArray1<Volume> for Array1<ForcePerDistancePowerFour>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<Stiffness>

impl MulArray1<Volume> for Array1<ForcePerVolume>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<Force>

impl MulArray1<Volume> for Array1<InverseArea>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<Distance>

impl MulArray1<Volume> for Array1<InverseDistance>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<Area>

impl MulArray1<Volume> for Array1<Stress>

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

fn mul_array1(self, rhs: Array1<Volume>) -> Array1<ForceDistance>

Implementors