Skip to content

Commit 184abf1

Browse files
jmh5309il
jmh530
authored and
9il
committed
Add mir.traits and functions
1 parent b438bd0 commit 184abf1

File tree

1 file changed

+228
-0
lines changed

1 file changed

+228
-0
lines changed

‎source/mir/ndslice/traits.d‎

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,228 @@
1+
/++
2+
$(H2 Multidimensional traits)
3+
4+
This is a submodule of $(MREF mir,ndslice).
5+
6+
$(BOOKTABLE $(H2 Function),
7+
$(TR $(TH Function Name) $(TH Description))
8+
9+
$(T2 isVector, Test if type is a one-dimensional slice.)
10+
$(T2 isMatrix, Test if type is a two-dimensional slice.)
11+
$(T2 isContiguousSlice, Test if type is a contiguous slice.)
12+
$(T2 isCanonicalSlice, Test if type is a canonical slice.)
13+
$(T2 isUniversalSlice, Test if type is a universal slice.)
14+
$(T2 isContiguousVector, Test if type is a contiguous one-dimensional slice.)
15+
$(T2 isUniversalVector, Test if type is a universal one-dimensional slice.)
16+
$(T2 isContiguousMatrix, Test if type is a contiguous two-dimensional slice.)
17+
$(T2 isCanonicalMatrix, Test if type is a canonical two-dimensional slice.)
18+
$(T2 isUniversalMatrix, Test if type is a universal two-dimensional slice.)
19+
)
20+
21+
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
22+
Copyright: Copyright © 2016-, Ilya Yaroshenko, John Hall
23+
Authors: John Hall
24+
25+
26+
Macros:
27+
SUBREF = $(REF_ALTTEXT $(TT $2), $2, mir, ndslice, $1)$(NBSP)
28+
T2=$(TR $(TDNW $(LREF $1)) $(TD $+))
29+
+/
30+
31+
module mir.ndslice.traits;
32+
33+
34+
/// Test if type is a one-dimensional slice.
35+
enum bool isVector(T) = is(T : Slice!(kind, [1], Iterator),
36+
SliceKind kind, Iterator);
37+
38+
/// Test if type is a two-dimensional slice.
39+
enum bool isMatrix(T) = is(T : Slice!(kind, [2], Iterator),
40+
SliceKind kind, Iterator);
41+
42+
/// Test if type is a contiguous slice.
43+
enum bool isContiguousSlice(T) = is(T : Slice!(Contiguous, packs, Iterator),
44+
size_t[] packs, Iterator);
45+
46+
/// Test if type is a canonical slice.
47+
enum bool isCanonicalSlice(T) = is(T : Slice!(Canonical, packs, Iterator),
48+
size_t[] packs, Iterator);
49+
50+
/// Test if type is a universal slice.
51+
enum bool isUniversalSlice(T) = is(T : Slice!(Universal, packs, Iterator),
52+
size_t[] packs, Iterator);
53+
54+
/// Test if type is a contiguous one-dimensional slice.
55+
enum bool isContiguousVector(T) = is(T : Slice!(Contiguous, [1], Iterator),
56+
Iterator);
57+
58+
/// Test if type is a universal one-dimensional slice.
59+
enum bool isUniversalVector(T) = is(T : Slice!(Universal, [1], Iterator),
60+
Iterator);
61+
62+
/// Test if type is a contiguous two-dimensional slice.
63+
enum bool isContiguousMatrix(T) = is(T : Slice!(Contiguous, [2], Iterator),
64+
Iterator);
65+
66+
/// Test if type is a canonical two-dimensional slice.
67+
enum bool isCanonicalMatrix(T) = is(T : Slice!(Canonical, [2], Iterator),
68+
Iterator);
69+
70+
/// Test if type is a universal two-dimensional slice.
71+
enum bool isUniversalMatrix(T) = is(T : Slice!(Universal, [2], Iterator),
72+
Iterator);
73+
74+
///
75+
@safe pure nothrow @nogc
76+
unittest
77+
{
78+
alias S1 = ContiguousVector!int;
79+
static assert(isContiguousVector!S1);
80+
static assert(!isUniversalVector!S1);
81+
82+
static assert(!isContiguousMatrix!S1);
83+
static assert(!isCanonicalMatrix!S1);
84+
static assert(!isUniversalMatrix!S1);
85+
86+
static assert(isVector!S1);
87+
static assert(!isMatrix!S1);
88+
89+
static assert(isContiguousSlice!S1);
90+
static assert(!isCanonicalSlice!S1);
91+
static assert(!isUniversalSlice!S1);
92+
}
93+
94+
@safe pure nothrow @nogc
95+
unittest
96+
{
97+
alias S2 = UniversalVector!float;
98+
static assert(!isContiguousVector!S2);
99+
static assert(isUniversalVector!S2);
100+
101+
static assert(!isContiguousMatrix!S2);
102+
static assert(!isCanonicalMatrix!S2);
103+
static assert(!isUniversalMatrix!S2);
104+
105+
static assert(isVector!S2);
106+
static assert(!isMatrix!S2);
107+
108+
static assert(!isContiguousSlice!S2);
109+
static assert(!isCanonicalSlice!S2);
110+
static assert(isUniversalSlice!S2);
111+
}
112+
113+
@safe pure nothrow @nogc
114+
unittest
115+
{
116+
alias S3 = ContiguousMatrix!byte;
117+
static assert(!isContiguousVector!S3);
118+
static assert(!isUniversalVector!S3);
119+
120+
static assert(isContiguousMatrix!S3);
121+
static assert(!isCanonicalMatrix!S3);
122+
static assert(!isUniversalMatrix!S3);
123+
124+
static assert(!isVector!S3);
125+
static assert(isMatrix!S3);
126+
127+
static assert(isContiguousSlice!S3);
128+
static assert(!isCanonicalSlice!S3);
129+
static assert(!isUniversalSlice!S3);
130+
}
131+
132+
@safe pure nothrow @nogc
133+
unittest
134+
{
135+
alias S4 = CanonicalMatrix!uint;
136+
static assert(!isContiguousVector!S4);
137+
static assert(!isUniversalVector!S4);
138+
139+
static assert(!isContiguousMatrix!S4);
140+
static assert(isCanonicalMatrix!S4);
141+
static assert(!isUniversalMatrix!S4);
142+
143+
static assert(!isVector!S4);
144+
static assert(isMatrix!S4);
145+
146+
static assert(!isContiguousSlice!S4);
147+
static assert(isCanonicalSlice!S4);
148+
static assert(!isUniversalSlice!S4);
149+
}
150+
151+
@safe pure nothrow @nogc
152+
unittest
153+
{
154+
alias S5 = UniversalMatrix!double;
155+
static assert(!isContiguousVector!S5);
156+
static assert(!isUniversalVector!S5);
157+
158+
static assert(!isContiguousMatrix!S5);
159+
static assert(!isCanonicalMatrix!S5);
160+
static assert(isUniversalMatrix!S5);
161+
162+
static assert(!isVector!S5);
163+
static assert(isMatrix!S5);
164+
165+
static assert(!isContiguousSlice!S5);
166+
static assert(!isCanonicalSlice!S5);
167+
static assert(isUniversalSlice!S5);
168+
}
169+
170+
@safe pure nothrow @nogc
171+
unittest
172+
{
173+
alias S6 = ContiguousTensor!(3, ubyte);
174+
175+
static assert(!isContiguousVector!S6);
176+
static assert(!isUniversalVector!S6);
177+
178+
static assert(!isContiguousMatrix!S6);
179+
static assert(!isCanonicalMatrix!S6);
180+
static assert(!isUniversalMatrix!S6);
181+
182+
static assert(!isVector!S6);
183+
static assert(!isMatrix!S6);
184+
185+
static assert(isContiguousSlice!S6);
186+
static assert(!isCanonicalSlice!S6);
187+
static assert(!isUniversalSlice!S6);
188+
}
189+
190+
@safe pure nothrow @nogc
191+
unittest
192+
{
193+
alias S7 = CanonicalTensor!(3, real);
194+
195+
static assert(!isContiguousVector!S7);
196+
static assert(!isUniversalVector!S7);
197+
198+
static assert(!isContiguousMatrix!S7);
199+
static assert(!isCanonicalMatrix!S7);
200+
static assert(!isUniversalMatrix!S7);
201+
202+
static assert(!isVector!S7);
203+
static assert(!isMatrix!S7);
204+
205+
static assert(!isContiguousSlice!S7);
206+
static assert(isCanonicalSlice!S7);
207+
static assert(!isUniversalSlice!S7);
208+
}
209+
210+
@safe pure nothrow @nogc
211+
unittest
212+
{
213+
alias S8 = UniversalTensor!(3, long);
214+
215+
static assert(!isContiguousVector!S8);
216+
static assert(!isUniversalVector!S8);
217+
218+
static assert(!isContiguousMatrix!S8);
219+
static assert(!isCanonicalMatrix!S8);
220+
static assert(!isUniversalMatrix!S8);
221+
222+
static assert(!isVector!S8);
223+
static assert(!isMatrix!S8);
224+
225+
static assert(!isContiguousSlice!S8);
226+
static assert(!isCanonicalSlice!S8);
227+
static assert(isUniversalSlice!S8);
228+
}

0 commit comments

Comments
 (0)