/Users/scm/git/github/teem/src/gage/vecGage.c

Bug Summary

File:	src/gage/vecGage.c
Location:	line 388, column 5
Description:	Assigned value is garbage or undefined

Annotated Source Code

Teem: Tools to process and visualize scientific data and images .

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public License

(LGPL) as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

The terms of redistributing and/or modifying this software also

include exceptions to the LGPL that facilitate static linking.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License

along with this library; if not, write to Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

#include "gage.h"

#include "privateGage.h"

* highly inefficient computation of the imaginary part of complex

* conjugate eigenvalues of a 3x3 non-symmetric matrix

double

gage_imaginary_part_eigenvalues(double *M ) {

double A, B, C, scale, frob, m[9], _eval[3];

double beta, _gamma;

int roots;

frob = ELL_3M_FROB(M)(sqrt((((M)+0)[0]*((M)+0)[0] + ((M)+0)[1]*((M)+0)[1] + ((M)+0
)[2]*((M)+0)[2]) + (((M)+3)[0]*((M)+3)[0] + ((M)+3)[1]*((M)+3
)[1] + ((M)+3)[2]*((M)+3)[2]) + (((M)+6)[0]*((M)+6)[0] + ((M)
+6)[1]*((M)+6)[1] + ((M)+6)[2]*((M)+6)[2])));

scale = frob > 10 ? 10.0/frob : 1.0;

ELL_3M_SCALE(m, scale, M)((((m)+0)[0] = ((scale))*((M)+0)[0], ((m)+0)[1] = ((scale))*(
(M)+0)[1], ((m)+0)[2] = ((scale))*((M)+0)[2]), (((m)+3)[0] = (
(scale))*((M)+3)[0], ((m)+3)[1] = ((scale))*((M)+3)[1], ((m)+
3)[2] = ((scale))*((M)+3)[2]), (((m)+6)[0] = ((scale))*((M)+6
)[0], ((m)+6)[1] = ((scale))*((M)+6)[1], ((m)+6)[2] = ((scale
))*((M)+6)[2]));

** from gordon with mathematica; these are the coefficients of the

** cubic polynomial in x: det(x*I - M). The full cubic is

** x^3 + A*x^2 + B*x + C.

A = -m[0] - m[4] - m[8];

B = m[0]*m[4] - m[3]*m[1]

+ m[0]*m[8] - m[6]*m[2]

+ m[4]*m[8] - m[7]*m[5];

C = (m[6]*m[4] - m[3]*m[7])*m[2]

+ (m[0]*m[7] - m[6]*m[1])*m[5]

+ (m[3]*m[1] - m[0]*m[4])*m[8];

roots = ell_cubic(_eval, A, B, C, AIR_TRUE1);

if ( roots != ell_cubic_root_single )

return 0.;

/* 2 complex conjuguate eigenvalues */

beta = A + _eval[0];

_gamma = -C/_eval[0];

return sqrt( 4.*_gamma - beta*beta );

}

gageItemEntry

_gageVecTable[GAGE_VEC_ITEM_MAX31+1] = {

/* enum value len, deriv, prereqs, parent item, parent index, needData */

{gageVecUnknown, 0, 0, {0}, 0, 0, AIR_FALSE0},

{gageVecVector, 3, 0, {0}, 0, 0, AIR_FALSE0},

{gageVecVector0, 1, 0, {gageVecVector}, gageVecVector, 0, AIR_FALSE0},

{gageVecVector1, 1, 0, {gageVecVector}, gageVecVector, 1, AIR_FALSE0},

{gageVecVector2, 1, 0, {gageVecVector}, gageVecVector, 2, AIR_FALSE0},

{gageVecLength, 1, 0, {gageVecVector}, 0, 0, AIR_FALSE0},

{gageVecNormalized, 3, 0, {gageVecVector, gageVecLength}, 0, 0, AIR_FALSE0},

{gageVecJacobian, 9, 1, {0}, 0, 0, AIR_FALSE0},

{gageVecStrain, 9, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecDivergence, 1, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecCurl, 3, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecCurlNorm, 1, 1, {gageVecCurl}, 0, 0, AIR_FALSE0},

{gageVecHelicity, 1, 1, {gageVecVector, gageVecCurl}, 0, 0, AIR_FALSE0},

{gageVecNormHelicity, 1, 1, {gageVecNormalized, gageVecCurl}, 0, 0, AIR_FALSE0},

{gageVecSOmega, 9, 1, {gageVecJacobian,gageVecStrain}, 0, 0, AIR_FALSE0},

{gageVecLambda2, 1, 1, {gageVecSOmega}, 0, 0, AIR_FALSE0},

{gageVecImaginaryPart, 1, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecHessian, 27, 2, {0}, 0, 0, AIR_FALSE0},

{gageVecDivGradient, 3, 1, {gageVecHessian}, 0, 0, AIR_FALSE0},

{gageVecCurlGradient, 9, 2, {gageVecHessian}, 0, 0, AIR_FALSE0},

{gageVecCurlNormGrad, 3, 2, {gageVecHessian, gageVecCurl}, 0, 0, AIR_FALSE0},

{gageVecNCurlNormGrad, 3, 2, {gageVecCurlNormGrad}, 0, 0, AIR_FALSE0},

{gageVecHelGradient, 3, 2, {gageVecVector, gageVecJacobian, gageVecCurl, gageVecCurlGradient}, 0, 0, AIR_FALSE0},

{gageVecDirHelDeriv, 1, 2, {gageVecNormalized, gageVecHelGradient}, 0, 0, AIR_FALSE0},

{gageVecProjHelGradient, 3, 2, {gageVecNormalized, gageVecHelGradient, gageVecDirHelDeriv}, 0, 0, AIR_FALSE0},

/* HEY: these should change to sub-items!!! */

{gageVecGradient0, 3, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecGradient1, 3, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecGradient2, 3, 1, {gageVecJacobian}, 0, 0, AIR_FALSE0},

{gageVecMultiGrad, 9, 1, {gageVecGradient0, gageVecGradient1, gageVecGradient2}, 0, 0, AIR_FALSE0},

{gageVecMGFrob, 1, 1, {gageVecMultiGrad}, 0, 0, AIR_FALSE0},

{gageVecMGEval, 3, 1, {gageVecMultiGrad}, 0, 0, AIR_FALSE0},

{gageVecMGEvec, 9, 1, {gageVecMultiGrad, gageVecMGEval}, 0, 0, AIR_FALSE0}

};

100

101

void

102

_gageVecFilter(gageContext *ctx, gagePerVolume *pvl) {

103

char me[]="_gageVecFilter";

104

double *fw00, *fw11, *fw22, *vec, *jac, *hes;

105

int fd;

106

gageScl3PFilter_t *filter[5] = {NULL((void*)0), gageScl3PFilter2, gageScl3PFilter4,

107

gageScl3PFilter6, gageScl3PFilter8};

108

unsigned int valIdx;

109

110

fd = 2*ctx->radius;

111

vec = pvl->directAnswer[gageVecVector];

112

jac = pvl->directAnswer[gageVecJacobian];

113

hes = pvl->directAnswer[gageVecHessian];

114

if (!ctx->parm.k3pack) {

115

fprintf(stderr__stderrp, "!%s: sorry, 6pack filtering not implemented\n", me);

116

return;

117

}

118

fw00 = ctx->fw + fd*3*gageKernel00;

119

fw11 = ctx->fw + fd*3*gageKernel11;

120

fw22 = ctx->fw + fd*3*gageKernel22;

121

/* perform the filtering */

122

if (fd <= 8) {

123

for (valIdx=0; valIdx<3; valIdx++) {

124

filter[ctx->radius](ctx->shape,

125

pvl->iv3 + valIdx*fd*fd*fd,

126

pvl->iv2 + valIdx*fd*fd,

127

pvl->iv1 + valIdx*fd,

128

fw00, fw11, fw22,

129

vec + valIdx, jac + valIdx*3, hes + valIdx*9,

130

pvl->needD);

131

}

132

} else {

133

for (valIdx=0; valIdx<3; valIdx++) {

134

gageScl3PFilterN(ctx->shape, fd,

135

pvl->iv3 + valIdx*fd*fd*fd,

136

pvl->iv2 + valIdx*fd*fd,

137

pvl->iv1 + valIdx*fd,

138

fw00, fw11, fw22,

139

vec + valIdx, jac + valIdx*3, hes + valIdx*9,

140

pvl->needD);

141

}

142

}

143

144

return;

145

}

