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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
//------------------------------------------------------------------------------
// GrB_Matrix_assign_[SCALAR]: assign a scalar to matrix, via scalar expansion
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//------------------------------------------------------------------------------
// Assigns a single scalar to a matrix:
// C<M>(Rows,Cols) = accum(C(Rows,Cols),x)
// The scalar x is implicitly expanded into a matrix A of size nRows-by-nCols,
// with each entry in A equal to x.
// Compare with GxB_Matrix_subassign_scalar,
// which uses M and C_Replace differently.
// The actual work is done in GB_assign_scalar.c.
#define GB_FREE_ALL ;
#include "GB_assign.h"
#include "GB_ij.h"
#include "GB_get_mask.h"
#define GB_ASSIGN_SCALAR(prefix,type,T,ampersand) \
GrB_Info GB_EVAL3 (prefix, _Matrix_assign_, T) /* C<M>(Rows,Cols) += x */ \
( \
GrB_Matrix C, /* input/output matrix for results */ \
const GrB_Matrix M, /* optional mask for C */ \
const GrB_BinaryOp accum, /* accum for Z=accum(C(Rows,Cols),x) */ \
type x, /* scalar to assign to C(Rows,Cols) */ \
const GrB_Index *Rows, /* row indices */ \
GrB_Index nRows, /* number of row indices */ \
const GrB_Index *Cols, /* column indices */ \
GrB_Index nCols, /* number of column indices */ \
const GrB_Descriptor desc /* descriptor for C and M */ \
) \
{ \
GB_WHERE (C, "GrB_Matrix_assign_" GB_STR(T) \
" (C, M, accum, x, Rows, nRows, Cols, nCols, desc)") ; \
GB_BURBLE_START ("GrB_assign") ; \
GB_RETURN_IF_NULL_OR_FAULTY (C) ; \
GB_RETURN_IF_FAULTY (M) ; \
GrB_Info info = GB_assign_scalar (C, M, accum, ampersand x, \
GB_## T ## _code, Rows, nRows, Cols, nCols, desc, Context) ; \
GB_BURBLE_END ; \
return (info) ; \
}
GB_ASSIGN_SCALAR (GrB, bool , BOOL , &)
GB_ASSIGN_SCALAR (GrB, int8_t , INT8 , &)
GB_ASSIGN_SCALAR (GrB, uint8_t , UINT8 , &)
GB_ASSIGN_SCALAR (GrB, int16_t , INT16 , &)
GB_ASSIGN_SCALAR (GrB, uint16_t , UINT16 , &)
GB_ASSIGN_SCALAR (GrB, int32_t , INT32 , &)
GB_ASSIGN_SCALAR (GrB, uint32_t , UINT32 , &)
GB_ASSIGN_SCALAR (GrB, int64_t , INT64 , &)
GB_ASSIGN_SCALAR (GrB, uint64_t , UINT64 , &)
GB_ASSIGN_SCALAR (GrB, float , FP32 , &)
GB_ASSIGN_SCALAR (GrB, double , FP64 , &)
GB_ASSIGN_SCALAR (GxB, GxB_FC32_t, FC32 , &)
GB_ASSIGN_SCALAR (GxB, GxB_FC64_t, FC64 , &)
GB_ASSIGN_SCALAR (GrB, void * , UDT , )
//------------------------------------------------------------------------------
// GrB_Matrix_assign_Scalar: assign a GrB_Scalar to a matrix
//------------------------------------------------------------------------------
// If the GrB_Scalar s is non-empty, then this is the same as the non-opapue
// scalar assignment above.
// If the GrB_Scalar s is empty of type stype, then this is identical to:
// GrB_Matrix_new (&S, stype, nRows, nCols) ;
// GrB_Matrix_assign (C, M, accum, S, Rows, nRows, Cols, nCols, desc) ;
// GrB_Matrix_free (&S) ;
#undef GB_FREE_ALL
#define GB_FREE_ALL GB_Matrix_free (&S) ;
#include "GB_static_header.h"
GB_PUBLIC
GrB_Info GrB_Matrix_assign_Scalar // C<Mask>(I,J) = accum (C(I,J),s)
(
GrB_Matrix C, // input/output matrix for results
const GrB_Matrix M_in, // optional mask for C, unused if NULL
const GrB_BinaryOp accum, // optional accum for Z=accum(C(I,J),x)
GrB_Scalar scalar, // scalar to assign to C(I,J)
const GrB_Index *I, // row indices
GrB_Index ni, // number of row indices
const GrB_Index *J, // column indices
GrB_Index nj, // number of column indices
const GrB_Descriptor desc // descriptor for C and Mask
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GrB_Matrix S = NULL ;
GB_WHERE (C, "GrB_Matrix_assign_Scalar"
" (C, M, accum, s, Rows, nRows, Cols, nCols, desc)") ;
GB_BURBLE_START ("GrB_assign") ;
GB_RETURN_IF_NULL_OR_FAULTY (C) ;
GB_RETURN_IF_NULL_OR_FAULTY (scalar) ;
GB_RETURN_IF_FAULTY (M_in) ;
GB_RETURN_IF_NULL (I) ;
GB_RETURN_IF_NULL (J) ;
// get the descriptor
GB_GET_DESCRIPTOR (info, desc, C_replace, Mask_comp, Mask_struct,
xx1, xx2, xx3, xx7) ;
// get the mask
GrB_Matrix M = GB_get_mask (M_in, &Mask_comp, &Mask_struct) ;
//--------------------------------------------------------------------------
// C<M>(Rows,Cols) = accum (C(Rows,Cols), scalar)
//--------------------------------------------------------------------------
GrB_Index nvals ;
GB_OK (GB_nvals (&nvals, (GrB_Matrix) scalar, Context)) ;
if (M == NULL && !Mask_comp && ni == 1 && nj == 1 && !C_replace)
{
//----------------------------------------------------------------------
// scalar assignment
//----------------------------------------------------------------------
const GrB_Index row = I [0] ;
const GrB_Index col = J [0] ;
if (nvals == 1)
{
// set the element: C(row,col) += scalar or C(row,col) = scalar
info = GB_setElement (C, accum, scalar->x, row, col,
scalar->type->code, Context) ;
}
else if (accum == NULL)
{
// delete the C(row,col) element
info = GB_Matrix_removeElement (C, row, col, Context) ;
}
}
else if (nvals == 1)
{
//----------------------------------------------------------------------
// the opaque GrB_Scalar has a single entry
//----------------------------------------------------------------------
// This is identical to non-opaque scalar assignment
info = GB_assign (
C, C_replace, // C matrix and its descriptor
M, Mask_comp, Mask_struct, // mask matrix and its descriptor
false, // do not transpose the mask
accum, // for accum (C(Rows,Cols),scalar)
NULL, false, // no explicit matrix A
I, ni, // row indices
J, nj, // column indices
true, // do scalar expansion
scalar->x, // scalar to assign, expands to become A
scalar->type->code, // type code of scalar to expand
GB_ASSIGN,
Context) ;
}
else
{
//----------------------------------------------------------------------
// the opaque GrB_Scalar has no entry
//----------------------------------------------------------------------
// determine the properites of the I and J index lists
int64_t nRows, nCols, RowColon [3], ColColon [3] ;
int RowsKind, ColsKind ;
GB_ijlength (I, ni, GB_NROWS (C), &nRows, &RowsKind, RowColon);
GB_ijlength (J, nj, GB_NCOLS (C), &nCols, &ColsKind, ColColon);
// create an empty matrix S of the right size, and use matrix assign
struct GB_Matrix_opaque S_header ;
GB_CLEAR_STATIC_HEADER (S, &S_header) ;
bool is_csc = C->is_csc ;
int64_t vlen = is_csc ? nRows : nCols ;
int64_t vdim = is_csc ? nCols : nRows ;
GB_OK (GB_new (&S, // existing header
scalar->type, vlen, vdim, GB_Ap_calloc, is_csc, GxB_AUTO_SPARSITY,
GB_HYPER_SWITCH_DEFAULT, 1, Context)) ;
info = GB_assign (
C, C_replace, // C matrix and its descriptor
M, Mask_comp, Mask_struct, // mask matrix and its descriptor
false, // do not transpose the mask
accum, // for accum (C(Rows,Cols),A)
S, false, // S matrix and its descriptor
I, ni, // row indices
J, nj, // column indices
false, NULL, GB_ignore_code, // no scalar expansion
GB_ASSIGN,
Context) ;
GB_FREE_ALL ;
}
GB_BURBLE_END ;
return (info) ;
}
|
