FilesExpand file tree

 master

/

shape_builder.rs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

125 lines (117 loc) · 2.77 KB

 master

/

shape_builder.rs

Copy path

Top

File metadata and controls

• Code
• Blame

125 lines (117 loc) · 2.77 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

use crate::dimension::IntoDimension;

use crate::Dimension;

use crate::{Shape, StrideShape};

/// A trait for `Shape` and `D where D: Dimension` that allows

/// customizing the memory layout (strides) of an array shape.

///

/// This trait is used together with array constructor methods like

/// `Array::from_shape_vec`.

pub trait ShapeBuilder {

type Dim: Dimension;

type Strides;

fn into_shape(self) -> Shape<Self::Dim>;

fn f(self) -> Shape<Self::Dim>;

fn set_f(self, is_f: bool) -> Shape<Self::Dim>;

fn strides(self, strides: Self::Strides) -> StrideShape<Self::Dim>;

}

impl<D> From<D> for Shape<D>

where

D: Dimension,

{

/// Create a `Shape` from `dimension`, using the default memory layout.

fn from(dimension: D) -> Shape<D> {

dimension.into_shape()

}

}

impl<T, D> From<T> for StrideShape<D>

where

D: Dimension,

T: ShapeBuilder<Dim = D>,

{

fn from(value: T) -> Self {

let shape = value.into_shape();

let d = shape.dim;

let st = if shape.is_c {

d.default_strides()

} else {

d.fortran_strides()

};

StrideShape {

strides: st,

dim: d,

custom: false,

}

}

}

/*

impl<D> From<Shape<D>> for StrideShape<D>

where D: Dimension

{

fn from(shape: Shape<D>) -> Self {

let d = shape.dim;

let st = if shape.is_c { d.default_strides() } else { d.fortran_strides() };

StrideShape {

strides: st,

dim: d,

custom: false,

}

}

}

*/

impl<T> ShapeBuilder for T

where

T: IntoDimension,

{

type Dim = T::Dim;

type Strides = T;

fn into_shape(self) -> Shape<Self::Dim> {

Shape {

dim: self.into_dimension(),

is_c: true,

}

}

fn f(self) -> Shape<Self::Dim> {

self.set_f(true)

}

fn set_f(self, is_f: bool) -> Shape<Self::Dim> {

self.into_shape().set_f(is_f)

}

fn strides(self, st: T) -> StrideShape<Self::Dim> {

self.into_shape().strides(st.into_dimension())

}

}

impl<D> ShapeBuilder for Shape<D>

where

D: Dimension,

{

type Dim = D;

type Strides = D;

fn into_shape(self) -> Shape<D> {

self

}

fn f(self) -> Self {

self.set_f(true)

}

fn set_f(mut self, is_f: bool) -> Self {

self.is_c = !is_f;

self

}

fn strides(self, st: D) -> StrideShape<D> {

StrideShape {

dim: self.dim,

strides: st,

custom: true,

}

}

}

impl<D> Shape<D>

where

D: Dimension,

{

// Return a reference to the dimension

//pub fn dimension(&self) -> &D { &self.dim }

/// Return the size of the shape in number of elements

pub fn size(&self) -> usize {

self.dim.size()

}

}