Context Navigation

network.c @ ca7769e

Visit:

RELEASE/1.1RELEASE/1.2debug-cidebug-ci-sanitisersstereowalls-data

Last change on this file since ca7769e was 856b6a0, checked in by Olly Betts <olly@…>, 21 years ago

Fixed to compile.

git-svn-id: file:///home/survex-svn/survex/branches/survex-1_1@2378 4b37db11-9a0c-4f06-9ece-9ab7cdaee568

Property mode set to 100644

File size: 22.5 KB

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

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

Context Navigation

source: git/src/network.c @ ca7769e

Download in other formats: