File: test_1136_regulararray_zeros_in_shape.py

package info (click to toggle)
python-awkward 2.8.9-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 24,932 kB
  • sloc: python: 178,875; cpp: 33,828; sh: 432; makefile: 21; javascript: 8
file content (163 lines) | stat: -rw-r--r-- 4,671 bytes parent folder | download
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
# BSD 3-Clause License; see https://github.com/scikit-hep/awkward/blob/main/LICENSE

from __future__ import annotations

import numpy as np
import pytest  # noqa: F401

import awkward as ak


def test_to_RegularArray():
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 7, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 7 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 7, 11, 0), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 7 * 11 * 0 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 7, 0, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 7 * 0 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 0, 7, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 0 * 7 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 0, 5, 7, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 0 * 5 * 7 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 0, 3, 5, 7, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 0 * 3 * 5 * 7 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((0, 2, 3, 5, 7, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "0 * 2 * 3 * 5 * 7 * 11 * float64"
    )

    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 7, 0, 11, 0), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 7 * 0 * 11 * 0 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 5, 0, 7, 11, 0), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 5 * 0 * 7 * 11 * 0 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 3, 0, 5, 7, 0, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 3 * 0 * 5 * 7 * 0 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((2, 0, 3, 5, 7, 0, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "2 * 0 * 3 * 5 * 7 * 0 * 11 * float64"
    )
    assert (
        str(
            ak.operations.type(
                ak.highlevel.Array(
                    ak.operations.from_numpy(
                        np.empty((0, 2, 3, 5, 7, 0, 11), np.float64)
                    ).layout.to_RegularArray()
                )
            )
        )
        == "0 * 2 * 3 * 5 * 7 * 0 * 11 * float64"
    )


def test_actual():
    x = ak.operations.from_numpy(np.arange(2 * 3 * 4, dtype=np.int64).reshape(2, 3, 4))
    s = x[..., :0]
    result = ak.operations.zip({"q": s, "t": s})
    assert str(ak.operations.type(result)) == "2 * 3 * 0 * {q: int64, t: int64}"