source: CIVL/examples/experimental/reverse_CIVL/head.cn.xb.pp.c

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 12.9 KB
Line 
1/************************** DISCLAIMER ********************************/
2/* */
3/* This file was generated on 04/13/17 09:49:48 by */
4/* ADIC version /* */
5/* ADIC was prepared as an account of work sponsored by an */
6/* agency of the United States Government and the University of */
7/* Chicago. NEITHER THE AUTHOR(S), THE UNITED STATES GOVERNMENT */
8/* NOR ANY AGENCY THEREOF, NOR THE UNIVERSITY OF CHICAGO, INCLUDING */
9/* ANY OF THEIR EMPLOYEES OR OFFICERS, MAKES ANY WARRANTY, EXPRESS */
10/* OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR */
11/* THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY INFORMATION OR */
12/* PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE */
13/* PRIVATELY OWNED RIGHTS. */
14/* */
15/**********************************************************************/
16#ifdef ADIC_DENSE
17#include "ad_types.h"
18#endif
19#ifdef ADIC_DENSE_REVERSE
20#include "ad_types.h"
21#endif
22#ifdef ADIC_DENSE_SEED
23#include "ad_types.h"
24#endif
25#ifdef ADIC_GRAD_LENGTH
26#include "ad_grad_length_types.h"
27#endif
28#ifdef ADIC_SPARSE_NO_GRAD
29#include "noderiv_sparslinc.h"
30#endif
31#ifdef ADIC_SPARSE
32#include "sparslinc.h"
33#endif
34#define epsilon 1.00000e-14
35/*****************************************************************************/
36/* This set of functions reference triangular elements to an equilateral */
37/* triangle. The input are the coordinates in the following order: */
38/* [x1 x2 x3 y1 y2 y3] */
39/* A zero return value indicates success, while a nonzero value indicates */
40/* failure. */
41/*****************************************************************************/
42/* Not all compilers substitute out constants (especially the square root). */
43/* Therefore, they are substituted out manually. The values below were */
44/* calculated on a solaris machine using long doubles. I believe they are */
45/* accurate. */
46/*****************************************************************************/
47#define sqrt3 .577350269189625797959429519858
48/* 1.0/sqrt(3.0) */
49/*#define tsqrt3 1.15470053837925159591885903972 2.0/sqrt(3.0) */
50#define a .500000000000000000000000000000 /* 1.0/2.0 */
51#define b -1.00000000000000000000000000000 /* -1.0/1.0 */
52#define bm1 -2.00000000000000000000000000000 /* -2.0/1.0 */
53// = 2.0/sqrt3;
54/* double tsqrt3; */
55DERIV_TYPE tsqrt3;
56//double tsqrt3 = 2.0/sqrt3;
57/* const */
58/*x)*/
59
60void ad_o_fcn(DERIV_TYPE *ad_var_ret,DERIV_TYPE *obj,DERIV_TYPE x[6])
61{
62 int ad_Symbol_3;
63 int ad_Symbol_5;
64 int ad_Symbol_4;
65 DERIV_TYPE ad_prp_0;
66 DERIV_TYPE ad_prp_1;
67 DERIV_TYPE ad_prp_4;
68 DERIV_TYPE ad_prp_3;
69 DERIV_TYPE ad_prp_2;
70 DERIV_TYPE ad_prp_5;
71 DERIV_TYPE ad_prp_6;
72 DERIV_TYPE ad_prp_7;
73 DERIV_TYPE ad_prp_10;
74 DERIV_TYPE ad_prp_9;
75 DERIV_TYPE ad_prp_8;
76 DERIV_TYPE ad_prp_11;
77 DERIV_TYPE ad_prp_12;
78 DERIV_TYPE ad_prp_13;
79 DERIV_TYPE ad_prp_14;
80 DERIV_TYPE ad_prp_15;
81 double ad_Symbol_9;
82 double ad_Symbol_8;
83 double ad_Symbol_7;
84 double ad_Symbol_6;
85 DERIV_TYPE ad_prp_18;
86 DERIV_TYPE ad_prp_19;
87 DERIV_TYPE ad_prp_20;
88 DERIV_TYPE ad_prp_21;
89 DERIV_TYPE ad_prp_22;
90 DERIV_TYPE ad_prp_23;
91 DERIV_TYPE ad_prp_24;
92 DERIV_TYPE ad_prp_25;
93 double ad_Symbol_19;
94 double ad_Symbol_18;
95 double ad_Symbol_17;
96 double ad_Symbol_16;
97 double ad_Symbol_15;
98 double ad_Symbol_14;
99 double ad_Symbol_13;
100 double ad_Symbol_12;
101 DERIV_TYPE ad_prp_27;
102 DERIV_TYPE ad_prp_26;
103 double ad_Symbol_11;
104 double ad_Symbol_10;
105 DERIV_TYPE ad_prp_16;
106 int ad_Symbol_0;
107 DERIV_TYPE ad_prp_17;
108 int ad_Symbol_2;
109 double ad_acc_2;
110 double ad_lin_13;
111 double ad_lin_12;
112 double ad_aux_2;
113 double ad_lin_11;
114 double ad_lin_10;
115 double ad_lin_9;
116 double ad_lin_8;
117 double ad_lin_7;
118 double ad_lin_6;
119 double ad_lin_5;
120 double ad_lin_4;
121 int ad_Symbol_1;
122 double ad_acc_1;
123 double ad_acc_0;
124 double ad_lin_3;
125 double ad_lin_2;
126 double ad_lin_1;
127 double ad_lin_0;
128 double ad_aux_1;
129 double ad_aux_0;
130 DERIV_TYPE f;
131 DERIV_TYPE g;
132 DERIV_TYPE matr[4];
133 DERIV_TYPE retval;
134 ZeroDeriv(ad_prp_0);
135 DERIV_val(ad_prp_0) = 0.00000;
136 ZeroDeriv(ad_prp_1);
137 DERIV_val(ad_prp_1) = 0.00000;
138 ZeroDeriv(ad_prp_4);
139 DERIV_val(ad_prp_4) = 0.00000;
140 ZeroDeriv(ad_prp_3);
141 DERIV_val(ad_prp_3) = 0.00000;
142 ZeroDeriv(ad_prp_2);
143 DERIV_val(ad_prp_2) = 0.00000;
144 ZeroDeriv(ad_prp_5);
145 DERIV_val(ad_prp_5) = 0.00000;
146 ZeroDeriv(ad_prp_6);
147 DERIV_val(ad_prp_6) = 0.00000;
148 ZeroDeriv(ad_prp_7);
149 DERIV_val(ad_prp_7) = 0.00000;
150 ZeroDeriv(ad_prp_10);
151 DERIV_val(ad_prp_10) = 0.00000;
152 ZeroDeriv(ad_prp_9);
153 DERIV_val(ad_prp_9) = 0.00000;
154 ZeroDeriv(ad_prp_8);
155 DERIV_val(ad_prp_8) = 0.00000;
156 ZeroDeriv(ad_prp_11);
157 DERIV_val(ad_prp_11) = 0.00000;
158 ZeroDeriv(ad_prp_12);
159 DERIV_val(ad_prp_12) = 0.00000;
160 ZeroDeriv(ad_prp_13);
161 DERIV_val(ad_prp_13) = 0.00000;
162 ZeroDeriv(ad_prp_14);
163 DERIV_val(ad_prp_14) = 0.00000;
164 ZeroDeriv(ad_prp_15);
165 DERIV_val(ad_prp_15) = 0.00000;
166 ZeroDeriv(ad_prp_18);
167 DERIV_val(ad_prp_18) = 0.00000;
168 ZeroDeriv(ad_prp_19);
169 DERIV_val(ad_prp_19) = 0.00000;
170 ZeroDeriv(ad_prp_20);
171 DERIV_val(ad_prp_20) = 0.00000;
172 ZeroDeriv(ad_prp_21);
173 DERIV_val(ad_prp_21) = 0.00000;
174 ZeroDeriv(ad_prp_22);
175 DERIV_val(ad_prp_22) = 0.00000;
176 ZeroDeriv(ad_prp_23);
177 DERIV_val(ad_prp_23) = 0.00000;
178 ZeroDeriv(ad_prp_24);
179 DERIV_val(ad_prp_24) = 0.00000;
180 ZeroDeriv(ad_prp_25);
181 DERIV_val(ad_prp_25) = 0.00000;
182 ZeroDeriv(ad_prp_27);
183 DERIV_val(ad_prp_27) = 0.00000;
184 ZeroDeriv(ad_prp_26);
185 DERIV_val(ad_prp_26) = 0.00000;
186 ZeroDeriv(ad_prp_16);
187 DERIV_val(ad_prp_16) = 0.00000;
188 ZeroDeriv(ad_prp_17);
189 DERIV_val(ad_prp_17) = 0.00000;
190 ZeroDeriv(f);
191 DERIV_val(f) = 0.00000;
192 ZeroDeriv(g);
193 DERIV_val(g) = 0.00000;
194 ZeroDerivvector(matr,4);
195 SetZeroValvector(matr,4);
196 ZeroDeriv(retval);
197 DERIV_val(retval) = 0.00000;
198 if (our_rev_mode . plain == 1) {
199/* static */
200/* double matr[4]; double f; double g; double retval; */
201 DERIV_TYPE matr[4];
202 DERIV_TYPE f;
203/* static */
204 DERIV_TYPE g;
205 DERIV_TYPE retval;
206 DERIV_val(retval) = 0.00000;
207 DERIV_val(matr[0]) = DERIV_val(x[1]) - DERIV_val(x[0]);
208 DERIV_val(matr[1]) = (2.00000 * DERIV_val(x[2]) - DERIV_val(x[1]) - DERIV_val(x[0])) * 0.577350269189625797959429519858;
209 DERIV_val(matr[2]) = DERIV_val(x[4]) - DERIV_val(x[3]);
210 DERIV_val(matr[3]) = (2.00000 * DERIV_val(x[5]) - DERIV_val(x[4]) - DERIV_val(x[3])) * 0.577350269189625797959429519858;
211 DERIV_val(g) = DERIV_val(matr[0]) * DERIV_val(matr[3]) - DERIV_val(matr[1]) * DERIV_val(matr[2]);
212 if (DERIV_val(g) <= 1.00000e-14) {
213 DERIV_val( *obj) = DERIV_val(g);
214 DERIV_val(retval) = 1.00000;
215 }
216 else {
217 DERIV_val(f) = DERIV_val(matr[0]) * DERIV_val(matr[0]) + DERIV_val(matr[1]) * DERIV_val(matr[1]) + DERIV_val(matr[2]) * DERIV_val(matr[2]) + DERIV_val(matr[3]) * DERIV_val(matr[3]);
218 DERIV_val( *obj) = 0.500000 * DERIV_val(f) / DERIV_val(g);
219 }
220 DERIV_val( *ad_var_ret) = DERIV_val(retval);
221 }
222 else if (our_rev_mode . tape == 1) {
223/* static */
224/* double matr[4]; double f; double g; double retval; */
225 DERIV_TYPE matr[4];
226 DERIV_TYPE f;
227/* static */
228 DERIV_TYPE g;
229 DERIV_TYPE retval;
230 DERIV_val(retval) = 0.00000;
231 DERIV_val(matr[0]) = DERIV_val(x[1]) - DERIV_val(x[0]);
232 ad_aux_0 = 2.00000 * DERIV_val(x[2]) - DERIV_val(x[1]) - DERIV_val(x[0]);
233 DERIV_val(matr[1]) = ad_aux_0 * 0.577350269189625797959429519858;
234 DERIV_val(matr[2]) = DERIV_val(x[4]) - DERIV_val(x[3]);
235 ad_aux_1 = 2.00000 * DERIV_val(x[5]) - DERIV_val(x[4]) - DERIV_val(x[3]);
236 DERIV_val(matr[3]) = ad_aux_1 * 0.577350269189625797959429519858;
237 ad_lin_0 = DERIV_val(matr[3]);
238 ad_lin_1 = DERIV_val(matr[0]);
239 ad_lin_2 = DERIV_val(matr[2]);
240 ad_lin_3 = DERIV_val(matr[1]);
241 DERIV_val(g) = DERIV_val(matr[0]) * DERIV_val(matr[3]) - DERIV_val(matr[1]) * DERIV_val(matr[2]);
242 ad_acc_0 = ad_lin_2 * -1;
243 ad_acc_1 = ad_lin_3 * -1;
244 push_s0(ad_lin_0);
245 push_s0(ad_lin_1);
246 push_s0(ad_acc_0);
247 push_s0(ad_acc_1);
248 if (DERIV_val(g) <= 1.00000e-14) {
249 DERIV_val( *obj) = DERIV_val(g);
250 DERIV_val(retval) = 1.00000;
251 ad_Symbol_1 = 1;
252 push_i_s0(ad_Symbol_1);
253 }
254 else {
255 ad_lin_4 = DERIV_val(matr[0]);
256 ad_lin_5 = DERIV_val(matr[0]);
257 ad_lin_6 = DERIV_val(matr[1]);
258 ad_lin_7 = DERIV_val(matr[1]);
259 ad_lin_8 = DERIV_val(matr[2]);
260 ad_lin_9 = DERIV_val(matr[2]);
261 ad_lin_10 = DERIV_val(matr[3]);
262 ad_lin_11 = DERIV_val(matr[3]);
263 DERIV_val(f) = DERIV_val(matr[0]) * DERIV_val(matr[0]) + DERIV_val(matr[1]) * DERIV_val(matr[1]) + DERIV_val(matr[2]) * DERIV_val(matr[2]) + DERIV_val(matr[3]) * DERIV_val(matr[3]);
264 push_s0(ad_lin_4);
265 push_s0(ad_lin_5);
266 push_s0(ad_lin_6);
267 push_s0(ad_lin_7);
268 push_s0(ad_lin_8);
269 push_s0(ad_lin_9);
270 push_s0(ad_lin_10);
271 push_s0(ad_lin_11);
272 ad_aux_2 = 0.500000 * DERIV_val(f);
273 ad_lin_12 = 1.00000 / DERIV_val(g);
274 ad_lin_13 = -(ad_aux_2 / (DERIV_val(g) * DERIV_val(g)));
275 DERIV_val( *obj) = ad_aux_2 / DERIV_val(g);
276 ad_acc_2 = 0.500000 * ad_lin_12;
277 push_s0(ad_lin_13);
278 push_s0(ad_acc_2);
279 ad_Symbol_2 = 0;
280 push_i_s0(ad_Symbol_2);
281 }
282 DERIV_val( *ad_var_ret) = DERIV_val(retval);
283 }
284 else if (our_rev_mode . adjoint == 1) {
285 IncDeriv(ad_prp_17, *ad_var_ret);
286 ZeroDeriv( *ad_var_ret);
287 IncDeriv(retval,ad_prp_17);
288 ZeroDeriv(ad_prp_17);
289 pop_i_s0(ad_Symbol_0);
290 if (ad_Symbol_0 != 0) {
291 IncDeriv(ad_prp_16, *obj);
292 ZeroDeriv( *obj);
293 IncDeriv(g,ad_prp_16);
294 ZeroDeriv(ad_prp_16);
295 ZeroDeriv(retval);
296 }
297 else {
298 pop_s0(ad_Symbol_10);
299 pop_s0(ad_Symbol_11);
300 Saxpy(ad_Symbol_10, *obj,ad_prp_26);
301 Saxpy(ad_Symbol_11, *obj,ad_prp_27);
302 ZeroDeriv( *obj);
303 IncDeriv(g,ad_prp_27);
304 ZeroDeriv(ad_prp_27);
305 IncDeriv(f,ad_prp_26);
306 ZeroDeriv(ad_prp_26);
307 pop_s0(ad_Symbol_12);
308 pop_s0(ad_Symbol_13);
309 pop_s0(ad_Symbol_14);
310 pop_s0(ad_Symbol_15);
311 pop_s0(ad_Symbol_16);
312 pop_s0(ad_Symbol_17);
313 pop_s0(ad_Symbol_18);
314 pop_s0(ad_Symbol_19);
315 Saxpy(ad_Symbol_12,f,ad_prp_25);
316 Saxpy(ad_Symbol_13,f,ad_prp_24);
317 Saxpy(ad_Symbol_14,f,ad_prp_23);
318 Saxpy(ad_Symbol_15,f,ad_prp_22);
319 Saxpy(ad_Symbol_16,f,ad_prp_21);
320 Saxpy(ad_Symbol_17,f,ad_prp_20);
321 Saxpy(ad_Symbol_18,f,ad_prp_19);
322 Saxpy(ad_Symbol_19,f,ad_prp_18);
323 ZeroDeriv(f);
324 IncDeriv(matr[3],ad_prp_25);
325 ZeroDeriv(ad_prp_25);
326 IncDeriv(matr[3],ad_prp_24);
327 ZeroDeriv(ad_prp_24);
328 IncDeriv(matr[2],ad_prp_23);
329 ZeroDeriv(ad_prp_23);
330 IncDeriv(matr[2],ad_prp_22);
331 ZeroDeriv(ad_prp_22);
332 IncDeriv(matr[1],ad_prp_21);
333 ZeroDeriv(ad_prp_21);
334 IncDeriv(matr[1],ad_prp_20);
335 ZeroDeriv(ad_prp_20);
336 IncDeriv(matr[0],ad_prp_19);
337 ZeroDeriv(ad_prp_19);
338 IncDeriv(matr[0],ad_prp_18);
339 ZeroDeriv(ad_prp_18);
340 }
341 pop_s0(ad_Symbol_6);
342 pop_s0(ad_Symbol_7);
343 pop_s0(ad_Symbol_8);
344 pop_s0(ad_Symbol_9);
345 Saxpy(ad_Symbol_6,g,ad_prp_15);
346 Saxpy(ad_Symbol_7,g,ad_prp_14);
347 Saxpy(ad_Symbol_8,g,ad_prp_13);
348 Saxpy(ad_Symbol_9,g,ad_prp_12);
349 ZeroDeriv(g);
350 IncDeriv(matr[2],ad_prp_15);
351 ZeroDeriv(ad_prp_15);
352 IncDeriv(matr[1],ad_prp_14);
353 ZeroDeriv(ad_prp_14);
354 IncDeriv(matr[3],ad_prp_13);
355 ZeroDeriv(ad_prp_13);
356 IncDeriv(matr[0],ad_prp_12);
357 ZeroDeriv(ad_prp_12);
358 Saxpy(0.577350269189625797959429519858,matr[3],ad_prp_11);
359 ZeroDeriv(matr[3]);
360 Saxpy(2.00000,ad_prp_11,ad_prp_8);
361 DecDeriv(ad_prp_9,ad_prp_11);
362 DecDeriv(ad_prp_10,ad_prp_11);
363 ZeroDeriv(ad_prp_11);
364 IncDeriv(x[3],ad_prp_10);
365 ZeroDeriv(ad_prp_10);
366 IncDeriv(x[4],ad_prp_9);
367 ZeroDeriv(ad_prp_9);
368 IncDeriv(x[5],ad_prp_8);
369 ZeroDeriv(ad_prp_8);
370 DecDeriv(ad_prp_7,matr[2]);
371 IncDeriv(ad_prp_6,matr[2]);
372 ZeroDeriv(matr[2]);
373 IncDeriv(x[3],ad_prp_7);
374 ZeroDeriv(ad_prp_7);
375 IncDeriv(x[4],ad_prp_6);
376 ZeroDeriv(ad_prp_6);
377 Saxpy(0.577350269189625797959429519858,matr[1],ad_prp_5);
378 ZeroDeriv(matr[1]);
379 Saxpy(2.00000,ad_prp_5,ad_prp_2);
380 DecDeriv(ad_prp_3,ad_prp_5);
381 DecDeriv(ad_prp_4,ad_prp_5);
382 ZeroDeriv(ad_prp_5);
383 IncDeriv(x[0],ad_prp_4);
384 ZeroDeriv(ad_prp_4);
385 IncDeriv(x[1],ad_prp_3);
386 ZeroDeriv(ad_prp_3);
387 IncDeriv(x[2],ad_prp_2);
388 ZeroDeriv(ad_prp_2);
389 DecDeriv(ad_prp_1,matr[0]);
390 IncDeriv(ad_prp_0,matr[0]);
391 ZeroDeriv(matr[0]);
392 IncDeriv(x[0],ad_prp_1);
393 ZeroDeriv(ad_prp_1);
394 IncDeriv(x[1],ad_prp_0);
395 ZeroDeriv(ad_prp_0);
396 ZeroDeriv(retval);
397 }
398}
Note: See TracBrowser for help on using the repository browser.