146

147

void

148

_gageVecAnswer(gageContext *ctx, gagePerVolume *pvl) {

149

char me[]="_gageVecAnswer";

150

double cmag, tmpMat[9], mgevec[9], mgeval[3];

151

double asym[9], tran[9], eval[3], tmpVec[3], norm;

152

double *vecAns, *normAns, *jacAns, *strainAns, *somegaAns,

153

*curlAns, *hesAns, *curlGradAns,

154

*helGradAns, *dirHelDirAns, *curlnormgradAns;

155

/* int asw; */

156

157

vecAns = pvl->directAnswer[gageVecVector];

158

normAns = pvl->directAnswer[gageVecNormalized];

159

jacAns = pvl->directAnswer[gageVecJacobian];

160

strainAns = pvl->directAnswer[gageVecStrain];

161

somegaAns = pvl->directAnswer[gageVecSOmega];

162

curlAns = pvl->directAnswer[gageVecCurl];

163

hesAns = pvl->directAnswer[gageVecHessian];

164

curlGradAns = pvl->directAnswer[gageVecCurlGradient];

165

curlnormgradAns = pvl->directAnswer[gageVecCurlNormGrad];

166

helGradAns = pvl->directAnswer[gageVecHelGradient];

167

dirHelDirAns = pvl->directAnswer[gageVecDirHelDeriv];

168

169

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecVector)(pvl->query[gageVecVector/8] & (1 << (gageVecVector
% 8)))) {

Taking false branch

→

170

/* done if doV */

171

if (ctx->verbose) {

172

fprintf(stderr__stderrp, "vec = ");

173

ell_3v_print_d(stderr__stderrp, vecAns);

174

}

175

}

176

/* done if doV

177

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecVector{0,1,2})) {

178

}

179

180

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecLength)(pvl->query[gageVecLength/8] & (1 << (gageVecLength
% 8)))) {

←

Taking false branch

→

181

pvl->directAnswer[gageVecLength][0] = ELL_3V_LEN(vecAns)(sqrt((((vecAns))[0]*((vecAns))[0] + ((vecAns))[1]*((vecAns))
[1] + ((vecAns))[2]*((vecAns))[2])));

182

}

183

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNormalized)(pvl->query[gageVecNormalized/8] & (1 << (gageVecNormalized
% 8)))) {

←

Taking false branch

→

184

if (pvl->directAnswer[gageVecLength][0]) {

185

ELL_3V_SCALE(normAns, 1.0/pvl->directAnswer[gageVecLength][0], vecAns)((normAns)[0] = (1.0/pvl->directAnswer[gageVecLength][0])*
(vecAns)[0], (normAns)[1] = (1.0/pvl->directAnswer[gageVecLength
][0])*(vecAns)[1], (normAns)[2] = (1.0/pvl->directAnswer[gageVecLength
][0])*(vecAns)[2]);

186

} else {

187

ELL_3V_COPY(normAns, gageZeroNormal)((normAns)[0] = (gageZeroNormal)[0], (normAns)[1] = (gageZeroNormal
)[1], (normAns)[2] = (gageZeroNormal)[2]);

188

}

189

}

190

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecJacobian)(pvl->query[gageVecJacobian/8] & (1 << (gageVecJacobian
% 8)))) {

←

Taking false branch

→

191

/* done if doD1 */

192

193

0:dv_x/dx 1:dv_x/dy 2:dv_x/dz

194

3:dv_y/dx 4:dv_y/dy 5:dv_y/dz

195

6:dv_z/dx 7:dv_z/dy 8:dv_z/dz

196

197

if (ctx->verbose) {

198

fprintf(stderr__stderrp, "%s: jac = \n", me);

199

ell_3m_print_d(stderr__stderrp, jacAns);

200

}

201

}

202

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDivergence)(pvl->query[gageVecDivergence/8] & (1 << (gageVecDivergence
% 8)))) {

←

Taking false branch

→

203

pvl->directAnswer[gageVecDivergence][0] = jacAns[0] + jacAns[4] + jacAns[8];

204

if (ctx->verbose) {

205

fprintf(stderr__stderrp, "%s: div = %g + %g + %g = %g\n", me,

206

jacAns[0], jacAns[4], jacAns[8],

207

pvl->directAnswer[gageVecDivergence][0]);

208

}

209

}

210

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurl)(pvl->query[gageVecCurl/8] & (1 << (gageVecCurl %
8)))) {

←

Taking false branch

→

211

ELL_3V_SET(curlAns,((curlAns)[0] = (jacAns[7] - jacAns[5]), (curlAns)[1] = (jacAns
[2] - jacAns[6]), (curlAns)[2] = (jacAns[3] - jacAns[1]))

212

jacAns[7] - jacAns[5],((curlAns)[0] = (jacAns[7] - jacAns[5]), (curlAns)[1] = (jacAns
[2] - jacAns[6]), (curlAns)[2] = (jacAns[3] - jacAns[1]))

213

jacAns[2] - jacAns[6],((curlAns)[0] = (jacAns[7] - jacAns[5]), (curlAns)[1] = (jacAns
[2] - jacAns[6]), (curlAns)[2] = (jacAns[3] - jacAns[1]))

214

jacAns[3] - jacAns[1])((curlAns)[0] = (jacAns[7] - jacAns[5]), (curlAns)[1] = (jacAns
[2] - jacAns[6]), (curlAns)[2] = (jacAns[3] - jacAns[1]));

215

}

216

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlNorm)(pvl->query[gageVecCurlNorm/8] & (1 << (gageVecCurlNorm
% 8)))) {

←

Taking false branch

→

217

pvl->directAnswer[gageVecCurlNorm][0] = ELL_3V_LEN(curlAns)(sqrt((((curlAns))[0]*((curlAns))[0] + ((curlAns))[1]*((curlAns
))[1] + ((curlAns))[2]*((curlAns))[2])));

218

}

219

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHelicity)(pvl->query[gageVecHelicity/8] & (1 << (gageVecHelicity
% 8)))) {

←

Taking false branch

→

220

pvl->directAnswer[gageVecHelicity][0] =

221

ELL_3V_DOT(vecAns, curlAns)((vecAns)[0]*(curlAns)[0] + (vecAns)[1]*(curlAns)[1] + (vecAns
)[2]*(curlAns)[2]);

222

}

223

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNormHelicity)(pvl->query[gageVecNormHelicity/8] & (1 << (gageVecNormHelicity
% 8)))) {

←

Taking false branch

→

224

cmag = ELL_3V_LEN(curlAns)(sqrt((((curlAns))[0]*((curlAns))[0] + ((curlAns))[1]*((curlAns
))[1] + ((curlAns))[2]*((curlAns))[2])));

225

pvl->directAnswer[gageVecNormHelicity][0] =

226

cmag ? ELL_3V_DOT(normAns, curlAns)((normAns)[0]*(curlAns)[0] + (normAns)[1]*(curlAns)[1] + (normAns
)[2]*(curlAns)[2])/cmag : 0;

227

}

228

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecStrain)(pvl->query[gageVecStrain/8] & (1 << (gageVecStrain
% 8)))) {

←

Taking false branch

→

229

ELL_3M_TRANSPOSE(tran, jacAns)((tran)[0] = (jacAns)[0], (tran)[1] = (jacAns)[3], (tran)[2] =
(jacAns)[6], (tran)[3] = (jacAns)[1], (tran)[4] = (jacAns)[4
], (tran)[5] = (jacAns)[7], (tran)[6] = (jacAns)[2], (tran)[7
] = (jacAns)[5], (tran)[8] = (jacAns)[8]);

230

/* symmetric part */

231

ELL_3M_SCALE_ADD2(strainAns, 0.5, jacAns, 0.5, tran)((((strainAns)+0)[0] = ((0.5))*((jacAns)+0)[0] + ((0.5))*((tran
)+0)[0], ((strainAns)+0)[1] = ((0.5))*((jacAns)+0)[1] + ((0.5
))*((tran)+0)[1], ((strainAns)+0)[2] = ((0.5))*((jacAns)+0)[2
] + ((0.5))*((tran)+0)[2]), (((strainAns)+3)[0] = ((0.5))*((jacAns
)+3)[0] + ((0.5))*((tran)+3)[0], ((strainAns)+3)[1] = ((0.5))
*((jacAns)+3)[1] + ((0.5))*((tran)+3)[1], ((strainAns)+3)[2] =
((0.5))*((jacAns)+3)[2] + ((0.5))*((tran)+3)[2]), (((strainAns
)+6)[0] = ((0.5))*((jacAns)+6)[0] + ((0.5))*((tran)+6)[0], ((
strainAns)+6)[1] = ((0.5))*((jacAns)+6)[1] + ((0.5))*((tran)+
6)[1], ((strainAns)+6)[2] = ((0.5))*((jacAns)+6)[2] + ((0.5))
*((tran)+6)[2]));

232

/* nested these ifs to make dependency explicit to the compiler */

233

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecSOmega)(pvl->query[gageVecSOmega/8] & (1 << (gageVecSOmega
% 8)))) {

234

/* antisymmetric part */

235

ELL_3M_SCALE_ADD2(asym, 0.5, jacAns, -0.5, tran)((((asym)+0)[0] = ((0.5))*((jacAns)+0)[0] + ((-0.5))*((tran)+
0)[0], ((asym)+0)[1] = ((0.5))*((jacAns)+0)[1] + ((-0.5))*((tran
)+0)[1], ((asym)+0)[2] = ((0.5))*((jacAns)+0)[2] + ((-0.5))*(
(tran)+0)[2]), (((asym)+3)[0] = ((0.5))*((jacAns)+3)[0] + ((-
0.5))*((tran)+3)[0], ((asym)+3)[1] = ((0.5))*((jacAns)+3)[1] +
((-0.5))*((tran)+3)[1], ((asym)+3)[2] = ((0.5))*((jacAns)+3)
[2] + ((-0.5))*((tran)+3)[2]), (((asym)+6)[0] = ((0.5))*((jacAns
)+6)[0] + ((-0.5))*((tran)+6)[0], ((asym)+6)[1] = ((0.5))*((jacAns
)+6)[1] + ((-0.5))*((tran)+6)[1], ((asym)+6)[2] = ((0.5))*((jacAns
)+6)[2] + ((-0.5))*((tran)+6)[2]));

236

/* square symmetric part */

237

ELL_3M_MUL(tmpMat, strainAns, strainAns)((tmpMat)[0] = (strainAns)[0]*(strainAns)[0] + (strainAns)[1]
*(strainAns)[3] + (strainAns)[2]*(strainAns)[6], (tmpMat)[1] =
(strainAns)[0]*(strainAns)[1] + (strainAns)[1]*(strainAns)[4
] + (strainAns)[2]*(strainAns)[7], (tmpMat)[2] = (strainAns)[
0]*(strainAns)[2] + (strainAns)[1]*(strainAns)[5] + (strainAns
)[2]*(strainAns)[8], (tmpMat)[3] = (strainAns)[3]*(strainAns)
[0] + (strainAns)[4]*(strainAns)[3] + (strainAns)[5]*(strainAns
)[6], (tmpMat)[4] = (strainAns)[3]*(strainAns)[1] + (strainAns
)[4]*(strainAns)[4] + (strainAns)[5]*(strainAns)[7], (tmpMat)
[5] = (strainAns)[3]*(strainAns)[2] + (strainAns)[4]*(strainAns
)[5] + (strainAns)[5]*(strainAns)[8], (tmpMat)[6] = (strainAns
)[6]*(strainAns)[0] + (strainAns)[7]*(strainAns)[3] + (strainAns
)[8]*(strainAns)[6], (tmpMat)[7] = (strainAns)[6]*(strainAns)
[1] + (strainAns)[7]*(strainAns)[4] + (strainAns)[8]*(strainAns
)[7], (tmpMat)[8] = (strainAns)[6]*(strainAns)[2] + (strainAns
)[7]*(strainAns)[5] + (strainAns)[8]*(strainAns)[8]);

238

ELL_3M_COPY(somegaAns, tmpMat)((((somegaAns)+0)[0] = ((tmpMat)+0)[0], ((somegaAns)+0)[1] = (
(tmpMat)+0)[1], ((somegaAns)+0)[2] = ((tmpMat)+0)[2]), (((somegaAns
)+3)[0] = ((tmpMat)+3)[0], ((somegaAns)+3)[1] = ((tmpMat)+3)[
1], ((somegaAns)+3)[2] = ((tmpMat)+3)[2]), (((somegaAns)+6)[0
] = ((tmpMat)+6)[0], ((somegaAns)+6)[1] = ((tmpMat)+6)[1], ((
somegaAns)+6)[2] = ((tmpMat)+6)[2]));

239

/* square antisymmetric part */

240

ELL_3M_MUL(tmpMat, asym, asym)((tmpMat)[0] = (asym)[0]*(asym)[0] + (asym)[1]*(asym)[3] + (asym
)[2]*(asym)[6], (tmpMat)[1] = (asym)[0]*(asym)[1] + (asym)[1]
*(asym)[4] + (asym)[2]*(asym)[7], (tmpMat)[2] = (asym)[0]*(asym
)[2] + (asym)[1]*(asym)[5] + (asym)[2]*(asym)[8], (tmpMat)[3]
= (asym)[3]*(asym)[0] + (asym)[4]*(asym)[3] + (asym)[5]*(asym
)[6], (tmpMat)[4] = (asym)[3]*(asym)[1] + (asym)[4]*(asym)[4]
+ (asym)[5]*(asym)[7], (tmpMat)[5] = (asym)[3]*(asym)[2] + (
asym)[4]*(asym)[5] + (asym)[5]*(asym)[8], (tmpMat)[6] = (asym
)[6]*(asym)[0] + (asym)[7]*(asym)[3] + (asym)[8]*(asym)[6], (
tmpMat)[7] = (asym)[6]*(asym)[1] + (asym)[7]*(asym)[4] + (asym
)[8]*(asym)[7], (tmpMat)[8] = (asym)[6]*(asym)[2] + (asym)[7]
*(asym)[5] + (asym)[8]*(asym)[8]);

241

/* sum of both */

242

ELL_3M_ADD2(somegaAns, somegaAns, tmpMat)((somegaAns)[0] = (somegaAns)[0] + (tmpMat)[0], (somegaAns)[1
] = (somegaAns)[1] + (tmpMat)[1], (somegaAns)[2] = (somegaAns
)[2] + (tmpMat)[2], (somegaAns)[3] = (somegaAns)[3] + (tmpMat
)[3], (somegaAns)[4] = (somegaAns)[4] + (tmpMat)[4], (somegaAns
)[5] = (somegaAns)[5] + (tmpMat)[5], (somegaAns)[6] = (somegaAns
)[6] + (tmpMat)[6], (somegaAns)[7] = (somegaAns)[7] + (tmpMat
)[7], (somegaAns)[8] = (somegaAns)[8] + (tmpMat)[8]);

243

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecLambda2)(pvl->query[gageVecLambda2/8] & (1 << (gageVecLambda2
% 8)))) {

244

/* get eigenvalues in sorted order */

245

/* asw = */ ell_3m_eigenvalues_d(eval, somegaAns, AIR_TRUE1);

246

pvl->directAnswer[gageVecLambda2][0] = eval[1];

247

}

248

}

249

}

250

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecImaginaryPart)(pvl->query[gageVecImaginaryPart/8] & (1 << (gageVecImaginaryPart
% 8)))) {

←

Taking false branch

→

251

pvl->directAnswer[gageVecImaginaryPart][0] =

252

gage_imaginary_part_eigenvalues(jacAns);

253

}

254

/* 2nd order vector derivative continued */

255

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHessian)(pvl->query[gageVecHessian/8] & (1 << (gageVecHessian
% 8)))) {

←

Taking false branch

→

256

/* done if doD2 */

257

/* the ordering is induced by the scalar hessian computation :

258

0:d2v_x/dxdx 1:d2v_x/dxdy 2:d2v_x/dxdz

259

3:d2v_x/dydx 4:d2v_x/dydy 5:d2v_x/dydz

260

6:d2v_x/dzdx 7:d2v_x/dzdy 8:d2v_x/dzdz

261

9:d2v_y/dxdx [. . .]

262

[. . .]

263

24:dv2_z/dzdx 25:d2v_z/dzdy 26:d2v_z/dzdz

264

265

if (ctx->verbose) {

266

fprintf(stderr__stderrp, "%s: hes = \n", me);

267

ell_3m_print_d(stderr__stderrp, hesAns); /* ?? */

268

}

269

}

270

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDivGradient)(pvl->query[gageVecDivGradient/8] & (1 << (gageVecDivGradient
% 8)))) {

←

Taking false branch

→

271

pvl->directAnswer[gageVecDivGradient][0] = hesAns[0] + hesAns[12] + hesAns[24];

272

pvl->directAnswer[gageVecDivGradient][1] = hesAns[1] + hesAns[13] + hesAns[25];

273

pvl->directAnswer[gageVecDivGradient][2] = hesAns[2] + hesAns[14] + hesAns[26];

274

}

275

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlGradient)(pvl->query[gageVecCurlGradient/8] & (1 << (gageVecCurlGradient
% 8)))) {

←

Taking false branch

→

276

pvl->directAnswer[gageVecCurlGradient][0] = hesAns[21]-hesAns[15];

277

pvl->directAnswer[gageVecCurlGradient][1] = hesAns[22]-hesAns[16];

278

pvl->directAnswer[gageVecCurlGradient][2] = hesAns[23]-hesAns[17];

279

pvl->directAnswer[gageVecCurlGradient][3] = hesAns[ 6]-hesAns[18];

280

pvl->directAnswer[gageVecCurlGradient][4] = hesAns[ 7]-hesAns[19];

281

pvl->directAnswer[gageVecCurlGradient][5] = hesAns[ 8]-hesAns[20];

282

pvl->directAnswer[gageVecCurlGradient][6] = hesAns[ 9]-hesAns[ 1];

283

pvl->directAnswer[gageVecCurlGradient][7] = hesAns[10]-hesAns[ 2];

284

pvl->directAnswer[gageVecCurlGradient][8] = hesAns[11]-hesAns[ 3];

285

}

286

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlNormGrad)(pvl->query[gageVecCurlNormGrad/8] & (1 << (gageVecCurlNormGrad
% 8)))) {

←

Taking false branch

→

287

norm = 1./ELL_3V_LEN(curlAns)(sqrt((((curlAns))[0]*((curlAns))[0] + ((curlAns))[1]*((curlAns
))[1] + ((curlAns))[2]*((curlAns))[2])));

288

289

tmpVec[0] = hesAns[21] - hesAns[15];

290

tmpVec[1] = hesAns[ 6] - hesAns[18];

291

tmpVec[2] = hesAns[ 9] - hesAns[ 3];

292

pvl->directAnswer[gageVecCurlNormGrad][0] =

293

norm*ELL_3V_DOT(tmpVec, curlAns)((tmpVec)[0]*(curlAns)[0] + (tmpVec)[1]*(curlAns)[1] + (tmpVec
)[2]*(curlAns)[2]);

294

295

tmpVec[0] = hesAns[22] - hesAns[16];

296

tmpVec[1] = hesAns[ 7] - hesAns[19];

297

tmpVec[2] = hesAns[10] - hesAns[ 4];

298

pvl->directAnswer[gageVecCurlNormGrad][1]=

299

norm*ELL_3V_DOT(tmpVec, curlAns)((tmpVec)[0]*(curlAns)[0] + (tmpVec)[1]*(curlAns)[1] + (tmpVec
)[2]*(curlAns)[2]);

300

301

tmpVec[0] = hesAns[23] - hesAns[17];

302

tmpVec[1] = hesAns[ 8] - hesAns[20];

303

tmpVec[2] = hesAns[11] - hesAns[ 5];

304

pvl->directAnswer[gageVecCurlNormGrad][2]=

305

norm*ELL_3V_DOT(tmpVec, curlAns)((tmpVec)[0]*(curlAns)[0] + (tmpVec)[1]*(curlAns)[1] + (tmpVec
)[2]*(curlAns)[2]);

306

}

307

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNCurlNormGrad)(pvl->query[gageVecNCurlNormGrad/8] & (1 << (gageVecNCurlNormGrad
% 8)))) {

←

Taking false branch

→

308

norm = 1./ELL_3V_LEN(curlnormgradAns)(sqrt((((curlnormgradAns))[0]*((curlnormgradAns))[0] + ((curlnormgradAns
))[1]*((curlnormgradAns))[1] + ((curlnormgradAns))[2]*((curlnormgradAns
))[2])));

309

ELL_3V_SCALE(pvl->directAnswer[gageVecNCurlNormGrad],((pvl->directAnswer[gageVecNCurlNormGrad])[0] = (norm)*(pvl
->directAnswer[gageVecCurlNormGrad])[0], (pvl->directAnswer
[gageVecNCurlNormGrad])[1] = (norm)*(pvl->directAnswer[gageVecCurlNormGrad
])[1], (pvl->directAnswer[gageVecNCurlNormGrad])[2] = (norm
)*(pvl->directAnswer[gageVecCurlNormGrad])[2])

310

norm, pvl->directAnswer[gageVecCurlNormGrad])((pvl->directAnswer[gageVecNCurlNormGrad])[0] = (norm)*(pvl
->directAnswer[gageVecCurlNormGrad])[0], (pvl->directAnswer
[gageVecNCurlNormGrad])[1] = (norm)*(pvl->directAnswer[gageVecCurlNormGrad
])[1], (pvl->directAnswer[gageVecNCurlNormGrad])[2] = (norm
)*(pvl->directAnswer[gageVecCurlNormGrad])[2]);

311

}

312

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHelGradient)(pvl->query[gageVecHelGradient/8] & (1 << (gageVecHelGradient
% 8)))) {

←

Taking false branch

→

313

pvl->directAnswer[gageVecHelGradient][0] =

314

jacAns[0]*curlAns[0]+

315

jacAns[3]*curlAns[1]+

316

jacAns[6]*curlAns[2]+

317

curlGradAns[0]*vecAns[0]+

318

curlGradAns[3]*vecAns[1]+

319

curlGradAns[6]*vecAns[2];

320

pvl->directAnswer[gageVecHelGradient][1] =

321

jacAns[1]*curlAns[0]+

322

jacAns[4]*curlAns[1]+

323

jacAns[7]*curlAns[2]+

324

curlGradAns[1]*vecAns[0]+

325

curlGradAns[4]*vecAns[1]+

326

curlGradAns[7]*vecAns[2];

327

pvl->directAnswer[gageVecHelGradient][0] =

328

jacAns[2]*curlAns[0]+

329

jacAns[5]*curlAns[1]+

330

jacAns[8]*curlAns[2]+

331

curlGradAns[2]*vecAns[0]+

332

curlGradAns[5]*vecAns[1]+

333

curlGradAns[8]*vecAns[2];

334

}

335

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDirHelDeriv)(pvl->query[gageVecDirHelDeriv/8] & (1 << (gageVecDirHelDeriv
% 8)))) {

←

Taking false branch

→

336

pvl->directAnswer[gageVecDirHelDeriv][0] =

337

ELL_3V_DOT(normAns, helGradAns)((normAns)[0]*(helGradAns)[0] + (normAns)[1]*(helGradAns)[1] +
(normAns)[2]*(helGradAns)[2]);

338

}

339

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecProjHelGradient)(pvl->query[gageVecProjHelGradient/8] & (1 << (gageVecProjHelGradient
% 8)))) {

←

Taking false branch

→

340

pvl->directAnswer[gageVecDirHelDeriv][0] =

341

helGradAns[0]-dirHelDirAns[0]*normAns[0];

342

pvl->directAnswer[gageVecDirHelDeriv][1] =

343

helGradAns[1]-dirHelDirAns[0]*normAns[1];

344

pvl->directAnswer[gageVecDirHelDeriv][2] =

345

helGradAns[2]-dirHelDirAns[0]*normAns[2];

346

}

347

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient0)(pvl->query[gageVecGradient0/8] & (1 << (gageVecGradient0
% 8)))) {

←

Taking false branch

→

348

ELL_3V_SET(pvl->directAnswer[gageVecGradient0],((pvl->directAnswer[gageVecGradient0])[0] = (jacAns[0]), (
pvl->directAnswer[gageVecGradient0])[1] = (jacAns[1]), (pvl
->directAnswer[gageVecGradient0])[2] = (jacAns[2]))

349

jacAns[0],((pvl->directAnswer[gageVecGradient0])[0] = (jacAns[0]), (
pvl->directAnswer[gageVecGradient0])[1] = (jacAns[1]), (pvl
->directAnswer[gageVecGradient0])[2] = (jacAns[2]))

350

jacAns[1],((pvl->directAnswer[gageVecGradient0])[0] = (jacAns[0]), (
pvl->directAnswer[gageVecGradient0])[1] = (jacAns[1]), (pvl
->directAnswer[gageVecGradient0])[2] = (jacAns[2]))

351

jacAns[2])((pvl->directAnswer[gageVecGradient0])[0] = (jacAns[0]), (
pvl->directAnswer[gageVecGradient0])[1] = (jacAns[1]), (pvl
->directAnswer[gageVecGradient0])[2] = (jacAns[2]));

352

}

353

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient1)(pvl->query[gageVecGradient1/8] & (1 << (gageVecGradient1
% 8)))) {

←

Taking false branch

→

354

ELL_3V_SET(pvl->directAnswer[gageVecGradient1],((pvl->directAnswer[gageVecGradient1])[0] = (jacAns[3]), (
pvl->directAnswer[gageVecGradient1])[1] = (jacAns[4]), (pvl
->directAnswer[gageVecGradient1])[2] = (jacAns[5]))

355

jacAns[3],((pvl->directAnswer[gageVecGradient1])[0] = (jacAns[3]), (
pvl->directAnswer[gageVecGradient1])[1] = (jacAns[4]), (pvl
->directAnswer[gageVecGradient1])[2] = (jacAns[5]))

356

jacAns[4],((pvl->directAnswer[gageVecGradient1])[0] = (jacAns[3]), (
pvl->directAnswer[gageVecGradient1])[1] = (jacAns[4]), (pvl
->directAnswer[gageVecGradient1])[2] = (jacAns[5]))

357

jacAns[5])((pvl->directAnswer[gageVecGradient1])[0] = (jacAns[3]), (
pvl->directAnswer[gageVecGradient1])[1] = (jacAns[4]), (pvl
->directAnswer[gageVecGradient1])[2] = (jacAns[5]));

358

}

359

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient2)(pvl->query[gageVecGradient2/8] & (1 << (gageVecGradient2
% 8)))) {

←

Taking false branch

→

360

ELL_3V_SET(pvl->directAnswer[gageVecGradient2],((pvl->directAnswer[gageVecGradient2])[0] = (jacAns[6]), (
pvl->directAnswer[gageVecGradient2])[1] = (jacAns[7]), (pvl
->directAnswer[gageVecGradient2])[2] = (jacAns[8]))

361

jacAns[6],((pvl->directAnswer[gageVecGradient2])[0] = (jacAns[6]), (
pvl->directAnswer[gageVecGradient2])[1] = (jacAns[7]), (pvl
->directAnswer[gageVecGradient2])[2] = (jacAns[8]))

362

jacAns[7],((pvl->directAnswer[gageVecGradient2])[0] = (jacAns[6]), (
pvl->directAnswer[gageVecGradient2])[1] = (jacAns[7]), (pvl
->directAnswer[gageVecGradient2])[2] = (jacAns[8]))

363

jacAns[8])((pvl->directAnswer[gageVecGradient2])[0] = (jacAns[6]), (
pvl->directAnswer[gageVecGradient2])[1] = (jacAns[7]), (pvl
->directAnswer[gageVecGradient2])[2] = (jacAns[8]));

364

}

365

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMultiGrad)(pvl->query[gageVecMultiGrad/8] & (1 << (gageVecMultiGrad
% 8)))) {

←

Taking false branch

→

366

ELL_3M_IDENTITY_SET(pvl->directAnswer[gageVecMultiGrad])((((pvl->directAnswer[gageVecMultiGrad])+0)[0] = (1), ((pvl
->directAnswer[gageVecMultiGrad])+0)[1] = (0), ((pvl->directAnswer
[gageVecMultiGrad])+0)[2] = (0)), (((pvl->directAnswer[gageVecMultiGrad
])+3)[0] = (0), ((pvl->directAnswer[gageVecMultiGrad])+3)[
1] = (1), ((pvl->directAnswer[gageVecMultiGrad])+3)[2] = (
0)), (((pvl->directAnswer[gageVecMultiGrad])+6)[0] = (0), (
(pvl->directAnswer[gageVecMultiGrad])+6)[1] = (0), ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] = (1)));

367

ELL_3MV_OUTER_INCR(pvl->directAnswer[gageVecMultiGrad],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient0])[0])*((pvl->directAnswer[gageVecGradient0
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient0])[0])*((pvl->directAnswer
[gageVecGradient0]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient0])[0])*((pvl
->directAnswer[gageVecGradient0]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient0
])[1])*((pvl->directAnswer[gageVecGradient0]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient0])[1])*((pvl->directAnswer[gageVecGradient0
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient0])[1])*((pvl->directAnswer
[gageVecGradient0]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient0])[2])*((pvl
->directAnswer[gageVecGradient0]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient0
])[2])*((pvl->directAnswer[gageVecGradient0]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient0])[2])*((pvl->directAnswer[gageVecGradient0
]))[2]))

368

