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
|
//------------------------------------------------------------------------------
// GB_bitmap_assign_noM_noaccum_whole: assign to C bitmap
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//------------------------------------------------------------------------------
// C<> = A assign
// C<> = A subassign
// C<repl> = A assign
// C<repl> = A subassign
// C<!> = A assign
// C<!> = A subassign
// C<!,repl> = A assign
// C<!,repl> = A subassign
//------------------------------------------------------------------------------
// C: bitmap
// M: none
// Mask_comp: true or false
// Mask_struct: true or false (ignored)
// C_replace: true or false
// accum: not present
// A: matrix (hyper, sparse, bitmap, or full), or scalar
// kind: assign or subassign (same action)
// If M is not present and Mask_comp is true, then an empty mask is
// complemented. This case is handled by GB_assign_prep: if C_replace is
// true, the matrix is cleared by GB_clear, or no action is taken otherwise.
// In either case, this method is not called. However, the "if (!Mask_comp)"
// test is left in below, for clarity. Mask_comp will always be false here.
// For scalar assignment, C = x, this method just calls GB_convert_any_to_full,
// which converts C to an iso full matrix (the iso value has already been set
// by GB_assign_prep).
// For matrix assignment, C = A, if A is sparse or hyper and C may become
// sparse or hyper, then the assignement is done by GB_subassign_24.
#include "GB_bitmap_assign_methods.h"
#include "GB_dense.h"
#define GB_FREE_ALL ;
GrB_Info GB_bitmap_assign_noM_noaccum_whole
(
// input/output:
GrB_Matrix C, // input/output matrix in bitmap format
// inputs:
const bool C_replace, // descriptor for C
// const GrB_Matrix M, // mask matrix, not present here
const bool Mask_comp, // true for !M, false for M
const bool Mask_struct, // true if M is structural, false if valued
// const GrB_BinaryOp accum, // not present
const GrB_Matrix A, // input matrix, not transposed
const void *scalar, // input scalar
const GrB_Type scalar_type, // type of input scalar
GB_Context Context
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GrB_Info info ;
GBURBLE_BITMAP_ASSIGN ("bit6:whole", NULL, Mask_comp, NULL,
GB_ALL, GB_ALL, GB_ASSIGN) ;
ASSERT_MATRIX_OK (C, "C for bitmap assign: noM, noaccum", GB0) ;
ASSERT_MATRIX_OK_OR_NULL (A, "A for bitmap assign: noM, noaccum", GB0) ;
//--------------------------------------------------------------------------
// do the assignment
//--------------------------------------------------------------------------
if (!Mask_comp)
{
//----------------------------------------------------------------------
// C = A or C = scalar
//----------------------------------------------------------------------
if (A == NULL)
{
//------------------------------------------------------------------
// scalar assignment: C = scalar
//------------------------------------------------------------------
ASSERT (C->iso) ;
GB_convert_any_to_full (C) ;
}
else
{
//------------------------------------------------------------------
// matrix assignment: C = A
//------------------------------------------------------------------
GB_GET_C_BITMAP ; // C must be bitmap
GB_GET_A_AND_SCALAR
if (GB_IS_BITMAP (A) || GB_IS_FULL (A))
{
//--------------------------------------------------------------
// C = A where C is bitmap and A is bitmap or full
//--------------------------------------------------------------
// copy or typecast the values
GB_cast_matrix (C, A, Context) ;
if (GB_IS_BITMAP (A))
{
// copy the bitmap
GB_memcpy (Cb, Ab, cnzmax, nthreads_max) ;
C->nvals = GB_nnz (A) ;
}
else
{
// free the bitmap or set it to all ones
GB_bitmap_assign_to_full (C, nthreads_max) ;
}
}
else
{
//--------------------------------------------------------------
// C = A where C is bitmap and A is sparse or hyper
//--------------------------------------------------------------
int sparsity_control =
GB_sparsity_control (C->sparsity_control, C->vdim) ;
if ((GB_IS_SPARSE (A) && (sparsity_control & GxB_SPARSE)) ||
(GB_IS_HYPERSPARSE (A) &&
(sparsity_control & GxB_HYPERSPARSE)))
{
// C becomes sparse or hypersparse, the same as A
GB_OK (GB_subassign_24 (C, A, Context)) ;
}
else
{
// C remains bitmap: scatter A into the C bitmap
GB_memset (Cb, 0, cnzmax, nthreads_max) ;
cnvals = 0 ;
#define GB_AIJ_WORK(pC,pA) \
{ \
/* Cx [pC] = Ax [pA] */ \
GB_ASSIGN_AIJ (pC, pA) ; \
Cb [pC] = 1 ; \
}
#include "GB_bitmap_assign_A_whole_template.c"
C->nvals = GB_nnz (A) ;
}
}
}
}
//--------------------------------------------------------------------------
// return result
//--------------------------------------------------------------------------
ASSERT_MATRIX_OK (C, "final C bitmap assign: noM, noaccum, whole", GB0) ;
return (GrB_SUCCESS) ;
}
|
