Context Navigation

network.c @ 7808455

Visit:

main

Last change on this file since 7808455 was ee93409, checked in by Olly Betts <olly@…>, 6 weeks ago

Initialise filename for delta-star invented prefix

Fixes undefined behaviour introduced by previous change.

Property mode set to 100644

File size: 21.6 KB

Line
1	/* network.c
2	* Survex network reduction - find patterns and apply network reductions
3	* Copyright (C) 1991-2002,2005,2024 Olly Betts
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, see
17	* <https://www.gnu.org/licenses/>.
18	*/
19
20	#if 0
21	#define DEBUG_INVALID 1
22	#define VALIDATE 1
23	#define DUMP_NETWORK 1
24	#endif
25
26	#include <config.h>
27
28	#include "validate.h"
29	#include "debug.h"
30	#include "cavern.h"
31	#include "message.h"
32	#include "netbits.h"
33	#include "network.h"
34	#include "osalloc.h"
35	#include "out.h"
36
37	typedef struct reduction {
38	struct reduction *next;
39	enum {
40	TYPE_PARALLEL,
41	TYPE_LOLLIPOP,
42	TYPE_DELTASTAR,
43	} type;
44	linkfor* join[];
45	} reduction;
46
47	#define allocate_reduction(N) osmalloc(sizeof(reduction) + (N) * sizeof(linkfor*))
48
49	// Head of linked list of reductions.
50	static reduction *reduction_stack;
51
52	/* can be altered by -z<letters> on command line */
53	unsigned long optimize = BITA('l') \| BITA('p') \| BITA('d');
54	/* Lollipops, Parallel legs, Iterate mx, Delta* */
55
56	extern void
57	remove_subnets(void)
58	{
59	node stn, stn2, stn3, stn4;
60	int dirn, dirn2, dirn3, dirn4;
61	reduction *trav;
62	linkfor newleg, newleg2;
63	bool fMore = true;
64
65	reduction_stack = NULL;
66
67	out_current_action(msg(/Simplifying network/129));
68
69	while (fMore) {
70	fMore = false;
71	if (optimize & BITA('l')) {
72	#if PRINT_NETBITS
73	printf("replacing lollipops\n");
74	#endif
75	/* NB can have non-fixed 0 nodes */
76	FOR_EACH_STN(stn, stnlist) {
77	if (three_node(stn)) {
78	dirn = -1;
79	if (stn->leg[1]->l.to == stn) dirn++;
80	if (stn->leg[0]->l.to == stn) dirn += 2;
81	if (dirn < 0) continue;
82
83	stn2 = stn->leg[dirn]->l.to;
84	if (fixed(stn2)) {
85	/* _
86	* ( )
87	* * stn
88	* \|
89	* * stn2 (fixed)
90	* : (may have other connections)
91	*
92	* The leg forming the "stick" of the lollipop is
93	* articulating so we can just fix stn with coordinates
94	* calculated by adding or subtracting the leg's vector.
95	*/
96	linkfor *leg = stn->leg[dirn];
97	linkfor *rev_leg = reverse_leg(leg);
98	leg->l.reverse \|= FLAG_ARTICULATION;
99	rev_leg->l.reverse \|= FLAG_ARTICULATION;
100	if (data_here(leg)) {
101	subdd(&POSD(stn), &POSD(stn2), &leg->d);
102	} else {
103	adddd(&POSD(stn), &POSD(stn2), &rev_leg->d);
104	}
105	remove_stn_from_list(&stnlist, stn);
106	add_stn_to_list(&fixedlist, stn);
107	continue;
108	}
109
110	SVX_ASSERT(three_node(stn2));
111
112	/* _
113	* ( )
114	* * stn
115	* \|
116	* * stn2
117	* / \
118	* stn4 * * stn3 --> stn4 --- stn3
119	* : : : :
120	*/
121	dirn2 = reverse_leg_dirn(stn->leg[dirn]);
122	dirn2 = (dirn2 + 1) % 3;
123	stn3 = stn2->leg[dirn2]->l.to;
124	if (stn2 == stn3) continue; /* dumb-bell - leave alone */
125
126	dirn3 = reverse_leg_dirn(stn2->leg[dirn2]);
127
128	trav = allocate_reduction(2);
129	trav->type = TYPE_LOLLIPOP;
130
131	newleg2 = (linkfor*)osnew(linkcommon);
132
133	newleg = copy_link(stn3->leg[dirn3]);
134
135	dirn2 = (dirn2 + 1) % 3;
136	stn4 = stn2->leg[dirn2]->l.to;
137	dirn4 = reverse_leg_dirn(stn2->leg[dirn2]);
138	#if 0
139	printf("Lollipop found with stn...stn4 = \n");
140	print_prefix(stn->name); putnl();
141	print_prefix(stn2->name); putnl();
142	print_prefix(stn3->name); putnl();
143	print_prefix(stn4->name); putnl();
144	#endif
145
146	addto_link(newleg, stn2->leg[dirn2]);
147
148	/* remove stn and stn2 */
149	remove_stn_from_list(&stnlist, stn);
150	remove_stn_from_list(&stnlist, stn2);
151
152	/* stack lollipop and replace with a leg between stn3 and stn4 */
153	trav->join[0] = stn3->leg[dirn3];
154	newleg->l.to = stn4;
155	newleg->l.reverse = dirn4 \| FLAG_DATAHERE \| FLAG_REPLACEMENTLEG;
156
157	trav->join[1] = stn4->leg[dirn4];
158	newleg2->l.to = stn3;
159	newleg2->l.reverse = dirn3 \| FLAG_REPLACEMENTLEG;
160
161	stn3->leg[dirn3] = newleg;
162	stn4->leg[dirn4] = newleg2;
163
164	trav->next = reduction_stack;
165	#if PRINT_NETBITS
166	printf("remove lollipop\n");
167	#endif
168	reduction_stack = trav;
169	fMore = true;
170	}
171	}
172	}
173
174	if (optimize & BITA('p')) {
175	#if PRINT_NETBITS
176	printf("replacing parallel legs\n");
177	#endif
178	FOR_EACH_STN(stn, stnlist) {
179	/*
180	* : :
181	* * stn3 * stn3
182	* \| \|
183	* * stn \|
184	* ( ) --> \|
185	* * stn2 \|
186	* \| \|
187	* * stn4 * stn4
188	* : :
189	*/
190	if (three_node(stn)) {
191	stn2 = stn->leg[0]->l.to;
192	if (stn2 == stn->leg[1]->l.to) {
193	dirn = 2;
194	} else if (stn2 == stn->leg[2]->l.to) {
195	dirn = 1;
196	} else {
197	if (stn->leg[1]->l.to != stn->leg[2]->l.to) continue;
198	stn2 = stn->leg[1]->l.to;
199	dirn = 0;
200	}
201
202	/* stn == stn2 => lollipop */
203	if (stn == stn2 \|\| fixed(stn2)) continue;
204
205	SVX_ASSERT(three_node(stn2));
206
207	stn3 = stn->leg[dirn]->l.to;
208	/* 3 parallel legs (=> nothing else) so leave */
209	if (stn3 == stn2) continue;
210
211	dirn3 = reverse_leg_dirn(stn->leg[dirn]);
212	dirn2 = (0 + 1 + 2 - reverse_leg_dirn(stn->leg[(dirn + 1) % 3])
213	- reverse_leg_dirn(stn->leg[(dirn + 2) % 3]));
214
215	stn4 = stn2->leg[dirn2]->l.to;
216	dirn4 = reverse_leg_dirn(stn2->leg[dirn2]);
217
218	trav = allocate_reduction(2);
219	trav->type = TYPE_PARALLEL;
220
221	newleg = copy_link(stn->leg[(dirn + 1) % 3]);
222	/* use newleg2 for scratch */
223	newleg2 = copy_link(stn->leg[(dirn + 2) % 3]);
224	{
225	#ifdef NO_COVARIANCES
226	vars sum;
227	var prod;
228	delta temp, temp2;
229	addss(&sum, &newleg->v, &newleg2->v);
230	SVX_ASSERT2(!fZeros(&sum), "loop of zero variance found");
231	mulss(&prod, &newleg->v, &newleg2->v);
232	mulsd(&temp, &newleg2->v, &newleg->d);
233	mulsd(&temp2, &newleg->v, &newleg2->d);
234	adddd(&temp, &temp, &temp2);
235	divds(&newleg->d, &temp, &sum);
236	sdivvs(&newleg->v, &prod, &sum);
237	#else
238	svar inv1, inv2, sum;
239	delta temp, temp2;
240	/* if leg one is an equate, we can just ignore leg two
241	* whatever it is */
242	if (invert_svar(&inv1, &newleg->v)) {
243	if (invert_svar(&inv2, &newleg2->v)) {
244	addss(&sum, &inv1, &inv2);
245	if (!invert_svar(&newleg->v, &sum)) {
246	BUG("matrix singular in parallel legs replacement");
247	}
248
249	mulsd(&temp, &inv1, &newleg->d);
250	mulsd(&temp2, &inv2, &newleg2->d);
251	adddd(&temp, &temp, &temp2);
252	mulsd(&newleg->d, &newleg->v, &temp);
253	} else {
254	/* leg two is an equate, so just ignore leg 1 */
255	linkfor *tmpleg;
256	tmpleg = newleg;
257	newleg = newleg2;
258	newleg2 = tmpleg;
259	}
260	}
261	#endif
262	}
263	free(newleg2);
264	newleg2 = (linkfor*)osnew(linkcommon);
265
266	addto_link(newleg, stn2->leg[dirn2]);
267	addto_link(newleg, stn3->leg[dirn3]);
268
269	#if 0
270	printf("Parallel found with stn...stn4 = \n");
271	(dump_node)(stn); (dump_node)(stn2); (dump_node)(stn3); (dump_node)(stn4);
272	printf("dirns = %d %d %d %d\n", dirn, dirn2, dirn3, dirn4);
273	#endif
274	SVX_ASSERT2(stn3->leg[dirn3]->l.to == stn, "stn3 end of \|\| doesn't recip");
275	SVX_ASSERT2(stn4->leg[dirn4]->l.to == stn2, "stn4 end of \|\| doesn't recip");
276	SVX_ASSERT2(stn->leg[(dirn+1)%3]->l.to == stn2 && stn->leg[(dirn + 2) % 3]->l.to == stn2, "\|\| legs aren't");
277
278	/* remove stn and stn2 (already discarded triple parallel) */
279	/* so stn!=stn4 <=> stn2!=stn3 */
280	remove_stn_from_list(&stnlist, stn);
281	remove_stn_from_list(&stnlist, stn2);
282
283	/* stack parallel and replace with a leg between stn3 and stn4 */
284	trav->join[0] = stn3->leg[dirn3];
285	newleg->l.to = stn4;
286	newleg->l.reverse = dirn4 \| FLAG_DATAHERE \| FLAG_REPLACEMENTLEG;
287
288	trav->join[1] = stn4->leg[dirn4];
289	newleg2->l.to = stn3;
290	newleg2->l.reverse = dirn3 \| FLAG_REPLACEMENTLEG;
291
292	stn3->leg[dirn3] = newleg;
293	stn4->leg[dirn4] = newleg2;
294
295	trav->next = reduction_stack;
296	#if PRINT_NETBITS
297	printf("remove parallel\n");
298	#endif
299	reduction_stack = trav;
300	fMore = true;
301	}
302	}
303	}
304
305	if (optimize & BITA('d')) {
306	node stn5, stn6;
307	int dirn5, dirn6;
308	linkfor legAB, legBC, *legCA;
309	#if PRINT_NETBITS
310	printf("replacing deltas with stars\n");
311	#endif
312	FOR_EACH_STN(stn, stnlist) {
313	/* printf("");/
314	/*
315	* : :
316	* * stn5 * stn5
317	* \| \|
318	* * stn2 \|
319	* / \ --> O stnZ
320	* \| \| / \
321	* stn --- stn3 / \
322	* / \ / \
323	* stn4 * * stn6 stn4 * * stn6
324	* : : : :
325	*/
326	if (three_node(stn)) {
327	for (int dirn12 = 0; dirn12 <= 2; dirn12++) {
328	stn2 = stn->leg[dirn12]->l.to;
329	if (stn2 == stn \|\| fixed(stn2)) continue;
330	SVX_ASSERT(three_node(stn2));
331	int dirn13 = (dirn12 + 1) % 3;
332	stn3 = stn->leg[dirn13]->l.to;
333	if (stn3 == stn \|\| stn3 == stn2 \|\| fixed(stn3)) continue;
334	SVX_ASSERT(three_node(stn3));
335	int dirn23 = reverse_leg_dirn(stn->leg[dirn12]);
336	dirn23 = (dirn23 + 1) % 3;
337	if (stn2->leg[dirn23]->l.to != stn3) {
338	dirn23 = (dirn23 + 1) % 3;
339	if (stn2->leg[dirn23]->l.to != stn3) {
340	continue;
341	}
342	}
343	legAB = copy_link(stn->leg[dirn12]);
344	legBC = copy_link(stn2->leg[dirn23]);
345	legCA = copy_link(stn3->leg[reverse_leg_dirn(stn->leg[dirn13])]);
346	dirn = (0 + 1 + 2) - dirn12 - dirn13;
347	dirn2 = (0 + 1 + 2) - dirn23 - reverse_leg_dirn(stn->leg[dirn12]);
348	dirn3 = (0 + 1 + 2) - reverse_leg_dirn(stn->leg[dirn13]) - reverse_leg_dirn(stn2->leg[dirn23]);
349	stn4 = stn->leg[dirn]->l.to;
350	stn5 = stn2->leg[dirn2]->l.to;
351	stn6 = stn3->leg[dirn3]->l.to;
352	if (stn4 == stn2 \|\| stn4 == stn3 \|\| stn5 == stn3) continue;
353	dirn4 = reverse_leg_dirn(stn->leg[dirn]);
354	dirn5 = reverse_leg_dirn(stn2->leg[dirn2]);
355	dirn6 = reverse_leg_dirn(stn3->leg[dirn3]);
356	#if 0
357	printf("delta-star, stn ... stn6 are:\n");
358	(dump_node)(stn);
359	(dump_node)(stn2);
360	(dump_node)(stn3);
361	(dump_node)(stn4);
362	(dump_node)(stn5);
363	(dump_node)(stn6);
364	#endif
365	SVX_ASSERT(stn4->leg[dirn4]->l.to == stn);
366	SVX_ASSERT(stn5->leg[dirn5]->l.to == stn2);
367	SVX_ASSERT(stn6->leg[dirn6]->l.to == stn3);
368
369	trav = allocate_reduction(3);
370	trav->type = TYPE_DELTASTAR;
371	{
372	linkfor legAZ, legBZ, *legCZ;
373	node *stnZ;
374	prefix *nameZ;
375	svar invAB, invBC, invCA, tmp, sum, inv;
376	var vtmp;
377	svar sumAZBZ, sumBZCZ, sumCZAZ;
378	delta temp, temp2;
379
380	/* FIXME: ought to handle cases when some legs are
381	* equates, but handle as a special case maybe? */
382	if (!invert_svar(&invAB, &legAB->v)) break;
383	if (!invert_svar(&invBC, &legBC->v)) break;
384	if (!invert_svar(&invCA, &legCA->v)) break;
385
386	addss(&sum, &legBC->v, &legCA->v);
387	addss(&tmp, &sum, &legAB->v);
388	if (!invert_svar(&inv, &tmp)) {
389	/* impossible - loop of zero variance */
390	BUG("loop of zero variance found");
391	}
392
393	legAZ = osnew(linkfor);
394	legBZ = osnew(linkfor);
395	legCZ = osnew(linkfor);
396
397	/* AZBZ */
398	/* done above: addvv(&sum, &legBC->v, &legCA->v); */
399	mulss(&vtmp, &sum, &inv);
400	smulvs(&sumAZBZ, &vtmp, &legAB->v);
401
402	adddd(&temp, &legBC->d, &legCA->d);
403	divds(&temp2, &temp, &sum);
404	mulsd(&temp, &invAB, &legAB->d);
405	subdd(&temp, &temp2, &temp);
406	mulsd(&legBZ->d, &sumAZBZ, &temp);
407
408	/* leg vectors after transform are determined up to
409	* a constant addition, so arbitrarily fix AZ = 0 */
410	legAZ->d[2] = legAZ->d[1] = legAZ->d[0] = 0;
411
412	/* BZCZ */
413	addss(&sum, &legCA->v, &legAB->v);
414	mulss(&vtmp, &sum, &inv);
415	smulvs(&sumBZCZ, &vtmp, &legBC->v);
416
417	/* CZAZ */
418	addss(&sum, &legAB->v, &legBC->v);
419	mulss(&vtmp, &sum, &inv);
420	smulvs(&sumCZAZ, &vtmp, &legCA->v);
421
422	adddd(&temp, &legAB->d, &legBC->d);
423	divds(&temp2, &temp, &sum);
424	mulsd(&temp, &invCA, &legCA->d);
425	/* NB: swapped arguments to negate answer for legCZ->d */
426	subdd(&temp, &temp, &temp2);
427	mulsd(&legCZ->d, &sumCZAZ, &temp);
428
429	free(legAB);
430	free(legBC);
431	free(legCA);
432
433	/* Now add two, subtract third, and scale by 0.5 */
434	addss(&sum, &sumAZBZ, &sumCZAZ);
435	subss(&sum, &sum, &sumBZCZ);
436	mulsc(&legAZ->v, &sum, 0.5);
437
438	addss(&sum, &sumBZCZ, &sumAZBZ);
439	subss(&sum, &sum, &sumCZAZ);
440	mulsc(&legBZ->v, &sum, 0.5);
441
442	addss(&sum, &sumCZAZ, &sumBZCZ);
443	subss(&sum, &sum, &sumAZBZ);
444	mulsc(&legCZ->v, &sum, 0.5);
445
446	nameZ = osnew(prefix);
447	nameZ->pos = osnew(pos);
448	nameZ->ident.p = NULL;
449	stnZ = osnew(node);
450	stnZ->name = nameZ;
451	nameZ->stn = stnZ;
452	nameZ->up = NULL;
453	nameZ->filename = NULL;
454	nameZ->min_export = nameZ->max_export = 0;
455	nameZ->sflags = 0;
456	unfix(stnZ);
457	add_stn_to_list(&stnlist, stnZ);
458	legAZ->l.to = stnZ;
459	legAZ->l.reverse = 0 \| FLAG_DATAHERE \| FLAG_REPLACEMENTLEG;
460	legBZ->l.to = stnZ;
461	legBZ->l.reverse = 1 \| FLAG_DATAHERE \| FLAG_REPLACEMENTLEG;
462	legCZ->l.to = stnZ;
463	legCZ->l.reverse = 2 \| FLAG_DATAHERE \| FLAG_REPLACEMENTLEG;
464	stnZ->leg[0] = (linkfor*)osnew(linkcommon);
465	stnZ->leg[1] = (linkfor*)osnew(linkcommon);
466	stnZ->leg[2] = (linkfor*)osnew(linkcommon);
467	stnZ->leg[0]->l.to = stn4;
468	stnZ->leg[0]->l.reverse = dirn4;
469	stnZ->leg[1]->l.to = stn5;
470	stnZ->leg[1]->l.reverse = dirn5;
471	stnZ->leg[2]->l.to = stn6;
472	stnZ->leg[2]->l.reverse = dirn6;
473	addto_link(legAZ, stn4->leg[dirn4]);
474	addto_link(legBZ, stn5->leg[dirn5]);
475	addto_link(legCZ, stn6->leg[dirn6]);
476	/* stack stuff */
477	trav->join[0] = stn4->leg[dirn4];
478	trav->join[1] = stn5->leg[dirn5];
479	trav->join[2] = stn6->leg[dirn6];
480	trav->next = reduction_stack;
481	#if PRINT_NETBITS
482	printf("remove delta*\n");
483	#endif
484	reduction_stack = trav;
485	fMore = true;
486
487	remove_stn_from_list(&stnlist, stn);
488	remove_stn_from_list(&stnlist, stn2);
489	remove_stn_from_list(&stnlist, stn3);
490	stn4->leg[dirn4] = legAZ;
491	stn5->leg[dirn5] = legBZ;
492	stn6->leg[dirn6] = legCZ;
493	}
494	break;
495	}
496	}
497	}
498	}
499
500	}
501	}
502
503	extern void
504	replace_subnets(void)
505	{
506	node stn2, stn3, *stn4;
507	int dirn2, dirn3, dirn4;
508
509	/* help to catch bad accesses */
510	stn2 = stn3 = stn4 = NULL;
511	dirn2 = dirn3 = dirn4 = 0;
512
513	out_current_action(msg(/Calculating network/130));
514
515	while (reduction_stack != NULL) {
516	/* printf("replace_subnets() type %d\n", reduction_stack->type);*/
517
518	#if PRINT_NETBITS
519	printf("replace_subnets\n");
520	if (reduction_stack->type == TYPE_LOLLIPOP) printf("islollipop\n");
521	if (reduction_stack->type == TYPE_PARALLEL) printf("isparallel\n");
522	if (reduction_stack->type == TYPE_DELTASTAR) printf("isdelta*\n");
523	#endif
524
525	if (reduction_stack->type != TYPE_DELTASTAR) {
526	linkfor *leg;
527	leg = reduction_stack->join[0]; leg = reverse_leg(leg);
528	stn3 = leg->l.to; dirn3 = reverse_leg_dirn(leg);
529	leg = reduction_stack->join[1]; leg = reverse_leg(leg);
530	stn4 = leg->l.to; dirn4 = reverse_leg_dirn(leg);
531
532	if (!fixed(stn3) \|\| !fixed(stn4)) {
533	SVX_ASSERT(!fixed(stn3) && !fixed(stn4));
534	goto skip;
535	}
536	SVX_ASSERT(data_here(stn3->leg[dirn3]));
537	}
538
539	if (reduction_stack->type == TYPE_LOLLIPOP) {
540	node *stn;
541	delta e;
542	linkfor *leg;
543	int zero;
544
545	leg = stn3->leg[dirn3];
546	stn2 = reduction_stack->join[0]->l.to;
547	dirn2 = reverse_leg_dirn(reduction_stack->join[0]);
548
549	zero = fZeros(&leg->v);
550	if (!zero) {
551	delta tmp;
552	subdd(&e, &POSD(stn4), &POSD(stn3));
553	subdd(&tmp, &e, &leg->d);
554	divds(&e, &tmp, &leg->v);
555	}
556	if (data_here(reduction_stack->join[0])) {
557	adddd(&POSD(stn2), &POSD(stn3), &reduction_stack->join[0]->d);
558	if (!zero) {
559	delta tmp;
560	mulsd(&tmp, &reduction_stack->join[0]->v, &e);
561	adddd(&POSD(stn2), &POSD(stn2), &tmp);
562	}
563	} else {
564	subdd(&POSD(stn2), &POSD(stn3), &stn2->leg[dirn2]->d);
565	if (!zero) {
566	delta tmp;
567	mulsd(&tmp, &stn2->leg[dirn2]->v, &e);
568	adddd(&POSD(stn2), &POSD(stn2), &tmp);
569	}
570	}
571	dirn2 = (dirn2 + 2) % 3; /* point back at stn again */
572	stn = stn2->leg[dirn2]->l.to;
573	#if 0
574	printf("Replacing lollipop with stn...stn4 = \n");
575	print_prefix(stn->name); putnl();
576	print_prefix(stn2->name); putnl();
577	print_prefix(stn3->name); putnl();
578	print_prefix(stn4->name); putnl();
579	#endif
580	if (data_here(stn2->leg[dirn2]))
581	adddd(&POSD(stn), &POSD(stn2), &stn2->leg[dirn2]->d);
582	else
583	subdd(&POSD(stn), &POSD(stn2), &reverse_leg(stn2->leg[dirn2])->d);
584
585	/* The "stick" of the lollipop is a new articulation. */
586	stn2->leg[dirn2]->l.reverse \|= FLAG_ARTICULATION;
587	reverse_leg(stn2->leg[dirn2])->l.reverse \|= FLAG_ARTICULATION;
588
589	add_stn_to_list(&fixedlist, stn);
590	add_stn_to_list(&fixedlist, stn2);
591
592	free(stn3->leg[dirn3]);
593	stn3->leg[dirn3] = reduction_stack->join[0];
594	free(stn4->leg[dirn4]);
595	stn4->leg[dirn4] = reduction_stack->join[1];
596	} else if (reduction_stack->type == TYPE_PARALLEL) {
597	/* parallel legs */
598	node *stn;
599	delta e, e2;
600	linkfor *leg;
601	int dirn;
602
603	stn = reduction_stack->join[0]->l.to;
604	stn2 = reduction_stack->join[1]->l.to;
605
606	dirn = reverse_leg_dirn(reduction_stack->join[0]);
607	dirn2 = reverse_leg_dirn(reduction_stack->join[1]);
608
609	leg = stn3->leg[dirn3];
610
611	if (leg->l.reverse & FLAG_ARTICULATION) {
612	reduction_stack->join[0]->l.reverse \|= FLAG_ARTICULATION;
613	stn->leg[dirn]->l.reverse \|= FLAG_ARTICULATION;
614	reduction_stack->join[1]->l.reverse \|= FLAG_ARTICULATION;
615	stn2->leg[dirn2]->l.reverse \|= FLAG_ARTICULATION;
616	}
617
618	if (fZeros(&leg->v))
619	e[0] = e[1] = e[2] = 0.0;
620	else {
621	delta tmp;
622	subdd(&e, &POSD(stn4), &POSD(stn3));
623	subdd(&tmp, &e, &leg->d);
624	divds(&e, &tmp, &leg->v);
625	}
626
627	if (data_here(reduction_stack->join[0])) {
628	leg = reduction_stack->join[0];
629	adddd(&POSD(stn), &POSD(stn3), &leg->d);
630	} else {
631	leg = stn->leg[dirn];
632	subdd(&POSD(stn), &POSD(stn3), &leg->d);
633	}
634	mulsd(&e2, &leg->v, &e);
635	adddd(&POSD(stn), &POSD(stn), &e2);
636
637	if (data_here(reduction_stack->join[1])) {
638	leg = reduction_stack->join[1];
639	adddd(&POSD(stn2), &POSD(stn4), &leg->d);
640	} else {
641	leg = stn2->leg[dirn2];
642	subdd(&POSD(stn2), &POSD(stn4), &leg->d);
643	}
644	mulsd(&e2, &leg->v, &e);
645	subdd(&POSD(stn2), &POSD(stn2), &e2);
646	#if 0
647	printf("Replacing parallel with stn...stn4 = \n");
648	print_prefix(stn->name); putnl();
649	print_prefix(stn2->name); putnl();
650	print_prefix(stn3->name); putnl();
651	print_prefix(stn4->name); putnl();
652	#endif
653
654	add_stn_to_list(&fixedlist, stn);
655	add_stn_to_list(&fixedlist, stn2);
656
657	free(stn3->leg[dirn3]);
658	stn3->leg[dirn3] = reduction_stack->join[0];
659	free(stn4->leg[dirn4]);
660	stn4->leg[dirn4] = reduction_stack->join[1];
661	} else if (reduction_stack->type == TYPE_DELTASTAR) {
662	node *stnZ;
663	node *stn[3];
664	int dirn[3];
665	int i;
666	linkfor *leg;
667
668	/* work out ends as we don't bother stacking them */
669	leg = reverse_leg(reduction_stack->join[0]);
670	stn[0] = leg->l.to;
671	dirn[0] = reverse_leg_dirn(leg);
672	stnZ = stn[0]->leg[dirn[0]]->l.to;
673	if (!fixed(stnZ)) {
674	SVX_ASSERT(!fixed(stn[0]));
675	goto skip;
676	}
677	stn[1] = stnZ->leg[1]->l.to;
678	dirn[1] = reverse_leg_dirn(stnZ->leg[1]);
679	stn[2] = stnZ->leg[2]->l.to;
680	dirn[2] = reverse_leg_dirn(stnZ->leg[2]);
681	/print_prefix(stnZ->name);printf(" %p\n",(void)stnZ);*/
682
683	for (i = 0; i < 3; i++) {
684	SVX_ASSERT2(fixed(stn[i]), "stn not fixed for D*");
685
686	leg = stn[i]->leg[dirn[i]];
687
688	SVX_ASSERT2(data_here(leg), "data not on leg for D*");
689	SVX_ASSERT2(leg->l.to == stnZ, "bad sub-network for D*");
690
691	stn2 = reduction_stack->join[i]->l.to;
692
693	if (data_here(reduction_stack->join[i])) {
694	adddd(&POSD(stn2), &POSD(stn[i]), &reduction_stack->join[i]->d);
695	} else {
696	subdd(&POSD(stn2), &POSD(stn[i]), &reverse_leg(reduction_stack->join[i])->d);
697	}
698
699	if (!fZeros(&leg->v)) {
700	delta e, tmp;
701	subdd(&e, &POSD(stnZ), &POSD(stn[i]));
702	subdd(&e, &e, &leg->d);
703	divds(&tmp, &e, &leg->v);
704	if (data_here(reduction_stack->join[i])) {
705	mulsd(&e, &reduction_stack->join[i]->v, &tmp);
706	} else {
707	mulsd(&e, &reverse_leg(reduction_stack->join[i])->v, &tmp);
708	}
709	adddd(&POSD(stn2), &POSD(stn2), &e);
710	}
711	add_stn_to_list(&fixedlist, stn2);
712	free(leg);
713	stn[i]->leg[dirn[i]] = reduction_stack->join[i];
714	/* transfer the articulation status of the radial legs */
715	if (stnZ->leg[i]->l.reverse & FLAG_ARTICULATION) {
716	reduction_stack->join[i]->l.reverse \|= FLAG_ARTICULATION;
717	reverse_leg(reduction_stack->join[i])->l.reverse \|= FLAG_ARTICULATION;
718	}
719	free(stnZ->leg[i]);
720	stnZ->leg[i] = NULL;
721	}
722	/printf("---%f %f %f\n",POS(stnZ, 0), POS(stnZ, 1), POS(stnZ, 2));/
723	remove_stn_from_list(&fixedlist, stnZ);
724	free(stnZ->name);
725	free(stnZ);
726	} else {
727	BUG("reduction_stack has unknown type");
728	}
729
730	skip:;
731	reduction *ptrOld = reduction_stack;
732	reduction_stack = reduction_stack->next;
733	free(ptrOld);
734	}
735	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: git/src/network.c @ 7808455

Download in other formats: