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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/*
* Copyright (C) 1997 NCSA
* All rights reserved.
*
* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, October 10, 1997
*/
#ifndef H5Vprivate_H
#define H5Vprivate_H
#include <H5private.h>
/* Vector comparison functions like Fortran66 comparison operators */
#define H5V_vector_eq(N,V1,V2) (H5V_vector_cmp (N, V1, V2)==0)
#define H5V_vector_lt(N,V1,V2) (H5V_vector_cmp (N, V1, V2)<0)
#define H5V_vector_gt(N,V1,V2) (H5V_vector_cmp (N, V1, V2)>0)
#define H5V_vector_le(N,V1,V2) (H5V_vector_cmp (N, V1, V2)<=0)
#define H5V_vector_ge(N,V1,V2) (H5V_vector_cmp (N, V1, V2)>=0)
/* Other functions */
#define H5V_vector_cpy(N,DST,SRC) { \
if (SRC) HDmemcpy (DST, SRC, (N)*sizeof(size_t)); \
else HDmemset (DST, 0, (N)*sizeof(size_t)); \
}
#define H5V_vector_zero(N,DST) HDmemset(DST,0,(N)*sizeof(size_t))
/* A null pointer is equivalent to a zero vector */
#define H5V_ZERO NULL
size_t H5V_hyper_stride(size_t n, const size_t *size, const size_t *total_size,
const size_t *offset, intn *stride);
hbool_t H5V_hyper_disjointp(size_t n, const size_t *offset1,
const size_t *size1, const size_t *offset2,
const size_t *size2);
hbool_t H5V_hyper_eq(size_t n, const size_t *offset1, const size_t *size1,
const size_t *offset2, const size_t *size2);
herr_t H5V_hyper_fill(size_t n, const size_t *total_size, const size_t *offset,
const size_t *size, void *buf, uint8 val);
herr_t H5V_hyper_copy(size_t n, const size_t *size,
const size_t *dst_total_size, const size_t *dst_offset,
void *_dst, const size_t *src_total_size,
const size_t *src_offset, const void *_src);
herr_t H5V_stride_fill(size_t n, size_t elmt_size, const size_t *size,
const intn *stride, void *_dst, uint8 fill_value);
herr_t H5V_stride_copy(size_t n, size_t elmt_size, const size_t *_size,
const intn *dst_stride, void *_dst,
const intn *src_stride, const void *_src);
herr_t H5V_stride_copy2(size_t nelmts, size_t elmt_size, size_t dst_n,
const size_t *dst_size, const intn *dst_stride,
void *_dst, size_t src_n, const size_t *src_size,
const intn *src_stride, const void *_src);
herr_t H5V_stride_optimize1(size_t *np, size_t *elmt_size, size_t *size,
intn *stride1);
herr_t H5V_stride_optimize2(size_t *np, size_t *elmt_size, size_t *size,
intn *stride1, intn *stride2);
/*-------------------------------------------------------------------------
* Function: H5V_vector_reduce_product
*
* Purpose: Product reduction of a vector. Vector elements and return
* value are size_t because we usually want the number of
* elements in an array and array dimensions are always of type
* size_t.
*
* Return: Success: Product of elements
*
* Failure: 1 if N is zero
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static inline size_t
__attribute__((unused))
H5V_vector_reduce_product(size_t n, const size_t *v)
{
size_t ans = 1;
if (n && !v)
return 0;
while (n--)
ans *= *v++;
return ans;
}
/*-------------------------------------------------------------------------
* Function: H5V_vector_zerop
*
* Purpose: Determines if all elements of a vector are zero.
*
* Return: Success: TRUE if all elements are zero,
* FALSE otherwise
*
* Failure: TRUE if N is zero
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static inline hbool_t
__attribute__((unused))
H5V_vector_zerop(size_t n, const size_t *v)
{
if (!v)
return TRUE;
while (n--)
if (*v++)
return FALSE;
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: H5V_vector_cmp
*
* Purpose: Compares two vectors of the same size and determines if V1 is
* lexicographically less than, equal, or greater than V2.
*
* Return: Success: -1 if V1 is less than V2
* 0 if they are equal
* 1 if V1 is greater than V2
*
* Failure: 0 if N is zero
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static inline intn
__attribute__((unused))
H5V_vector_cmp(size_t n, const size_t *v1, const size_t *v2)
{
if (v1 == v2)
return 0;
while (n--) {
if ((v1 ? *v1 : 0) < (v2 ? *v2 : 0))
return -1;
if ((v1 ? *v1 : 0) > (v2 ? *v2 : 0))
return 1;
if (v1)
v1++;
if (v2)
v2++;
}
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5V_vector_inc
*
* Purpose: Increments V1 by V2
*
* Return: void
*
* Programmer: Robb Matzke
* Monday, October 13, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static inline void
__attribute__((unused))
H5V_vector_inc(size_t n, size_t *v1, const size_t *v2)
{
while (n--)
*v1++ += *v2++;
}
#endif
|