pvl->directAnswer[gageVecGradient0],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient0])[0])*((pvl->directAnswer[gageVecGradient0
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient0])[0])*((pvl->directAnswer
[gageVecGradient0]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient0])[0])*((pvl
->directAnswer[gageVecGradient0]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient0
])[1])*((pvl->directAnswer[gageVecGradient0]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient0])[1])*((pvl->directAnswer[gageVecGradient0
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient0])[1])*((pvl->directAnswer
[gageVecGradient0]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient0])[2])*((pvl
->directAnswer[gageVecGradient0]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient0
])[2])*((pvl->directAnswer[gageVecGradient0]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient0])[2])*((pvl->directAnswer[gageVecGradient0
]))[2]))

369

pvl->directAnswer[gageVecGradient0])((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient0])[0])*((pvl->directAnswer[gageVecGradient0
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient0])[0])*((pvl->directAnswer
[gageVecGradient0]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient0])[0])*((pvl
->directAnswer[gageVecGradient0]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient0
])[1])*((pvl->directAnswer[gageVecGradient0]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient0])[1])*((pvl->directAnswer[gageVecGradient0
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient0])[1])*((pvl->directAnswer
[gageVecGradient0]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient0])[2])*((pvl
->directAnswer[gageVecGradient0]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient0
])[2])*((pvl->directAnswer[gageVecGradient0]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient0])[2])*((pvl->directAnswer[gageVecGradient0
]))[2]));

370

ELL_3MV_OUTER_INCR(pvl->directAnswer[gageVecMultiGrad],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient1])[0])*((pvl->directAnswer[gageVecGradient1
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient1])[0])*((pvl->directAnswer
[gageVecGradient1]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient1])[0])*((pvl
->directAnswer[gageVecGradient1]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient1
])[1])*((pvl->directAnswer[gageVecGradient1]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient1])[1])*((pvl->directAnswer[gageVecGradient1
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient1])[1])*((pvl->directAnswer
[gageVecGradient1]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient1])[2])*((pvl
->directAnswer[gageVecGradient1]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient1
])[2])*((pvl->directAnswer[gageVecGradient1]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient1])[2])*((pvl->directAnswer[gageVecGradient1
]))[2]))

371

pvl->directAnswer[gageVecGradient1],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient1])[0])*((pvl->directAnswer[gageVecGradient1
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient1])[0])*((pvl->directAnswer
[gageVecGradient1]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient1])[0])*((pvl
->directAnswer[gageVecGradient1]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient1
])[1])*((pvl->directAnswer[gageVecGradient1]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient1])[1])*((pvl->directAnswer[gageVecGradient1
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient1])[1])*((pvl->directAnswer
[gageVecGradient1]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient1])[2])*((pvl
->directAnswer[gageVecGradient1]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient1
])[2])*((pvl->directAnswer[gageVecGradient1]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient1])[2])*((pvl->directAnswer[gageVecGradient1
]))[2]))

372

pvl->directAnswer[gageVecGradient1])((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient1])[0])*((pvl->directAnswer[gageVecGradient1
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient1])[0])*((pvl->directAnswer
[gageVecGradient1]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient1])[0])*((pvl
->directAnswer[gageVecGradient1]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient1
])[1])*((pvl->directAnswer[gageVecGradient1]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient1])[1])*((pvl->directAnswer[gageVecGradient1
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient1])[1])*((pvl->directAnswer
[gageVecGradient1]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient1])[2])*((pvl
->directAnswer[gageVecGradient1]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient1
])[2])*((pvl->directAnswer[gageVecGradient1]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient1])[2])*((pvl->directAnswer[gageVecGradient1
]))[2]));

373

ELL_3MV_OUTER_INCR(pvl->directAnswer[gageVecMultiGrad],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient2])[0])*((pvl->directAnswer[gageVecGradient2
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient2])[0])*((pvl->directAnswer
[gageVecGradient2]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient2])[0])*((pvl
->directAnswer[gageVecGradient2]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient2
])[1])*((pvl->directAnswer[gageVecGradient2]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient2])[1])*((pvl->directAnswer[gageVecGradient2
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient2])[1])*((pvl->directAnswer
[gageVecGradient2]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient2])[2])*((pvl
->directAnswer[gageVecGradient2]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient2
])[2])*((pvl->directAnswer[gageVecGradient2]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient2])[2])*((pvl->directAnswer[gageVecGradient2
]))[2]))

374

pvl->directAnswer[gageVecGradient2],((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient2])[0])*((pvl->directAnswer[gageVecGradient2
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient2])[0])*((pvl->directAnswer
[gageVecGradient2]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient2])[0])*((pvl
->directAnswer[gageVecGradient2]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient2
])[1])*((pvl->directAnswer[gageVecGradient2]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient2])[1])*((pvl->directAnswer[gageVecGradient2
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient2])[1])*((pvl->directAnswer
[gageVecGradient2]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient2])[2])*((pvl
->directAnswer[gageVecGradient2]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient2
])[2])*((pvl->directAnswer[gageVecGradient2]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient2])[2])*((pvl->directAnswer[gageVecGradient2
]))[2]))

375

pvl->directAnswer[gageVecGradient2])((((pvl->directAnswer[gageVecMultiGrad])+0)[0] += ((pvl->
directAnswer[gageVecGradient2])[0])*((pvl->directAnswer[gageVecGradient2
]))[0], ((pvl->directAnswer[gageVecMultiGrad])+0)[1] += ((
pvl->directAnswer[gageVecGradient2])[0])*((pvl->directAnswer
[gageVecGradient2]))[1], ((pvl->directAnswer[gageVecMultiGrad
])+0)[2] += ((pvl->directAnswer[gageVecGradient2])[0])*((pvl
->directAnswer[gageVecGradient2]))[2]), (((pvl->directAnswer
[gageVecMultiGrad])+3)[0] += ((pvl->directAnswer[gageVecGradient2
])[1])*((pvl->directAnswer[gageVecGradient2]))[0], ((pvl->
directAnswer[gageVecMultiGrad])+3)[1] += ((pvl->directAnswer
[gageVecGradient2])[1])*((pvl->directAnswer[gageVecGradient2
]))[1], ((pvl->directAnswer[gageVecMultiGrad])+3)[2] += ((
pvl->directAnswer[gageVecGradient2])[1])*((pvl->directAnswer
[gageVecGradient2]))[2]), (((pvl->directAnswer[gageVecMultiGrad
])+6)[0] += ((pvl->directAnswer[gageVecGradient2])[2])*((pvl
->directAnswer[gageVecGradient2]))[0], ((pvl->directAnswer
[gageVecMultiGrad])+6)[1] += ((pvl->directAnswer[gageVecGradient2
])[2])*((pvl->directAnswer[gageVecGradient2]))[1], ((pvl->
directAnswer[gageVecMultiGrad])+6)[2] += ((pvl->directAnswer
[gageVecGradient2])[2])*((pvl->directAnswer[gageVecGradient2
]))[2]));

376

}

377

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGFrob)(pvl->query[gageVecMGFrob/8] & (1 << (gageVecMGFrob
% 8)))) {

←

Taking false branch

→

378

pvl->directAnswer[gageVecMGFrob][0]

379

= ELL_3M_FROB(pvl->directAnswer[gageVecMultiGrad])(sqrt((((pvl->directAnswer[gageVecMultiGrad])+0)[0]*((pvl->
directAnswer[gageVecMultiGrad])+0)[0] + ((pvl->directAnswer
[gageVecMultiGrad])+0)[1]*((pvl->directAnswer[gageVecMultiGrad
])+0)[1] + ((pvl->directAnswer[gageVecMultiGrad])+0)[2]*((
pvl->directAnswer[gageVecMultiGrad])+0)[2]) + (((pvl->directAnswer
[gageVecMultiGrad])+3)[0]*((pvl->directAnswer[gageVecMultiGrad
])+3)[0] + ((pvl->directAnswer[gageVecMultiGrad])+3)[1]*((
pvl->directAnswer[gageVecMultiGrad])+3)[1] + ((pvl->directAnswer
[gageVecMultiGrad])+3)[2]*((pvl->directAnswer[gageVecMultiGrad
])+3)[2]) + (((pvl->directAnswer[gageVecMultiGrad])+6)[0]*
((pvl->directAnswer[gageVecMultiGrad])+6)[0] + ((pvl->directAnswer
[gageVecMultiGrad])+6)[1]*((pvl->directAnswer[gageVecMultiGrad
])+6)[1] + ((pvl->directAnswer[gageVecMultiGrad])+6)[2]*((
pvl->directAnswer[gageVecMultiGrad])+6)[2])));

380

}

381

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGEval)(pvl->query[gageVecMGEval/8] & (1 << (gageVecMGEval
% 8)))) {

←

Taking false branch

→

382

ELL_3M_COPY(tmpMat, pvl->directAnswer[gageVecMultiGrad])((((tmpMat)+0)[0] = ((pvl->directAnswer[gageVecMultiGrad])
+0)[0], ((tmpMat)+0)[1] = ((pvl->directAnswer[gageVecMultiGrad
])+0)[1], ((tmpMat)+0)[2] = ((pvl->directAnswer[gageVecMultiGrad
])+0)[2]), (((tmpMat)+3)[0] = ((pvl->directAnswer[gageVecMultiGrad
])+3)[0], ((tmpMat)+3)[1] = ((pvl->directAnswer[gageVecMultiGrad
])+3)[1], ((tmpMat)+3)[2] = ((pvl->directAnswer[gageVecMultiGrad
])+3)[2]), (((tmpMat)+6)[0] = ((pvl->directAnswer[gageVecMultiGrad
])+6)[0], ((tmpMat)+6)[1] = ((pvl->directAnswer[gageVecMultiGrad
])+6)[1], ((tmpMat)+6)[2] = ((pvl->directAnswer[gageVecMultiGrad
])+6)[2]));

383

/* HEY: look at the return value for root multiplicity? */

384

ell_3m_eigensolve_d(mgeval, mgevec, tmpMat, AIR_TRUE1);

385

ELL_3V_COPY(pvl->directAnswer[gageVecMGEval], mgeval)((pvl->directAnswer[gageVecMGEval])[0] = (mgeval)[0], (pvl
->directAnswer[gageVecMGEval])[1] = (mgeval)[1], (pvl->
directAnswer[gageVecMGEval])[2] = (mgeval)[2]);

386

}

387

if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGEvec)(pvl->query[gageVecMGEvec/8] & (1 << (gageVecMGEvec
% 8)))) {

←

Taking true branch

→

388

ELL_3M_COPY(pvl->directAnswer[gageVecMGEvec], mgevec)((((pvl->directAnswer[gageVecMGEvec])+0)[0] = ((mgevec)+0)
[0], ((pvl->directAnswer[gageVecMGEvec])+0)[1] = ((mgevec)
+0)[1], ((pvl->directAnswer[gageVecMGEvec])+0)[2] = ((mgevec
)+0)[2]), (((pvl->directAnswer[gageVecMGEvec])+3)[0] = ((mgevec
)+3)[0], ((pvl->directAnswer[gageVecMGEvec])+3)[1] = ((mgevec
)+3)[1], ((pvl->directAnswer[gageVecMGEvec])+3)[2] = ((mgevec
)+3)[2]), (((pvl->directAnswer[gageVecMGEvec])+6)[0] = ((mgevec
)+6)[0], ((pvl->directAnswer[gageVecMGEvec])+6)[1] = ((mgevec
)+6)[1], ((pvl->directAnswer[gageVecMGEvec])+6)[2] = ((mgevec
)+6)[2]));

←

Within the expansion of the macro 'ELL_3M_COPY':

a	Assigned value is garbage or undefined

389

}

390

391

return;

392

}

393

394

const char *

395

_gageVecStr[] = {

396

"(unknown gageVec)",

397

"vector",

398

"vector0",

399

"vector1",

400

"vector2",

401

"length",

402

"normalized",

403

"Jacobian",

404

"strain",

405

"divergence",

406

"curl",

407

"curl norm",

408

"helicity",

409

"normalized helicity",

410

"SOmega",

411

"lambda2",

412

"imag",

413

"vector hessian",

414

"div gradient",

415

"curl gradient",

416

"curl norm gradient",

417

"normalized curl norm gradient",

418

"helicity gradient",

419

"directional helicity derivative",

420

"projected helicity gradient",

421

"gradient0",

422

"gradient1",

423

"gradient2",

424

"multigrad",

425

"frob(multigrad)",

426

"multigrad eigenvalues",

427

"multigrad eigenvectors",

428

};

429

430

const char *

431

_gageVecDesc[] = {

432

"unknown gageVec query",

433

"component-wise-interpolated vector",

434

"vector[0]",

435

"vector[1]",

436

"vector[2]",

437

"length of vector",

438

"normalized vector",

439

"3x3 Jacobian",

440

"rate-of-strain tensor",

441

"divergence",

442

"curl",

443

"curl magnitude",

444

"helicity: dot(vector,curl)",

445

"normalized helicity",

446

"S squared plus Omega squared for vortex characterization",

447

"lambda2 value of SOmega",

448

"imaginary part of complex-conjugate eigenvalues of Jacobian",

449

"3x3x3 second-order vector derivative",

450

"gradient of divergence",

451

"3x3 derivative of curl",

452

"gradient of curl norm",

453

"normalized gradient of curl norm",

454

"gradient of helicity",

455

"directional derivative of helicity along flow",

456

"projection of the helicity gradient onto plane orthogonal to flow",

457

"gradient of 1st component of vector",

458

"gradient of 2nd component of vector",

459

"gradient of 3rd component of vector",

460

"multi-gradient: sum of outer products of gradients",

461

"frob norm of multi-gradient",

462

"eigenvalues of multi-gradient",

463

"eigenvectors of multi-gradient"

464

};

465

466

const int

467

_gageVecVal[] = {

468

gageVecUnknown,

469

gageVecVector,

470

gageVecVector0,

471

gageVecVector1,

472

gageVecVector2,

473

gageVecLength,

474

gageVecNormalized,

475

gageVecJacobian,

476

gageVecStrain,

477

gageVecDivergence,

478

gageVecCurl,

479

gageVecCurlNorm,

480

gageVecHelicity,

481

gageVecNormHelicity,

482

gageVecSOmega,

483

gageVecLambda2,

484

gageVecImaginaryPart,

485

gageVecHessian,

486

gageVecDivGradient,

487

gageVecCurlGradient,

488

gageVecCurlNormGrad,

489

gageVecNCurlNormGrad,

490

gageVecHelGradient,

491

gageVecDirHelDeriv,

492

gageVecProjHelGradient,

493

gageVecGradient0,

494

gageVecGradient1,

495

gageVecGradient2,

496

gageVecMultiGrad,

497

gageVecMGFrob,

498

gageVecMGEval,

499

gageVecMGEvec,

500

};

501

502

#define GV_VgageVecVector gageVecVector

503

#define GV_V0gageVecVector0 gageVecVector0

504

#define GV_V1gageVecVector1 gageVecVector1

505

#define GV_V2gageVecVector2 gageVecVector2

506

#define GV_LgageVecLength gageVecLength

507

#define GV_NgageVecNormalized gageVecNormalized

508

#define GV_JgageVecJacobian gageVecJacobian

509

#define GV_SgageVecStrain gageVecStrain

510

#define GV_DgageVecDivergence gageVecDivergence

511

#define GV_CgageVecCurl gageVecCurl

512

#define GV_CMgageVecCurlNorm gageVecCurlNorm

513

#define GV_HgageVecHelicity gageVecHelicity

514

#define GV_NHgageVecNormHelicity gageVecNormHelicity

515

#define GV_SOgageVecSOmega gageVecSOmega

516

#define GV_LBgageVecLambda2 gageVecLambda2

517

#define GV_IMgageVecImaginaryPart gageVecImaginaryPart

518

#define GV_VHgageVecHessian gageVecHessian

519

#define GV_DGgageVecDivGradient gageVecDivGradient

520

#define GV_CGgageVecCurlGradient gageVecCurlGradient

521

#define GV_CNGgageVecCurlNormGrad gageVecCurlNormGrad

522

#define GV_NCGgageVecNCurlNormGrad gageVecNCurlNormGrad

523

#define GV_HGgageVecHelGradient gageVecHelGradient

524

#define GV_DHgageVecDirHelDeriv gageVecDirHelDeriv

525

#define GV_PHgageVecProjHelGradient gageVecProjHelGradient

526

#define GV_G0gageVecGradient0 gageVecGradient0

527

#define GV_G1gageVecGradient1 gageVecGradient1

528

#define GV_G2gageVecGradient2 gageVecGradient2

529

#define GV_MGgageVecMultiGrad gageVecMultiGrad

530

#define GV_MFgageVecMGFrob gageVecMGFrob

531

#define GV_MLgageVecMGEval gageVecMGEval

532

#define GV_MCgageVecMGEvec gageVecMGEvec

533

534

const char *

535

_gageVecStrEqv[] = {

536

"v", "vector", "vec",

537

"v0", "vector0", "vec0",

538

"v1", "vector1", "vec1",

539

"v2", "vector2", "vec2",

540

"l", "length", "len",

541

"n", "normalized", "normalized vector",

542

"jacobian", "jac", "j",

543

"strain", "S",

544

"divergence", "div", "d",

545

"curl", "c",

546

"curlnorm", "curl norm", "curl magnitude", "cm",

547

"h", "hel", "hell", "helicity",

548

"nh", "nhel", "normhel", "normhell", "normalized helicity",

549

"SOmega",

550

"lbda2", "lambda2",

551

"imag", "imagpart",

552

"vh", "vhes", "vhessian", "vector hessian",

553

"dg", "divgrad", "div gradient",

554

"cg", "curlgrad", "curlg", "curljac", "curl gradient",

555

"cng", "curl norm gradient",

556

"ncng", "norm curl norm gradient", "normalized curl norm gradient",

557

"hg", "helg", "helgrad", "helicity gradient",

558

"dirhelderiv", "dhd", "ddh", "directional helicity derivative",

559

"phg", "projhel", "projhelgrad", "projected helicity gradient",

560

"g0", "grad0", "gradient0",

561

"g1", "grad1", "gradient1",

562

"g2", "grad2", "gradient2",

563

"mg", "multigrad",

564

"mgfrob", "frob(multigrad)",

565

"mgeval", "mg eval", "multigrad eigenvalues",

566

"mgevec", "mg evec", "multigrad eigenvectors",

567

568

};

569

570

const int

571

_gageVecValEqv[] = {

572

GV_VgageVecVector, GV_VgageVecVector, GV_VgageVecVector,

573

GV_V0gageVecVector0, GV_V0gageVecVector0, GV_V0gageVecVector0,

574

GV_V1gageVecVector1, GV_V1gageVecVector1, GV_V1gageVecVector1,

575

GV_V2gageVecVector2, GV_V2gageVecVector2, GV_V2gageVecVector2,

576

GV_LgageVecLength, GV_LgageVecLength, GV_LgageVecLength,

577

GV_NgageVecNormalized, GV_NgageVecNormalized, GV_NgageVecNormalized,

578

GV_JgageVecJacobian, GV_JgageVecJacobian, GV_JgageVecJacobian,

579

GV_SgageVecStrain, GV_SgageVecStrain,

580

GV_DgageVecDivergence, GV_DgageVecDivergence, GV_DgageVecDivergence,

581

GV_CgageVecCurl, GV_CgageVecCurl,

582

GV_CMgageVecCurlNorm, GV_CMgageVecCurlNorm, GV_CMgageVecCurlNorm, GV_CMgageVecCurlNorm,

583

GV_HgageVecHelicity, GV_HgageVecHelicity, GV_HgageVecHelicity, GV_HgageVecHelicity,

584

GV_NHgageVecNormHelicity, GV_NHgageVecNormHelicity, GV_NHgageVecNormHelicity, GV_NHgageVecNormHelicity, GV_NHgageVecNormHelicity,

585

GV_SOgageVecSOmega,

586

GV_LBgageVecLambda2, GV_LBgageVecLambda2,

587

GV_IMgageVecImaginaryPart, GV_IMgageVecImaginaryPart,

588

GV_VHgageVecHessian, GV_VHgageVecHessian, GV_VHgageVecHessian, GV_VHgageVecHessian,

589

GV_DGgageVecDivGradient, GV_DGgageVecDivGradient, GV_DGgageVecDivGradient,

590

GV_CGgageVecCurlGradient, GV_CGgageVecCurlGradient, GV_CGgageVecCurlGradient, GV_CGgageVecCurlGradient, GV_CGgageVecCurlGradient,

591

GV_CNGgageVecCurlNormGrad, GV_CNGgageVecCurlNormGrad,

592

GV_NCGgageVecNCurlNormGrad, GV_NCGgageVecNCurlNormGrad, GV_NCGgageVecNCurlNormGrad,

593

GV_HGgageVecHelGradient, GV_HGgageVecHelGradient, GV_HGgageVecHelGradient, GV_HGgageVecHelGradient,

594

GV_DHgageVecDirHelDeriv, GV_DHgageVecDirHelDeriv, GV_DHgageVecDirHelDeriv, GV_DHgageVecDirHelDeriv,

595

GV_PHgageVecProjHelGradient, GV_PHgageVecProjHelGradient, GV_PHgageVecProjHelGradient, GV_PHgageVecProjHelGradient,

596

GV_G0gageVecGradient0, GV_G0gageVecGradient0, GV_G0gageVecGradient0,

597

GV_G1gageVecGradient1, GV_G1gageVecGradient1, GV_G1gageVecGradient1,

598

GV_G2gageVecGradient2, GV_G2gageVecGradient2, GV_G2gageVecGradient2,

599

GV_MGgageVecMultiGrad, GV_MGgageVecMultiGrad,

600

GV_MFgageVecMGFrob, GV_MFgageVecMGFrob,

601

GV_MLgageVecMGEval, GV_MLgageVecMGEval, GV_MLgageVecMGEval,

602

GV_MCgageVecMGEvec, GV_MCgageVecMGEvec, GV_MCgageVecMGEvec

603

};

604

605

const airEnum

606

_gageVec = {

607

"gageVec",

608

GAGE_VEC_ITEM_MAX31,

609

_gageVecStr, _gageVecVal,

610

_gageVecDesc,

611

_gageVecStrEqv, _gageVecValEqv,

612

AIR_FALSE0

613

};

614

const airEnum *const

615

gageVec = &_gageVec;

616

617

gageKind

618

_gageKindVec = {

619

AIR_FALSE0, /* statically allocated */

620

"vector",

621

&_gageVec,

622

1, /* baseDim */

623

3, /* valLen */

624

GAGE_VEC_ITEM_MAX31,

625

_gageVecTable,

626

_gageVecIv3Print,

627

_gageVecFilter,

628

_gageVecAnswer,

629

NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0),

630

NULL((void*)0)

631

};

632

gageKind *const

633

gageKindVec = &_gageKindVec;

634