Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

imgMlp.c @ 31

Last change on this file since 31 was 14, checked in by cecile, 13 years ago
vis2.3
File size: 231.1 KB

Line
1	/CFile*********************************************************************
2
3	FileName [imgMlp.c]
4
5	PackageName [img]
6
7	Synopsis [Routines for image computation using MLP(Minimal Lifetime
8	Permutation) published in FMCAD00.]
9
10	Description []
11
12	SeeAlso []
13
14	Author [In-Ho Moon]
15
16	Copyright [Copyright (c) 1994-1996 The Regents of the Univ. of Colorado.
17	All rights reserved.
18
19	Permission is hereby granted, without written agreement and without license
20	or royalty fees, to use, copy, modify, and distribute this software and its
21	documentation for any purpose, provided that the above copyright notice and
22	the following two paragraphs appear in all copies of this software.
23
24	IN NO EVENT SHALL THE UNIVERSITY OF COLORADO BE LIABLE TO ANY PARTY FOR
25	DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
26	OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
27	COLORADO HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29	THE UNIVERSITY OF COLORADO SPECIFICALLY DISCLAIMS ANY WARRANTIES,
30	INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
31	FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
32	"AS IS" BASIS, AND THE UNIVERSITY OF COLORADO HAS NO OBLIGATION TO PROVIDE
33	MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.]
34
35	******************************************************************************/
36	#include "imgInt.h"
37	#include "fsm.h"
38
39	static char rcsid[] UNUSED = "$Id: imgMlp.c,v 1.31 2005/04/26 19:08:33 jinh Exp $";
40
41
42	/---------------------------------------------------------------------------/
43	/* Constant declarations */
44	/---------------------------------------------------------------------------/
45
46	/---------------------------------------------------------------------------/
47	/* Type declarations */
48	/---------------------------------------------------------------------------/
49
50
51	/---------------------------------------------------------------------------/
52	/* Structure declarations */
53	/---------------------------------------------------------------------------/
54
55	/Struct********************************************************************
56
57	Synopsis [This structure contains the information of each row and
58	column.]
59
60	Description []
61
62	******************************************************************************/
63	typedef struct RcInfo_s {
64	int pos; /* level */
65	int lNum;
66	int lMin; /* index */
67	int lMax; /* index */
68	int gNum;
69	int gMin; /* index */
70	int gMax; /* index */
71	int prevG; /* level */
72	int nextG; /* level */
73	union {
74	struct {
75	bdd_t *func;
76	array_t *nsVarBddArray;
77	} row;
78	struct {
79	bdd_t *var;
80	int type;
81	} col;
82	} data;
83	} RcInfo_t;
84
85	/Struct********************************************************************
86
87	Synopsis [This structure is a list of row and coulmn.]
88
89	Description []
90
91	******************************************************************************/
92	typedef struct RcList_s {
93	int index;
94	int otherIndex;
95	struct RcList_s *next;
96	struct RcList_s *prev;
97	} RcList_t;
98
99	/Struct********************************************************************
100
101	Synopsis [This structure contains the information of row and column
102	list.]
103
104	Description []
105
106	******************************************************************************/
107	typedef struct RcListInfo_s {
108	int num;
109	int maxNum;
110	int curIndex;
111	st_table *table;
112	RcList_t *cur;
113	RcList_t *head;
114	RcList_t *tail;
115	} RcListInfo_t;
116
117	/Struct********************************************************************
118
119	Synopsis [This structure contains the information of each cluster.]
120
121	Description []
122
123	******************************************************************************/
124	typedef struct ClusterList_s {
125	int flag; /* 0 : to be conjuncted
126	1 : start element
127	2 : last element
128	3 : isolated
129	*/
130	int start;
131	int end;
132	char *supports;
133	int minCol; /* index */
134	int maxCol; /* index */
135	int nSupports;
136	float affinity;
137	int nQuantifyVars;
138	mdd_t *product;
139	array_t *nsVarBddArray;
140	struct ClusterList_s *prev;
141	struct ClusterList_s *next;
142	} ClusterList_t;
143
144	/Struct********************************************************************
145
146	Synopsis [This structure is a list of a sorted cluster.]
147
148	Description []
149
150	******************************************************************************/
151	typedef struct ClusterSortedList_s {
152	ClusterList_t *list;
153	struct ClusterSortedList_s *next;
154	} ClusterSortedList_t;
155
156	/Struct********************************************************************
157
158	Synopsis [This structure contains the information of the list of
159	connected component.]
160
161	Description []
162
163	******************************************************************************/
164	typedef struct SccList_s {
165	int startFunc;
166	int lastFunc;
167	int startVar;
168	int lastVar;
169	int nFuncs;
170	int nVars;
171	struct SccList_s *next;
172	} SccList_t;
173
174	/Struct********************************************************************
175
176	Synopsis [This structure constains latch information from reading a
177	cluster file.]
178
179	Description []
180
181	******************************************************************************/
182	typedef struct LatchList_s {
183	int number;
184	int bddId;
185	mdd_t *relation;
186	st_table *table;
187	} LatchList_t;
188
189
190	/---------------------------------------------------------------------------/
191	/* Variable declarations */
192	/---------------------------------------------------------------------------/
193
194	static int nMoves;
195
196
197	/---------------------------------------------------------------------------/
198	/* Macro declarations */
199	/---------------------------------------------------------------------------/
200
201
202	/AutomaticStart***********************************************************/
203
204	/---------------------------------------------------------------------------/
205	/* Static function prototypes */
206	/---------------------------------------------------------------------------/
207
208	static void SetupMlp(mdd_manager mddManager, char xy, int nRows, int nCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, int varPos, array_t nsVarBddArray, int nActiveRows, int nActiveCols, array_t nonAppearingVarBddArray, Img_DirectionType direction, ImgTrmOption_t *option);
209	static SccList_t * MlpDecomposeScc(mdd_manager mddManager, char xy, int nRows, int nActiveRows, int nActiveCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, int clusteredFlag, ImgTrmOption_t option);
210	static int SccSortListIncreasingWithVars(const void p1, const void p2);
211	static int SccSortListDecreasingWithVars(const void p1, const void p2);
212	static int SccSortListIncreasingWithArea(const void p1, const void p2);
213	static int SccSortListDecreasingWithArea(const void p1, const void p2);
214	static int SccSortListIncreasingWithRatio(const void p1, const void p2);
215	static int SccSortListDecreasingWithRatio(const void p1, const void p2);
216	static int SccSortRc(const void p1, const void p2);
217	static void FreeSccList(SccList_t *sccHeadList);
218	static int NumOfSccs(SccList_t *sccHeadList);
219	static void BlockLowerTriangle(char *xy, int nRows, int nCols, int nActiveRows, int nActiveCols, SccList_t sccList, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, ImgTrmOption_t *option);
220	static void MoveBestRows(char *xy, SccList_t sccList, int nRows, int nCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, int startFunc, int lastFunc, int startVar, int lastVar, ImgTrmOption_t *option);
221	static void MoveBestCols(char *xy, SccList_t sccList, int nRows, int nCols, int nActiveRows, int nActiveCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, int startFunc, int lastFunc, int startVar, int lastVar, ImgTrmOption_t *option);
222	static void MlpPostProcess(char *xy, SccList_t sccList, int nVars, int nRows, int nCols, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, Img_DirectionType direction, ImgTrmOption_t *option);
223	static float ComputeLambdaMlp(char *xy, int nVars, int nRows, int nCols, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, Img_DirectionType direction, int mode, int asIs, ImgTrmOption_t option);
224	static void FindAndMoveSingletonRows(char *xy, SccList_t sccList, int nRows, int nCols, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, ImgTrmOption_t *option);
225	static int MoveSingletonRow(char *xy, SccList_t sccList, int nRows, int nCols, int x, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, ImgTrmOption_t option);
226	static void FindAndMoveSingletonCols(char *xy, SccList_t sccList, int nRows, int nCols, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, ImgTrmOption_t *option);
227	static int MoveSingletonCol(char *xy, SccList_t sccList, int nRows, int nCols, int y, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, ImgTrmOption_t option);
228	static void MoveRowToTop(char *xy, int x, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, int method);
229	static void MoveColToLeft(char *xy, int y, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, int method);
230	static void MoveRowToBottom(char *xy, int x, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, int method);
231	static void MoveColToRight(char *xy, int y, int startFunc, int lastFunc, int startVar, int lastVar, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, RcListInfo_t candList, int method);
232	static void PrintMatrix(char *xy, int nRows, int nCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t *colInfo, int startFunc, int lastFunc, int startVar, int lastVar);
233	static void PrintMatrixWithCluster(char *xy, ClusterList_t headCluster, int nCols, int rowOrder, int colOrder, Img_DirectionType direction);
234	static void PrintClusterMatrix(ClusterList_t headCluster, int nCols, int colOrder, Img_DirectionType direction);
235	static void CheckMatrix(char *xy, SccList_t sccList, int nRows, int nCols, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, int startFunc, int lastFunc, int startVar, int lastVar, int local);
236	static void CheckCluster(ClusterList_t headCluster, int nCols, RcInfo_t colInfo, int *colOrder);
237	static void WriteMatrix(FILE fout, char xy, int nRows, int nCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t *colInfo);
238	static void PrintRow(char *xy, int nRows, int nCols, int rowOrder, int *colOrder, int from, int to);
239	static void PrintCol(char *xy, int nRows, int nCols, int rowOrder, int *colOrder, int from, int to);
240	static RcListInfo_t * SortedListAlloc(void);
241	static void SortedListFree(RcListInfo_t *candList);
242	static void SortedListInsert(RcListInfo_t candList, int index, int otherIndex, RcInfo_t otherInfo, int method);
243	static void SortedListDelete(RcListInfo_t *candList, int index);
244	static void SortedListMove(RcListInfo_t candList, RcInfo_t info, int index, int method);
245	static void CheckSortedList(RcListInfo_t candList, RcInfo_t info, int method);
246	static void MlpCluster(mdd_manager mddManager, char xy, int nRows, int nCols, int nActiveRows, int nActiveCols, int nClusterRows, int nClusterCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, array_t clusterArray, array_t arraySmoothVarBddArray, Img_DirectionType direction, int cRowOrder, array_t nsVarBddArray, int sccBorder, int varPos, ImgTrmOption_t option);
247	static int MlpCountSupport(ClusterList_t list, int colOrder, int nActiveCols);
248	static float MlpSupportAffinity(ClusterList_t curList, ClusterList_t nextList, RcInfo_t colInfo, int colOrder, int nActiveCols, int clusterMethod);
249	static int RecursiveCluster(mdd_manager mddManager, ClusterList_t headCluster, ClusterSortedList_t clusterSortedList, char xy, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, int nActiveRows, int nClusterCols, Img_DirectionType direction, int varPos, int moveFlag, ImgTrmOption_t *option);
250	static int RemoveLocalVarsInCluster(mdd_manager mddManager, char xy, ClusterList_t list, int nActiveRows, int nClusterCols, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder, int moveFlag, ImgTrmOption_t *option);
251	static int MlpNumQuantifyVars(ClusterList_t list, RcInfo_t rowInfo, RcInfo_t colInfo, int colOrder, int nClusterCols);
252	static ClusterSortedList_t * ClusterSortedListInsert(ClusterSortedList_t clusterSortedList, ClusterList_t list, int useQuantifyVars);
253	static int CountClusterList(ClusterList_t *clusterList);
254	static int CountClusterSortedList(ClusterSortedList_t *clusterSortedList);
255	static array_t * CreateInitialCluster(mdd_manager mddManager, array_t relationArray, ImgFunctionData_t functionData, array_t nsVarBddArray, ImgTrmOption_t *option);
256	static void SortCol(char *xy, int nRows, int nCols, RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int *colOrder);
257	static void UpdateDisapearingPsVars(mdd_manager mddManager, char xy, int nActiveRows, int nActiveCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, int row, ImgTrmOption_t option);
258	static void UpdateDisapearingPsVarsInCluster(mdd_manager mddManager, char xy, int nActiveRows, int nActiveCols, int rowOrder, int colOrder, RcInfo_t rowInfo, RcInfo_t colInfo, ClusterList_t list, int moveFlag, ImgTrmOption_t *option);
259	static void UpdateNonappearingNsVars(mdd_manager mddManager, array_t nsVarBddArray, int nRows, RcInfo_t rowInfo, int rowOrder, array_t *nonAppearingVarBddArray);
260	static void WriteOrder(FILE fout, int nCols, int colOrder, RcInfo_t *colInfo);
261
262	/AutomaticEnd*************************************************************/
263
264
265	/---------------------------------------------------------------------------/
266	/* Definition of exported functions */
267	/---------------------------------------------------------------------------/
268
269
270	/Function******************************************************************
271
272	Synopsis [Prints the options for MLP image computation.]
273
274	Description [Prints the options for MLP image computation.]
275
276	SideEffects []
277
278	SeeAlso []
279
280	******************************************************************************/
281	void
282	Img_PrintMlpOptions(void)
283	{
284	ImgTrmOption_t *options;
285	char dummy[80];
286
287	options = ImgGetTrmOptions();
288
289	switch (options->mlpCluster) {
290	case 0 :
291	sprintf(dummy, "linear clustering");
292	break;
293	case 1 :
294	sprintf(dummy, "affinity based tree clustering (default)");
295	break;
296	default :
297	sprintf(dummy, "invalid");
298	break;
299	}
300	fprintf(vis_stdout, "MLP: mlp_cluster = %d (%s)\n",
301	options->mlpCluster, dummy);
302
303	switch (options->mlpReorder) {
304	case 0 :
305	sprintf(dummy, "no reordering after clustering (default)");
306	break;
307	case 1 :
308	sprintf(dummy, "reorder using MLP after clustering (inside)");
309	break;
310	case 2 :
311	sprintf(dummy, "reorder using MLP after clustering (outside)");
312	break;
313	case 3 :
314	sprintf(dummy, "reorder using IWLS95 after clustering");
315	break;
316	default :
317	sprintf(dummy, "invalid");
318	break;
319	}
320	fprintf(vis_stdout, "MLP: mlp_reorder = %d (%s)\n",
321	options->mlpReorder, dummy);
322
323	switch (options->mlpPreReorder) {
324	case 0 :
325	sprintf(dummy, "no reordering after clustering (default)");
326	break;
327	case 1 :
328	sprintf(dummy, "reorder using MLP after clustering (inside)");
329	break;
330	case 2 :
331	sprintf(dummy, "reorder using MLP after clustering (outside)");
332	break;
333	case 3 :
334	sprintf(dummy, "reorder using IWLS95 after clustering");
335	break;
336	default :
337	sprintf(dummy, "invalid");
338	break;
339	}
340	fprintf(vis_stdout, "MLP: mlp_pre_reorder = %d (%s)\n",
341	options->mlpPreReorder, dummy);
342
343	switch (options->mlpPostProcess) {
344	case 0 :
345	sprintf(dummy, "no postprocessing (default)");
346	break;
347	case 1 :
348	sprintf(dummy, "do postprocessing after ordering");
349	break;
350	case 2 :
351	sprintf(dummy, "do postprocessing after clustering or reordering");
352	break;
353	case 3 :
354	sprintf(dummy, "do both 1 and 2");
355	break;
356	default :
357	sprintf(dummy, "invalid");
358	break;
359	}
360	fprintf(vis_stdout, "MLP: mlp_postprocess = %d (%s)\n",
361	options->mlpPostProcess, dummy);
362	}
363
364
365	/---------------------------------------------------------------------------/
366	/* Definition of internal functions */
367	/---------------------------------------------------------------------------/
368
369
370	/Function******************************************************************
371
372	Synopsis [Performs multiway and_smooth using MLP.]
373
374	Description [Performs multiway and_smooth using MLP.]
375
376	SideEffects []
377
378	******************************************************************************/
379	bdd_t *
380	ImgMlpMultiwayAndSmooth(mdd_manager *mddManager,
381	ImgFunctionData_t *functionData,
382	array_t *relationArray,
383	array_t *domainVarBddArray,
384	array_t *quantifyVarBddArray,
385	array_t *rangeVarBddArray,
386	Img_DirectionType direction,
387	ImgTrmOption_t *option)
388	{
389	int i, clusterSize;
390	array_t *clusteredRelationArray;
391	mdd_t result, relation, *tmp;
392
393	if (direction == Img_Forward_c) {
394	if (array_n(domainVarBddArray) == 0 && array_n(quantifyVarBddArray) == 0) {
395	if (array_n(relationArray) == 1) {
396	relation = array_fetch(mdd_t *, relationArray, 0);
397	result = bdd_dup(relation);
398	} else {
399	result = array_fetch(mdd_t *, relationArray, 0);
400	for (i = 1; i < array_n(relationArray); i++) {
401	relation = array_fetch(mdd_t *, relationArray, i);
402	tmp = result;
403	result = bdd_and(tmp, relation, 1, 1);
404	mdd_free(tmp);
405	}
406	}
407	return(result);
408	}
409	}
410
411	clusterSize = option->clusterSize;
412	option->clusterSize = 1000000000;
413	ImgMlpClusterRelationArray(mddManager, functionData, relationArray,
414	domainVarBddArray, quantifyVarBddArray, rangeVarBddArray,
415	direction, &clusteredRelationArray, NIL(array_t *), option);
416	option->clusterSize = clusterSize;
417
418	assert(array_n(clusteredRelationArray) == 1);
419	result = array_fetch(mdd_t *, clusteredRelationArray, 0);
420	array_free(clusteredRelationArray);
421
422	return(result);
423	}
424
425
426	/Function******************************************************************
427
428	Synopsis [Clusters relation array and makes quantification schedule.]
429
430	Description [Orders and clusters relation array and makes quantification
431	schedule. (Order/Cluster.)]
432
433	Description []
434
435	SideEffects [ImgClusterRelationArray]
436
437	******************************************************************************/
438	void
439	ImgMlpClusterRelationArray(mdd_manager *mddManager,
440	ImgFunctionData_t *functionData,
441	array_t *relationArray,
442	array_t *domainVarBddArray,
443	array_t *quantifyVarBddArray,
444	array_t *rangeVarBddArray,
445	Img_DirectionType direction,
446	array_t **clusteredRelationArrayPtr,
447	array_t **arraySmoothVarBddArrayPtr,
448	ImgTrmOption_t *option)
449	{
450	int i, j, x, y, nRows, nCols, nActiveRows, nActiveCols;
451	int rowOrder, colOrder, *cRowOrder;
452	RcInfo_t rowInfo, colInfo;
453	char **xy;
454	int nClusterRows, nClusterCols;
455	array_t *clusterArray;
456	bdd_t cluster, relation, tempCluster, var, *nsVar;
457	int row, col, s, t;
458	array_t arraySmoothVarBddArray, smoothVarBddArray;
459	int qVarPos;
460	array_t *nonAppearingVarBddArray;
461	int *varPos;
462	array_t psVarBddArray, nsVarBddArray;
463	int index, nVars, nc;
464	long initialTime, finalTime;
465	array_t *clusteredRelationArray;
466	SccList_t sccHeadList, sccList;
467	int *sccBorder;
468	float lambda1, lambda2, lambda3;
469	FILE *fout;
470
471	if (option->mlpVerbosity)
472	initialTime = util_cpu_time();
473	else
474	initialTime = 0;
475
476	psVarBddArray = domainVarBddArray;
477	nsVarBddArray = rangeVarBddArray;
478
479	if (option->mlpInitialCluster && functionData) {
480	clusteredRelationArray = CreateInitialCluster(mddManager, relationArray,
481	functionData, nsVarBddArray,
482	option);
483	} else
484	clusteredRelationArray = relationArray;
485
486	nRows = array_n(clusteredRelationArray);
487	if (direction == Img_Forward_c)
488	nCols = array_n(domainVarBddArray) + array_n(quantifyVarBddArray);
489	else
490	nCols = array_n(rangeVarBddArray) + array_n(quantifyVarBddArray);
491
492	xy = ALLOC(char *, nRows);
493	for (i = 0; i < nRows; i++) {
494	xy[i] = ALLOC(char, nCols);
495	memset(xy[i], 0, sizeof(char) * nCols);
496	}
497
498	rowOrder = ALLOC(int, nRows);
499	for (i = 0; i < nRows; i++)
500	rowOrder[i] = i;
501	colOrder = ALLOC(int, nCols);
502	for (i = 0; i < nCols; i++)
503	colOrder[i] = i;
504
505	rowInfo = ALLOC(RcInfo_t, nRows);
506	memset(rowInfo, 0, sizeof(RcInfo_t) * nRows);
507	colInfo = ALLOC(RcInfo_t, nCols);
508	memset(colInfo, 0, sizeof(RcInfo_t) * nCols);
509	nVars = bdd_num_vars(mddManager);
510	varPos = ALLOC(int, nVars);
511	memset(varPos, 0, sizeof(int) * nVars);
512
513	for (i = 0; i < nRows; i++) {
514	relation = array_fetch(bdd_t *, clusteredRelationArray, i);
515	rowInfo[i].data.row.func = bdd_dup(relation);
516	}
517
518	nc = 0;
519	for (i = 0; i < array_n(psVarBddArray); i++) {
520	var = array_fetch(bdd_t *, psVarBddArray, i);
521	colInfo[nc].data.col.var = var;
522	colInfo[nc].data.col.type = 1;
523	index = (int)bdd_top_var_id(var);
524	varPos[index] = nc;
525	nc++;
526	}
527	for (i = 0; i < array_n(quantifyVarBddArray); i++) {
528	var = array_fetch(bdd_t *, quantifyVarBddArray, i);
529	colInfo[nc].data.col.var = var;
530	colInfo[nc].data.col.type = 2;
531	index = (int)bdd_top_var_id(var);
532	varPos[index] = nc;
533	nc++;
534	}
535
536	if (arraySmoothVarBddArrayPtr)
537	nonAppearingVarBddArray = array_alloc(bdd_t *, 0);
538	else
539	nonAppearingVarBddArray = NIL(array_t);
540
541	SetupMlp(mddManager, xy, nRows, nCols, rowOrder, colOrder,
542	rowInfo, colInfo, varPos, nsVarBddArray, &nActiveRows, &nActiveCols,
543	nonAppearingVarBddArray, direction, option);
544
545	if (nActiveRows == 0) {
546	clusterArray = array_alloc(mdd_t *, 0);
547	cluster = bdd_one(mddManager);
548	for (i = nActiveRows; i < nRows; i++) {
549	row = rowOrder[i];
550	relation = rowInfo[row].data.row.func;
551	tempCluster = bdd_and(cluster, relation, 1, 1);
552	bdd_free(cluster);
553	cluster = tempCluster;
554	}
555	array_insert_last(bdd_t *, clusterArray, cluster);
556	*clusteredRelationArrayPtr = clusterArray;
557
558	if (arraySmoothVarBddArrayPtr) {
559	arraySmoothVarBddArray = array_alloc(array_t *, 0);
560	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
561	array_insert_last(array_t *, arraySmoothVarBddArray,
562	nonAppearingVarBddArray);
563	if (direction == Img_Forward_c) {
564	smoothVarBddArray = array_alloc(array_t *, 0);
565	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
566	} else {
567	smoothVarBddArray = array_alloc(array_t *, 0);
568	for (i = 0; i < nRows; i++) {
569	row = rowOrder[i];
570	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
571	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray,
572	j);
573	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
574	}
575	}
576	array_insert_last(array_t *, arraySmoothVarBddArray,
577	smoothVarBddArray);
578	}
579	}
580
581	FREE(varPos);
582	for (i = 0; i < nRows; i++) {
583	if (xy[i])
584	FREE(xy[i]);
585	}
586	FREE(xy);
587	FREE(rowOrder);
588	FREE(colOrder);
589	for (i = 0; i < nRows; i++) {
590	bdd_free(rowInfo[i].data.row.func);
591	if (rowInfo[i].data.row.nsVarBddArray)
592	array_free(rowInfo[i].data.row.nsVarBddArray);
593	}
594	FREE(rowInfo);
595	FREE(colInfo);
596	return;
597	}
598	sccHeadList = MlpDecomposeScc(mddManager, xy, nRows, nActiveRows, nActiveCols,
599	rowOrder, colOrder, rowInfo, colInfo,
600	0, option);
601	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
602	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
603	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
604	}
605	sccList = sccHeadList;
606	while (sccList) {
607	BlockLowerTriangle(xy, nRows, nCols, nActiveRows, nActiveCols, sccList,
608	rowOrder, colOrder, rowInfo, colInfo, option);
609	sccList = sccList->next;
610	}
611	if (option->mlpVerbosity >= 2) {
612	lambda1 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
613	rowInfo, colInfo, rowOrder, colOrder,
614	direction, 0, 0, option);
615	lambda2 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
616	rowInfo, colInfo, rowOrder, colOrder,
617	direction, 1, 0, option);
618	lambda3 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
619	rowInfo, colInfo, rowOrder, colOrder,
620	direction, 2, 0, option);
621	fprintf(vis_stdout, "Lambda after MLP = %f (%f, %f)\n",
622	lambda1, lambda2, lambda3);
623	}
624
625	if (option->mlpVerbosity) {
626	finalTime = util_cpu_time();
627	fprintf(vis_stdout, "time for MLP = %10g\n",
628	(double)(finalTime - initialTime) / 1000.0);
629	}
630	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
631	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
632	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
633	}
634
635	if (option->mlpPostProcess == 1 \|\| option->mlpPostProcess == 3) {
636	for (x = 0; x < nActiveRows; x++) {
637	row = rowOrder[x];
638	rowInfo[row].lNum = rowInfo[row].gNum;
639	rowInfo[row].lMin = rowInfo[row].gMin;
640	rowInfo[row].lMax = rowInfo[row].gMax;
641	rowInfo[row].prevG = -1;
642	rowInfo[row].nextG = nActiveCols;
643	}
644	for (y = 0; y < nActiveCols; y++) {
645	col = colOrder[y];
646	colInfo[col].lNum = colInfo[col].gNum;
647	colInfo[col].lMin = colInfo[col].gMin;
648	colInfo[col].lMax = colInfo[col].gMax;
649	colInfo[col].prevG = -1;
650	colInfo[col].nextG = nActiveRows;
651	}
652
653	sccList = sccHeadList;
654	while (sccList) {
655	MlpPostProcess(xy, sccList, nCols, nActiveRows, nActiveCols,
656	rowInfo, colInfo, rowOrder, colOrder, direction, option);
657	sccList = sccList->next;
658	}
659	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
660	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
661	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
662	}
663	}
664
665	if (option->mlpWriteOrder) {
666	fout = fopen(option->mlpWriteOrder, "w");
667	if (fout) {
668	WriteOrder(fout, nActiveCols, colOrder, colInfo);
669	fclose(fout);
670	} else {
671	fprintf(vis_stderr, "** img error: can't open file [%s]\n",
672	option->mlpWriteOrder);
673	}
674	}
675
676	clusterArray = array_alloc(bdd_t *, 0);
677	if (arraySmoothVarBddArrayPtr) {
678	arraySmoothVarBddArray = array_alloc(array_t *, 0);
679	array_insert_last(array_t *, arraySmoothVarBddArray,
680	nonAppearingVarBddArray);
681	} else
682	arraySmoothVarBddArray = NIL(array_t);
683
684	if ((direction == Img_Forward_c && option->mlpReorder) \|\|
685	(direction == Img_Backward_c && option->mlpPreReorder) \|\|
686	option->mlpPostProcess >= 2) {
687	cRowOrder = ALLOC(int, nActiveRows);
688	for (i = 0; i < nActiveCols; i++) {
689	col = colOrder[i];
690	colInfo[col].lNum = 0;
691	colInfo[col].lMin = nActiveRows;
692	colInfo[col].lMax = -1;
693	}
694	} else
695	cRowOrder = NIL(int);
696
697	if (option->mlpClusterScc) {
698	sccBorder = ALLOC(int, nRows);
699	memset(sccBorder, 0, sizeof(int) * nRows);
700	sccList = sccHeadList;
701	while (sccList) {
702	sccBorder[sccList->startFunc] = 1;
703	sccBorder[sccList->lastFunc] = 2;
704	sccList = sccList->next;
705	}
706	} else
707	sccBorder = NIL(int);
708
709	MlpCluster(mddManager, xy, nRows, nCols, nActiveRows, nActiveCols,
710	&nClusterRows, &nClusterCols,
711	rowOrder, colOrder, rowInfo, colInfo,
712	clusterArray, arraySmoothVarBddArray,
713	direction, cRowOrder, nsVarBddArray, sccBorder, varPos, option);
714
715	if (sccBorder)
716	FREE(sccBorder);
717
718	if ((direction == Img_Forward_c && option->mlpReorder) \|\|
719	(direction == Img_Backward_c && option->mlpPreReorder) \|\|
720	option->mlpPostProcess >= 2) {
721	if (option->mlpDecomposeScc && NumOfSccs(sccHeadList) > 1) {
722	FreeSccList(sccHeadList);
723	sccHeadList = MlpDecomposeScc(mddManager, xy, nRows,
724	nClusterRows, nClusterCols,
725	cRowOrder, colOrder, rowInfo, colInfo,
726	1, option);
727	} else {
728	sccHeadList->startFunc = 0;
729	sccHeadList->lastFunc = nClusterRows - 1;
730	sccHeadList->startVar = 0;
731	sccHeadList->lastVar = nClusterCols - 1;
732	sccHeadList->nFuncs = nClusterRows;
733	sccHeadList->nVars = nClusterCols;
734	}
735	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
736	PrintMatrix(xy, nClusterRows, nClusterCols, cRowOrder, colOrder,
737	rowInfo, colInfo, 0, nClusterRows - 1, 0, nClusterCols - 1);
738	}
739
740	if ((direction == Img_Forward_c && option->mlpReorder) \|\|
741	(direction == Img_Backward_c && option->mlpPreReorder)) {
742	sccList = sccHeadList;
743	while (sccList) {
744	BlockLowerTriangle(xy, nRows, nCols, nClusterRows, nClusterCols,
745	sccList, cRowOrder, colOrder, rowInfo, colInfo,
746	option);
747	sccList = sccList->next;
748	}
749	if (option->mlpVerbosity >= 2) {
750	lambda1 = ComputeLambdaMlp(xy, nCols, nClusterRows, nClusterCols,
751	rowInfo, colInfo, rowOrder, colOrder,
752	direction, 0, 0, option);
753	lambda2 = ComputeLambdaMlp(xy, nCols, nClusterRows, nClusterCols,
754	rowInfo, colInfo, rowOrder, colOrder,
755	direction, 1, 0, option);
756	lambda3 = ComputeLambdaMlp(xy, nCols, nClusterRows, nClusterCols,
757	rowInfo, colInfo, rowOrder, colOrder,
758	direction, 2, 0, option);
759	fprintf(vis_stdout, "Lambda after MLP-cluster = %f (%f, %f)\n",
760	lambda1, lambda2, lambda3);
761	}
762
763	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
764	PrintMatrix(xy, nClusterRows, nClusterCols, cRowOrder, colOrder,
765	rowInfo, colInfo, 0, nClusterRows - 1, 0, nClusterCols - 1);
766	}
767	}
768
769	if (option->mlpPostProcess >= 2) {
770	for (x = 0; x < nClusterRows; x++) {
771	row = rowOrder[x];
772	rowInfo[row].lNum = rowInfo[row].gNum;
773	rowInfo[row].lMin = rowInfo[row].gMin;
774	rowInfo[row].lMax = rowInfo[row].gMax;
775	rowInfo[row].prevG = -1;
776	rowInfo[row].nextG = nClusterCols;
777	}
778	for (y = 0; y < nClusterCols; y++) {
779	col = colOrder[y];
780	colInfo[col].lNum = colInfo[col].gNum;
781	colInfo[col].lMin = colInfo[col].gMin;
782	colInfo[col].lMax = colInfo[col].gMax;
783	colInfo[col].prevG = -1;
784	colInfo[col].nextG = nClusterRows;
785	}
786
787	sccList = sccHeadList;
788	while (sccList) {
789	MlpPostProcess(xy, sccList, nCols, nClusterRows, nClusterCols,
790	rowInfo, colInfo, cRowOrder, colOrder, direction, option);
791	sccList = sccList->next;
792	}
793	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
794	PrintMatrix(xy, nClusterRows, nClusterCols, cRowOrder, colOrder,
795	rowInfo, colInfo, 0, nClusterRows - 1, 0, nClusterCols - 1);
796	}
797	}
798
799	*clusteredRelationArrayPtr = clusterArray;
800
801	if (direction == Img_Forward_c) {
802	for (i = nClusterRows - 1; i >= 0; i--) {
803	row = cRowOrder[i];
804	array_insert_last(bdd_t *, clusterArray, rowInfo[row].data.row.func);
805	rowInfo[row].data.row.func = NIL(bdd_t);
806	}
807
808	if (nRows > nActiveRows) {
809	cluster = bdd_one(mddManager);
810	for (i = nActiveRows; i < nRows; i++) {
811	row = rowOrder[i];
812	relation = rowInfo[row].data.row.func;
813	tempCluster = bdd_and(cluster, relation, 1, 1);
814	bdd_free(cluster);
815	cluster = tempCluster;
816	}
817	array_insert_last(bdd_t *, clusterArray, cluster);
818	}
819	} else {
820	if (nRows > nActiveRows) {
821	UpdateNonappearingNsVars(mddManager, nsVarBddArray, nClusterRows,
822	rowInfo, cRowOrder, nonAppearingVarBddArray);
823
824	cluster = bdd_one(mddManager);
825	for (i = nActiveRows; i < nRows; i++) {
826	row = rowOrder[i];
827	relation = rowInfo[row].data.row.func;
828	tempCluster = bdd_and(cluster, relation, 1, 1);
829	bdd_free(cluster);
830	cluster = tempCluster;
831	}
832	array_insert_last(bdd_t *, clusterArray, cluster);
833	}
834
835	for (i = 0; i < nClusterRows; i++) {
836	row = cRowOrder[i];
837	array_insert_last(bdd_t *, clusterArray, rowInfo[row].data.row.func);
838	rowInfo[row].data.row.func = NIL(bdd_t);
839	}
840	}
841
842	if (arraySmoothVarBddArrayPtr) {
843	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
844
845	if (direction == Img_Forward_c) {
846	if (nCols > nClusterCols) {
847	for (i = nClusterCols; i < nCols; i++) {
848	col = colOrder[i];
849	array_insert_last(bdd_t *, nonAppearingVarBddArray,
850	bdd_dup(colInfo[col].data.col.var));
851	}
852	}
853	qVarPos = nClusterCols - 1;
854	if (qVarPos >= 0) {
855	col = colOrder[qVarPos];
856	while (colInfo[col].gNum == 0) {
857	array_insert_last(bdd_t *, nonAppearingVarBddArray,
858	bdd_dup(colInfo[col].data.col.var));
859	if (qVarPos == 0)
860	break;
861	qVarPos--;
862	col = colOrder[qVarPos];
863	}
864	}
865	for (i = nClusterRows - 1; i >= 0; i--) {
866	row = cRowOrder[i];
867	smoothVarBddArray = array_alloc(array_t *, 0);
868	col = colOrder[qVarPos];
869	while (rowInfo[colInfo[col].gMin].pos == i) {
870	array_insert_last(bdd_t *, smoothVarBddArray,
871	bdd_dup(colInfo[col].data.col.var));
872	if (qVarPos == 0)
873	break;
874	qVarPos--;
875	col = colOrder[qVarPos];
876	}
877	array_insert_last(array_t *, arraySmoothVarBddArray,
878	smoothVarBddArray);
879	}
880
881	if (nRows > nActiveRows) {
882	smoothVarBddArray = array_alloc(array_t *, 0);
883	array_insert_last(array_t *, arraySmoothVarBddArray,
884	smoothVarBddArray);
885	}
886	} else {
887	if (nRows == nActiveRows) {
888	UpdateNonappearingNsVars(mddManager, nsVarBddArray, nClusterRows,
889	rowInfo, cRowOrder, nonAppearingVarBddArray);
890	} else {
891	smoothVarBddArray = array_alloc(array_t *, 0);
892	for (i = nActiveRows; i < nRows; i++) {
893	row = rowOrder[i];
894	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
895	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray,
896	j);
897	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
898	}
899	}
900	array_insert_last(array_t *, arraySmoothVarBddArray,
901	smoothVarBddArray);
902	}
903	for (i = 0; i < nClusterRows; i++) {
904	row = cRowOrder[i];
905	smoothVarBddArray = array_alloc(array_t *, 0);
906	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
907	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray,
908	j);
909	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
910	}
911
912	s = colInfo[rowInfo[row].gMin].pos;
913	t = colInfo[rowInfo[row].gMax].pos;
914	for (j = s; j <= t; j++) {
915	col = colOrder[j];
916	if (colInfo[col].data.col.type == 2) {
917	if (rowInfo[colInfo[col].gMax].pos == i) {
918	array_insert_last(bdd_t *, smoothVarBddArray,
919	bdd_dup(colInfo[col].data.col.var));
920	}
921	}
922	}
923	array_insert_last(array_t *, arraySmoothVarBddArray,
924	smoothVarBddArray);
925	}
926	}
927	}
928
929	FREE(cRowOrder);
930
931	if (option->mlpVerbosity) {
932	finalTime = util_cpu_time();
933	fprintf(vis_stdout, "time for MLP-clustering-reorder = %10g\n",
934	(double)(finalTime - initialTime) / 1000.0);
935	}
936	} else {
937	*clusteredRelationArrayPtr = clusterArray;
938	if (arraySmoothVarBddArrayPtr)
939	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
940
941	if (option->mlpVerbosity) {
942	finalTime = util_cpu_time();
943	fprintf(vis_stdout, "time for MLP-clustering = %10g\n",
944	(double)(finalTime - initialTime) / 1000.0);
945	}
946	}
947
948	FreeSccList(sccHeadList);
949
950	FREE(varPos);
951	for (i = 0; i < nRows; i++) {
952	if (xy[i])
953	FREE(xy[i]);
954	}
955	FREE(xy);
956	FREE(rowOrder);
957	FREE(colOrder);
958	for (i = 0; i < nRows; i++) {
959	if (rowInfo[i].data.row.func)
960	bdd_free(rowInfo[i].data.row.func);
961	if (rowInfo[i].data.row.nsVarBddArray)
962	array_free(rowInfo[i].data.row.nsVarBddArray);
963	}
964	FREE(rowInfo);
965	FREE(colInfo);
966	if (option->mlpInitialCluster)
967	mdd_array_free(clusteredRelationArray);
968	}
969
970
971	/Function******************************************************************
972
973	Synopsis [Orders relation array and makes quantification schedule.]
974
975	Description [Orders relation array and makes quantification schedule.]
976
977	SideEffects []
978
979	******************************************************************************/
980	void
981	ImgMlpOrderRelationArray(mdd_manager *mddManager,
982	array_t *relationArray,
983	array_t *domainVarBddArray,
984	array_t *quantifyVarBddArray,
985	array_t *rangeVarBddArray,
986	Img_DirectionType direction,
987	array_t **orderedRelationArrayPtr,
988	array_t **arraySmoothVarBddArrayPtr,
989	ImgTrmOption_t *option)
990	{
991	int i, j, x, y, nRows, nCols, nActiveRows, nActiveCols;
992	int rowOrder, colOrder;
993	RcInfo_t rowInfo, colInfo;
994	char **xy;
995	array_t *orderedArray;
996	bdd_t relation, var, *nsVar;
997	int row, col, s, t;
998	array_t arraySmoothVarBddArray, smoothVarBddArray;
999	int qVarPos;
1000	array_t *nonAppearingVarBddArray;
1001	int *varPos;
1002	array_t psVarBddArray, nsVarBddArray;
1003	int index, nVars, nc;
1004	long initialTime, finalTime;
1005	SccList_t sccHeadList, sccList;
1006	float lambda1, lambda2, lambda3;
1007
1008	arraySmoothVarBddArray = NIL(array_t);
1009	nRows = array_n(relationArray);
1010	if (direction == Img_Forward_c)
1011	nCols = array_n(domainVarBddArray) + array_n(quantifyVarBddArray);
1012	else
1013	nCols = array_n(rangeVarBddArray) + array_n(quantifyVarBddArray);
1014
1015	if (nCols == 0) {
1016	if (direction == Img_Forward_c) {
1017	orderedArray = mdd_array_duplicate(relationArray);
1018	*orderedRelationArrayPtr = orderedArray;
1019	if (arraySmoothVarBddArrayPtr) {
1020	arraySmoothVarBddArray = array_alloc(array_t *, 0);
1021	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
1022	for (i = 0; i <= nRows; i++) {
1023	smoothVarBddArray = array_alloc(array_t *, 0);
1024	array_insert_last(array_t *, arraySmoothVarBddArray,
1025	smoothVarBddArray);
1026	}
1027	}
1028	} else {
1029	orderedArray = array_alloc(mdd_t *, 0);
1030	array_insert_last(mdd_t *, orderedArray, mdd_one(mddManager));
1031	*orderedRelationArrayPtr = orderedArray;
1032	if (arraySmoothVarBddArrayPtr) {
1033	arraySmoothVarBddArray = array_alloc(array_t *, 0);
1034	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
1035	for (i = 0; i <= 1; i++) {
1036	smoothVarBddArray = array_alloc(array_t *, 0);
1037	array_insert_last(array_t *, arraySmoothVarBddArray,
1038	smoothVarBddArray);
1039	}
1040	}
1041	}
1042	return;
1043	}
1044
1045	if (option->mlpVerbosity)
1046	initialTime = util_cpu_time();
1047	else
1048	initialTime = 0;
1049
1050	xy = ALLOC(char *, nRows);
1051	for (i = 0; i < nRows; i++) {
1052	xy[i] = ALLOC(char, nCols);
1053	memset(xy[i], 0, sizeof(char) * nCols);
1054	}
1055
1056	rowOrder = ALLOC(int, nRows);
1057	for (i = 0; i < nRows; i++)
1058	rowOrder[i] = i;
1059	colOrder = ALLOC(int, nCols);
1060	for (i = 0; i < nCols; i++)
1061	colOrder[i] = i;
1062
1063	rowInfo = ALLOC(RcInfo_t, nRows);
1064	memset(rowInfo, 0, sizeof(RcInfo_t) * nRows);
1065	colInfo = ALLOC(RcInfo_t, nCols);
1066	memset(colInfo, 0, sizeof(RcInfo_t) * nCols);
1067	nVars = bdd_num_vars(mddManager);
1068	varPos = ALLOC(int, nVars);
1069	memset(varPos, 0, sizeof(int) * nVars);
1070
1071	for (i = 0; i < nRows; i++) {
1072	relation = array_fetch(bdd_t *, relationArray, i);
1073	rowInfo[i].data.row.func = bdd_dup(relation);
1074	}
1075
1076	psVarBddArray = domainVarBddArray;
1077	nsVarBddArray = rangeVarBddArray;
1078	nc = 0;
1079	for (i = 0; i < array_n(psVarBddArray); i++) {
1080	var = array_fetch(bdd_t *, psVarBddArray, i);
1081	colInfo[nc].data.col.var = var;
1082	colInfo[nc].data.col.type = 1;
1083	index = (int)bdd_top_var_id(var);
1084	varPos[index] = nc;
1085	nc++;
1086	}
1087	for (i = 0; i < array_n(quantifyVarBddArray); i++) {
1088	var = array_fetch(bdd_t *, quantifyVarBddArray, i);
1089	colInfo[nc].data.col.var = var;
1090	colInfo[nc].data.col.type = 2;
1091	index = (int)bdd_top_var_id(var);
1092	varPos[index] = nc;
1093	nc++;
1094	}
1095
1096	if (arraySmoothVarBddArrayPtr)
1097	nonAppearingVarBddArray = array_alloc(bdd_t *, 0);
1098	else
1099	nonAppearingVarBddArray = NIL(array_t);
1100	SetupMlp(mddManager, xy, nRows, nCols, rowOrder, colOrder,
1101	rowInfo, colInfo, varPos, nsVarBddArray, &nActiveRows, &nActiveCols,
1102	nonAppearingVarBddArray, direction, option);
1103	if (nActiveRows == 0) {
1104	orderedArray = array_alloc(bdd_t *, 0);
1105	if (arraySmoothVarBddArrayPtr) {
1106	arraySmoothVarBddArray = array_alloc(array_t *, 0);
1107	array_insert_last(array_t *, arraySmoothVarBddArray,
1108	nonAppearingVarBddArray);
1109	}
1110	for (i = 0; i < nRows; i++) {
1111	row = rowOrder[i];
1112	relation = rowInfo[row].data.row.func;
1113	array_insert_last(bdd_t *, orderedArray, mdd_dup(relation));
1114	if (arraySmoothVarBddArrayPtr) {
1115	if (direction == Img_Forward_c) {
1116	smoothVarBddArray = array_alloc(array_t *, 0);
1117	array_insert_last(array_t *, arraySmoothVarBddArray,
1118	smoothVarBddArray);
1119	} else {
1120	smoothVarBddArray = rowInfo[row].data.row.nsVarBddArray;
1121	rowInfo[row].data.row.nsVarBddArray = NIL(array_t);
1122	array_insert_last(array_t *, arraySmoothVarBddArray,
1123	smoothVarBddArray);
1124	}
1125	}
1126	}
1127	*orderedRelationArrayPtr = orderedArray;
1128	if (arraySmoothVarBddArrayPtr)
1129	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
1130
1131	FREE(varPos);
1132	for (i = 0; i < nRows; i++) {
1133	if (xy[i])
1134	FREE(xy[i]);
1135	}
1136	FREE(xy);
1137	FREE(rowOrder);
1138	FREE(colOrder);
1139	for (i = 0; i < nRows; i++) {
1140	bdd_free(rowInfo[i].data.row.func);
1141	if (rowInfo[i].data.row.nsVarBddArray)
1142	array_free(rowInfo[i].data.row.nsVarBddArray);
1143	}
1144	FREE(rowInfo);
1145	FREE(colInfo);
1146	return;
1147	}
1148	sccHeadList = MlpDecomposeScc(mddManager, xy, nRows, nActiveRows, nActiveCols,
1149	rowOrder, colOrder, rowInfo, colInfo,
1150	0, option);
1151	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
1152	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
1153	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
1154	}
1155	sccList = sccHeadList;
1156	while (sccList) {
1157	BlockLowerTriangle(xy, nRows, nCols, nActiveRows, nActiveCols, sccList,
1158	rowOrder, colOrder, rowInfo, colInfo, option);
1159	sccList = sccList->next;
1160	}
1161	if (option->mlpVerbosity >= 2) {
1162	lambda1 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1163	rowInfo, colInfo, rowOrder, colOrder,
1164	direction, 0, 0, option);
1165	lambda2 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1166	rowInfo, colInfo, rowOrder, colOrder,
1167	direction, 1, 0, option);
1168	lambda3 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1169	rowInfo, colInfo, rowOrder, colOrder,
1170	direction, 2, 0, option);
1171	fprintf(vis_stdout, "Lambda after MLP = %f (%f, %f)\n",
1172	lambda1, lambda2, lambda3);
1173	}
1174
1175	if (option->mlpVerbosity) {
1176	finalTime = util_cpu_time();
1177	fprintf(vis_stdout, "time for MLP = %10g\n",
1178	(double)(finalTime - initialTime) / 1000.0);
1179	}
1180	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
1181	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
1182	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
1183	}
1184
1185	if (option->mlpPostProcess) {
1186	for (x = 0; x < nRows; x++) {
1187	row = rowOrder[x];
1188	rowInfo[row].lNum = rowInfo[row].gNum;
1189	rowInfo[row].lMin = rowInfo[row].gMin;
1190	rowInfo[row].lMax = rowInfo[row].gMax;
1191	rowInfo[row].prevG = -1;
1192	rowInfo[row].nextG = nCols;
1193	}
1194	for (y = 0; y < nCols; y++) {
1195	col = colOrder[y];
1196	colInfo[col].lNum = colInfo[col].gNum;
1197	colInfo[col].lMin = colInfo[col].gMin;
1198	colInfo[col].lMax = colInfo[col].gMax;
1199	colInfo[col].prevG = -1;
1200	colInfo[col].nextG = nRows;
1201	}
1202
1203	sccList = sccHeadList;
1204	while (sccList) {
1205	MlpPostProcess(xy, sccList, nCols, nActiveRows, nActiveCols,
1206	rowInfo, colInfo, rowOrder, colOrder, direction, option);
1207	sccList = sccList->next;
1208	}
1209	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
1210	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
1211	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
1212	}
1213	}
1214
1215	orderedArray = array_alloc(bdd_t *, 0);
1216	if (arraySmoothVarBddArrayPtr) {
1217	arraySmoothVarBddArray = array_alloc(array_t *, 0);
1218	array_insert_last(array_t *, arraySmoothVarBddArray,
1219	nonAppearingVarBddArray);
1220	}
1221
1222	assert(nActiveCols > 0);
1223	if (direction == Img_Forward_c) {
1224	if (arraySmoothVarBddArrayPtr) {
1225	if (nCols > nActiveCols) {
1226	for (i = nActiveCols; i < nCols; i++) {
1227	col = colOrder[i];
1228	array_insert_last(bdd_t *, nonAppearingVarBddArray,
1229	bdd_dup(colInfo[col].data.col.var));
1230	}
1231	}
1232	qVarPos = nActiveCols - 1;
1233	if (qVarPos >= 0) {
1234	col = colOrder[qVarPos];
1235	while (colInfo[col].gNum == 0) {
1236	array_insert_last(bdd_t *, nonAppearingVarBddArray,
1237	bdd_dup(colInfo[col].data.col.var));
1238	if (qVarPos == 0)
1239	break;
1240	qVarPos--;
1241	col = colOrder[qVarPos];
1242	}
1243	}
1244	} else
1245	qVarPos = 0; /* to avoid warning */
1246	for (i = nActiveRows - 1; i >= 0; i--) {
1247	row = rowOrder[i];
1248	if (arraySmoothVarBddArrayPtr) {
1249	smoothVarBddArray = array_alloc(array_t *, 0);
1250	col = colOrder[qVarPos];
1251	while (rowInfo[colInfo[col].gMin].pos == i) {
1252	index = (int)bdd_top_var_id(colInfo[col].data.col.var);
1253	array_insert_last(bdd_t *, smoothVarBddArray,
1254	bdd_dup(colInfo[col].data.col.var));
1255	if (qVarPos == 0)
1256	break;
1257	qVarPos--;
1258	col = colOrder[qVarPos];
1259	}
1260	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1261	}
1262	relation = bdd_dup(rowInfo[row].data.row.func);
1263	array_insert_last(bdd_t *, orderedArray, relation);
1264	}
1265
1266	if (nRows > nActiveRows) {
1267	for (i = nActiveRows; i < nRows; i++) {
1268	row = rowOrder[i];
1269	relation = rowInfo[row].data.row.func;
1270	array_insert_last(bdd_t *, orderedArray, mdd_dup(relation));
1271	if (arraySmoothVarBddArrayPtr) {
1272	smoothVarBddArray = array_alloc(array_t *, 0);
1273	array_insert_last(array_t *, arraySmoothVarBddArray,
1274	smoothVarBddArray);
1275	}
1276	}
1277	}
1278	} else {
1279	if (arraySmoothVarBddArrayPtr) {
1280	UpdateNonappearingNsVars(mddManager, nsVarBddArray, nActiveRows,
1281	rowInfo, rowOrder, nonAppearingVarBddArray);
1282	}
1283	if (nRows > nActiveRows) {
1284	for (i = nActiveRows; i < nRows; i++) {
1285	row = rowOrder[i];
1286	relation = rowInfo[row].data.row.func;
1287	array_insert_last(bdd_t *, orderedArray, mdd_dup(relation));
1288	if (arraySmoothVarBddArrayPtr) {
1289	smoothVarBddArray = rowInfo[row].data.row.nsVarBddArray;
1290	rowInfo[row].data.row.nsVarBddArray = NIL(array_t);
1291	array_insert_last(array_t *, arraySmoothVarBddArray,
1292	smoothVarBddArray);
1293	}
1294	}
1295	}
1296	for (i = 0; i < nActiveRows; i++) {
1297	row = rowOrder[i];
1298	if (arraySmoothVarBddArrayPtr) {
1299	smoothVarBddArray = array_alloc(array_t *, 0);
1300	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
1301	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, j);
1302	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
1303	}
1304
1305	s = colInfo[rowInfo[row].gMin].pos;
1306	t = colInfo[rowInfo[row].gMax].pos;
1307	for (j = s; j <= t; j++) {
1308	col = colOrder[j];
1309	if (colInfo[col].data.col.type == 2) {
1310	if (rowInfo[colInfo[col].gMax].pos == i) {
1311	array_insert_last(bdd_t *, smoothVarBddArray,
1312	bdd_dup(colInfo[col].data.col.var));
1313	}
1314	}
1315	}
1316	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1317	}
1318	relation = bdd_dup(rowInfo[row].data.row.func);
1319	array_insert_last(bdd_t *, orderedArray, relation);
1320	}
1321	}
1322
1323	*orderedRelationArrayPtr = orderedArray;
1324	if (arraySmoothVarBddArrayPtr)
1325	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
1326
1327	FreeSccList(sccHeadList);
1328
1329	FREE(varPos);
1330	for (i = 0; i < nRows; i++) {
1331	if (xy[i])
1332	FREE(xy[i]);
1333	}
1334	FREE(xy);
1335	FREE(rowOrder);
1336	FREE(colOrder);
1337	for (i = 0; i < nRows; i++) {
1338	bdd_free(rowInfo[i].data.row.func);
1339	if (rowInfo[i].data.row.nsVarBddArray)
1340	array_free(rowInfo[i].data.row.nsVarBddArray);
1341	}
1342	FREE(rowInfo);
1343	FREE(colInfo);
1344	}
1345
1346
1347	/Function******************************************************************
1348
1349	Synopsis [Compute variables lifetime using MLP.]
1350
1351	Description [Compute variables lifetime using MLP.]
1352
1353	SideEffects []
1354
1355	******************************************************************************/
1356	float
1357	ImgMlpComputeLambda(mdd_manager *mddManager,
1358	array_t *relationArray,
1359	array_t *domainVarBddArray,
1360	array_t *quantifyVarBddArray,
1361	array_t *rangeVarBddArray,
1362	Img_DirectionType direction,
1363	int mode,
1364	int asIs,
1365	int *prevArea,
1366	float *improvedLambda,
1367	ImgTrmOption_t *option)
1368	{
1369	int i, nRows, nCols, nActiveRows, nActiveCols;
1370	int rowOrder, colOrder;
1371	RcInfo_t rowInfo, colInfo;
1372	char **xy;
1373	bdd_t relation, var;
1374	int *varPos;
1375	array_t psVarBddArray, nsVarBddArray;
1376	int index, nVars, nc;
1377	SccList_t sccHeadList, sccList;
1378	float lambda;
1379	int area;
1380
1381	nRows = array_n(relationArray);
1382	if (direction == Img_Forward_c)
1383	nCols = array_n(domainVarBddArray) + array_n(quantifyVarBddArray);
1384	else
1385	nCols = array_n(rangeVarBddArray) + array_n(quantifyVarBddArray);
1386
1387	if (nCols == 0) {
1388	if (improvedLambda) {
1389	*improvedLambda = 0.0;
1390	*prevArea = 0;
1391	}
1392	return(0.0);
1393	}
1394
1395	xy = ALLOC(char *, nRows);
1396	for (i = 0; i < nRows; i++) {
1397	xy[i] = ALLOC(char, nCols);
1398	memset(xy[i], 0, sizeof(char) * nCols);
1399	}
1400
1401	rowOrder = ALLOC(int, nRows);
1402	for (i = 0; i < nRows; i++)
1403	rowOrder[i] = i;
1404	colOrder = ALLOC(int, nCols);
1405	for (i = 0; i < nCols; i++)
1406	colOrder[i] = i;
1407
1408	rowInfo = ALLOC(RcInfo_t, nRows);
1409	memset(rowInfo, 0, sizeof(RcInfo_t) * nRows);
1410	colInfo = ALLOC(RcInfo_t, nCols);
1411	memset(colInfo, 0, sizeof(RcInfo_t) * nCols);
1412	nVars = bdd_num_vars(mddManager);
1413	varPos = ALLOC(int, nVars);
1414	memset(varPos, 0, sizeof(int) * nVars);
1415
1416	for (i = 0; i < nRows; i++) {
1417	relation = array_fetch(bdd_t *, relationArray, i);
1418	rowInfo[i].data.row.func = bdd_dup(relation);
1419	}
1420
1421	psVarBddArray = domainVarBddArray;
1422	nsVarBddArray = rangeVarBddArray;
1423	nc = 0;
1424	for (i = 0; i < array_n(psVarBddArray); i++) {
1425	var = array_fetch(bdd_t *, psVarBddArray, i);
1426	colInfo[nc].data.col.var = var;
1427	colInfo[nc].data.col.type = 1;
1428	index = (int)bdd_top_var_id(var);
1429	varPos[index] = nc;
1430	nc++;
1431	}
1432	for (i = 0; i < array_n(quantifyVarBddArray); i++) {
1433	var = array_fetch(bdd_t *, quantifyVarBddArray, i);
1434	colInfo[nc].data.col.var = var;
1435	colInfo[nc].data.col.type = 2;
1436	index = (int)bdd_top_var_id(var);
1437	varPos[index] = nc;
1438	nc++;
1439	}
1440
1441	SetupMlp(mddManager, xy, nRows, nCols, rowOrder, colOrder,
1442	rowInfo, colInfo, varPos, nsVarBddArray, &nActiveRows, &nActiveCols,
1443	NIL(array_t), direction, option);
1444	if (nActiveRows == 0) {
1445	FREE(varPos);
1446	for (i = 0; i < nRows; i++) {
1447	if (xy[i])
1448	FREE(xy[i]);
1449	}
1450	FREE(xy);
1451	FREE(rowOrder);
1452	FREE(colOrder);
1453	for (i = 0; i < nRows; i++) {
1454	bdd_free(rowInfo[i].data.row.func);
1455	if (rowInfo[i].data.row.nsVarBddArray)
1456	array_free(rowInfo[i].data.row.nsVarBddArray);
1457	}
1458	FREE(rowInfo);
1459	FREE(colInfo);
1460
1461	if (improvedLambda) {
1462	*improvedLambda = 0.0;
1463	*prevArea = 0;
1464	}
1465	return(0.0);
1466	}
1467	sccHeadList = MlpDecomposeScc(mddManager, xy, nRows, nActiveRows, nActiveCols,
1468	rowOrder, colOrder, rowInfo, colInfo,
1469	0, option);
1470	sccList = sccHeadList;
1471	while (sccList) {
1472	BlockLowerTriangle(xy, nRows, nCols, nActiveRows, nActiveCols, sccList,
1473	rowOrder, colOrder, rowInfo, colInfo, option);
1474	sccList = sccList->next;
1475	}
1476
1477	lambda = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1478	rowInfo, colInfo, rowOrder, colOrder,
1479	direction, mode, asIs, option);
1480
1481	FreeSccList(sccHeadList);
1482
1483	FREE(varPos);
1484	for (i = 0; i < nRows; i++) {
1485	if (xy[i])
1486	FREE(xy[i]);
1487	}
1488	FREE(xy);
1489	FREE(rowOrder);
1490	FREE(colOrder);
1491	for (i = 0; i < nRows; i++) {
1492	bdd_free(rowInfo[i].data.row.func);
1493	if (rowInfo[i].data.row.nsVarBddArray)
1494	array_free(rowInfo[i].data.row.nsVarBddArray);
1495	}
1496	FREE(rowInfo);
1497	FREE(colInfo);
1498
1499	if (option->mlpLambdaMode == 0)
1500	area = nActiveRows * nActiveCols;
1501	else
1502	area = nActiveRows * nCols;
1503	if (improvedLambda) {
1504	if (*prevArea)
1505	improvedLambda = lambda (float)area / (*prevArea);
1506	else
1507	*improvedLambda = 0.0;
1508	*prevArea = area;
1509	}
1510	return(lambda);
1511	}
1512
1513
1514	/Function******************************************************************
1515
1516	Synopsis [Makes a quantification schedule using MLP.]
1517
1518	Description [Makes a quantification schedule using MLP.]
1519
1520	SideEffects []
1521
1522	******************************************************************************/
1523	void
1524	ImgMlpGetQuantificationSchedule(mdd_manager *mddManager,
1525	array_t *relationArray,
1526	array_t *domainVarBddArray,
1527	array_t *quantifyVarBddArray,
1528	array_t *rangeVarBddArray,
1529	array_t **clusteredRelationArrayPtr,
1530	array_t **arraySmoothVarBddArrayPtr,
1531	Img_DirectionType direction,
1532	ImgTrmOption_t *option)
1533	{
1534	int i, j, nRows, nCols, nActiveRows, nActiveCols;
1535	int rowOrder, colOrder;
1536	RcInfo_t rowInfo, colInfo;
1537	char **xy;
1538	bdd_t relation, var, *nsVar;
1539	int *varPos;
1540	array_t psVarBddArray, nsVarBddArray;
1541	int index, nVars, nc;
1542	array_t arraySmoothVarBddArray, smoothVarBddArray;
1543	int qVarPos, row, col, s, t;
1544	array_t *nonAppearingVarBddArray;
1545	array_t *clusteredRelationArray;
1546
1547	nRows = array_n(relationArray);
1548	if (direction == Img_Forward_c)
1549	nCols = array_n(domainVarBddArray) + array_n(quantifyVarBddArray);
1550	else
1551	nCols = array_n(rangeVarBddArray) + array_n(quantifyVarBddArray);
1552
1553	xy = ALLOC(char *, nRows);
1554	for (i = 0; i < nRows; i++) {
1555	xy[i] = ALLOC(char, nCols);
1556	memset(xy[i], 0, sizeof(char) * nCols);
1557	}
1558
1559	rowOrder = ALLOC(int, nRows);
1560	for (i = 0; i < nRows; i++)
1561	rowOrder[i] = i;
1562	colOrder = ALLOC(int, nCols);
1563	for (i = 0; i < nCols; i++)
1564	colOrder[i] = i;
1565
1566	rowInfo = ALLOC(RcInfo_t, nRows);
1567	memset(rowInfo, 0, sizeof(RcInfo_t) * nRows);
1568	colInfo = ALLOC(RcInfo_t, nCols);
1569	memset(colInfo, 0, sizeof(RcInfo_t) * nCols);
1570	nVars = bdd_num_vars(mddManager);
1571	varPos = ALLOC(int, nVars);
1572	memset(varPos, 0, sizeof(int) * nVars);
1573
1574	psVarBddArray = domainVarBddArray;
1575	nsVarBddArray = rangeVarBddArray;
1576	if (direction == Img_Forward_c) {
1577	for (i = 0; i < nRows; i++) {
1578	relation = array_fetch(bdd_t *, relationArray, nRows - 1 - i);
1579	rowInfo[i].data.row.func = bdd_dup(relation);
1580	}
1581	} else {
1582	for (i = 0; i < nRows; i++) {
1583	relation = array_fetch(bdd_t *, relationArray, i);
1584	rowInfo[i].data.row.func = bdd_dup(relation);
1585	}
1586	}
1587	nc = 0;
1588	for (i = 0; i < array_n(psVarBddArray); i++) {
1589	var = array_fetch(bdd_t *, psVarBddArray, i);
1590	colInfo[nc].data.col.var = var;
1591	colInfo[nc].data.col.type = 1;
1592	index = (int)bdd_top_var_id(var);
1593	varPos[index] = nc;
1594	nc++;
1595	}
1596	for (i = 0; i < array_n(quantifyVarBddArray); i++) {
1597	var = array_fetch(bdd_t *, quantifyVarBddArray, i);
1598	colInfo[nc].data.col.var = var;
1599	colInfo[nc].data.col.type = 2;
1600	index = (int)bdd_top_var_id(var);
1601	varPos[index] = nc;
1602	nc++;
1603	}
1604
1605	nonAppearingVarBddArray = array_alloc(bdd_t *, 0);
1606	SetupMlp(mddManager, xy, nRows, nCols, rowOrder, colOrder,
1607	rowInfo, colInfo, varPos, nsVarBddArray, &nActiveRows, &nActiveCols,
1608	nonAppearingVarBddArray, direction, option);
1609	SortCol(xy, nActiveRows, nActiveCols, rowInfo, colInfo, rowOrder, colOrder);
1610
1611	clusteredRelationArray = array_alloc(mdd_t *, 0);
1612	arraySmoothVarBddArray = array_alloc(array_t *, 0);
1613	if (direction == Img_Forward_c) {
1614	if (nCols > nActiveCols) {
1615	for (i = nActiveCols; i < nCols; i++) {
1616	col = colOrder[i];
1617	array_insert_last(bdd_t *, nonAppearingVarBddArray,
1618	bdd_dup(colInfo[col].data.col.var));
1619	}
1620	}
1621	qVarPos = nActiveCols - 1;
1622	if (qVarPos >= 0) {
1623	col = colOrder[qVarPos];
1624	while (colInfo[col].gNum == 0) {
1625	array_insert_last(bdd_t *, nonAppearingVarBddArray,
1626	bdd_dup(colInfo[col].data.col.var));
1627	if (qVarPos == 0)
1628	break;
1629	qVarPos--;
1630	col = colOrder[qVarPos];
1631	}
1632	}
1633	array_insert_last(array_t *, arraySmoothVarBddArray,
1634	nonAppearingVarBddArray);
1635	for (i = nActiveRows - 1; i >= 0; i--) {
1636	row = rowOrder[i];
1637	smoothVarBddArray = array_alloc(array_t *, 0);
1638	if (rowInfo[row].gNum > 0) {
1639	col = colOrder[qVarPos];
1640	while (rowInfo[colInfo[col].gMin].pos == i) {
1641	index = (int)bdd_top_var_id(colInfo[col].data.col.var);
1642	array_insert_last(bdd_t *, smoothVarBddArray,
1643	bdd_dup(colInfo[col].data.col.var));
1644	if (qVarPos == 0)
1645	break;
1646	qVarPos--;
1647	col = colOrder[qVarPos];
1648	}
1649	}
1650	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1651	relation = bdd_dup(rowInfo[row].data.row.func);
1652	array_insert_last(bdd_t *, clusteredRelationArray, relation);
1653	}
1654	if (nRows > nActiveRows) {
1655	for (i = nActiveRows; i < nRows; i++) {
1656	row = rowOrder[i];
1657	smoothVarBddArray = array_alloc(array_t *, 0);
1658	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1659	relation = bdd_dup(rowInfo[row].data.row.func);
1660	array_insert_last(bdd_t *, clusteredRelationArray, relation);
1661	}
1662	}
1663	} else {
1664	array_insert_last(array_t *, arraySmoothVarBddArray,
1665	nonAppearingVarBddArray);
1666	if (nRows > nActiveRows) {
1667	for (i = nActiveRows; i < nRows; i++) {
1668	row = rowOrder[i];
1669	smoothVarBddArray = rowInfo[row].data.row.nsVarBddArray;
1670	rowInfo[row].data.row.nsVarBddArray = NIL(array_t);
1671	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1672	relation = bdd_dup(rowInfo[row].data.row.func);
1673	array_insert_last(bdd_t *, clusteredRelationArray, relation);
1674	}
1675	}
1676	for (i = 0; i < nActiveRows; i++) {
1677	row = rowOrder[i];
1678	smoothVarBddArray = array_alloc(array_t *, 0);
1679	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
1680	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, j);
1681	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
1682	}
1683	if (rowInfo[row].gNum > 0) {
1684	s = colInfo[rowInfo[row].gMin].pos;
1685	t = colInfo[rowInfo[row].gMax].pos;
1686	for (j = s; j <= t; j++) {
1687	col = colOrder[j];
1688	if (colInfo[col].data.col.type == 2) {
1689	if (rowInfo[colInfo[col].gMax].pos == i) {
1690	array_insert_last(bdd_t *, smoothVarBddArray,
1691	bdd_dup(colInfo[col].data.col.var));
1692	}
1693	}
1694	}
1695	}
1696	array_insert_last(array_t *, arraySmoothVarBddArray, smoothVarBddArray);
1697	relation = bdd_dup(rowInfo[row].data.row.func);
1698	array_insert_last(bdd_t *, clusteredRelationArray, relation);
1699	}
1700	}
1701
1702	FREE(varPos);
1703	for (i = 0; i < nRows; i++) {
1704	if (xy[i])
1705	FREE(xy[i]);
1706	}
1707	FREE(xy);
1708	FREE(rowOrder);
1709	FREE(colOrder);
1710	for (i = 0; i < nRows; i++) {
1711	bdd_free(rowInfo[i].data.row.func);
1712	if (rowInfo[i].data.row.nsVarBddArray)
1713	array_free(rowInfo[i].data.row.nsVarBddArray);
1714	}
1715	FREE(rowInfo);
1716	FREE(colInfo);
1717
1718	*clusteredRelationArrayPtr = clusteredRelationArray;
1719	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
1720	}
1721
1722
1723	/Function******************************************************************
1724
1725	Synopsis [Prints dependence matrix.]
1726
1727	Description [Prints dependence matrix.]
1728
1729	SideEffects []
1730
1731	******************************************************************************/
1732	void
1733	ImgMlpPrintDependenceMatrix(mdd_manager *mddManager,
1734	array_t *relationArray,
1735	array_t *domainVarBddArray,
1736	array_t *quantifyVarBddArray,
1737	array_t *rangeVarBddArray,
1738	Img_DirectionType direction,
1739	int printFlag, FILE *fout,
1740	ImgTrmOption_t *option)
1741	{
1742	int i, nRows, nCols, nActiveRows, nActiveCols;
1743	int rowOrder, colOrder;
1744	RcInfo_t rowInfo, colInfo;
1745	char **xy;
1746	bdd_t relation, var;
1747	int *varPos;
1748	array_t psVarBddArray, nsVarBddArray;
1749	int index, nVars, nc;
1750	float lambda1, lambda2, lambda3;
1751
1752	nRows = array_n(relationArray);
1753	if (direction == Img_Forward_c)
1754	nCols = array_n(domainVarBddArray) + array_n(quantifyVarBddArray);
1755	else
1756	nCols = array_n(rangeVarBddArray) + array_n(quantifyVarBddArray);
1757
1758	xy = ALLOC(char *, nRows);
1759	for (i = 0; i < nRows; i++) {
1760	xy[i] = ALLOC(char, nCols);
1761	memset(xy[i], 0, sizeof(char) * nCols);
1762	}
1763
1764	rowOrder = ALLOC(int, nRows);
1765	for (i = 0; i < nRows; i++)
1766	rowOrder[i] = i;
1767	colOrder = ALLOC(int, nCols);
1768	for (i = 0; i < nCols; i++)
1769	colOrder[i] = i;
1770
1771	rowInfo = ALLOC(RcInfo_t, nRows);
1772	memset(rowInfo, 0, sizeof(RcInfo_t) * nRows);
1773	colInfo = ALLOC(RcInfo_t, nCols);
1774	memset(colInfo, 0, sizeof(RcInfo_t) * nCols);
1775	nVars = bdd_num_vars(mddManager);
1776	varPos = ALLOC(int, nVars);
1777	memset(varPos, 0, sizeof(int) * nVars);
1778
1779	psVarBddArray = domainVarBddArray;
1780	nsVarBddArray = rangeVarBddArray;
1781	if (direction == Img_Forward_c) {
1782	for (i = 0; i < nRows; i++) {
1783	relation = array_fetch(bdd_t *, relationArray, nRows - 1 - i);
1784	rowInfo[i].data.row.func = bdd_dup(relation);
1785	}
1786	} else {
1787	for (i = 0; i < nRows; i++) {
1788	relation = array_fetch(bdd_t *, relationArray, i);
1789	rowInfo[i].data.row.func = bdd_dup(relation);
1790	}
1791	}
1792	nc = 0;
1793	for (i = 0; i < array_n(psVarBddArray); i++) {
1794	var = array_fetch(bdd_t *, psVarBddArray, i);
1795	colInfo[nc].data.col.var = var;
1796	colInfo[nc].data.col.type = 1;
1797	index = (int)bdd_top_var_id(var);
1798	varPos[index] = nc;
1799	nc++;
1800	}
1801	for (i = 0; i < array_n(quantifyVarBddArray); i++) {
1802	var = array_fetch(bdd_t *, quantifyVarBddArray, i);
1803	colInfo[nc].data.col.var = var;
1804	colInfo[nc].data.col.type = 2;
1805	index = (int)bdd_top_var_id(var);
1806	varPos[index] = nc;
1807	nc++;
1808	}
1809
1810	SetupMlp(mddManager, xy, nRows, nCols, rowOrder, colOrder,
1811	rowInfo, colInfo, varPos, nsVarBddArray, &nActiveRows, &nActiveCols,
1812	NIL(array_t), direction, option);
1813	SortCol(xy, nActiveRows, nActiveCols, rowInfo, colInfo, rowOrder, colOrder);
1814
1815	if (printFlag) {
1816	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
1817	rowInfo, colInfo, 0, nActiveRows - 1, 0, nActiveCols - 1);
1818	}
1819	if (fout) {
1820	WriteMatrix(fout, xy, nActiveRows, nActiveCols, rowOrder, colOrder,
1821	rowInfo, colInfo);
1822	}
1823	lambda1 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1824	rowInfo, colInfo, rowOrder, colOrder,
1825	direction, 0, 0, option);
1826	lambda2 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1827	rowInfo, colInfo, rowOrder, colOrder,
1828	direction, 1, 0, option);
1829	lambda3 = ComputeLambdaMlp(xy, nCols, nActiveRows, nActiveCols,
1830	rowInfo, colInfo, rowOrder, colOrder,
1831	direction, 2, 0, option);
1832	fprintf(vis_stdout, "Lambda = %f (%f, %f)\n", lambda1, lambda2, lambda3);
1833
1834	FREE(varPos);
1835	for (i = 0; i < nRows; i++) {
1836	if (xy[i])
1837	FREE(xy[i]);
1838	}
1839	FREE(xy);
1840	FREE(rowOrder);
1841	FREE(colOrder);
1842	for (i = 0; i < nRows; i++) {
1843	bdd_free(rowInfo[i].data.row.func);
1844	if (rowInfo[i].data.row.nsVarBddArray)
1845	array_free(rowInfo[i].data.row.nsVarBddArray);
1846	}
1847	FREE(rowInfo);
1848	FREE(colInfo);
1849	}
1850
1851
1852	/Function******************************************************************
1853
1854	Synopsis [Writes cluster to a file.]
1855
1856	Description [Writes cluster to a file.]
1857
1858	SideEffects []
1859
1860	******************************************************************************/
1861	void
1862	ImgMlpWriteClusterFile(FILE *fout,
1863	mdd_manager *mddManager,
1864	array_t *relationArray,
1865	array_t *psVarBddArray,
1866	array_t *nsVarBddArray)
1867	{
1868	int i, j, k, nVars;
1869	int bddId, mddId, id, index;
1870	mdd_t *relation;
1871	mdd_t psVar, nsVar, nsVars, ns2ps;
1872	array_t supportBddIdArray, bddIdArray;
1873	char *name;
1874	int count;
1875
1876	nVars = bdd_num_vars(mddManager);
1877	nsVars = ALLOC(bdd_t *, nVars);
1878	memset(nsVars, 0, sizeof(bdd_t ) nVars);
1879	ns2ps = ALLOC(bdd_t *, nVars);
1880	memset(ns2ps, 0, sizeof(bdd_t ) nVars);
1881
1882	for (i = 0; i < array_n(nsVarBddArray); i++) {
1883	psVar = array_fetch(bdd_t *, psVarBddArray, i);
1884	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
1885	index = (int)bdd_top_var_id(nsVar);
1886	nsVars[index] = nsVar;
1887	ns2ps[index] = psVar;
1888	}
1889
1890	count = 0;
1891	for (i = 0; i < array_n(relationArray); i++) {
1892	relation = array_fetch(mdd_t *, relationArray, i);
1893	supportBddIdArray = mdd_get_bdd_support_ids(mddManager, relation);
1894	psVar = NULL;
1895	for (j = 0; j < array_n(supportBddIdArray); j++) {
1896	bddId = array_fetch(int, supportBddIdArray, j);
1897	psVar = ns2ps[bddId];
1898	if (psVar) {
1899	break;
1900	}
1901	}
1902	if (psVar) {
1903	if (count == 0)
1904	fprintf(fout, "CLUSTER[%d] {\n", count);
1905	else
1906	fprintf(fout, "\nCLUSTER[%d] {\n", count);
1907	count++;
1908	}
1909	for (j = 0; j < array_n(supportBddIdArray); j++) {
1910	bddId = array_fetch(int, supportBddIdArray, j);
1911	psVar = ns2ps[bddId];
1912	if (psVar) {
1913	name = mdd_read_var_name(psVar);
1914	nsVar = nsVars[bddId];
1915	mddId = mdd_read_mdd_id(nsVar);
1916	bddIdArray = mdd_id_to_bdd_id_array(mddManager, mddId);
1917	for (k = 0; k < array_n(bddIdArray); k++) {
1918	id = array_fetch(int, bddIdArray, k);
1919	if (id == bddId) {
1920	fprintf(fout, "%s %d\n", name, k);
1921	break;
1922	}
1923	}
1924	array_free(bddIdArray);
1925	}
1926	}
1927	array_free(supportBddIdArray);
1928	fprintf(fout, "}\n");
1929	}
1930
1931	FREE(nsVars);
1932	FREE(ns2ps);
1933	}
1934
1935
1936
1937
1938	/Function******************************************************************
1939
1940	Synopsis [Reads cluster file.]
1941
1942	Description [Reads cluster file.]
1943
1944	SideEffects []
1945
1946	******************************************************************************/
1947	void
1948	ImgMlpReadClusterFile(FILE fin, mdd_manager mddManager,
1949	ImgFunctionData_t *functionData,
1950	array_t *relationArray,
1951	array_t *psVarBddArray,
1952	array_t *nsVarBddArray,
1953	array_t *quantifyVarBddArray,
1954	Img_DirectionType direction,
1955	array_t **clusteredRelationArrayPtr,
1956	array_t **arraySmoothVarBddArrayPtr,
1957	ImgTrmOption_t *option)
1958	{
1959	array_t clusteredRelationArray, newRelationArray;
1960	array_t *arraySmoothVarBddArray;
1961	int i, j, k, nVars;
1962	long bddId;
1963	int mddId, id, index;
1964	mdd_t relation, cluster, *newCluster;
1965	mdd_t var, psVar, nsVar, nsVars, *ns2ps;
1966	array_t supportBddIdArray, bddIdArray;
1967	char *name;
1968	LatchList_t **latchList;
1969	st_table intermediateTable, nameTable, quantifyVarsTable, idTable;
1970	int nRelVars, relBddId, relMddId;
1971	mdd_t *relVar;
1972	char *resolved;
1973	char line[512], nameArray[512];
1974	st_generator stGen1, stGen2;
1975
1976	nVars = bdd_num_vars(mddManager);
1977	nsVars = ALLOC(bdd_t *, nVars);
1978	memset(nsVars, 0, sizeof(bdd_t ) nVars);
1979	ns2ps = ALLOC(bdd_t *, nVars);
1980	memset(ns2ps, 0, sizeof(bdd_t ) nVars);
1981	latchList = ALLOC(LatchList_t *, nVars);
1982	memset(latchList, 0, sizeof(LatchList_t ) nVars);
1983	resolved = ALLOC(char, nVars);
1984	memset(resolved, 0, sizeof(char) * nVars);
1985
1986	quantifyVarsTable = st_init_table(st_numcmp, st_numhash);
1987	for (i = 0; i < array_n(functionData->quantifyBddVars); i++) {
1988	var = array_fetch(mdd_t *, functionData->quantifyBddVars, i);
1989	index = (int)bdd_top_var_id(var);
1990	st_insert(quantifyVarsTable, (char *)(long)index, NIL(char));
1991	}
1992
1993	nameTable = st_init_table(strcmp, st_strhash);
1994	for (i = 0; i < array_n(nsVarBddArray); i++) {
1995	psVar = array_fetch(bdd_t *, psVarBddArray, i);
1996	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
1997	index = (int)bdd_top_var_id(nsVar);
1998	nsVars[index] = nsVar;
1999	ns2ps[index] = psVar;
2000	name = mdd_read_var_name(psVar);
2001	mddId = mdd_read_mdd_id(nsVar);
2002	st_insert(nameTable, name, (char *)(long)mddId);
2003
2004	index = (int)bdd_top_var_id(psVar);
2005	st_insert(quantifyVarsTable, (char *)(long)index, NIL(char));
2006	}
2007
2008	i = 0;
2009	st_foreach_item_int(nameTable, stGen1, &name, &mddId) {
2010	printf("[%d] name = %s mdd = %d\n", i, name, mddId);
2011	i++;
2012	}
2013
2014	intermediateTable = st_init_table(st_ptrcmp, st_ptrhash);
2015	for (i = 0; i < array_n(relationArray); i++) {
2016	relation = array_fetch(mdd_t *, relationArray, i);
2017	supportBddIdArray = mdd_get_bdd_support_ids(mddManager, relation);
2018	nRelVars = 0;
2019	psVar = NIL(bdd_t);
2020	nsVar = NIL(bdd_t);
2021	relVar = NIL(bdd_t);
2022	relBddId = -1;
2023	relMddId = -1;
2024	idTable = st_init_table(st_numcmp, st_numhash);
2025	for (j = 0; j < array_n(supportBddIdArray); j++) {
2026	bddId = (long) array_fetch(int, supportBddIdArray, j);
2027	if (st_lookup(quantifyVarsTable, (char )bddId, NIL(char )))
2028	continue;
2029	psVar = ns2ps[bddId];
2030	if (psVar) {
2031	if (relVar) {
2032	bdd_free(relVar);
2033	relVar = NIL(bdd_t);
2034	}
2035	nsVar = nsVars[bddId];
2036	relMddId = mdd_read_mdd_id(nsVar);
2037	relBddId = (int) bddId;
2038	break;
2039	} else {
2040	if (nRelVars > 0) {
2041	if (relVar)
2042	bdd_free(relVar);
2043	}
2044	relVar = bdd_var_with_index(mddManager, (int) bddId);
2045	relMddId = mdd_read_mdd_id(relVar);
2046	relBddId = (int) bddId;
2047	name = mdd_read_var_name(relVar);
2048	st_insert(nameTable, name, (char *)(long)relMddId);
2049	st_insert(idTable, (char *)bddId, NIL(char));
2050	if (nRelVars >= 1) {
2051	bdd_free(relVar);
2052	relVar = NIL(bdd_t);
2053	}
2054	nRelVars++;
2055	}
2056	}
2057	array_free(supportBddIdArray);
2058	if (nsVar \|\| relVar) {
2059	bddId = (int) relBddId;
2060	mddId = relMddId;
2061
2062	if (relVar)
2063	resolved[bddId] = 1;
2064
2065	bddIdArray = mdd_id_to_bdd_id_array(mddManager, mddId);
2066	for (k = 0; k < array_n(bddIdArray); k++) {
2067	id = array_fetch(int, bddIdArray, k);
2068	if (id == bddId) {
2069	if (latchList[mddId]) {
2070	if (latchList[mddId]->number == 1) {
2071	latchList[mddId]->table = st_init_table(st_numcmp, st_numhash);
2072	st_insert(latchList[mddId]->table,
2073	(char *)(long)latchList[mddId]->bddId,
2074	(char *)latchList[mddId]->relation);
2075	}
2076	st_insert(latchList[mddId]->table, (char *)bddId,
2077	(char *)relation);
2078	} else {
2079	latchList[mddId] = ALLOC(LatchList_t, 1);
2080	latchList[mddId]->bddId = (int) bddId;
2081	latchList[mddId]->relation = relation;
2082	latchList[mddId]->number = 1;
2083	latchList[mddId]->table = NIL(st_table);
2084	}
2085	break;
2086	}
2087	}
2088	array_free(bddIdArray);
2089	st_free_table(idTable);
2090	} else {
2091	st_insert(intermediateTable, (char )relation, (char )idTable);
2092	}
2093	}
2094
2095	i = 0;
2096	st_foreach_item_int(nameTable, stGen1, &name, &mddId) {
2097	printf("[%d] name = %s mdd = %d\n", i, name, mddId);
2098	i++;
2099	}
2100
2101	while (intermediateTable->num_entries > 0) {
2102	st_foreach_item(intermediateTable, stGen1, &relation, &idTable) {
2103	st_foreach_item(idTable, stGen2, &bddId, NIL(char *)) {
2104	if (resolved[bddId])
2105	st_delete(idTable, &bddId, NIL(char *));
2106	}
2107	if (idTable->num_entries == 1) {
2108	st_foreach_item(idTable, stGen2, &bddId, NULL);
2109	relVar = bdd_var_with_index(mddManager, (int) bddId);
2110	mddId = mdd_read_mdd_id(relVar);
2111	mdd_free(relVar);
2112
2113	st_delete(intermediateTable, &relation, NULL);
2114
2115	bddIdArray = mdd_id_to_bdd_id_array(mddManager, mddId);
2116	for (k = 0; k < array_n(bddIdArray); k++) {
2117	id = array_fetch(int, bddIdArray, k);
2118	if (id == bddId) {
2119	if (latchList[mddId]) {
2120	if (latchList[mddId]->number == 1) {
2121	latchList[mddId]->table = st_init_table(st_numcmp, st_numhash);
2122	st_insert(latchList[mddId]->table,
2123	(char *)(long)latchList[mddId]->bddId,
2124	(char *)latchList[mddId]->relation);
2125	}
2126	st_insert(latchList[mddId]->table, (char *)bddId,
2127	(char *)relation);
2128	} else {
2129	latchList[mddId] = ALLOC(LatchList_t, 1);
2130	latchList[mddId]->bddId = (int) bddId;
2131	latchList[mddId]->relation = relation;
2132	latchList[mddId]->number = 1;
2133	latchList[mddId]->table = NIL(st_table);
2134	}
2135	break;
2136	}
2137	}
2138	array_free(bddIdArray);
2139	}
2140	}
2141	}
2142	st_free_table(intermediateTable);
2143
2144	i = 0;
2145	st_foreach_item_int(nameTable, stGen1, &name, &mddId) {
2146	printf("[%d] name = %s mdd = %d\n", i, name, mddId);
2147	i++;
2148	}
2149
2150	cluster = NIL(mdd_t);
2151	clusteredRelationArray = array_alloc(mdd_t *, 0);
2152	while (fgets(line, 512, fin)) {
2153	if (line[0] == '\n' \|\| line[0] == '#')
2154	continue;
2155	if (strncmp(line, "CLUSTER", 7) == 0)
2156	cluster = mdd_one(mddManager);
2157	else if (strncmp(line, "}", 1) == 0)
2158	array_insert_last(mdd_t *, clusteredRelationArray, cluster);
2159	else {
2160	sscanf(line, "%s %d", nameArray, &id);
2161	if (st_lookup_int(nameTable, nameArray, &mddId) == 0)
2162	assert(0);
2163	if (latchList[mddId]) {
2164	if (latchList[mddId]->table) {
2165	bddIdArray = mdd_id_to_bdd_id_array(mddManager, mddId);
2166	assert(id < array_n(bddIdArray));
2167	bddId = (long) array_fetch(int, bddIdArray, id);
2168	if (st_lookup(latchList[mddId]->table, (char *)bddId, &relation)) {
2169	latchList[mddId]->number--;
2170	if (latchList[mddId]->number == 0) {
2171	st_free_table(latchList[mddId]->table);
2172	FREE(latchList[mddId]);
2173	latchList[mddId] = NIL(LatchList_t);
2174	}
2175	} else
2176	assert(0);
2177	} else {
2178	relation = latchList[mddId]->relation;
2179	FREE(latchList[mddId]);
2180	latchList[mddId] = NIL(LatchList_t);
2181	}
2182	newCluster = bdd_and(cluster, relation, 1, 1);
2183	mdd_free(cluster);
2184	cluster = newCluster;
2185	} else
2186	assert(0);
2187	}
2188	}
2189
2190	for (i = 0; i < nVars; i++) {
2191	if (latchList[i]) {
2192	if (latchList[i]->table) {
2193	st_foreach_item(latchList[i]->table, stGen1, &bddId, &relation) {
2194	cluster = bdd_dup(relation);
2195	array_insert_last(mdd_t *, clusteredRelationArray, cluster);
2196	}
2197	st_free_table(latchList[i]->table);
2198	} else {
2199	cluster = bdd_dup(latchList[i]->relation);
2200	array_insert_last(mdd_t *, clusteredRelationArray, cluster);
2201	}
2202	FREE(latchList[i]);
2203	}
2204	}
2205
2206	FREE(nsVars);
2207	FREE(ns2ps);
2208	FREE(resolved);
2209	FREE(latchList);
2210
2211	st_free_table(nameTable);
2212	st_free_table(quantifyVarsTable);
2213
2214	if (arraySmoothVarBddArrayPtr) {
2215	ImgMlpGetQuantificationSchedule(mddManager,
2216	clusteredRelationArray, psVarBddArray, quantifyVarBddArray,
2217	nsVarBddArray, &newRelationArray, &arraySmoothVarBddArray,
2218	direction, option);
2219	mdd_array_free(clusteredRelationArray);
2220	clusteredRelationArray = newRelationArray;
2221	} else
2222	arraySmoothVarBddArray = NIL(array_t);
2223
2224	*clusteredRelationArrayPtr = clusteredRelationArray;
2225	*arraySmoothVarBddArrayPtr = arraySmoothVarBddArray;
2226	}
2227
2228
2229	/---------------------------------------------------------------------------/
2230	/* Definition of static functions */
2231	/---------------------------------------------------------------------------/
2232
2233	/Function******************************************************************
2234
2235	Synopsis [Setups MLP.]
2236
2237	Description [Setups MLP.]
2238
2239	SideEffects []
2240
2241	******************************************************************************/
2242	static void
2243	SetupMlp(mdd_manager *mddManager,
2244	char *xy, int nRows, int nCols, int rowOrder, int *colOrder,
2245	RcInfo_t rowInfo, RcInfo_t colInfo, int *varPos,
2246	array_t nsVarBddArray, int nActiveRows, int *nActiveCols,
2247	array_t *nonAppearingVarBddArray,
2248	Img_DirectionType direction, ImgTrmOption_t *option)
2249	{
2250	int i, j, x, y, s, t;
2251	int row, col, otherCol, nr, nc, index;
2252	long initialTime, finalTime;
2253	bdd_t relation, nsVar;
2254	array_t supportArray, localVarBddArray;
2255	int support;
2256	array_t **arrayLocalVarBddArray;
2257	float lambda1, lambda2, lambda3;
2258	bdd_t **nsVarArray;
2259	int nVars;
2260
2261	if (option->mlpVerbosity >= 2)
2262	initialTime = util_cpu_time();
2263	else
2264	initialTime = 0;
2265
2266	nVars = bdd_num_vars(mddManager);
2267	nsVarArray = ALLOC(bdd_t *, nVars);
2268	memset(nsVarArray, 0, sizeof(bdd_t ) nVars);
2269	for (i = 0; i < array_n(nsVarBddArray); i++) {
2270	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
2271	index = (int)bdd_top_var_id(nsVar);
2272	nsVarArray[index] = nsVar;
2273	}
2274
2275	for (i = 0; i < nRows; i++) {
2276	relation = rowInfo[i].data.row.func;
2277	rowInfo[i].data.row.nsVarBddArray = array_alloc(bdd_t *, 0);
2278	supportArray = mdd_get_bdd_support_ids(mddManager, relation);
2279	for (j = 0; j < array_n(supportArray); j++) {
2280	support = array_fetch(int, supportArray, j);
2281	nsVar = nsVarArray[support];
2282	if (nsVar) {
2283	array_insert_last(bdd_t *, rowInfo[i].data.row.nsVarBddArray, nsVar);
2284	if (varPos[support])
2285	xy[i][varPos[support]] = 1;
2286	else {
2287	index = (int)bdd_top_var_id(colInfo[0].data.col.var);
2288	if (index == support)
2289	xy[i][varPos[support]] = 1;
2290	}
2291	} else
2292	xy[i][varPos[support]] = 1;
2293	}
2294	array_free(supportArray);
2295	}
2296	FREE(nsVarArray);
2297
2298	for (x = 0; x < nRows; x++) {
2299	rowInfo[x].gMin = nCols;
2300	rowInfo[x].gMax = -1;
2301	rowInfo[x].pos = x;
2302	rowInfo[x].prevG = -1;
2303	rowInfo[x].nextG = nCols;
2304	}
2305	for (y = 0; y < nCols; y++) {
2306	colInfo[y].gMin = nRows;
2307	colInfo[y].gMax = -1;
2308	colInfo[y].pos = y;
2309	colInfo[y].prevG = -1;
2310	colInfo[y].nextG = nRows;
2311	}
2312
2313	for (x = 0; x < nRows; x++) {
2314	for (y = 0; y < nCols; y++) {
2315	if (xy[x][y]) {
2316	if (x < colInfo[y].gMin)
2317	colInfo[y].gMin = x;
2318	if (x > colInfo[y].gMax)
2319	colInfo[y].gMax = x;
2320	if (y < rowInfo[x].gMin)
2321	rowInfo[x].gMin = y;
2322	if (y > rowInfo[x].gMax)
2323	rowInfo[x].gMax = y;
2324	rowInfo[x].gNum++;
2325	colInfo[y].gNum++;
2326	}
2327	}
2328	}
2329
2330	nc = nCols;
2331	arrayLocalVarBddArray = ALLOC(array_t *, nRows);
2332	memset(arrayLocalVarBddArray, 0, sizeof(array_t ) nRows);
2333	for (y = 0; y < nc; y++) {
2334	col = colOrder[y];
2335	if (colInfo[col].data.col.type == 2 && colInfo[col].gNum == 1) {
2336	row = colInfo[col].gMin;
2337	rowInfo[row].gNum--;
2338	if (rowInfo[row].gNum == 1) {
2339	if (rowInfo[row].gMin == col) {
2340	rowInfo[row].gMin = rowInfo[row].gMax;
2341	rowInfo[row].lMin = rowInfo[row].lMax;
2342	} else {
2343	rowInfo[row].gMax = rowInfo[row].gMin;
2344	rowInfo[row].lMax = rowInfo[row].lMin;
2345	}
2346	} else if (rowInfo[row].gNum > 1) {
2347	if (rowInfo[row].gMin == col) {
2348	s = colInfo[rowInfo[row].gMin].pos;
2349	t = colInfo[rowInfo[row].gMax].pos;
2350	for (j = s + 1; j <= t; j++) {
2351	otherCol = colOrder[j];
2352	if (xy[row][otherCol]) {
2353	rowInfo[row].gMin = otherCol;
2354	rowInfo[row].lMin = otherCol;
2355	break;
2356	}
2357	}
2358	} else if (rowInfo[row].gMax == col) {
2359	s = colInfo[rowInfo[row].gMin].pos;
2360	t = colInfo[rowInfo[row].gMax].pos;
2361	for (j = t - 1; j >= s; j--) {
2362	otherCol = colOrder[j];
2363	if (xy[row][otherCol]) {
2364	rowInfo[row].gMax = otherCol;
2365	rowInfo[row].lMax = otherCol;
2366	break;
2367	}
2368	}
2369	}
2370	}
2371
2372	for (j = y; j < nc - 1; j++) {
2373	colOrder[j] = colOrder[j + 1];
2374	colInfo[colOrder[j]].pos = j;
2375	}
2376	colOrder[nc - 1] = col;
2377	colInfo[col].pos = nc - 1;
2378
2379	nc--;
2380	y--;
2381
2382	if (!arrayLocalVarBddArray[row])
2383	arrayLocalVarBddArray[row] = array_alloc(bdd_t *, 0);
2384	array_insert_last(bdd_t *, arrayLocalVarBddArray[row],
2385	colInfo[col].data.col.var);
2386	}
2387	}
2388
2389	if (direction == Img_Backward_c) {
2390	long lindex;
2391	st_table *unusedNsTable;
2392	st_generator *gen;
2393
2394	unusedNsTable = st_init_table(st_numcmp, st_numhash);
2395	for (i = 0; i < array_n(nsVarBddArray); i++) {
2396	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
2397	lindex = (long) bdd_top_var_id(nsVar);
2398	st_insert(unusedNsTable, (char )lindex, (char )nsVar);
2399	}
2400	for (i = 0; i < nRows; i++) {
2401	for (j = 0; j < array_n(rowInfo[i].data.row.nsVarBddArray); j++) {
2402	nsVar = array_fetch(bdd_t *, rowInfo[i].data.row.nsVarBddArray, j);
2403	lindex = (long) bdd_top_var_id(nsVar);
2404	st_delete(unusedNsTable, &lindex, NULL);
2405	}
2406	}
2407	st_foreach_item(unusedNsTable, gen, &lindex, &nsVar) {
2408	array_insert_last(bdd_t *, nonAppearingVarBddArray, bdd_dup(nsVar));
2409	}
2410	st_free_table(unusedNsTable);
2411	}
2412
2413	for (i = 0; i < nRows; i++) {
2414	localVarBddArray = arrayLocalVarBddArray[i];
2415	if (localVarBddArray) {
2416	relation = bdd_smooth(rowInfo[i].data.row.func, localVarBddArray);
2417	if (nonAppearingVarBddArray && direction == Img_Backward_c &&
2418	bdd_is_tautology(relation, 1)) {
2419	for (j = 0; j < array_n(rowInfo[i].data.row.nsVarBddArray); j++) {
2420	nsVar = array_fetch(bdd_t *, rowInfo[i].data.row.nsVarBddArray, j);
2421	array_insert_last(bdd_t *, nonAppearingVarBddArray, bdd_dup(nsVar));
2422	}
2423	}
2424	bdd_free(rowInfo[i].data.row.func);
2425	rowInfo[i].data.row.func = relation;
2426	UpdateDisapearingPsVars(mddManager, xy, nRows, nCols,
2427	rowOrder, colOrder, rowInfo, colInfo,
2428	i, option);
2429	if (localVarBddArray)
2430	array_free(localVarBddArray);
2431	}
2432	}
2433	FREE(arrayLocalVarBddArray);
2434
2435	for (y = 0; y < nc; y++) {
2436	col = colOrder[y];
2437	if (colInfo[col].gNum == 0) {
2438	if (nonAppearingVarBddArray &&
2439	direction == Img_Forward_c && colInfo[col].data.col.type == 1) {
2440	array_insert_last(bdd_t *, nonAppearingVarBddArray,
2441	bdd_dup(colInfo[col].data.col.var));
2442	}
2443	for (j = y; j < nc - 1; j++) {
2444	colOrder[j] = colOrder[j + 1];
2445	colInfo[colOrder[j]].pos = j;
2446	}
2447	colOrder[nc - 1] = col;
2448	colInfo[col].pos = nc - 1;
2449	nc--;
2450	y--;
2451	}
2452	}
2453
2454	nr = nRows;
2455	for (x = 0; x < nr; x++) {
2456	row = rowOrder[x];
2457	if (rowInfo[row].gNum == 0) {
2458	for (i = x; i < nr - 1; i++) {
2459	rowOrder[i] = rowOrder[i + 1];
2460	rowInfo[rowOrder[i]].pos = i;
2461	}
2462	rowOrder[nr - 1] = row;
2463	rowInfo[row].pos = nr - 1;
2464	nr--;
2465	x--;
2466	}
2467	}
2468
2469	for (x = 0; x < nr; x++) {
2470	row = rowOrder[x];
2471	rowInfo[row].lMin = rowInfo[row].gMin;
2472	rowInfo[row].lMax = rowInfo[row].gMax;
2473	rowInfo[row].lNum = rowInfo[row].gNum;
2474	if (nc != nCols && rowInfo[row].nextG == nCols)
2475	rowInfo[row].nextG = nc;
2476	}
2477	for (y = 0; y < nc; y++) {
2478	col = colOrder[y];
2479	colInfo[col].lMin = colInfo[col].gMin;
2480	colInfo[col].lMax = colInfo[col].gMax;
2481	colInfo[col].lNum = colInfo[col].gNum;
2482	if (nr != nRows && colInfo[col].nextG == nRows)
2483	colInfo[col].nextG = nr;
2484	}
2485	if (option->mlpVerbosity >= 2) {
2486	finalTime = util_cpu_time();
2487	fprintf(vis_stdout, "time for setup = %10g\n",
2488	(double)(finalTime - initialTime) / 1000.0);
2489
2490	lambda1 = ComputeLambdaMlp(xy, nCols, nr, nc, rowInfo, colInfo,
2491	rowOrder, colOrder, direction, 0, 0, option);
2492	lambda2 = ComputeLambdaMlp(xy, nCols, nr, nc, rowInfo, colInfo,
2493	rowOrder, colOrder, direction, 1, 0, option);
2494	lambda3 = ComputeLambdaMlp(xy, nCols, nr, nc, rowInfo, colInfo,
2495	rowOrder, colOrder, direction, 2, 0, option);
2496	fprintf(vis_stdout, "Initial Lambda = %f (%f, %f)\n",
2497	lambda1, lambda2, lambda3);
2498	}
2499
2500	if (option->mlpDebug) {
2501	CheckMatrix(xy, NIL(SccList_t), nr, nc, rowInfo, colInfo,
2502	rowOrder, colOrder, 0, nr - 1, 0, nc - 1, 1);
2503	}
2504
2505	*nActiveRows = nr;
2506	*nActiveCols = nc;
2507	}
2508
2509
2510	/Function******************************************************************
2511
2512	Synopsis [Performs connected component decomposition.]
2513
2514	Description [Performs connected component decomposition.]
2515
2516	SideEffects []
2517
2518	******************************************************************************/
2519	static SccList_t *
2520	MlpDecomposeScc(mdd_manager mddManager, char *xy, int nRows,
2521	int nActiveRows, int nActiveCols, int rowOrder, int colOrder,
2522	RcInfo_t rowInfo, RcInfo_t colInfo,
2523	int clusteredFlag, ImgTrmOption_t *option)
2524	{
2525	int i, j, x, y, size, nVars;
2526	int startRow, startCol;
2527	int nGroups, nChosen;
2528	int row, col, otherRow;
2529	int s1, t1, s2, t2;
2530	char rowFlag, colFlag, *stackFlag;
2531	int *stack;
2532	SccList_t sccHeadList, sccTailList, *sccList;
2533	array_t rowScc, colScc, *sccArray;
2534	long initialTime, finalTime;
2535	int newRowOrder, newColOrder;
2536	int nCurRows, nCurCols;
2537
2538	if (!option->mlpDecomposeScc) {
2539	sccList = ALLOC(SccList_t, 1);
2540	sccList->nFuncs = nActiveRows;
2541	sccList->nVars = nActiveCols;
2542	sccList->startFunc = 0;
2543	sccList->lastFunc = nActiveRows - 1;
2544	sccList->startVar = 0;
2545	sccList->lastVar = nActiveCols - 1;
2546	sccList->next = NIL(SccList_t);
2547	return(sccList);
2548	}
2549
2550	if (option->mlpVerbosity >= 2)
2551	initialTime = util_cpu_time();
2552	else
2553	initialTime = 0;
2554
2555	sccHeadList = NIL(SccList_t);
2556	sccTailList = NIL(SccList_t);
2557
2558	rowFlag = ALLOC(char, nRows);
2559	memset(rowFlag, 0, sizeof(char) * nRows);
2560	nVars = bdd_num_vars(mddManager);
2561	colFlag = ALLOC(char, nVars);
2562	memset(colFlag, 0, sizeof(char) * nVars);
2563	stack = ALLOC(int, nActiveRows);
2564	stackFlag = ALLOC(char, nRows);
2565	memset(stackFlag, 0, sizeof(char) * nRows);
2566
2567	startRow = 0;
2568	startCol = 0;
2569	nGroups = 0;
2570	nChosen = 0;
2571	while (nChosen < nActiveRows) {
2572	rowScc = array_alloc(int, 0);
2573	colScc = array_alloc(int, 0);
2574
2575	size = 0;
2576	for (i = startRow; i < nActiveRows; i++) {
2577	row = rowOrder[i];
2578	if (rowFlag[row] == 0) {
2579	stack[0] = row;
2580	size = 1;
2581	stackFlag[row] = 1;
2582	break;
2583	}
2584	}
2585
2586	while (size) {
2587	if (size + array_n(rowScc) == nRows) {
2588	FREE(stack);
2589	FREE(stackFlag);
2590	FREE(rowFlag);
2591	FREE(colFlag);
2592	array_free(rowScc);
2593	array_free(colScc);
2594
2595	sccList = ALLOC(SccList_t, 1);
2596	sccList->nFuncs = nActiveRows;
2597	sccList->nVars = nActiveCols;
2598	sccList->startFunc = 0;
2599	sccList->lastFunc = nActiveRows - 1;
2600	sccList->startVar = 0;
2601	sccList->lastVar = nActiveCols - 1;
2602	sccList->next = NIL(SccList_t);
2603	return(sccList);
2604	}
2605
2606	size--;
2607	row = stack[size];
2608	x = rowInfo[row].pos;
2609	rowFlag[row] = nGroups + 1;
2610	array_insert_last(int, rowScc, x);
2611	nChosen++;
2612	s1 = colInfo[rowInfo[row].gMin].pos;
2613	t1 = colInfo[rowInfo[row].gMax].pos;
2614	for (y = s1; y <= t1; y++) {
2615	col = colOrder[y];
2616	if (colInfo[col].gNum == nRows) {
2617	FREE(stack);
2618	FREE(stackFlag);
2619	FREE(rowFlag);
2620	FREE(colFlag);
2621	array_free(rowScc);
2622	array_free(colScc);
2623
2624	sccList = ALLOC(SccList_t, 1);
2625	sccList->nFuncs = nActiveRows;
2626	sccList->nVars = nActiveCols;
2627	sccList->startFunc = 0;
2628	sccList->lastFunc = nActiveRows - 1;
2629	sccList->startVar = 0;
2630	sccList->lastVar = nActiveCols - 1;
2631	sccList->next = NIL(SccList_t);
2632	return(sccList);
2633	}
2634	if (!xy[row][col] \|\| colFlag[col])
2635	continue;
2636	colFlag[col] = nGroups + 1;
2637	array_insert_last(int, colScc, y);
2638	s2 = rowInfo[colInfo[col].gMin].pos;
2639	t2 = rowInfo[colInfo[col].gMax].pos;
2640	for (i = s2; i <= t2; i++) {
2641	otherRow = rowOrder[i];
2642	if (rowFlag[otherRow] \|\| stackFlag[otherRow])
2643	continue;
2644	if (xy[otherRow][col]) {
2645	stack[size] = otherRow;
2646	size++;
2647	stackFlag[otherRow] = 1;
2648	}
2649	}
2650	}
2651	}
2652
2653	nGroups++;
2654	if (nGroups == 1 && nChosen == nActiveRows) {
2655	sccList = ALLOC(SccList_t, 1);
2656	sccList->nFuncs = nActiveRows;
2657	sccList->nVars = nActiveCols;
2658	sccList->startFunc = 0;
2659	sccList->lastFunc = nActiveRows - 1;
2660	sccList->startVar = 0;
2661	sccList->lastVar = nActiveCols - 1;
2662	sccList->next = NIL(SccList_t);
2663
2664	sccHeadList = sccList;
2665
2666	array_free(rowScc);
2667	array_free(colScc);
2668	break;
2669	}
2670
2671	/* Move the rows and columns that belong to the current group to top-left */
2672	array_sort(rowScc, SccSortRc);
2673	array_sort(colScc, SccSortRc);
2674	for (i = 0; i < array_n(rowScc); i++) {
2675	x = array_fetch(int, rowScc, i);
2676	if (x == startRow + i)
2677	continue;
2678	row = rowOrder[x];
2679	for (j = x; j > startRow + i; j--) {
2680	rowOrder[j] = rowOrder[j - 1];
2681	rowInfo[rowOrder[j]].pos = j;
2682	}
2683	rowOrder[startRow + i] = row;
2684	rowInfo[row].pos = startRow + i;
2685	}
2686	for (i = 0; i < array_n(colScc); i++) {
2687	y = array_fetch(int, colScc, i);
2688	if (y == startCol + i)
2689	continue;
2690	col = colOrder[y];
2691	for (j = y; j > startCol + i; j--) {
2692	colOrder[j] = colOrder[j - 1];
2693	colInfo[colOrder[j]].pos = j;
2694	}
2695	colOrder[startCol + i] = col;
2696	colInfo[col].pos = startCol + i;
2697	}
2698
2699	sccList = ALLOC(SccList_t, 1);
2700	sccList->nFuncs = array_n(rowScc);
2701	sccList->nVars = array_n(colScc);
2702	sccList->startFunc = startRow;
2703	sccList->lastFunc = startRow + sccList->nFuncs - 1;
2704	sccList->startVar = startCol;
2705	sccList->lastVar = startCol + sccList->nVars - 1;
2706	sccList->next = NIL(SccList_t);
2707	startRow += sccList->nFuncs;
2708	startCol += sccList->nVars;
2709
2710	if (sccTailList)
2711	sccTailList->next = sccList;
2712	else
2713	sccHeadList = sccList;
2714	sccTailList = sccList;
2715
2716	array_free(rowScc);
2717	array_free(colScc);
2718
2719	if (option->mlpDebug) {
2720	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nActiveCols,
2721	rowInfo, colInfo, rowOrder, colOrder,
2722	0, nActiveRows - 1, 0, nActiveCols - 1, 1);
2723	}
2724	}
2725
2726	FREE(stack);
2727	FREE(stackFlag);
2728	FREE(rowFlag);
2729	FREE(colFlag);
2730
2731	if (option->mlpSortScc && clusteredFlag == 0) {
2732	sccArray = array_alloc(SccList_t *, 0);
2733	sccList = sccHeadList;
2734	while (sccList) {
2735	array_insert_last(SccList_t *, sccArray, sccList);
2736	sccList = sccList->next;
2737	}
2738
2739	if (option->mlpSortSccMode == 0) {
2740	if (option->mlpSortScc == 1)
2741	array_sort(sccArray, SccSortListIncreasingWithArea);
2742	else
2743	array_sort(sccArray, SccSortListDecreasingWithArea);
2744	} else if (option->mlpSortSccMode == 1) {
2745	if (option->mlpSortScc == 1)
2746	array_sort(sccArray, SccSortListIncreasingWithVars);
2747	else
2748	array_sort(sccArray, SccSortListDecreasingWithVars);
2749	} else {
2750	if (option->mlpSortScc == 1)
2751	array_sort(sccArray, SccSortListIncreasingWithRatio);
2752	else
2753	array_sort(sccArray, SccSortListDecreasingWithRatio);
2754	}
2755
2756	newRowOrder = ALLOC(int, nActiveRows);
2757	newColOrder = ALLOC(int, nActiveCols);
2758
2759	nCurRows = 0;
2760	nCurCols = 0;
2761	sccHeadList = NIL(SccList_t);
2762	for (i = 0; i < array_n(sccArray); i++) {
2763	sccList = array_fetch(SccList_t *, sccArray, i);
2764	if (sccHeadList)
2765	sccTailList->next = sccList;
2766	else
2767	sccHeadList = sccList;
2768	sccTailList = sccList;
2769	sccList->next = NIL(SccList_t);
2770
2771	for (j = sccList->startFunc; j <= sccList->lastFunc; j++) {
2772	row = rowOrder[j];
2773	newRowOrder[nCurRows + j - sccList->startFunc] = rowOrder[j];
2774	rowInfo[row].pos = nCurRows + j - sccList->startFunc;
2775	}
2776	sccList->startFunc = nCurRows;
2777	sccList->lastFunc = nCurRows + sccList->nFuncs - 1;
2778	nCurRows += sccList->nFuncs;
2779
2780	for (j = sccList->startVar; j <= sccList->lastVar; j++) {
2781	col = colOrder[j];
2782	newColOrder[nCurCols + j - sccList->startVar] = colOrder[j];
2783	colInfo[col].pos = nCurCols + j - sccList->startVar;
2784	}
2785	sccList->startVar = nCurCols;
2786	sccList->lastVar = nCurCols + sccList->nVars - 1;
2787	nCurCols += sccList->nVars;
2788	}
2789
2790	memcpy(rowOrder, newRowOrder, sizeof(int) * nActiveRows);
2791	memcpy(colOrder, newColOrder, sizeof(int) * nActiveCols);
2792
2793	if (option->mlpDebug) {
2794	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nActiveCols,
2795	rowInfo, colInfo, rowOrder, colOrder,
2796	0, nActiveRows - 1, 0, nActiveCols - 1, 1);
2797	}
2798
2799	FREE(newRowOrder);
2800	FREE(newColOrder);
2801	array_free(sccArray);
2802	}
2803
2804	if (option->mlpVerbosity >= 2) {
2805	finalTime = util_cpu_time();
2806	fprintf(vis_stdout, "time for scc decomposition = %10g (#scc=%d)\n",
2807	(double)(finalTime - initialTime) / 1000.0, nGroups);
2808	}
2809
2810	return(sccHeadList);
2811	}
2812
2813
2814	/Function******************************************************************
2815
2816	Synopsis [Sorts connected components with the number of variables.]
2817
2818	Description [Sorts connected components with the number of variables.]
2819
2820	SideEffects []
2821
2822	******************************************************************************/
2823	static int
2824	SccSortListIncreasingWithVars(const void p1, const void p2)
2825	{
2826	SccList_t scc1 = (SccList_t ) p1;
2827	SccList_t scc2 = (SccList_t ) p2;
2828	if ((scc1)->nVars > (scc2)->nVars)
2829	return(1);
2830	else if ((scc1)->nVars < (scc2)->nVars)
2831	return(-1);
2832	else
2833	return(0);
2834	}
2835
2836
2837	/Function******************************************************************
2838
2839	Synopsis [Sorts connected components with the number of variables.]
2840
2841	Description [Sorts connected components with the number of variables.]
2842
2843	SideEffects []
2844
2845	******************************************************************************/
2846	static int
2847	SccSortListDecreasingWithVars(const void p1, const void p2)
2848	{
2849	SccList_t scc1 = (SccList_t ) p1;
2850	SccList_t scc2 = (SccList_t ) p2;
2851	if ((scc1)->nVars < (scc2)->nVars)
2852	return(1);
2853	else if ((scc1)->nVars > (scc2)->nVars)
2854	return(-1);
2855	else
2856	return(0);
2857	}
2858
2859
2860	/Function******************************************************************
2861
2862	Synopsis [Sorts connected components with area.]
2863
2864	Description [Sorts connected components with area.]
2865
2866	SideEffects []
2867
2868	******************************************************************************/
2869	static int
2870	SccSortListIncreasingWithArea(const void p1, const void p2)
2871	{
2872	SccList_t scc1 = (SccList_t ) p1;
2873	SccList_t scc2 = (SccList_t ) p2;
2874	int area1, area2;
2875
2876	area1 = (scc1)->nFuncs (*scc1)->nVars;
2877	area2 = (scc2)->nFuncs (*scc2)->nVars;
2878	if (area1 > area2)
2879	return(1);
2880	else if (area1 < area2)
2881	return(-1);
2882	else
2883	return(0);
2884	}
2885
2886
2887	/Function******************************************************************
2888
2889	Synopsis [Sorts connected components with area.]
2890
2891	Description [Sorts connected components with area.]
2892
2893	SideEffects []
2894
2895	******************************************************************************/
2896	static int
2897	SccSortListDecreasingWithArea(const void p1, const void p2)
2898	{
2899	SccList_t scc1 = (SccList_t ) p1;
2900	SccList_t scc2 = (SccList_t ) p2;
2901	int area1, area2;
2902
2903	area1 = (scc1)->nFuncs (*scc1)->nVars;
2904	area2 = (scc2)->nFuncs (*scc2)->nVars;
2905	if (area1 < area2)
2906	return(1);
2907	else if (area1 > area2)
2908	return(-1);
2909	else
2910	return(0);
2911	}
2912
2913
2914	/Function******************************************************************
2915
2916	Synopsis [Sorts connected components with aspect ratio.]
2917
2918	Description [Sorts connected components with aspect ratio.]
2919
2920	SideEffects []
2921
2922	******************************************************************************/
2923	static int
2924	SccSortListIncreasingWithRatio(const void p1, const void p2)
2925	{
2926	SccList_t scc1 = (SccList_t ) p1;
2927	SccList_t scc2 = (SccList_t ) p2;
2928	float ratio1, ratio2;
2929
2930	ratio1 = (float)((scc1)->nVars) / (float)((scc1)->nFuncs);
2931	ratio2 = (float)((scc2)->nVars) / (float)((scc2)->nFuncs);
2932	if (ratio1 > ratio2)
2933	return(1);
2934	else if (ratio1 < ratio2)
2935	return(-1);
2936	else
2937	return(0);
2938	}
2939
2940
2941	/Function******************************************************************
2942
2943	Synopsis [Sorts connected components with aspect ratio.]
2944
2945	Description [Sorts connected components with aspect ratio.]
2946
2947	SideEffects []
2948
2949	******************************************************************************/
2950	static int
2951	SccSortListDecreasingWithRatio(const void p1, const void p2)
2952	{
2953	SccList_t scc1 = (SccList_t ) p1;
2954	SccList_t scc2 = (SccList_t ) p2;
2955	float ratio1, ratio2;
2956
2957	ratio1 = (float)((scc1)->nVars) / (float)((scc1)->nFuncs);
2958	ratio2 = (float)((scc2)->nVars) / (float)((scc2)->nFuncs);
2959	if (ratio1 < ratio2)
2960	return(1);
2961	else if (ratio1 > ratio2)
2962	return(-1);
2963	else
2964	return(0);
2965	}
2966
2967
2968	/Function******************************************************************
2969
2970	Synopsis [Sorts rows or columns using connected component index.]
2971
2972	Description [Sorts rows or columns using connected component index.]
2973
2974	SideEffects []
2975
2976	******************************************************************************/
2977	static int
2978	SccSortRc(const void * p1, const void * p2)
2979	{
2980	int n1 = (int ) p1;
2981	int n2 = (int ) p2;
2982	if (n1 > n2)
2983	return(1);
2984	else if (n1 < n2)
2985	return(-1);
2986	else
2987	return(0);
2988	}
2989
2990
2991	/Function******************************************************************
2992
2993	Synopsis [Frees list of connected components.]
2994
2995	Description [Frees list of connected components.]
2996
2997	SideEffects []
2998
2999	******************************************************************************/
3000	static void
3001	FreeSccList(SccList_t *sccHeadList)
3002	{
3003	SccList_t sccList, sccNextList;
3004
3005	sccList = sccHeadList;
3006	while (sccList) {
3007	sccNextList = sccList->next;
3008	FREE(sccList);
3009	sccList = sccNextList;
3010	}
3011	}
3012
3013
3014	/Function******************************************************************
3015
3016	Synopsis [Returns the number of connected components in the list.]
3017
3018	Description [Returns the number of connected components in the list.]
3019
3020	SideEffects []
3021
3022	******************************************************************************/
3023	static int
3024	NumOfSccs(SccList_t *sccHeadList)
3025	{
3026	SccList_t *sccList;
3027	int num = 0;
3028
3029	sccList = sccHeadList;
3030	while (sccList) {
3031	num++;
3032	sccList = sccList->next;
3033	}
3034	return(num);
3035	}
3036
3037
3038	/Function******************************************************************
3039
3040	Synopsis [Makes dependence matrix block lower triangle.]
3041
3042	Description [Makes dependence matrix block lower triangle by pivoting
3043	rows and columns.]
3044
3045	SideEffects []
3046
3047	******************************************************************************/
3048	static void
3049	BlockLowerTriangle(char **xy, int nRows, int nCols,
3050	int nActiveRows, int nActiveCols,
3051	SccList_t sccList, int rowOrder, int *colOrder,
3052	RcInfo_t rowInfo, RcInfo_t colInfo,
3053	ImgTrmOption_t *option)
3054	{
3055	long initialTime, finalTime;
3056	int startFunc, lastFunc, startVar, lastVar;
3057	int nLeftRows, nLeftCols;
3058	int saveStartFunc, saveLastFunc;
3059	int saveStartVar, saveLastVar;
3060
3061	if (sccList) {
3062	if (sccList->nFuncs == 1 \|\| sccList->nVars == 1)
3063	return;
3064	startFunc = sccList->startFunc;
3065	lastFunc = sccList->lastFunc;
3066	startVar = sccList->startVar;
3067	lastVar = sccList->lastVar;
3068	} else {
3069	startFunc = 0;
3070	lastFunc = nActiveRows - 1;
3071	startVar = 0;
3072	lastVar = nActiveCols - 1;
3073	}
3074
3075	if (option->mlpVerbosity >= 2) {
3076	saveStartFunc = startFunc;
3077	saveLastFunc = lastFunc;
3078	saveStartVar = startVar;
3079	saveLastVar = lastVar;
3080	} else {
3081	/* To remove compiler warnings */
3082	saveStartFunc = 0;
3083	saveLastFunc = 0;
3084	saveStartVar = 0;
3085	saveLastVar = 0;
3086	}
3087
3088	if (option->mlpDebug) {
3089	CheckMatrix(xy, sccList, nActiveRows, nActiveCols, rowInfo, colInfo,
3090	rowOrder, colOrder, startFunc, lastFunc, startVar, lastVar, 1);
3091	}
3092
3093	if (option->mlpCsFirst) {
3094	/*
3095	* Find singleton columns and move each column to the right of the active
3096	* window and move its row to the bottom of the active window.
3097	*/
3098	if (option->mlpSkipCs == 0) {
3099	if (option->mlpVerbosity >= 2)
3100	initialTime = util_cpu_time();
3101	else /* to remove uninitialized variables warning */
3102	initialTime = 0;
3103	FindAndMoveSingletonCols(xy, sccList, nActiveRows, nActiveCols,
3104	&startFunc, &lastFunc, &startVar, &lastVar,
3105	rowInfo, colInfo, rowOrder, colOrder, option);
3106	if (option->mlpVerbosity >= 2) {
3107	finalTime = util_cpu_time();
3108	fprintf(vis_stdout,
3109	"time for col singleton = %10g (#row=%d, #col=%d)\n",
3110	(double)(finalTime - initialTime) / 1000.0,
3111	saveLastFunc - lastFunc, saveLastVar - lastVar);
3112	}
3113	}
3114
3115	/*
3116	* Find singleton rows and move each row to the top of the active window
3117	* and move its column to the left of the active window.
3118	*/
3119	if (option->mlpSkipRs == 0) {
3120	if (option->mlpVerbosity >= 2)
3121	initialTime = util_cpu_time();
3122	else /* to remove uninitialized variables warning */
3123	initialTime = 0;
3124	FindAndMoveSingletonRows(xy, sccList, nActiveRows, nActiveCols,
3125	&startFunc, &lastFunc, &startVar, &lastVar,
3126	rowInfo, colInfo, rowOrder, colOrder, option);
3127	if (option->mlpVerbosity >= 2) {
3128	finalTime = util_cpu_time();
3129	fprintf(vis_stdout,
3130	"time for row singleton = %10g (#row=%d, #col=%d)\n",
3131	(double)(finalTime - initialTime) / 1000.0,
3132	startFunc - saveStartFunc, startVar - saveStartVar);
3133	}
3134	}
3135	} else {
3136	/*
3137	* Find singleton rows and move each row to the top of the active window
3138	* and move its column to the left of the active window.
3139	*/
3140	if (option->mlpSkipRs == 0) {
3141	if (option->mlpVerbosity >= 2)
3142	initialTime = util_cpu_time();
3143	else /* to remove uninitialized variables warning */
3144	initialTime = 0;
3145	FindAndMoveSingletonRows(xy, sccList, nActiveRows, nActiveCols,
3146	&startFunc, &lastFunc, &startVar, &lastVar,
3147	rowInfo, colInfo, rowOrder, colOrder, option);
3148	if (option->mlpVerbosity >= 2) {
3149	finalTime = util_cpu_time();
3150	fprintf(vis_stdout,
3151	"time for row singleton = %10g (#row=%d, #col=%d)\n",
3152	(double)(finalTime - initialTime) / 1000.0,
3153	startFunc - saveStartFunc, startVar - saveStartVar);
3154	}
3155	}
3156
3157	/*
3158	* Find singleton columns and move each column to the right of the active
3159	* window and move its row to the bottom of the active window.
3160	*/
3161	if (option->mlpSkipCs == 0) {
3162	if (option->mlpVerbosity >= 2)
3163	initialTime = util_cpu_time();
3164	else /* to remove uninitialized variables warning */
3165	initialTime = 0;
3166	FindAndMoveSingletonCols(xy, sccList, nActiveRows, nActiveCols,
3167	&startFunc, &lastFunc, &startVar, &lastVar,
3168	rowInfo, colInfo, rowOrder, colOrder, option);
3169	if (option->mlpVerbosity >= 2) {
3170	finalTime = util_cpu_time();
3171	fprintf(vis_stdout,
3172	"time for col singleton = %10g (#row=%d, #col=%d)\n",
3173	(double)(finalTime - initialTime) / 1000.0,
3174	saveLastFunc - lastFunc, saveLastVar - lastVar);
3175	}
3176	}
3177	}
3178
3179	if (option->mlpVerbosity >= 2) {
3180	initialTime = util_cpu_time();
3181	nLeftRows = lastFunc - startFunc + 1;
3182	nLeftCols = lastVar - startVar + 1;
3183	} else {
3184	/* To remove compiler warnings */
3185	initialTime = 0;
3186	nLeftRows = 0;
3187	nLeftCols = 0;
3188	}
3189
3190	if (option->mlpRowBased) {
3191	MoveBestRows(xy, sccList, nActiveRows, nActiveCols, rowOrder, colOrder,
3192	rowInfo, colInfo,
3193	startFunc, lastFunc, startVar, lastVar, option);
3194	} else {
3195	MoveBestCols(xy, sccList, nRows, nCols, nActiveRows, nActiveCols,
3196	rowOrder, colOrder, rowInfo, colInfo,
3197	startFunc, lastFunc, startVar, lastVar, option);
3198	}
3199
3200	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3201	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
3202	rowInfo, colInfo, startFunc, lastFunc, startVar, lastVar);
3203	}
3204
3205	if (option->mlpVerbosity >= 2) {
3206	finalTime = util_cpu_time();
3207	if (option->mlpRowBased) {
3208	fprintf(vis_stdout, "time for best row = %10g (#row=%d, #col=%d)\n",
3209	(double)(finalTime - initialTime) / 1000.0,
3210	nLeftRows - lastFunc + startFunc - 1,
3211	nLeftCols - lastVar + startVar - 1);
3212	} else {
3213	fprintf(vis_stdout, "time for best col = %10g (#row=%d, #col=%d)\n",
3214	(double)(finalTime - initialTime) / 1000.0,
3215	nLeftRows - lastFunc + startFunc - 1,
3216	nLeftCols - lastVar + startVar - 1);
3217	}
3218	}
3219	}
3220
3221
3222	/Function******************************************************************
3223
3224	Synopsis [Finds and moves the best row iteratively.]
3225
3226	Description [Finds and moves the best row iteratively.]
3227
3228	SideEffects []
3229
3230	******************************************************************************/
3231	static void
3232	MoveBestRows(char *xy, SccList_t sccList, int nRows, int nCols,
3233	int rowOrder, int colOrder,
3234	RcInfo_t rowInfo, RcInfo_t colInfo,
3235	int startFunc, int lastFunc, int startVar, int lastVar,
3236	ImgTrmOption_t *option)
3237	{
3238	int x, y, s1, t1, s2, t2;
3239	int min, bestX;
3240	int row, col, lastCol, moveRow, bestRow;
3241	int regionX, overlap, nOverlaps, nMore;
3242
3243	regionX = 0;
3244	bestX = -1;
3245	while (startFunc < lastFunc && startVar < lastVar) {
3246	min = nCols;
3247	overlap = 0;
3248	for (x = startFunc; x <= lastFunc; x++) {
3249	row = rowOrder[x];
3250	assert(rowInfo[row].lNum);
3251	if (overlap) {
3252	if (rowInfo[row].lNum < min) {
3253	s1 = colInfo[rowInfo[row].gMin].pos;
3254	if (s1 < regionX)
3255	s1 = regionX;
3256	nOverlaps = 0;
3257	for (y = s1; y < startVar; y++) {
3258	col = colOrder[y];
3259	if (xy[row][col]) {
3260	nOverlaps++;
3261	break;
3262	}
3263	}
3264
3265	if (nOverlaps) {
3266	bestX = x;
3267	min = rowInfo[row].lNum;
3268	}
3269	}
3270	} else {
3271	s1 = colInfo[rowInfo[row].gMin].pos;
3272	if (s1 < regionX)
3273	s1 = regionX;
3274	nOverlaps = 0;
3275	for (y = s1; y < startVar; y++) {
3276	col = colOrder[y];
3277	if (xy[row][col]) {
3278	nOverlaps++;
3279	break;
3280	}
3281	}
3282
3283	if (nOverlaps) {
3284	bestX = x;
3285	min = rowInfo[row].lNum;
3286	overlap = 1;
3287	} else {
3288	if (rowInfo[row].lNum < min) {
3289	bestX = x;
3290	min = rowInfo[row].lNum;
3291	}
3292	}
3293	}
3294	}
3295
3296	assert(bestX != -1);
3297	if (!overlap)
3298	regionX = startFunc;
3299
3300	row = rowOrder[bestX];
3301	while (1) {
3302	bestRow = row;
3303	s1 = colInfo[rowInfo[row].lMin].pos;
3304	t1 = colInfo[rowInfo[row].lMax].pos;
3305	min = rowInfo[row].lNum;
3306	for (x = startFunc; x <= lastFunc; x++) {
3307	moveRow = rowOrder[x];
3308	if (moveRow == row)
3309	continue;
3310	s2 = colInfo[rowInfo[moveRow].lMin].pos;
3311	t2 = colInfo[rowInfo[moveRow].lMax].pos;
3312	if (s2 < s1 \|\| t2 > t1)
3313	continue;
3314	nMore = 0;
3315	nOverlaps = 0;
3316	for (y = s2; y <= t2; y++) {
3317	col = colOrder[y];
3318	if (xy[row][col]) {
3319	if (xy[moveRow][col])
3320	nOverlaps++;
3321	} else {
3322	if (xy[moveRow][col]) {
3323	nMore++;
3324	break;
3325	}
3326	}
3327	}
3328	if (nMore \|\| nOverlaps == 0 \|\| nOverlaps >= min)
3329	continue;
3330	min = nOverlaps;
3331	bestRow = moveRow;
3332	}
3333
3334	lastCol = -1;
3335	s1 = colInfo[rowInfo[bestRow].lMin].pos;
3336	t1 = colInfo[rowInfo[bestRow].lMax].pos;
3337	for (y = s1; y <= t1; y++) {
3338	col = colOrder[y];
3339	if (xy[bestRow][col]) {
3340	if (option->mlpVerbosity >= 3) {
3341	fprintf(vis_stdout, "[%d] Moving Col %d(%d) to %d (best row)\n",
3342	nMoves, y, col, startVar);
3343	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3344	startFunc, lastFunc, startVar, lastVar);
3345	}
3346	MoveColToLeft(xy, y, startFunc, lastFunc, startVar, lastVar,
3347	rowInfo, colInfo, rowOrder, colOrder,
3348	NIL(RcListInfo_t), option->mlpMethod);
3349	startVar++;
3350	lastCol = col;
3351
3352	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3353	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder, rowInfo, colInfo,
3354	startFunc, lastFunc, startVar, lastVar);
3355	}
3356	if (option->mlpDebug) {
3357	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo,
3358	rowOrder, colOrder,
3359	startFunc, lastFunc, startVar, lastVar, 1);
3360	}
3361	}
3362	}
3363
3364	if (lastCol != -1) {
3365	s2 = rowInfo[colInfo[lastCol].lMin].pos;
3366	t2 = rowInfo[colInfo[lastCol].lMax].pos;
3367	for (x = s2; x <= t2; x++) {
3368	moveRow = rowOrder[x];
3369	if (xy[moveRow][lastCol] && rowInfo[moveRow].lNum == 0) {
3370	if (option->mlpVerbosity >= 3) {
3371	fprintf(vis_stdout, "[%d] Moving row %d(%d) to %d (best row)\n",
3372	nMoves, x, moveRow, startFunc);
3373	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3374	startFunc, lastFunc, startVar, lastVar);
3375	}
3376	MoveRowToTop(xy, x, startFunc, lastFunc, startVar, lastVar,
3377	rowInfo, colInfo, rowOrder, colOrder,
3378	NIL(RcListInfo_t), option->mlpMethod);
3379	startFunc++;
3380	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3381	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder,
3382	rowInfo, colInfo,
3383	startFunc, lastFunc, startVar, lastVar);
3384	}
3385	if (option->mlpDebug) {
3386	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo,
3387	rowOrder, colOrder,
3388	startFunc, lastFunc, startVar, lastVar, 1);
3389	}
3390	}
3391	}
3392	}
3393
3394	if (row == bestRow)
3395	break;
3396	}
3397	}
3398	}
3399
3400
3401	/Function******************************************************************
3402
3403	Synopsis [Finds and moves the best column iteratively.]
3404
3405	Description [Finds and moves the best column iteratively.]
3406
3407	SideEffects []
3408
3409	******************************************************************************/
3410	static void
3411	MoveBestCols(char *xy, SccList_t sccList, int nRows, int nCols,
3412	int nActiveRows, int nActiveCols,
3413	int rowOrder, int colOrder,
3414	RcInfo_t rowInfo, RcInfo_t colInfo,
3415	int startFunc, int lastFunc, int startVar, int lastVar,
3416	ImgTrmOption_t *option)
3417	{
3418	int x, y, i, s1, t1, s2, t2;
3419	char rowFlag, colFlag;
3420	int min, bestY, bestCol;
3421	int row, col, tie, newTies, intersect = 0, maxIntersect, maxLength;
3422	int minX, maxX;
3423	RcListInfo_t sortedRows, sortedCols;
3424	RcList_t cur, list;
3425
3426	if (option->mlpSortedRows) {
3427	sortedRows = SortedListAlloc();
3428	for (x = startFunc; x <= lastFunc; x++) {
3429	row = rowOrder[x];
3430	SortedListInsert(sortedRows, row, row, rowInfo, 3);
3431	}
3432
3433	if (option->mlpSortedCols)
3434	sortedCols = SortedListAlloc();
3435	else
3436	sortedCols = NIL(RcListInfo_t);
3437
3438	if (option->mlpDebug)
3439	CheckSortedList(sortedRows, rowInfo, 3);
3440	} else {
3441	sortedRows = NIL(RcListInfo_t);
3442	sortedCols = NIL(RcListInfo_t);
3443	}
3444
3445	rowFlag = ALLOC(char, nRows);
3446	if (sortedCols)
3447	memset(rowFlag, 0, sizeof(char) * nRows);
3448	colFlag = ALLOC(char, nCols);
3449	while (startFunc != lastFunc && startVar != lastVar) {
3450	min = nActiveCols;
3451	if (!sortedCols)
3452	memset(rowFlag, 0, sizeof(char) * nRows);
3453	tie = 0;
3454	minX = lastFunc;
3455	maxX = startFunc;
3456	if (sortedCols) {
3457	bestY = nActiveCols;
3458	bestCol = nActiveCols;
3459	if (sortedCols->num == 0) {
3460	if (sortedRows) {
3461	cur = sortedRows->head;
3462	while (cur) {
3463	row = cur->index;
3464	x = rowInfo[row].pos;
3465	if (rowInfo[row].lNum == 0) {
3466	cur = cur->next;
3467	continue;
3468	}
3469	if (rowInfo[row].lNum > min)
3470	break;
3471	rowFlag[row] = 1;
3472	s1 = colInfo[rowInfo[row].lMin].pos;
3473	t1 = colInfo[rowInfo[row].lMax].pos;
3474	for (y = s1; y <= t1; y++) {
3475	col = colOrder[y];
3476	if (!xy[row][col])
3477	continue;
3478	if (st_lookup(sortedCols->table, (char *)(long)col, &list)) {
3479	list->otherIndex++;
3480	SortedListMove(sortedCols, colInfo, col, 4);
3481	} else
3482	SortedListInsert(sortedCols, col, 1, colInfo, 4);
3483	}
3484	min = rowInfo[row].lNum;
3485	tie++;
3486	cur = cur->next;
3487	}
3488	}
3489	} else {
3490	if (sortedRows) {
3491	cur = sortedRows->head;
3492	while (cur) {
3493	row = cur->index;
3494	x = rowInfo[row].pos;
3495	if (rowInfo[row].lNum == 0) {
3496	cur = cur->next;
3497	continue;
3498	}
3499	if (rowInfo[row].lNum > min)
3500	break;
3501	min = rowInfo[row].lNum;
3502	tie++;
3503	cur = cur->next;
3504	}
3505	}
3506	}
3507
3508	if (option->mlpDebug) {
3509	if (sortedRows)
3510	CheckSortedList(sortedRows, rowInfo, 3);
3511	CheckSortedList(sortedCols, colInfo, 4);
3512	}
3513
3514	bestCol = sortedCols->head->index;
3515	bestY = colInfo[bestCol].pos;
3516	assert(bestY >= startVar && bestY <= lastVar);
3517	maxLength = colInfo[bestCol].lNum;
3518	intersect = sortedCols->head->otherIndex;
3519	} else {
3520	if (sortedRows) {
3521	if (option->mlpDebug)
3522	CheckSortedList(sortedRows, rowInfo, 3);
3523
3524	cur = sortedRows->head;
3525	while (cur) {
3526	row = cur->index;
3527	x = rowInfo[row].pos;
3528	if (rowInfo[row].lNum == 0) {
3529	cur = cur->next;
3530	continue;
3531	}
3532	if (rowInfo[row].lNum < min) {
3533	min = rowInfo[row].lNum;
3534	tie = 1;
3535	memset(rowFlag, 0, sizeof(char) * nRows);
3536	rowFlag[x] = 1;
3537	minX = x;
3538	maxX = x;
3539	} else if (rowInfo[row].lNum == min) {
3540	tie++;
3541	rowFlag[x] = 1;
3542	if (x < minX)
3543	minX = x;
3544	if (x > maxX)
3545	maxX = x;
3546	} else
3547	break;
3548	cur = cur->next;
3549	}
3550	} else {
3551	for (x = startFunc; x <= lastFunc; x++) {
3552	row = rowOrder[x];
3553	if (rowInfo[row].lNum == 0)
3554	continue;
3555	if (rowInfo[row].lNum < min) {
3556	min = rowInfo[row].lNum;
3557	tie = 1;
3558	memset(rowFlag, 0, sizeof(char) * nRows);
3559	rowFlag[x] = 1;
3560	minX = x;
3561	maxX = x;
3562	} else if (rowInfo[row].lNum == min) {
3563	tie++;
3564	rowFlag[x] = 1;
3565	maxX = x;
3566	}
3567	}
3568	}
3569
3570	if (tie == 0)
3571	break;
3572
3573	maxLength = 0;
3574	maxIntersect = 0;
3575	memset(colFlag, 0, sizeof(char) * nCols);
3576	bestY = nActiveCols;
3577	bestCol = nActiveCols;
3578	for (x = minX; x <= maxX; x++) {
3579	if (!rowFlag[x])
3580	continue;
3581	row = rowOrder[x];
3582	s1 = colInfo[rowInfo[row].lMin].pos;
3583	t1 = colInfo[rowInfo[row].lMax].pos;
3584	for (y = s1; y <= t1; y++) {
3585	col = colOrder[y];
3586	if (xy[row][col]) {
3587	if (colFlag[y])
3588	continue;
3589	colFlag[y] = 1;
3590	intersect = 0;
3591	s2 = rowInfo[colInfo[col].lMin].pos;
3592	t2 = rowInfo[colInfo[col].lMax].pos;
3593	if (s2 < minX)
3594	s2 = minX;
3595	if (t2 > maxX)
3596	t2 = maxX;
3597	for (i = s2; i <= t2; i++) {
3598	if (xy[rowOrder[i]][col]) {
3599	if (rowFlag[i])
3600	intersect++;
3601	}
3602	}
3603	if (intersect > maxIntersect \|\|
3604	(intersect == maxIntersect && colInfo[col].lNum > maxLength) \|\|
3605	(intersect == maxIntersect && colInfo[col].lNum == maxLength &&
3606	y < bestY)) {
3607	bestY = y;
3608	bestCol = colOrder[bestY];
3609	maxLength = colInfo[bestCol].lNum;
3610	maxIntersect = intersect;
3611	}
3612	}
3613	}
3614	}
3615	}
3616
3617	if (option->mlpVerbosity >= 3) {
3618	fprintf(vis_stdout,
3619	"[%d] Moving Col %d(%d) to %d (best col, min=%d, intersect=%d, length=%d)\n",
3620	nMoves, bestY, bestCol, startVar, min, intersect, maxLength);
3621	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3622	startFunc, lastFunc, startVar, lastVar);
3623	}
3624	MoveColToLeft(xy, bestY, startFunc, lastFunc, startVar, lastVar,
3625	rowInfo, colInfo, rowOrder, colOrder,
3626	NIL(RcListInfo_t), option->mlpMethod);
3627	startVar++;
3628	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3629	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
3630	rowInfo, colInfo, startFunc, lastFunc, startVar, lastVar);
3631	}
3632	if (option->mlpDebug) {
3633	CheckMatrix(xy, sccList, nActiveRows, nActiveCols, rowInfo, colInfo,
3634	rowOrder, colOrder,
3635	startFunc, lastFunc, startVar, lastVar, 1);
3636	}
3637
3638	if (sortedCols)
3639	SortedListDelete(sortedCols, bestCol);
3640
3641	if (sortedRows) {
3642	if (min == 1) {
3643	cur = sortedRows->head;
3644	while (cur) {
3645	row = cur->index;
3646	if (rowInfo[row].lNum > min)
3647	break;
3648	else if (rowInfo[row].lNum == min) {
3649	cur = cur->next;
3650	continue;
3651	}
3652	x = rowInfo[row].pos;
3653	if (option->mlpVerbosity >= 3) {
3654	fprintf(vis_stdout, "[%d] Moving row %d(%d) to %d (empty row)\n",
3655	nMoves, x, row, startFunc);
3656	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3657	startFunc, lastFunc, startVar, lastVar);
3658	}
3659	MoveRowToTop(xy, x, startFunc, lastFunc, startVar, lastVar,
3660	rowInfo, colInfo, rowOrder, colOrder,
3661	NIL(RcListInfo_t), option->mlpMethod);
3662	startFunc++;
3663	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3664	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
3665	rowInfo, colInfo,
3666	startFunc, lastFunc, startVar, lastVar);
3667	}
3668	if (option->mlpDebug) {
3669	CheckMatrix(xy, sccList, nActiveRows, nActiveCols,
3670	rowInfo, colInfo, rowOrder, colOrder,
3671	startFunc, lastFunc, startVar, lastVar, 1);
3672	}
3673	cur = cur->next;
3674	SortedListDelete(sortedRows, row);
3675	}
3676	}
3677
3678	/* Update sortedRows */
3679	/*
3680	cur = sortedRows->head;
3681	while (cur) {
3682	row = cur->index;
3683	if (xy[row][bestCol]) {
3684	assert(rowInfo[row].lNum > 0);
3685	SortedListMove(sortedRows, rowInfo, row, 3);
3686	}
3687	cur = cur->next;
3688	}
3689	if (option->mlpDebug)
3690	CheckSortedList(sortedRows, rowInfo, 3);
3691	*/
3692	s1 = rowInfo[colInfo[bestCol].lMin].pos;
3693	t1 = rowInfo[colInfo[bestCol].lMax].pos;
3694	cur = sortedRows->head;
3695	while (cur) {
3696	row = cur->index;
3697	x = rowInfo[row].pos;
3698	if (x < s1) {
3699	cur = cur->next;
3700	continue;
3701	}
3702	if (xy[row][bestCol] && rowInfo[row].lNum > 0) {
3703	SortedListMove(sortedRows, rowInfo, row, 3);
3704	if (sortedCols && min == 1) {
3705	if (rowInfo[row].lNum == 1 && rowFlag[row] == 0) {
3706	rowFlag[row] = 1;
3707	s2 = colInfo[rowInfo[row].lMin].pos;
3708	t2 = colInfo[rowInfo[row].lMax].pos;
3709	for (y = s2; y <= t2; y++) {
3710	col = colOrder[y];
3711	if (!xy[row][col])
3712	continue;
3713	if (st_lookup(sortedCols->table, (char *)(long)col, &list)) {
3714	list->otherIndex++;
3715	SortedListMove(sortedCols, colInfo, col, 4);
3716	} else
3717	SortedListInsert(sortedCols, col, 1, colInfo, 4);
3718	}
3719	}
3720	}
3721	}
3722	cur = cur->next;
3723	}
3724
3725	newTies = 0;
3726	if (sortedCols && min > 1) {
3727	min = nActiveCols;
3728	cur = sortedRows->head;
3729	while (cur) {
3730	row = cur->index;
3731	x = rowInfo[row].pos;
3732	if (rowInfo[row].lNum == 0) {
3733	cur = cur->next;
3734	continue;
3735	}
3736	if (rowInfo[row].lNum > min)
3737	break;
3738	min = rowInfo[row].lNum;
3739	newTies++;
3740	cur = cur->next;
3741	}
3742
3743	if (newTies != tie) {
3744	SortedListFree(sortedCols);
3745	sortedCols = SortedListAlloc();
3746
3747	cur = sortedRows->head;
3748	while (cur) {
3749	row = cur->index;
3750	x = rowInfo[row].pos;
3751	if (rowInfo[row].lNum == 0) {
3752	cur = cur->next;
3753	continue;
3754	}
3755	if (rowInfo[row].lNum > min)
3756	break;
3757	rowFlag[row] = 1;
3758	s1 = colInfo[rowInfo[row].lMin].pos;
3759	t1 = colInfo[rowInfo[row].lMax].pos;
3760	for (y = s1; y <= t1; y++) {
3761	col = colOrder[y];
3762	if (!xy[row][col])
3763	continue;
3764	if (st_lookup(sortedCols->table, (char *)(long)col, &list)) {
3765	list->otherIndex++;
3766	SortedListMove(sortedCols, colInfo, col, 4);
3767	} else
3768	SortedListInsert(sortedCols, col, 1, colInfo, 4);
3769	}
3770	cur = cur->next;
3771	}
3772	}
3773	}
3774	} else {
3775	if (min == 1) {
3776	s1 = rowInfo[colInfo[bestCol].lMin].pos;
3777	t1 = rowInfo[colInfo[bestCol].lMax].pos;
3778	for (x = s1; x <= t1; x++) {
3779	row = rowOrder[x];
3780	if (xy[row][bestCol] && rowInfo[row].lNum == 0) {
3781	if (option->mlpVerbosity >= 3) {
3782	fprintf(vis_stdout, "[%d] Moving row %d(%d) to %d (empty row)\n",
3783	nMoves, x, row, startFunc);
3784	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3785	startFunc, lastFunc, startVar, lastVar);
3786	}
3787	MoveRowToTop(xy, x, startFunc, lastFunc, startVar, lastVar,
3788	rowInfo, colInfo, rowOrder, colOrder,
3789	NIL(RcListInfo_t), option->mlpMethod);
3790	startFunc++;
3791	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3792	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
3793	rowInfo, colInfo,
3794	startFunc, lastFunc, startVar, lastVar);
3795	}
3796	if (option->mlpDebug) {
3797	CheckMatrix(xy, sccList, nActiveRows, nActiveCols,
3798	rowInfo, colInfo, rowOrder, colOrder,
3799	startFunc, lastFunc, startVar, lastVar, 1);
3800	}
3801	}
3802	}
3803	}
3804	}
3805	}
3806
3807	if (sortedRows) {
3808	cur = sortedRows->head;
3809	while (cur) {
3810	row = cur->index;
3811	x = rowInfo[row].pos;
3812	if (option->mlpVerbosity >= 3) {
3813	fprintf(vis_stdout, "[%d] Moving row %d(%d) to %d (bandwidth)\n",
3814	nMoves, x, row, startFunc);
3815	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
3816	startFunc, lastFunc, startVar, lastVar);
3817	}
3818	MoveRowToTop(xy, x, startFunc, lastFunc, startVar, lastVar,
3819	rowInfo, colInfo, rowOrder, colOrder,
3820	NIL(RcListInfo_t), option->mlpMethod);
3821	startFunc++;
3822	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3823	PrintMatrix(xy, nActiveRows, nActiveCols, rowOrder, colOrder,
3824	rowInfo, colInfo,
3825	startFunc, lastFunc, startVar, lastVar);
3826	}
3827	if (option->mlpDebug) {
3828	CheckMatrix(xy, sccList, nActiveRows, nActiveCols, rowInfo, colInfo,
3829	rowOrder, colOrder,
3830	startFunc, lastFunc, startVar, lastVar, 1);
3831	}
3832	cur = cur->next;
3833	SortedListDelete(sortedRows, row);
3834	}
3835	SortedListFree(sortedRows);
3836	}
3837
3838	if (sortedCols) {
3839	cur = sortedCols->head;
3840	while (cur) {
3841	col = cur->index;
3842	cur = cur->next;
3843	SortedListDelete(sortedCols, col);
3844	}
3845	SortedListFree(sortedCols);
3846	}
3847
3848	FREE(rowFlag);
3849	FREE(colFlag);
3850	}
3851
3852
3853	/Function******************************************************************
3854
3855	Synopsis [Performs a postprocessing after MLP.]
3856
3857	Description [Performs a postprocessing after MLP. Tries to exchange adjacent
3858	two rows if the exchange lowers variable lifetime.]
3859
3860	SideEffects []
3861
3862	******************************************************************************/
3863	static void
3864	MlpPostProcess(char *xy, SccList_t sccList, int nVars, int nRows, int nCols,
3865	RcInfo_t rowInfo, RcInfo_t colInfo,
3866	int rowOrder, int colOrder,
3867	Img_DirectionType direction, ImgTrmOption_t *option)
3868	{
3869	int x, y, i, j, r, c, row, col, otherRow, otherCol, tmpRow, tmpCol;
3870	int nqv1, nqv2, niv1, niv2, benefit1, benefit2;
3871	int s1, t1, s2, t2, s3, t3, s4, t4;
3872	long initialTime, finalTime;
3873	int nSwaps;
3874	float lambda1, lambda2, lambda3;
3875	int startFunc, lastFunc;
3876
3877	if (sccList) {
3878	startFunc = sccList->startFunc;
3879	lastFunc = sccList->lastFunc;
3880	} else {
3881	startFunc = 0;
3882	lastFunc = nRows - 1;
3883	}
3884
3885	if (option->mlpVerbosity)
3886	initialTime = util_cpu_time();
3887	else
3888	initialTime = 0;
3889
3890	nSwaps = 0;
3891	for (x = lastFunc - 1; x >= startFunc; x--) {
3892	row = rowOrder[x];
3893	if (rowInfo[row].data.row.nsVarBddArray)
3894	niv1 = array_n(rowInfo[row].data.row.nsVarBddArray);
3895	else
3896	niv1 = 0;
3897
3898	col = rowInfo[row].gMin;
3899	if (rowInfo[row].gNum == 1 &&
3900	colInfo[col].gNum > 1 && colInfo[col].gMin == x) {
3901	t1 = rowInfo[colInfo[col].gMax].pos;
3902	for (i = x + 1; i <= t1; i++) {
3903	otherRow = rowOrder[i];
3904	if (xy[otherRow][col]) {
3905	if (x < i - 1) {
3906	for (j = x; j < i - 1; j++) {
3907	rowOrder[j] = rowOrder[j + 1];
3908	rowInfo[rowOrder[j]].pos = j;
3909	}
3910	rowOrder[i - 1] = row;
3911	rowInfo[row].pos = i - 1;
3912
3913	if (rowInfo[otherRow].gNum == 1)
3914	break;
3915
3916	s2 = colInfo[rowInfo[otherRow].gMin].pos;
3917	t2 = colInfo[rowInfo[otherRow].gMax].pos;
3918	for (j = t2; j >= s2; j--) {
3919	otherCol = colOrder[j];
3920	if (colInfo[otherCol].gMin == otherRow)
3921	t2 = j - 1;
3922	else
3923	break;
3924	}
3925
3926	s3 = rowInfo[colInfo[col].gMin].pos;
3927	t3 = rowInfo[colInfo[col].gMax].pos;
3928	for (r = s3; r <= t3; r++) {
3929	tmpRow = rowOrder[r];
3930	if (col == rowInfo[tmpRow].gMin) {
3931	s4 = colInfo[rowInfo[tmpRow].gMin].pos;
3932	t4 = colInfo[rowInfo[tmpRow].gMax].pos;
3933	if (t4 > t2)
3934	t4 = t2;
3935	for (c = s4 + 1; c <= t4; c++) {
3936	tmpCol = colOrder[c];
3937	if (xy[tmpRow][tmpCol]) {
3938	rowInfo[tmpRow].gMin = tmpCol;
3939	rowInfo[tmpRow].lMin = tmpCol;
3940	break;
3941	}
3942	}
3943	}
3944
3945	if (xy[tmpRow][col] && t2 >= colInfo[rowInfo[tmpRow].gMax].pos) {
3946	rowInfo[tmpRow].gMax = col;
3947	rowInfo[tmpRow].lMax = col;
3948	}
3949	}
3950
3951	y = colInfo[col].pos;
3952	if (y < t2) {
3953	for (j = y; j < t2; j++) {
3954	colOrder[j] = colOrder[j + 1];
3955	colInfo[colOrder[j]].pos = j;
3956	}
3957	colOrder[t2] = col;
3958	colInfo[col].pos = t2;
3959	}
3960
3961	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
3962	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder,
3963	rowInfo, colInfo, 0, nRows - 1, 0, nCols - 1);
3964	}
3965	if (option->mlpDebug) {
3966	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo,
3967	rowOrder, colOrder, 0, nRows - 1, 0, nCols - 1, 1);
3968	}
3969
3970	nSwaps++;
3971	}
3972	break;
3973	}
3974	}
3975	continue;
3976	}
3977
3978	for (i = x + 1; i <= lastFunc; i++) {
3979	otherRow = rowOrder[i];
3980	if (rowInfo[otherRow].data.row.nsVarBddArray)
3981	niv2 = array_n(rowInfo[otherRow].data.row.nsVarBddArray);
3982	else
3983	niv2 = 0;
3984
3985	nqv1 = 0;
3986	s1 = colInfo[rowInfo[row].gMin].pos;
3987	t1 = colInfo[rowInfo[row].gMax].pos;
3988	for (y = t1; y >= s1; y--) {
3989	col = colOrder[y];
3990	if (colInfo[col].gMin == row) {
3991	if (!xy[otherRow][col])
3992	nqv1++;
3993	} else
3994	break;
3995	}
3996	benefit1 = nqv1 - niv1;
3997
3998	nqv2 = 0;
3999	s2 = colInfo[rowInfo[otherRow].gMin].pos;
4000	t2 = colInfo[rowInfo[otherRow].gMax].pos;
4001	for (y = t2; y >= s2; y--) {
4002	col = colOrder[y];
4003	if (colInfo[col].gMin == otherRow)
4004	nqv2++;
4005	else
4006	break;
4007	}
4008	benefit2 = nqv2 - niv2;
4009
4010	if (benefit1 > benefit2 \|\|
4011	(benefit1 == benefit2 &&
4012	(rowInfo[row].gNum > rowInfo[otherRow].gNum \|\|
4013	(rowInfo[row].gNum == rowInfo[otherRow].gNum &&
4014	bdd_size(rowInfo[row].data.row.func) <
4015	bdd_size(rowInfo[otherRow].data.row.func))))) {
4016	nqv1 = 0;
4017	for (y = t1; y >= s1; y--) {
4018	if (t1 > t2)
4019	break;
4020	col = colOrder[y];
4021	if (colInfo[col].gMin == row) {
4022	if (!xy[otherRow][col]) {
4023	s3 = rowInfo[colInfo[col].gMin].pos;
4024	t3 = rowInfo[colInfo[col].gMax].pos;
4025	for (r = s3; r <= t3; r++) {
4026	tmpRow = rowOrder[r];
4027	if (col == rowInfo[tmpRow].gMin) {
4028	s4 = colInfo[rowInfo[tmpRow].gMin].pos;
4029	t4 = colInfo[rowInfo[tmpRow].gMax].pos;
4030	if (t4 > t2 - nqv1)
4031	t4 = t2 - nqv1;
4032	for (c = s4 + 1; c <= t4; c++) {
4033	tmpCol = colOrder[c];
4034	if (xy[tmpRow][tmpCol] && colInfo[tmpCol].gMin != row) {
4035	rowInfo[tmpRow].gMin = tmpCol;
4036	rowInfo[tmpRow].lMin = tmpCol;
4037	break;
4038	}
4039	}
4040	}
4041
4042	if (nqv1 == 0 && xy[tmpRow][col] &&
4043	t2 - nqv1 >= colInfo[rowInfo[tmpRow].gMax].pos) {
4044	rowInfo[tmpRow].gMax = col;
4045	rowInfo[tmpRow].lMax = col;
4046	}
4047	}
4048
4049	for (j = y; j < t2 - nqv1; j++) {
4050	colOrder[j] = colOrder[j + 1];
4051	colInfo[colOrder[j]].pos = j;
4052	}
4053	colOrder[t2 - nqv1] = col;
4054	colInfo[col].pos = t2 - nqv1;
4055	nqv1++;
4056	} else {
4057	colInfo[col].gMin = otherRow;
4058	colInfo[col].lMin = otherRow;
4059	if (colInfo[col].gMax == otherRow) {
4060	colInfo[col].gMax = row;
4061	colInfo[col].lMax = row;
4062	}
4063	}
4064	} else {
4065	if (colInfo[col].gMax == otherRow && xy[row][col]) {
4066	colInfo[col].gMax = row;
4067	colInfo[col].lMax = row;
4068	}
4069	}
4070	}
4071
4072	rowOrder[i - 1] = otherRow;
4073	rowInfo[otherRow].pos = i - 1;
4074	rowOrder[i] = row;
4075	rowInfo[row].pos = i;
4076	nSwaps++;
4077
4078	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
4079	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder,
4080	rowInfo, colInfo, 0, nRows - 1, 0, nCols - 1);
4081	}
4082	if (option->mlpDebug) {
4083	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo,
4084	rowOrder, colOrder, 0, nRows - 1, 0, nCols - 1, 1);
4085	}
4086	} else
4087	break;
4088	}
4089	}
4090
4091	if (option->mlpVerbosity) {
4092	if (option->mlpVerbosity >= 2) {
4093	lambda1 = ComputeLambdaMlp(xy, nVars, nRows, nCols, rowInfo, colInfo,
4094	rowOrder, colOrder, direction, 0, 0, option);
4095	lambda2 = ComputeLambdaMlp(xy, nVars, nRows, nCols, rowInfo, colInfo,
4096	rowOrder, colOrder, direction, 1, 0, option);
4097	lambda3 = ComputeLambdaMlp(xy, nVars, nRows, nCols, rowInfo, colInfo,
4098	rowOrder, colOrder, direction, 2, 0, option);
4099	fprintf(vis_stdout, "Optimized Lambda = %f (%f, %f)\n",
4100	lambda1, lambda2, lambda3);
4101	}
4102	finalTime = util_cpu_time();
4103	fprintf(vis_stdout, "time for postprocessing = %10g (#swap=%d)\n",
4104	(double)(finalTime - initialTime) / 1000.0, nSwaps);
4105	}
4106	}
4107
4108
4109	/Function******************************************************************
4110
4111	Synopsis [Compute variable lifetime lambda.]
4112
4113	Description [Compute variable lifetime lambda.]
4114
4115	SideEffects []
4116
4117	******************************************************************************/
4118	static float
4119	ComputeLambdaMlp(char **xy, int nVars, int nRows, int nCols,
4120	RcInfo_t rowInfo, RcInfo_t colInfo,
4121	int rowOrder, int colOrder,
4122	Img_DirectionType direction,
4123	int mode, int asIs, ImgTrmOption_t *option)
4124	{
4125	int lifetime, area;
4126	int highest, lowest;
4127	int x, y, row, col;
4128	int nIntroducedVars, nYVars;
4129	float lambda;
4130
4131	lifetime = 0;
4132
4133	if (direction == Img_Forward_c) {
4134	for (y = 0; y < nCols; y++) {
4135	col = colOrder[y];
4136	lowest = rowInfo[colInfo[col].gMin].pos;
4137	if (mode == 1) { /* active lifetime (alpha) */
4138	highest = rowInfo[colInfo[col].gMax].pos;
4139	lifetime += highest - lowest + 1;
4140	} else { /* total lifetime (lambda) */
4141	lifetime += nRows - lowest;
4142	}
4143	}
4144	} else {
4145	for (y = 0; y < nCols; y++) {
4146	col = colOrder[y];
4147	lowest = rowInfo[colInfo[col].gMin].pos;
4148	if (mode == 1) { /* active lifetime (alpha) */
4149	highest = rowInfo[colInfo[col].gMax].pos;
4150	lifetime += highest - lowest + 1;
4151	} else { /* total lifetime (lambda) */
4152	if (colInfo[col].data.col.type == 2) /* primary input variables */
4153	lifetime += lowest + 1;
4154	else { /* present state variables */
4155	if (mode == 2)
4156	lifetime += nRows - lowest;
4157	}
4158	}
4159	}
4160	}
4161
4162	/* total lifetime (lambda) with introducedVars */
4163	nIntroducedVars = 0;;
4164	if (mode == 2 \|\| (mode == 0 && direction == Img_Backward_c)) {
4165	if (asIs) { /* contains next state variables */
4166	for (x = 0; x < nRows; x++) {
4167	row = rowOrder[x];
4168	nYVars = array_n(rowInfo[row].data.row.nsVarBddArray);
4169	nIntroducedVars += nYVars;
4170	lifetime += (x + 1) * nYVars;
4171	}
4172	} else { /* does not contain next state variables */
4173	nIntroducedVars = nRows;
4174	lifetime += nIntroducedVars * (nIntroducedVars + 1) / 2;
4175	}
4176	}
4177
4178	if (option->mlpLambdaMode == 0)
4179	area = nRows * (nCols + nIntroducedVars);
4180	else
4181	area = nRows * (nVars + nIntroducedVars);
4182	lambda = (float)lifetime / (float)area;
4183	return(lambda);
4184	}
4185
4186
4187	/Function******************************************************************
4188
4189	Synopsis [Finds and moves singleton rows.]
4190
4191	Description [Finds and moves singleton rows.]
4192
4193	SideEffects []
4194
4195	******************************************************************************/
4196	static void
4197	FindAndMoveSingletonRows(char *xy, SccList_t sccList, int nRows, int nCols,
4198	int startFunc, int lastFunc, int startVar, int lastVar,
4199	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder,
4200	ImgTrmOption_t *option)
4201	{
4202	int x, row, col, add, found;
4203	RcListInfo_t *candList;
4204
4205	if (option->mlpMethod == 0) {
4206	while (startFunc != lastFunc && startVar != lastVar) {
4207	found = 0;
4208	for (x = startFunc; x <= lastFunc; x++) {
4209	row = rowOrder[x];
4210	if (rowInfo[row].lNum == 1) {
4211	found = 1;
4212	add = MoveSingletonRow(xy, sccList, nRows, nCols, x,
4213	startFunc, lastFunc, startVar, lastVar,
4214	rowInfo, colInfo, rowOrder, colOrder,
4215	NIL(RcListInfo_t), option);
4216	if (startFunc == lastFunc \|\| startVar == lastVar) {
4217	found = 0;
4218	break;
4219	}
4220	x += add;
4221	}
4222	}
4223	if (!found)
4224	break;
4225	}
4226	} else {
4227	if (startFunc != lastFunc && startVar != lastVar) {
4228	candList = SortedListAlloc();
4229	for (x = startFunc; x <= lastFunc; x++) {
4230	row = rowOrder[x];
4231	if (rowInfo[row].lNum == 1) {
4232	col = rowInfo[row].lMin;
4233	SortedListInsert(candList, row, col, colInfo, option->mlpMethod);
4234	}
4235	}
4236	if (option->mlpDebug)
4237	CheckSortedList(candList, colInfo, option->mlpMethod);
4238	while (candList->cur) {
4239	candList->curIndex = candList->cur->index;
4240	x = rowInfo[candList->curIndex].pos;
4241	MoveSingletonRow(xy, sccList, nRows, nCols, x,
4242	startFunc, lastFunc, startVar, lastVar,
4243	rowInfo, colInfo, rowOrder, colOrder,
4244	candList, option);
4245	if (option->mlpDebug)
4246	CheckSortedList(candList, colInfo, option->mlpMethod);
4247	if (startFunc == lastFunc \|\| startVar == lastVar) {
4248	break;
4249	}
4250	}
4251	if (option->mlpVerbosity) {
4252	fprintf(vis_stdout, "max number of elements in list = %d\n",
4253	candList->maxNum);
4254	}
4255	SortedListFree(candList);
4256	}
4257	}
4258	}
4259
4260
4261	/Function******************************************************************
4262
4263	Synopsis [Moves a singleton row.]
4264
4265	Description [Moves a singleton row.]
4266
4267	SideEffects []
4268
4269	******************************************************************************/
4270	static int
4271	MoveSingletonRow(char *xy, SccList_t sccList, int nRows, int nCols, int x,
4272	int startFunc, int lastFunc, int startVar, int lastVar,
4273	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder,
4274	RcListInfo_t candList, ImgTrmOption_t option)
4275	{
4276	int y, i, add;
4277	int row, col, otherRow;
4278	int startRow, lastRow, startCol, lastCol;
4279
4280	startRow = *startFunc;
4281	startCol = *startVar;
4282	lastRow = *lastFunc;
4283	lastCol = *lastVar;
4284
4285	row = rowOrder[x];
4286	col = rowInfo[row].lMin;
4287	y = colInfo[col].pos;
4288
4289	if (option->mlpVerbosity >= 3) {
4290	fprintf(vis_stdout, "[%d] Moving Col %d(%d) to %d (row singleton)\n",
4291	nMoves, y, col, startCol);
4292	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
4293	startRow, lastRow, startCol, lastCol);
4294	}
4295	MoveColToLeft(xy, y, startRow, lastRow, startCol, lastCol,
4296	rowInfo, colInfo, rowOrder, colOrder, candList,
4297	option->mlpMethod);
4298	startCol++;
4299	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
4300	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder, rowInfo, colInfo,
4301	startRow, lastRow, startCol, lastCol);
4302	}
4303	if (option->mlpDebug) {
4304	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo, rowOrder, colOrder,
4305	startRow, lastRow, startCol, lastCol, 1);
4306	}
4307
4308	add = 0;
4309	for (i = rowInfo[colInfo[col].lMin].pos;
4310	colInfo[col].lNum && i <= rowInfo[colInfo[col].lMax].pos; i++) {
4311	otherRow = rowOrder[i];
4312	if (!xy[otherRow][col])
4313	continue;
4314	if (rowInfo[otherRow].lNum == 0) {
4315	if (option->mlpVerbosity >= 3) {
4316	fprintf(vis_stdout, "[%d] Moving row %d(%d) to %d (row singleton)\n",
4317	nMoves, i, otherRow, startRow);
4318	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
4319	startRow, lastRow, startCol, lastCol);
4320	}
4321	MoveRowToTop(xy, i, startRow, lastRow, startCol, lastCol,
4322	rowInfo, colInfo, rowOrder, colOrder,
4323	NIL(RcListInfo_t), option->mlpMethod);
4324	startRow++;
4325	if (i > x)
4326	add++;
4327	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
4328	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder, rowInfo, colInfo,
4329	startRow, lastRow, startCol, lastCol);
4330	}
4331	if (option->mlpDebug) {
4332	CheckMatrix(xy, sccList, nRows, nCols,
4333	rowInfo, colInfo, rowOrder, colOrder,
4334	startRow, lastRow, startCol, lastCol, 1);
4335	}
4336	}
4337	}
4338
4339	*startFunc = startRow;
4340	*startVar = startCol;
4341	return(add);
4342	}
4343
4344
4345	/Function******************************************************************
4346
4347	Synopsis [Finds and moves singleton columns.]
4348
4349	Description [Finds and moves singleton columns.]
4350
4351	SideEffects []
4352
4353	******************************************************************************/
4354	static void
4355	FindAndMoveSingletonCols(char *xy, SccList_t sccList, int nRows, int nCols,
4356	int startFunc, int lastFunc, int startVar, int lastVar,
4357	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder,
4358	ImgTrmOption_t *option)
4359	{
4360	int y, row, col, add, found;
4361	RcListInfo_t *candList;
4362
4363	if (option->mlpMethod == 0) {
4364	while (startFunc != lastFunc && startVar != lastVar) {
4365	found = 0;
4366	for (y = startVar; y <= lastVar; y++) {
4367	col = colOrder[y];
4368	if (colInfo[col].lNum == 1) {
4369	found = 1;
4370	add = MoveSingletonCol(xy, sccList, nRows, nCols, y,
4371	startFunc, lastFunc, startVar, lastVar,
4372	rowInfo, colInfo, rowOrder, colOrder,
4373	NIL(RcListInfo_t), option);
4374	if (startFunc == lastFunc \|\| startVar == lastVar) {
4375	found = 0;
4376	break;
4377	}
4378	y -= add;
4379	}
4380	}
4381	if (!found)
4382	break;
4383	}
4384	} else {
4385	if (startFunc != lastFunc && startVar != lastVar) {
4386	candList = SortedListAlloc();
4387	for (y = startVar; y <= lastVar; y++) {
4388	col = colOrder[y];
4389	if (colInfo[col].lNum == 1) {
4390	row = colInfo[col].lMin;
4391	SortedListInsert(candList, col, row, rowInfo, option->mlpMethod);
4392	}
4393	}
4394	if (option->mlpDebug)
4395	CheckSortedList(candList, rowInfo, option->mlpMethod);
4396	while (candList->cur) {
4397	candList->curIndex = candList->cur->index;
4398	y = colInfo[candList->curIndex].pos;
4399	MoveSingletonCol(xy, sccList, nRows, nCols, y,
4400	startFunc, lastFunc, startVar, lastVar,
4401	rowInfo, colInfo, rowOrder, colOrder, candList, option);
4402	if (option->mlpDebug)
4403	CheckSortedList(candList, rowInfo, option->mlpMethod);
4404	if (startFunc == lastFunc \|\| startVar == lastVar) {
4405	break;
4406	}
4407	}
4408	if (option->mlpVerbosity >= 2) {
4409	fprintf(vis_stdout, "max number of elements in list = %d\n",
4410	candList->maxNum);
4411	}
4412	SortedListFree(candList);
4413	}
4414	}
4415	}
4416
4417
4418	/Function******************************************************************
4419
4420	Synopsis [Moves a singleton column.]
4421
4422	Description [Moves a singleton column.]
4423
4424	SideEffects []
4425
4426	******************************************************************************/
4427	static int
4428	MoveSingletonCol(char *xy, SccList_t sccList, int nRows, int nCols, int y,
4429	int startFunc, int lastFunc, int startVar, int lastVar,
4430	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder,
4431	RcListInfo_t candList, ImgTrmOption_t option)
4432	{
4433	int x, j, add;
4434	int row, col, otherCol;
4435	int startRow, lastRow, startCol, lastCol;
4436
4437	startRow = *startFunc;
4438	startCol = *startVar;
4439	lastRow = *lastFunc;
4440	lastCol = *lastVar;
4441
4442	col = colOrder[y];
4443	row = colInfo[col].lMin;
4444	x = rowInfo[row].pos;
4445
4446	if (option->mlpVerbosity >= 3) {
4447	fprintf(vis_stdout, "[%d] Moving Row %d(%d) to %d (col singleton)\n",
4448	nMoves, x, row, lastRow);
4449	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
4450	startRow, lastRow, startCol, lastCol);
4451	}
4452	MoveRowToBottom(xy, x, startRow, lastRow, startCol, lastCol,
4453	rowInfo, colInfo, rowOrder, colOrder, candList,
4454	option->mlpMethod);
4455	lastRow--;
4456	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
4457	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder, rowInfo, colInfo,
4458	startRow, lastRow, startCol, lastCol);
4459	}
4460	if (option->mlpDebug) {
4461	CheckMatrix(xy, sccList, nRows, nCols, rowInfo, colInfo, rowOrder, colOrder,
4462	startRow, lastRow, startCol, lastCol, 1);
4463	}
4464
4465	add = 0;
4466	for (j = colInfo[rowInfo[row].lMin].pos;
4467	rowInfo[row].lNum && j <= colInfo[rowInfo[row].lMax].pos; j++) {
4468	otherCol = colOrder[j];
4469	if (!xy[row][otherCol])
4470	continue;
4471	if (colInfo[otherCol].lNum == 0) {
4472	if (option->mlpVerbosity >= 3) {
4473	fprintf(vis_stdout, "[%d] Moving Col %d(%d) to %d (col singleton)\n",
4474	nMoves, j, otherCol, lastCol);
4475	fprintf(vis_stdout, "active window [%d-%d, %d-%d]\n",
4476	startRow, lastRow, startCol, lastCol);
4477	}
4478	MoveColToRight(xy, j, startRow, lastRow, startCol, lastCol,
4479	rowInfo, colInfo, rowOrder, colOrder,
4480	NIL(RcListInfo_t), option->mlpMethod);
4481	lastCol--;
4482	j--;
4483	if (otherCol <= col)
4484	add++;
4485	if (option->mlpVerbosity >= 4 && option->mlpPrintMatrix) {
4486	PrintMatrix(xy, nRows, nCols, rowOrder, colOrder, rowInfo, colInfo,
4487	startRow, lastRow, startCol, lastCol);
4488	}
4489	if (option->mlpDebug) {
4490	CheckMatrix(xy, sccList, nRows, nCols,
4491	rowInfo, colInfo, rowOrder, colOrder,
4492	startRow, lastRow, startCol, lastCol, 1);
4493	}
4494	}
4495	}
4496
4497	*lastFunc = lastRow;
4498	*lastVar = lastCol;
4499	return(add);
4500	}
4501
4502
4503	/Function******************************************************************
4504
4505	Synopsis [Moves a row to the top of the active region.]
4506
4507	Description [Moves a row to the top of the active region.]
4508
4509	SideEffects []
4510
4511	******************************************************************************/
4512	static void
4513	MoveRowToTop(char **xy, int x, int startFunc, int lastFunc,
4514	int startVar, int lastVar, RcInfo_t *rowInfo,
4515	RcInfo_t colInfo, int rowOrder, int *colOrder,
4516	RcListInfo_t *candList, int method)
4517	{
4518	int i, j, s, t;
4519	int row, col, tmpRow;
4520
4521	assert(x >= startFunc && x <= lastFunc);
4522
4523	row = rowOrder[x];
4524	if (x != startFunc) {
4525	/* Change row order */
4526	for (i = x; i > startFunc; i--) {
4527	rowOrder[i] = rowOrder[i - 1];
4528	rowInfo[rowOrder[i]].pos = i;
4529	}
4530	rowOrder[startFunc] = row;
4531	rowInfo[row].pos = startFunc;
4532	}
4533
4534	s = colInfo[rowInfo[row].gMin].pos;
4535	t = colInfo[rowInfo[row].gMax].pos;
4536	for (j = s; j <= t; j++) {
4537	col = colOrder[j];
4538	if (!xy[row][col])
4539	continue;
4540	colInfo[col].prevG = startFunc;
4541	if (colInfo[col].lNum == 1) {
4542	colInfo[col].lMin = row;
4543	colInfo[col].lMax = row;
4544	} else {
4545	if (row == colInfo[col].lMin) {
4546	for (i = x + 1; i <= rowInfo[colInfo[col].lMax].pos; i++) {
4547	tmpRow = rowOrder[i];
4548	if (xy[tmpRow][col]) {
4549	colInfo[col].lMin = tmpRow;
4550	break;
4551	}
4552	}
4553	} else if (row == colInfo[col].lMax) {
4554	for (i = x; i >= rowInfo[colInfo[col].lMin].pos; i--) {
4555	tmpRow = rowOrder[i];
4556	if (xy[tmpRow][col]) {
4557	colInfo[col].lMax = tmpRow;
4558	break;
4559	}
4560	}
4561	}
4562	}
4563
4564	if (colInfo[col].gNum == 1) {
4565	colInfo[col].gMin = row;
4566	colInfo[col].gMax = row;
4567	} else {
4568	if (row == colInfo[col].gMin)
4569	colInfo[col].gMin = row;
4570	else if (row == colInfo[col].gMax) {
4571	colInfo[col].gMax = colInfo[col].lMax;
4572	if (startFunc <= rowInfo[colInfo[col].gMin].pos)
4573	colInfo[col].gMin = row;
4574	} else if (startFunc <= rowInfo[colInfo[col].gMin].pos)
4575	colInfo[col].gMin = row;
4576	}
4577
4578	if (rowInfo[row].lNum) {
4579	if (j == rowInfo[row].prevG)
4580	j = colInfo[rowInfo[row].lMin].pos - 1;
4581	else if (j == colInfo[rowInfo[row].lMax].pos)
4582	j = rowInfo[row].nextG - 1;
4583	}
4584	}
4585
4586	s = colInfo[rowInfo[row].lMin].pos;
4587	t = colInfo[rowInfo[row].lMax].pos;
4588	for (j = s; j <= t; j++) {
4589	col = colOrder[j];
4590	if (xy[row][col]) {
4591	colInfo[col].lNum--;
4592	if (candList) {
4593	if (colInfo[col].lNum == 0)
4594	SortedListDelete(candList, col);
4595	else if (colInfo[col].lNum == 1)
4596	SortedListInsert(candList, col, row, rowInfo, method);
4597	}
4598	}
4599	}
4600
4601	nMoves++;
4602	}
4603
4604
4605	/Function******************************************************************
4606
4607	Synopsis [Moves a column to the left of the active region.]
4608
4609	Description [Moves a column to the left of the active region.]
4610
4611	SideEffects []
4612
4613	******************************************************************************/
4614	static void
4615	MoveColToLeft(char **xy, int y, int startFunc, int lastFunc,
4616	int startVar, int lastVar, RcInfo_t *rowInfo,
4617	RcInfo_t colInfo, int rowOrder, int *colOrder,
4618	RcListInfo_t *candList, int method)
4619	{
4620	int i, j, s, t;
4621	int row, col, tmpCol;
4622
4623	assert(y >= startVar && y <= lastVar);
4624
4625	col = colOrder[y];
4626	if (y != startVar) {
4627	/* Change col order */
4628	for (j = y; j > startVar; j--) {
4629	colOrder[j] = colOrder[j - 1];
4630	colInfo[colOrder[j]].pos = j;
4631	}
4632	colOrder[startVar] = col;
4633	colInfo[col].pos = startVar;
4634	}
4635
4636	s = rowInfo[colInfo[col].gMin].pos;
4637	t = rowInfo[colInfo[col].gMax].pos;
4638	for (i = s; i <= t; i++) {
4639	row = rowOrder[i];
4640	if (!xy[row][col])
4641	continue;
4642	rowInfo[row].prevG = startVar;
4643	if (rowInfo[row].lNum == 1) {
4644	rowInfo[row].lMin = col;
4645	rowInfo[row].lMax = col;
4646	} else {
4647	if (col == rowInfo[row].lMin) {
4648	for (j = y + 1; j <= colInfo[rowInfo[row].lMax].pos; j++) {
4649	tmpCol = colOrder[j];
4650	if (xy[row][tmpCol]) {
4651	rowInfo[row].lMin = tmpCol;
4652	break;
4653	}
4654	}
4655	} else if (col == rowInfo[row].lMax) {
4656	for (j = y; j >= colInfo[rowInfo[row].lMin].pos; j--) {
4657	tmpCol = colOrder[j];
4658	if (xy[row][tmpCol]) {
4659	rowInfo[row].lMax = tmpCol;
4660	break;
4661	}
4662	}
4663	}
4664	}
4665
4666	if (rowInfo[row].gNum == 1) {
4667	rowInfo[row].gMin = col;
4668	rowInfo[row].gMax = col;
4669	} else {
4670	if (col == rowInfo[row].gMin)
4671	rowInfo[row].gMin = col;
4672	else if (col == rowInfo[row].gMax) {
4673	rowInfo[row].gMax = rowInfo[row].lMax;
4674	if (startVar <= colInfo[rowInfo[row].gMin].pos)
4675	rowInfo[row].gMin = col;
4676	} else if (startVar <= colInfo[rowInfo[row].gMin].pos)
4677	rowInfo[row].gMin = col;
4678	}
4679
4680	if (colInfo[col].lNum) {
4681	if (i == colInfo[col].prevG)
4682	i = rowInfo[colInfo[col].lMin].pos - 1;
4683	else if (i == rowInfo[colInfo[col].lMax].pos)
4684	i = colInfo[col].nextG - 1;
4685	}
4686	}
4687
4688	s = rowInfo[colInfo[col].lMin].pos;
4689	t = rowInfo[colInfo[col].lMax].pos;
4690	for (i = s; i <= t; i++) {
4691	row = rowOrder[i];
4692	if (xy[row][col]) {
4693	rowInfo[row].lNum--;
4694	if (candList) {
4695	if (rowInfo[row].lNum == 0)
4696	SortedListDelete(candList, row);
4697	else if (rowInfo[row].lNum == 1)
4698	SortedListInsert(candList, row, col, colInfo, method);
4699	}
4700	}
4701	}
4702
4703	nMoves++;
4704	}
4705
4706
4707	/Function******************************************************************
4708
4709	Synopsis [Moves a row to the bottom of the active region.]
4710
4711	Description [Moves a row to the bottom of the active region.]
4712
4713	SideEffects []
4714
4715	******************************************************************************/
4716	static void
4717	MoveRowToBottom(char **xy, int x, int startFunc, int lastFunc,
4718	int startVar, int lastVar, RcInfo_t *rowInfo,
4719	RcInfo_t colInfo, int rowOrder, int *colOrder,
4720	RcListInfo_t *candList, int method)
4721	{
4722	int i, j, s, t;
4723	int row, col, tmpRow;
4724
4725	assert(x >= startFunc && x <= lastFunc);
4726
4727	row = rowOrder[x];
4728	if (x != lastFunc) {
4729	/* Change row order */
4730	for (i = x; i < lastFunc; i++) {
4731	rowOrder[i] = rowOrder[i + 1];
4732	rowInfo[rowOrder[i]].pos = i;
4733	}
4734	rowOrder[lastFunc] = row;
4735	rowInfo[row].pos = lastFunc;
4736	}
4737
4738	s = colInfo[rowInfo[row].gMin].pos;
4739	t = colInfo[rowInfo[row].gMax].pos;
4740	for (j = s; j <= t; j++) {
4741	col = colOrder[j];
4742	if (!xy[row][col])
4743	continue;
4744	colInfo[col].nextG = lastFunc;
4745	if (colInfo[col].lNum == 1) {
4746	colInfo[col].lMin = row;
4747	colInfo[col].lMax = row;
4748	} else {
4749	if (row == colInfo[col].lMin) {
4750	for (i = x; i <= rowInfo[colInfo[col].lMax].pos; i++) {
4751	tmpRow = rowOrder[i];
4752	if (xy[tmpRow][col]) {
4753	colInfo[col].lMin = tmpRow;
4754	break;
4755	}
4756	}
4757	} else if (row == colInfo[col].lMax) {
4758	for (i = x - 1; i >= rowInfo[colInfo[col].lMin].pos; i--) {
4759	tmpRow = rowOrder[i];
4760	if (xy[tmpRow][col]) {
4761	colInfo[col].lMax = tmpRow;
4762	break;
4763	}
4764	}
4765	}
4766	}
4767
4768	if (colInfo[col].gNum == 1) {
4769	colInfo[col].gMin = row;
4770	colInfo[col].gMax = row;
4771	} else {
4772	if (row == colInfo[col].gMax)
4773	colInfo[col].gMax = row;
4774	else if (row == colInfo[col].gMin) {
4775	colInfo[col].gMin = colInfo[col].lMin;
4776	if (lastFunc >= rowInfo[colInfo[col].gMax].pos)
4777	colInfo[col].gMax = row;
4778	} else if (lastFunc >= rowInfo[colInfo[col].gMax].pos)
4779	colInfo[col].gMax = row;
4780	}
4781
4782	if (rowInfo[row].lNum) {
4783	if (j == rowInfo[row].prevG)
4784	j = colInfo[rowInfo[row].lMin].pos - 1;
4785	else if (j == colInfo[rowInfo[row].lMax].pos)
4786	j = rowInfo[row].nextG - 1;
4787	}
4788	}
4789
4790	s = colInfo[rowInfo[row].lMin].pos;
4791	t = colInfo[rowInfo[row].lMax].pos;
4792	for (j = s; j <= t; j++) {
4793	col = colOrder[j];
4794	if (xy[row][col]) {
4795	colInfo[col].lNum--;
4796	if (candList) {
4797	if (colInfo[col].lNum == 0)
4798	SortedListDelete(candList, col);
4799	else if (colInfo[col].lNum == 1)
4800	SortedListInsert(candList, col, row, rowInfo, method);
4801	}
4802	}
4803	}
4804
4805	nMoves++;
4806	}
4807
4808
4809	/Function******************************************************************
4810
4811	Synopsis [Moves a column to the tight of the active region.]
4812
4813	Description [Moves a column to the tight of the active region.]
4814
4815	SideEffects []
4816
4817	******************************************************************************/
4818	static void
4819	MoveColToRight(char **xy, int y, int startFunc, int lastFunc,
4820	int startVar, int lastVar, RcInfo_t *rowInfo,
4821	RcInfo_t colInfo, int rowOrder, int *colOrder,
4822	RcListInfo_t *candList, int method)
4823	{
4824	int i, j, s, t;
4825	int row, col, tmpCol;
4826
4827	assert(y >= startVar && y <= lastVar);
4828
4829	col = colOrder[y];
4830	if (y != lastVar) {
4831	/* Change col order */
4832	for (j = y; j < lastVar; j++) {
4833	colOrder[j] = colOrder[j + 1];
4834	colInfo[colOrder[j]].pos = j;
4835	}
4836	colOrder[lastVar] = col;
4837	colInfo[col].pos = lastVar;
4838	}
4839
4840	s = rowInfo[colInfo[col].gMin].pos;
4841	t = rowInfo[colInfo[col].gMax].pos;
4842	for (i = s; i <= t; i++) {
4843	row = rowOrder[i];
4844	if (!xy[row][col])
4845	continue;
4846	rowInfo[row].nextG = lastVar;
4847	if (rowInfo[row].lNum == 1) {
4848	rowInfo[row].lMin = col;
4849	rowInfo[row].lMax = col;
4850	} else {
4851	if (col == rowInfo[row].lMin) {
4852	for (j = y; j <= colInfo[rowInfo[row].lMax].pos; j++) {
4853	tmpCol = colOrder[j];
4854	if (xy[row][tmpCol]) {
4855	rowInfo[row].lMin = tmpCol;
4856	break;
4857	}
4858	}
4859	} else if (col == rowInfo[row].lMax) {
4860	for (j = y - 1; j >= colInfo[rowInfo[row].lMin].pos; j--) {
4861	tmpCol = colOrder[j];
4862	if (xy[row][tmpCol]) {
4863	rowInfo[row].lMax = tmpCol;
4864	break;
4865	}
4866	}
4867	}
4868	}
4869
4870	if (rowInfo[row].gNum == 1) {
4871	rowInfo[row].gMin = col;
4872	rowInfo[row].gMax = col;
4873	} else {
4874	if (col == rowInfo[row].gMax)
4875	rowInfo[row].gMax = col;
4876	else if (col == rowInfo[row].gMin) {
4877	rowInfo[row].gMin = rowInfo[row].lMin;
4878	if (lastVar >= colInfo[rowInfo[row].gMax].pos)
4879	rowInfo[row].gMax = col;
4880	} else if (lastVar >= colInfo[rowInfo[row].gMax].pos)
4881	rowInfo[row].gMax = col;
4882	}
4883
4884	if (colInfo[col].lNum) {
4885	if (i == colInfo[col].prevG)
4886	i = rowInfo[colInfo[col].lMin].pos - 1;
4887	else if (i == rowInfo[colInfo[col].lMax].pos)
4888	i = colInfo[col].nextG - 1;
4889	}
4890	}
4891
4892	s = rowInfo[colInfo[col].lMin].pos;
4893	t = rowInfo[colInfo[col].lMax].pos;
4894	for (i = s; i <= t; i++) {
4895	row = rowOrder[i];
4896	if (xy[row][col]) {
4897	rowInfo[row].lNum--;
4898	if (candList) {
4899	if (rowInfo[row].lNum == 0)
4900	SortedListDelete(candList, row);
4901	else if (rowInfo[row].lNum == 1)
4902	SortedListInsert(candList, row, col, colInfo, method);
4903	}
4904	}
4905	}
4906
4907	nMoves++;
4908	}
4909
4910
4911	/Function******************************************************************
4912
4913	Synopsis [Prints a maxtrix.]
4914
4915	Description [Prints a maxtrix.]
4916
4917	SideEffects []
4918
4919	******************************************************************************/
4920	static void
4921	PrintMatrix(char *xy, int nRows, int nCols, int rowOrder, int *colOrder,
4922	RcInfo_t rowInfo, RcInfo_t colInfo,
4923	int startFunc, int lastFunc, int startVar, int lastVar)
4924	{
4925	int i, j, x, y;
4926	int row, col, index;
4927	char line[2048];
4928	bdd_t *nsVar;
4929
4930	line[nCols] = '\0';
4931	for (x = 0; x < nRows; x++) {
4932	if (startFunc != lastFunc && startVar != lastVar &&
4933	x == startFunc && x != 0) {
4934	for (y = 0; y < nCols; y++) {
4935	if (y == startVar \|\| y == lastVar)
4936	line[y] = '%';
4937	else
4938	line[y] = '=';
4939	}
4940	fprintf(vis_stdout, "%s\n", line);
4941	}
4942	i = rowOrder[x];
4943	for (y = 0; y < nCols; y++) {
4944	j = colOrder[y];
4945	if (xy[i][j])
4946	line[y] = '1';
4947	else
4948	line[y] = '.';
4949	}
4950	fprintf(vis_stdout, "%s\n", line);
4951	if (startFunc != lastFunc && startVar != lastVar &&
4952	x == lastFunc && x < nRows - 1) {
4953	for (y = 0; y < nCols; y++) {
4954	if (y == startVar \|\| y == lastVar)
4955	line[y] = '%';
4956	else
4957	line[y] = '=';
4958	}
4959	fprintf(vis_stdout, "%s\n", line);
4960	}
4961	}
4962	fprintf(vis_stdout, "row order :");
4963	for (x = 0; x < nRows; x++) {
4964	row = rowOrder[x];
4965	fprintf(vis_stdout, " %d(", row);
4966	if (rowInfo[row].data.row.nsVarBddArray) {
4967	for (i = 0; i < array_n(rowInfo[row].data.row.nsVarBddArray); i++) {
4968	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, i);
4969	index = (int)bdd_top_var_id(nsVar);
4970	if (i == 0)
4971	fprintf(vis_stdout, "%d", index);
4972	else
4973	fprintf(vis_stdout, ",%d", index);
4974	}
4975	}
4976	fprintf(vis_stdout, ")");
4977	}
4978	fprintf(vis_stdout, "\n");
4979	fprintf(vis_stdout, "col order :");
4980	for (y = 0; y < nCols; y++) {
4981	col = colOrder[y];
4982	index = (int)bdd_top_var_id(colInfo[col].data.col.var);
4983	fprintf(vis_stdout, " %d(%d)", col, index);
4984	}
4985	fprintf(vis_stdout, "\n");
4986	fprintf(vis_stdout, "#active rows : %d-%d\n", startFunc, lastFunc);
4987	fprintf(vis_stdout, "#active cols : %d-%d\n", startVar, lastVar);
4988	}
4989
4990
4991	/Function******************************************************************
4992
4993	Synopsis [Prints a matrix with cluster information.]
4994
4995	Description [Prints a matrix with cluster information.]
4996
4997	SideEffects []
4998
4999	******************************************************************************/
5000	static void
5001	PrintMatrixWithCluster(char *xy, ClusterList_t headCluster, int nCols,
5002	int rowOrder, int colOrder,
5003	Img_DirectionType direction)
5004	{
5005	int i, j, x, y;
5006	char line[2048];
5007	ClusterList_t list, tailCluster;
5008
5009	line[nCols] = '\0';
5010	if (direction == Img_Forward_c) {
5011	tailCluster = headCluster;
5012	list = headCluster;
5013	while (list->next) {
5014	tailCluster = list->next;
5015	list = tailCluster;
5016	}
5017	list = tailCluster;
5018	while (list) {
5019	for (x = list->start; x <= list->end; x++) {
5020	i = rowOrder[x];
5021	for (y = 0; y < nCols; y++) {
5022	j = colOrder[y];
5023	if (xy[i][j])
5024	line[y] = '1';
5025	else
5026	line[y] = '.';
5027	}
5028	fprintf(vis_stdout, "%s\n", line);
5029	}
5030	list = list->prev;
5031	if (list) {
5032	for (y = 0; y < nCols; y++)
5033	line[y] = '-';
5034	fprintf(vis_stdout, "%s\n", line);
5035	}
5036	}
5037	} else {
5038	list = headCluster;
5039	while (list) {
5040	for (x = list->start; x <= list->end; x++) {
5041	i = rowOrder[x];
5042	for (y = 0; y < nCols; y++) {
5043	j = colOrder[y];
5044	if (xy[i][j])
5045	line[y] = '1';
5046	else
5047	line[y] = '.';
5048	}
5049	fprintf(vis_stdout, "%s\n", line);
5050	}
5051	list = list->next;
5052	if (list) {
5053	for (y = 0; y < nCols; y++)
5054	line[y] = '-';
5055	fprintf(vis_stdout, "%s\n", line);
5056	}
5057	}
5058	}
5059	}
5060
5061
5062	/Function******************************************************************
5063
5064	Synopsis [Prints cluster information.]
5065
5066	Description [Prints cluster information.]
5067
5068	SideEffects []
5069
5070	******************************************************************************/
5071	static void
5072	PrintClusterMatrix(ClusterList_t *headCluster, int nCols,
5073	int *colOrder, Img_DirectionType direction)
5074	{
5075	int j, y;
5076	char line[2048];
5077	ClusterList_t list, tailCluster;
5078
5079	line[nCols] = '\0';
5080	if (direction == Img_Forward_c) {
5081	tailCluster = headCluster;
5082	list = headCluster;
5083	while (list->next) {
5084	tailCluster = list->next;
5085	list = tailCluster;
5086	}
5087	list = tailCluster;
5088	while (list) {
5089	for (y = 0; y < nCols; y++) {
5090	j = colOrder[y];
5091	if (list->supports[j])
5092	line[y] = '1';
5093	else
5094	line[y] = '.';
5095	}
5096	fprintf(vis_stdout, "%s\n", line);
5097	list = list->prev;
5098	if (list) {
5099	for (y = 0; y < nCols; y++)
5100	line[y] = '-';
5101	fprintf(vis_stdout, "%s\n", line);
5102	}
5103	}
5104	} else {
5105	list = headCluster;
5106	while (list) {
5107	for (y = 0; y < nCols; y++) {
5108	j = colOrder[y];
5109	if (list->supports[j])
5110	line[y] = '1';
5111	else
5112	line[y] = '.';
5113	}
5114	fprintf(vis_stdout, "%s\n", line);
5115	list = list->next;
5116	if (list) {
5117	for (y = 0; y < nCols; y++)
5118	line[y] = '-';
5119	fprintf(vis_stdout, "%s\n", line);
5120	}
5121	}
5122	}
5123	}
5124
5125
5126	/Function******************************************************************
5127
5128	Synopsis [Checks a matrix for sanity.]
5129
5130	Description [Checks a matrix for sanity.]
5131
5132	SideEffects []
5133
5134	******************************************************************************/
5135	static void
5136	CheckMatrix(char *xy, SccList_t sccList, int nRows, int nCols,
5137	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder,
5138	int startFunc, int lastFunc, int startVar, int lastVar, int local)
5139	{
5140	int i, j, x, y;
5141	int lMin, lMax, gMin, gMax, lNum, gNum, prevG, nextG;
5142	int error = 0;
5143
5144	for (x = 0; x < nRows; x++) {
5145	i = rowOrder[x];
5146	if (x != rowInfo[i].pos) {
5147	fprintf(vis_stderr, "Error : wrong rowOrder (%d != %d) in Row %d\n",
5148	x, rowInfo[i].pos, x);
5149	error = 1;
5150	}
5151
5152	lMin = gMin = nCols;
5153	lMax = gMax = -1;
5154	lNum = gNum = 0;
5155	prevG = -1;
5156	nextG = nCols;
5157
5158	for (y = 0; y < nCols; y++) {
5159	j = colOrder[y];
5160	if (xy[i][j]) {
5161	gNum++;
5162	if (y < gMin)
5163	gMin = y;
5164	if (y > gMax)
5165	gMax = y;
5166	if (local) {
5167	if (x >= startFunc && x <= lastFunc &&
5168	y >= startVar && y <= lastVar) {
5169	if (y < lMin)
5170	lMin = y;
5171	if (y > lMax)
5172	lMax = y;
5173	lNum++;
5174	}
5175	if (!sccList \|\|
5176	(x >= sccList->startFunc && x <= sccList->lastFunc)) {
5177	if (y < startVar)
5178	prevG = y;
5179	if (y > lastVar && nextG == nCols)
5180	nextG = y;
5181	}
5182	}
5183	}
5184	}
5185	if (gNum != rowInfo[i].gNum) {
5186	fprintf(vis_stderr, "Error : wrong gNum (%d != %d) in Row %d\n",
5187	gNum, rowInfo[i].gNum, x);
5188	error = 1;
5189	}
5190	if (gNum > 0) {
5191	if (gMin != colInfo[rowInfo[i].gMin].pos) {
5192	fprintf(vis_stderr, "Error : wrong gMin (%d != %d) in Row %d\n",
5193	gMin, colInfo[rowInfo[i].gMin].pos, x);
5194	error = 1;
5195	}
5196	if (gMax != colInfo[rowInfo[i].gMax].pos) {
5197	fprintf(vis_stderr, "Error : wrong gMax (%d != %d) in Row %d\n",
5198	gMax, colInfo[rowInfo[i].gMax].pos, x);
5199	error = 1;
5200	}
5201	}
5202	if (local) {
5203	if (x >= startFunc && x <= lastFunc &&
5204	lNum != rowInfo[i].lNum) {
5205	fprintf(vis_stderr, "Error : wrong lNum (%d != %d) in Row %d\n",
5206	lNum, rowInfo[i].lNum, x);
5207	error = 1;
5208	}
5209	if (x >= startFunc && x <= lastFunc && lMin < nCols &&
5210	lMin != colInfo[rowInfo[i].lMin].pos) {
5211	fprintf(vis_stderr, "Error : wrong lMin (%d != %d) in Row %d\n",
5212	lMin, colInfo[rowInfo[i].lMin].pos, x);
5213	error = 1;
5214	}
5215	if (x >= startFunc && x <= lastFunc && lMax > -1 &&
5216	lMax != colInfo[rowInfo[i].lMax].pos) {
5217	fprintf(vis_stderr, "Error : wrong lMax (%d != %d) in Row %d\n",
5218	lMax, colInfo[rowInfo[i].lMax].pos, x);
5219	error = 1;
5220	}
5221	if (!sccList \|\| (x >= sccList->startFunc && x <= sccList->lastFunc)) {
5222	if (prevG != rowInfo[i].prevG) {
5223	fprintf(vis_stderr, "Error : wrong prevG (%d != %d) in Row %d\n",
5224	prevG, rowInfo[i].prevG, x);
5225	error = 1;
5226	}
5227	if (nextG != rowInfo[i].nextG) {
5228	fprintf(vis_stderr, "Error : wrong nextG (%d != %d) in Row %d\n",
5229	nextG, rowInfo[i].nextG, x);
5230	error = 1;
5231	}
5232	}
5233	}
5234	}
5235
5236	for (y = 0; y < nCols; y++) {
5237	j = colOrder[y];
5238	if (y != colInfo[j].pos) {
5239	fprintf(vis_stderr, "Error : wrong colOrder (%d != %d) in Col %d\n",
5240	y, colInfo[y].pos, y);
5241	error = 1;
5242	}
5243
5244	lMin = gMin = nRows;
5245	lMax = gMax = -1;
5246	lNum = gNum = 0;
5247	prevG = -1;
5248	nextG = nRows;
5249
5250	for (x = 0; x < nRows; x++) {
5251	i = rowOrder[x];
5252	if (xy[i][j]) {
5253	gNum++;
5254	if (x < gMin)
5255	gMin = x;
5256	if (x > gMax)
5257	gMax = x;
5258	if (local) {
5259	if (x >= startFunc && x <= lastFunc &&
5260	y >= startVar && y <= lastVar) {
5261	if (x < lMin)
5262	lMin = x;
5263	if (x > lMax)
5264	lMax = x;
5265	lNum++;
5266	}
5267	if (!sccList \|\|
5268	(y >= sccList->startVar && y <= sccList->lastVar)) {
5269	if (x < startFunc)
5270	prevG = x;
5271	if (x > lastFunc && nextG == nRows)
5272	nextG = x;
5273	}
5274	}
5275	}
5276	}
5277	if (gNum != colInfo[j].gNum) {
5278	fprintf(vis_stderr, "Error : wrong gNum (%d != %d) in Col %d\n",
5279	gNum, colInfo[j].gNum, y);
5280	error = 1;
5281	}
5282	if (gNum > 0) {
5283	if (gMin != rowInfo[colInfo[j].gMin].pos) {
5284	fprintf(vis_stderr, "Error : wrong gMin (%d != %d) in Col %d\n",
5285	gMin, rowInfo[colInfo[j].gMin].pos, y);
5286	error = 1;
5287	}
5288	if (gMax != rowInfo[colInfo[j].gMax].pos) {
5289	fprintf(vis_stderr, "Error : wrong gMax (%d != %d) in Col %d\n",
5290	gMax, rowInfo[colInfo[j].gMax].pos, y);
5291	error = 1;
5292	}
5293	}
5294	if (local) {
5295	if (y >= startVar && y <= lastVar &&
5296	lNum != colInfo[j].lNum) {
5297	fprintf(vis_stderr, "Error : wrong lNum (%d != %d) in Col %d\n",
5298	lNum, colInfo[j].lNum, y);
5299	error = 1;
5300	}
5301	if (y >= startVar && y <= lastVar && lMin < nRows &&
5302	lMin != rowInfo[colInfo[j].lMin].pos) {
5303	fprintf(vis_stderr, "Error : wrong lMin (%d != %d) in Col %d\n",
5304	lMin, rowInfo[colInfo[j].lMin].pos, y);
5305	error = 1;
5306	}
5307	if (y >= startVar && y <= lastVar && lMax > -1 &&
5308	lMax != rowInfo[colInfo[j].lMax].pos) {
5309	fprintf(vis_stderr, "Error : wrong lMax (%d != %d) in Col %d\n",
5310	lMax, rowInfo[colInfo[j].lMax].pos, y);
5311	error = 1;
5312	}
5313	if (!sccList \|\| (y >= sccList->startVar && y <= sccList->lastVar)) {
5314	if (prevG != colInfo[j].prevG) {
5315	fprintf(vis_stderr, "Error : wrong prevG (%d != %d) in Col %d\n",
5316	prevG, colInfo[j].prevG, y);
5317	error = 1;
5318	}
5319	if (nextG != colInfo[j].nextG) {
5320	fprintf(vis_stderr, "Error : wrong nextG (%d != %d) in Col %d\n",
5321	nextG, colInfo[j].nextG, y);
5322	error = 1;
5323	}
5324	}
5325	}
5326	}
5327
5328	assert(!error);
5329	}
5330
5331
5332	/Function******************************************************************
5333
5334	Synopsis [Checks cluster for sanity.]
5335
5336	Description [Checks cluster for sanity.]
5337
5338	SideEffects []
5339
5340	******************************************************************************/
5341	static void
5342	CheckCluster(ClusterList_t *headCluster, int nCols,
5343	RcInfo_t colInfo, int colOrder)
5344	{
5345	int j, y, n;
5346	int gMin, gMax, gNum;
5347	int error = 0;
5348	ClusterList_t *list;
5349
5350	n = 0;
5351	list = headCluster;
5352	while (list) {
5353	gMin = nCols;
5354	gMax = -1;
5355	gNum = 0;
5356
5357	for (y = 0; y < nCols; y++) {
5358	j = colOrder[y];
5359	if (list->supports[j]) {
5360	gNum++;
5361	if (y < gMin)
5362	gMin = y;
5363	if (y > gMax)
5364	gMax = y;
5365	}
5366	}
5367	if (gNum != list->nSupports) {
5368	fprintf(vis_stderr, "Error : wrong nSupports (%d != %d) in Cluster %d\n",
5369	gNum, list->nSupports, n);
5370	error = 1;
5371	}
5372	if (gNum > 0) {
5373	if (gMin != colInfo[list->minCol].pos) {
5374	fprintf(vis_stderr, "Error : wrong gMin (%d != %d) in Cluster %d\n",
5375	gMin, colInfo[list->minCol].pos, n);
5376	error = 1;
5377	}
5378	if (gMax != colInfo[list->maxCol].pos) {
5379	fprintf(vis_stderr, "Error : wrong gMax (%d != %d) in Cluster %d\n",
5380	gMax, colInfo[list->maxCol].pos, n);
5381	error = 1;
5382	}
5383	}
5384	n++;
5385	list = list->next;
5386	}
5387
5388	assert(!error);
5389	}
5390
5391
5392	/Function******************************************************************
5393
5394	Synopsis [Writes a matrix to a file.]
5395
5396	Description [Writes a matrix to a file.]
5397
5398	SideEffects []
5399
5400	******************************************************************************/
5401	static void
5402	WriteMatrix(FILE fout, char xy, int nRows, int nCols, int rowOrder,
5403	int colOrder, RcInfo_t rowInfo, RcInfo_t *colInfo)
5404	{
5405	int x, y;
5406	int row, col;
5407
5408	for (x = 0; x < nRows; x++) {
5409	row = rowOrder[x];
5410	for (y = 0; y < nCols; y++) {
5411	col = colOrder[y];
5412	if (xy[row][col])
5413	fprintf(fout, "%d %d %d\n", y, x, colInfo[col].data.col.type);
5414	}
5415	}
5416	}
5417
5418
5419	/Function******************************************************************
5420
5421	Synopsis [Prints a row.]
5422
5423	Description [Prints a row.]
5424
5425	SideEffects []
5426
5427	******************************************************************************/
5428	static void
5429	PrintRow(char *xy, int nRows, int nCols, int rowOrder, int *colOrder,
5430	int from, int to)
5431	{
5432	int x, y, row, col;
5433
5434	for (x = from; x <= to; x++) {
5435	row = rowOrder[x];
5436	fprintf(vis_stdout, "[%d]%d :", x, row);
5437	for (y = 0; y < nCols; y++) {
5438	col = colOrder[y];
5439	if (xy[row][col])
5440	fprintf(vis_stdout, " %d(%d)", y, col);
5441	}
5442	fprintf(vis_stdout, "\n");
5443	}
5444	}
5445
5446
5447	/Function******************************************************************
5448
5449	Synopsis [Prints a column.]
5450
5451	Description [Prints a column.]
5452
5453	SideEffects []
5454
5455	******************************************************************************/
5456	static void
5457	PrintCol(char *xy, int nRows, int nCols, int rowOrder, int *colOrder,
5458	int from, int to)
5459	{
5460	int x, y, row, col;
5461
5462	for (y = from; y <= to; y++) {
5463	col = colOrder[y];
5464	fprintf(vis_stdout, "[%d]%d :", y, col);
5465	for (x = 0; x < nRows; x++) {
5466	row = rowOrder[x];
5467	if (xy[row][col])
5468	fprintf(vis_stdout, " %d(%d)", x, row);
5469	}
5470	fprintf(vis_stdout, "\n");
5471	}
5472	}
5473
5474
5475	/Function******************************************************************
5476
5477	Synopsis [Allocates a list for sorting.]
5478
5479	Description [Allocates a list for sorting.]
5480
5481	SideEffects []
5482
5483	******************************************************************************/
5484	static RcListInfo_t *
5485	SortedListAlloc(void)
5486	{
5487	RcListInfo_t *listInfo;
5488
5489	listInfo = ALLOC(RcListInfo_t, 1);
5490	memset(listInfo, 0, sizeof(RcListInfo_t));
5491	listInfo->table = st_init_table(st_numcmp, st_numhash);
5492	return(listInfo);
5493	}
5494
5495
5496	/Function******************************************************************
5497
5498	Synopsis [Frees a list used for sorting.]
5499
5500	Description [Frees a list used for sorting.]
5501
5502	SideEffects []
5503
5504	******************************************************************************/
5505	static void
5506	SortedListFree(RcListInfo_t *candList)
5507	{
5508	RcList_t candidate, next;
5509
5510	candidate = candList->head;
5511	while (candidate) {
5512	next = candidate->next;
5513	FREE(candidate);
5514	candidate = next;
5515	}
5516	st_free_table(candList->table);
5517	FREE(candList);
5518	}
5519
5520
5521	/Function******************************************************************
5522
5523	Synopsis [Inserts a list to the sorting list.]
5524
5525	Description [Inserts a list to the sorting list.]
5526
5527	SideEffects []
5528
5529	******************************************************************************/
5530	static void
5531	SortedListInsert(RcListInfo_t *candList, int index,
5532	int otherIndex, RcInfo_t *otherInfo, int method)
5533	{
5534	RcList_t candidate, cur;
5535	int lNum, gNum, diffH, diffT;
5536
5537	candidate = ALLOC(RcList_t, 1);
5538	candidate->index = index;
5539	candidate->otherIndex = otherIndex;
5540	st_insert(candList->table, (char )(long)index, (char )candidate);
5541
5542	if (candList->num == 0) {
5543	candidate->next = NIL(RcList_t);
5544	candidate->prev = NIL(RcList_t);
5545	candList->cur = candidate;
5546	candList->head = candidate;
5547	candList->tail = candidate;
5548	candList->num = 1;
5549	candList->maxNum = 1;
5550	return;
5551	}
5552
5553	candList->num++;
5554	if (candList->num > candList->maxNum)
5555	candList->maxNum = candList->num;
5556
5557	if (method == 1) {
5558	diffH = abs(index - candList->head->index);
5559	diffT = abs(index - candList->tail->index);
5560
5561	if (diffH < diffT) {
5562	cur = candList->head;
5563	while (cur) {
5564	if (index < cur->index) {
5565	candidate->next = cur;
5566	candidate->prev = cur->prev;
5567	if (cur->prev)
5568	cur->prev->next = candidate;
5569	cur->prev = candidate;
5570	if (cur == candList->head)
5571	candList->head = candidate;
5572	break;
5573	}
5574	cur = cur->next;
5575	}
5576	if (!cur) {
5577	candidate->next = NIL(RcList_t);
5578	candidate->prev = candList->tail;
5579	candList->tail->next = candidate;
5580	candList->tail = candidate;
5581	}
5582	} else {
5583	cur = candList->tail;
5584	while (cur) {
5585	if (index > cur->index) {
5586	candidate->next = cur->next;
5587	if (cur->next)
5588	cur->next->prev = candidate;
5589	candidate->prev = cur;
5590	cur->next = candidate;
5591	if (cur == candList->tail)
5592	candList->tail = candidate;
5593	break;
5594	}
5595	cur = cur->prev;
5596	}
5597	if (!cur) {
5598	candidate->next = candList->head;
5599	candidate->prev = NIL(RcList_t);
5600	candList->head->prev = candidate;
5601	candList->head = candidate;
5602	}
5603	}
5604
5605	if (candList->cur) {
5606	if (candList->cur->index == candList->curIndex)
5607	return;
5608	else if (candList->cur->index > candList->curIndex) {
5609	cur = candList->cur->prev;
5610	while (cur) {
5611	if (cur->index <= candList->curIndex)
5612	break;
5613	candList->cur = cur;
5614	cur = cur->prev;
5615	}
5616	} else {
5617	if (candidate->index > candList->curIndex)
5618	candList->cur = candidate;
5619	else
5620	candList->cur = candList->head;
5621	}
5622	} else
5623	candList->cur = candList->head;
5624	} else if (method == 2) {
5625	lNum = otherInfo[otherIndex].lNum;
5626	gNum = otherInfo[otherIndex].gNum;
5627	diffH = abs(lNum - otherInfo[candList->head->otherIndex].lNum);
5628	diffT = abs(lNum - otherInfo[candList->tail->otherIndex].lNum);
5629
5630	if (diffH < diffT) {
5631	cur = candList->head;
5632	while (cur) {
5633	if (lNum < otherInfo[cur->otherIndex].lNum \|\|
5634	(lNum == otherInfo[cur->otherIndex].lNum &&
5635	(gNum < otherInfo[cur->otherIndex].gNum \|\|
5636	(gNum == otherInfo[cur->otherIndex].gNum &&
5637	index < cur->index)))) {
5638	candidate->next = cur;
5639	candidate->prev = cur->prev;
5640	if (cur->prev)
5641	cur->prev->next = candidate;
5642	cur->prev = candidate;
5643	if (cur == candList->head)
5644	candList->head = candidate;
5645	break;
5646	}
5647	cur = cur->next;
5648	}
5649	if (!cur) {
5650	candidate->next = NIL(RcList_t);
5651	candidate->prev = candList->tail;
5652	candList->tail->next = candidate;
5653	candList->tail = candidate;
5654	}
5655	} else {
5656	cur = candList->tail;
5657	while (cur) {
5658	if (lNum > otherInfo[cur->otherIndex].lNum \|\|
5659	(lNum == otherInfo[cur->otherIndex].lNum &&
5660	(gNum > otherInfo[cur->otherIndex].gNum \|\|
5661	(gNum == otherInfo[cur->otherIndex].gNum &&
5662	index > cur->index)))) {
5663	candidate->next = cur->next;
5664	if (cur->next)
5665	cur->next->prev = candidate;
5666	candidate->prev = cur;
5667	cur->next = candidate;
5668	if (cur == candList->tail)
5669	candList->tail = candidate;
5670	break;
5671	}
5672	cur = cur->prev;
5673	}
5674	if (!cur) {
5675	candidate->next = candList->head;
5676	candidate->prev = NIL(RcList_t);
5677	candList->head->prev = candidate;
5678	candList->head = candidate;
5679	}
5680	}
5681	} else if (method == 3) {
5682	lNum = otherInfo[otherIndex].lNum;
5683	gNum = otherInfo[otherIndex].gNum;
5684	diffH = abs(lNum - otherInfo[candList->head->otherIndex].lNum);
5685	diffT = abs(lNum - otherInfo[candList->tail->otherIndex].lNum);
5686
5687	if (diffH < diffT) {
5688	cur = candList->head;
5689	while (cur) {
5690	if (lNum < otherInfo[cur->otherIndex].lNum \|\|
5691	(lNum == otherInfo[cur->otherIndex].lNum &&
5692	(gNum > otherInfo[cur->otherIndex].gNum \|\|
5693	(gNum == otherInfo[cur->otherIndex].gNum &&
5694	otherInfo[index].pos < otherInfo[cur->index].pos)))) {
5695	candidate->next = cur;
5696	candidate->prev = cur->prev;
5697	if (cur->prev)
5698	cur->prev->next = candidate;
5699	cur->prev = candidate;
5700	if (cur == candList->head)
5701	candList->head = candidate;
5702	break;
5703	}
5704	cur = cur->next;
5705	}
5706	if (!cur) {
5707	candidate->next = NIL(RcList_t);
5708	candidate->prev = candList->tail;
5709	candList->tail->next = candidate;
5710	candList->tail = candidate;
5711	}
5712	} else {
5713	cur = candList->tail;
5714	while (cur) {
5715	if (lNum > otherInfo[cur->otherIndex].lNum \|\|
5716	(lNum == otherInfo[cur->otherIndex].lNum &&
5717	(gNum < otherInfo[cur->otherIndex].gNum \|\|
5718	(gNum == otherInfo[cur->otherIndex].gNum &&
5719	otherInfo[index].pos > otherInfo[cur->index].pos)))) {
5720	candidate->next = cur->next;
5721	if (cur->next)
5722	cur->next->prev = candidate;
5723	candidate->prev = cur;
5724	cur->next = candidate;
5725	if (cur == candList->tail)
5726	candList->tail = candidate;
5727	break;
5728	}
5729	cur = cur->prev;
5730	}
5731	if (!cur) {
5732	candidate->next = candList->head;
5733	candidate->prev = NIL(RcList_t);
5734	candList->head->prev = candidate;
5735	candList->head = candidate;
5736	}
5737	}
5738	} else if (method == 4) {
5739	lNum = otherInfo[index].lNum;
5740	cur = candList->tail;
5741	while (cur) {
5742	if (cur->otherIndex > 1 \|\|
5743	(cur->otherIndex == 1 && otherInfo[cur->index].lNum > lNum) \|\|
5744	(cur->otherIndex == 1 && otherInfo[cur->index].lNum == lNum &&
5745	otherInfo[index].pos > otherInfo[cur->index].pos)) {
5746	candidate->next = cur->next;
5747	if (cur->next)
5748	cur->next->prev = candidate;
5749	candidate->prev = cur;
5750	cur->next = candidate;
5751	if (cur == candList->tail)
5752	candList->tail = candidate;
5753	break;
5754	}
5755	cur = cur->prev;
5756	}
5757	if (!cur) {
5758	candidate->next = candList->head;
5759	candidate->prev = NIL(RcList_t);
5760	candList->head->prev = candidate;
5761	candList->head = candidate;
5762	}
5763	} else {
5764	fprintf(vis_stderr, "** mlp error: invalid sort mode %d\n", method);
5765	}
5766
5767	candList->cur = candList->head;
5768	}
5769
5770
5771	/Function******************************************************************
5772
5773	Synopsis [Deletes a list from the sorting list.]
5774
5775	Description [Deletes a list from the sorting list.]
5776
5777	SideEffects []
5778
5779	******************************************************************************/
5780	static void
5781	SortedListDelete(RcListInfo_t *candList, int index)
5782	{
5783	RcList_t *candidate;
5784	long lindex = (long) index;
5785
5786	if (st_lookup(candList->table, (char *)lindex, &candidate)) {
5787	if (candidate == candList->head)
5788	candList->head = candidate->next;
5789	else
5790	candidate->prev->next = candidate->next;
5791	if (candidate == candList->tail)
5792	candList->tail = candidate->prev;
5793	else
5794	candidate->next->prev = candidate->prev;
5795	if (candidate == candList->cur) {
5796	if (candidate->next)
5797	candList->cur = candidate->next;
5798	else
5799	candList->cur = candList->head;
5800	}
5801	st_delete(candList->table, &lindex, NULL);
5802	candList->num--;
5803	FREE(candidate);
5804	}
5805	}
5806
5807
5808	/Function******************************************************************
5809
5810	Synopsis [Moves a list in the sorting list.]
5811
5812	Description [Moves a list in the sorting list.]
5813
5814	SideEffects []
5815
5816	******************************************************************************/
5817	static void
5818	SortedListMove(RcListInfo_t candList, RcInfo_t info, int index, int method)
5819	{
5820	RcList_t cur, prev, left, right;
5821
5822	if (st_lookup(candList->table, (char *)(long)index, &cur)) {
5823	if (method == 1) {
5824	} else if (method == 2) {
5825	} else if (method == 3) {
5826	while (cur != candList->head) {
5827	prev = cur->prev;
5828	if (info[prev->index].lNum < info[cur->index].lNum \|\|
5829	(info[prev->index].lNum == info[cur->index].lNum &&
5830	(info[prev->index].gNum > info[cur->index].gNum \|\|
5831	(info[prev->index].gNum == info[cur->index].gNum &&
5832	info[prev->index].pos < info[cur->index].pos)))) {
5833	break;
5834	}
5835
5836	/* swap */
5837	if (prev == candList->head)
5838	candList->head = cur;
5839	if (cur == candList->tail)
5840	candList->tail = prev;
5841	left = prev->prev;
5842	right = cur->next;
5843	if (left)
5844	left->next = cur;
5845	cur->next = prev;
5846	prev->next = right;
5847	if (right)
5848	right->prev = prev;
5849	prev->prev = cur;
5850	cur->prev = left;
5851	}
5852	} else if (method == 4) {
5853	while (cur != candList->head) {
5854	prev = cur->prev;
5855	if (prev->otherIndex > cur->otherIndex \|\|
5856	(prev->otherIndex == cur->otherIndex &&
5857	(info[prev->index].lNum > info[cur->index].lNum \|\|
5858	(info[prev->index].lNum == info[cur->index].lNum &&
5859	info[prev->index].pos < info[cur->index].pos)))) {
5860	break;
5861	}
5862
5863	/* swap */
5864	if (prev == candList->head)
5865	candList->head = cur;
5866	if (cur == candList->tail)
5867	candList->tail = prev;
5868	left = prev->prev;
5869	right = cur->next;
5870	if (left)
5871	left->next = cur;
5872	cur->next = prev;
5873	prev->next = right;
5874	if (right)
5875	right->prev = prev;
5876	prev->prev = cur;
5877	cur->prev = left;
5878	}
5879	}
5880	}
5881	}
5882
5883
5884	/Function******************************************************************
5885
5886	Synopsis [Checks the sorting list for sanity.]
5887
5888	Description [Checks the sorting list for sanity.]
5889
5890	SideEffects []
5891
5892	******************************************************************************/
5893	static void
5894	CheckSortedList(RcListInfo_t candList, RcInfo_t info, int method)
5895	{
5896	RcList_t cur, next, *candidate;
5897	int error = 0;
5898	int num = 0;
5899
5900	cur = candList->head;
5901	while (cur) {
5902	num++;
5903	next = cur->next;
5904	if (next) {
5905	if (next->prev != cur) {
5906	error++;
5907	if (next->prev) {
5908	fprintf(vis_stderr, "Error : prev of %d is not %d (!= %d) in list\n",
5909	next->index, cur->index, next->prev->index);
5910	} else {
5911	fprintf(vis_stderr, "Error : prev of %d is not %d (!= nil) in list\n",
5912	next->index, cur->index);
5913	}
5914	}
5915	if (method == 1) {
5916	} else if (method == 2) {
5917	} else if (method == 3) {
5918	if (info[cur->index].lNum > info[next->index].lNum) {
5919	error++;
5920	fprintf(vis_stderr,
5921	"Error : cur(%d) lNum(%d) > next(%d) lNum(%d) in row list\n",
5922	cur->index, info[cur->index].lNum,
5923	next->index, info[next->index].lNum);
5924	} else if (info[cur->index].lNum == info[next->index].lNum &&
5925	info[cur->index].gNum < info[next->index].gNum) {
5926	error++;
5927	fprintf(vis_stderr,
5928	"Error : cur(%d) gNum(%d) < next(%d) gNum(%d) in row list\n",
5929	cur->index, info[cur->index].gNum,
5930	next->index, info[next->index].gNum);
5931	} else if (info[cur->index].lNum == info[next->index].lNum &&
5932	info[cur->index].gNum == info[next->index].gNum &&
5933	info[cur->index].pos > info[next->index].pos) {
5934	error++;
5935	fprintf(vis_stderr,
5936	"Error : cur(%d) pos(%d) > next(%d) pos(%d) in row list\n",
5937	cur->index, info[cur->index].pos,
5938	next->index, info[next->index].pos);
5939	}
5940	} else if (method == 4) {
5941	if (cur->otherIndex < next->otherIndex) {
5942	error++;
5943	fprintf(vis_stderr,
5944	"Error : cur(%d) length(%d) < next(%d) length(%d) in col list\n",
5945	cur->index, cur->otherIndex, next->index, next->otherIndex);
5946	} else if (cur->otherIndex == next->otherIndex &&
5947	info[cur->index].lNum < info[next->index].lNum) {
5948	error++;
5949	fprintf(vis_stderr,
5950	"Error : cur(%d) lNum(%d) < next(%d) lNum(%d) in col list\n",
5951	cur->index, info[cur->index].lNum,
5952	next->index, info[next->index].lNum);
5953	} else if (cur->otherIndex == next->otherIndex &&
5954	info[cur->index].lNum == info[next->index].lNum &&
5955	info[cur->index].pos > info[next->index].pos) {
5956	error++;
5957	fprintf(vis_stderr,
5958	"Error : cur(%d) pos(%d) > next(%d) pos(%d) in col list\n",
5959	cur->index, info[cur->index].pos,
5960	next->index, info[next->index].pos);
5961	}
5962	}
5963	} else {
5964	if (cur != candList->tail) {
5965	error++;
5966	if (candList->tail) {
5967	fprintf(vis_stderr, "Error : different tail in list (%d != %d)\n",
5968	cur->index, candList->tail->index);
5969	} else {
5970	fprintf(vis_stderr, "Error : different tail in list (%d != nil)\n",
5971	cur->index);
5972	}
5973	}
5974	}
5975	if (!st_lookup(candList->table, (char *)(long)cur->index, &candidate)) {
5976	error++;
5977	fprintf(vis_stderr, "Error : index %d not in table\n", cur->index);
5978	}
5979	cur = next;
5980	}
5981	if (num != candList->num) {
5982	error++;
5983	fprintf(vis_stderr,
5984	"Error : different number of elements in list (%d != %d)\n",
5985	num, candList->num);
5986	}
5987	if (num != st_count(candList->table)) {
5988	error++;
5989	fprintf(vis_stderr,
5990	"Error : different number of elements in table (%d != %d)\n",
5991	num, st_count(candList->table));
5992	}
5993	assert(!error);
5994	}
5995
5996
5997	/Function******************************************************************
5998
5999	Synopsis [Clusters on the ordered bits.]
6000
6001	Description [Clusters on the ordered bits.]
6002
6003	SideEffects []
6004
6005	******************************************************************************/
6006	static void
6007	MlpCluster(mdd_manager mddManager, char *xy, int nRows, int nCols,
6008	int nActiveRows, int nActiveCols,
6009	int nClusterRows, int nClusterCols,
6010	int rowOrder, int colOrder,
6011	RcInfo_t rowInfo, RcInfo_t colInfo,
6012	array_t clusterArray, array_t arraySmoothVarBddArray,
6013	Img_DirectionType direction, int *cRowOrder,
6014	array_t nsVarBddArray, int sccBorder,
6015	int varPos, ImgTrmOption_t option)
6016	{
6017	int i, j, row, col;
6018	int ncRows, ncCols;
6019	int index, qVarPos;
6020	int s1, t1, s2;
6021	array_t *smoothVarBddArray;
6022	mdd_t nsVar, relation, cluster, tempCluster;
6023	ClusterList_t list, headCluster, tailCluster, nextList, *prevList;
6024	ClusterSortedList_t *clusterSortedList;
6025	long initialTime, finalTime;
6026	int moveFlag = 1;
6027	array_t *nonAppearingVarBddArray;
6028	char *existFlag;
6029	array_t supportArray, tmpArray;
6030	int nVars = bdd_num_vars(mddManager);
6031	mdd_t *one;
6032
6033	if (option->mlpVerbosity)
6034	initialTime = util_cpu_time();
6035	else
6036	initialTime = 0;
6037
6038	ncCols = nActiveCols;
6039	headCluster = NIL(ClusterList_t);
6040	tailCluster = NIL(ClusterList_t);
6041	clusterSortedList = NIL(ClusterSortedList_t);
6042	if (option->mlpCluster == 0) {
6043	if (direction == Img_Forward_c) {
6044	for (i = nActiveRows - 1; i >= 0;) {
6045	row = rowOrder[i];
6046
6047	list = ALLOC(ClusterList_t, 1);
6048	memset(list, 0, sizeof(ClusterList_t));
6049	list->flag = 3;
6050	list->start = i;
6051	list->end = i;
6052	list->supports = ALLOC(char, nCols);
6053	memcpy(list->supports, xy[row], sizeof(char) * nCols);
6054	list->minCol = rowInfo[row].gMin;
6055	list->maxCol = rowInfo[row].gMax;
6056	list->nSupports = MlpCountSupport(list, colOrder, ncCols);
6057	list->product = bdd_dup(rowInfo[row].data.row.func);
6058	list->nQuantifyVars = 0;
6059	list->affinity = 0.0;
6060	if (rowInfo[row].data.row.nsVarBddArray)
6061	list->nsVarBddArray = array_dup(rowInfo[row].data.row.nsVarBddArray);
6062	else
6063	list->nsVarBddArray = NIL(array_t);
6064
6065	if (headCluster)
6066	tailCluster->next = list;
6067	else
6068	headCluster = list;
6069	list->next = NIL(ClusterList_t);
6070	list->prev = tailCluster;
6071	tailCluster = list;
6072
6073	i--;
6074
6075	if (sccBorder && sccBorder[i + 1] == 1)
6076	continue;
6077	if (bdd_size(list->product) >= option->clusterSize)
6078	continue;
6079
6080	while (i >= 0) {
6081	row = rowOrder[i];
6082	relation = rowInfo[row].data.row.func;
6083	if (bdd_size(list->product) >= option->clusterSize)
6084	break;
6085	cluster = bdd_and(list->product, relation, 1, 1);
6086	if (bdd_size(cluster) <= option->clusterSize) {
6087	mdd_free(list->product);
6088	list->product = cluster;
6089	list->start = i;
6090
6091	if (list->nsVarBddArray) {
6092	array_append(list->nsVarBddArray,
6093	rowInfo[row].data.row.nsVarBddArray);
6094	}
6095
6096	list->nSupports = 0;
6097	list->minCol = nActiveCols;
6098	list->maxCol = -1;
6099	s1 = nActiveCols;
6100	t1 = -1;
6101	supportArray = mdd_get_bdd_support_ids(mddManager, list->product);
6102	for (j = 0; j < array_n(supportArray); j++) {
6103	index = array_fetch(int, supportArray, j);
6104	if (varPos[index] == 0) {
6105	if ((int)bdd_top_var_id(colInfo[0].data.col.var) != index)
6106	continue;
6107	}
6108	index = varPos[index];
6109	list->supports[index] = 1;
6110	list->nSupports++;
6111	s2 = colInfo[index].pos;
6112	if (s2 < s1) {
6113	s1 = s2;
6114	list->minCol = index;
6115	}
6116	if (s2 > t1) {
6117	t1 = s2;
6118	list->maxCol = index;
6119	}
6120	}
6121	array_free(supportArray);
6122
6123	i--;
6124	if (option->mlpDebug)
6125	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6126	} else {
6127	mdd_free(cluster);
6128	break;
6129	}
6130	}
6131
6132	ncCols = RemoveLocalVarsInCluster(mddManager, xy,
6133	list, nActiveRows, ncCols,
6134	rowInfo, colInfo,
6135	rowOrder, colOrder,
6136	moveFlag, option);
6137	}
6138	} else {
6139	for (i = 0; i < nActiveRows;) {
6140	row = rowOrder[i];
6141
6142	list = ALLOC(ClusterList_t, 1);
6143	memset(list, 0, sizeof(ClusterList_t));
6144	list->flag = 3;
6145	list->start = i;
6146	list->end = i;
6147	list->supports = ALLOC(char, nCols);
6148	memcpy(list->supports, xy[row], sizeof(char) * nCols);
6149	list->minCol = rowInfo[row].gMin;
6150	list->maxCol = rowInfo[row].gMax;
6151	list->nSupports = MlpCountSupport(list, colOrder, ncCols);
6152	list->product = bdd_dup(rowInfo[row].data.row.func);
6153	list->nQuantifyVars = 0;
6154	list->affinity = 0.0;
6155	if (rowInfo[row].data.row.nsVarBddArray)
6156	list->nsVarBddArray = array_dup(rowInfo[row].data.row.nsVarBddArray);
6157	else
6158	list->nsVarBddArray = NIL(array_t);
6159
6160	if (headCluster)
6161	tailCluster->next = list;
6162	else
6163	headCluster = list;
6164	list->next = NIL(ClusterList_t);
6165	list->prev = tailCluster;
6166	tailCluster = list;
6167
6168	i++;
6169
6170	if (sccBorder && sccBorder[i - 1] == 2)
6171	continue;
6172	if (bdd_size(list->product) >= option->clusterSize)
6173	continue;
6174
6175	while (i < nActiveRows) {
6176	row = rowOrder[i];
6177	relation = rowInfo[row].data.row.func;
6178	if (bdd_size(list->product) >= option->clusterSize)
6179	break;
6180	cluster = bdd_and(list->product, relation, 1, 1);
6181	if (bdd_size(cluster) <= option->clusterSize) {
6182	mdd_free(list->product);
6183	list->product = cluster;
6184	list->end = i;
6185
6186	if (list->nsVarBddArray) {
6187	array_append(list->nsVarBddArray,
6188	rowInfo[row].data.row.nsVarBddArray);
6189	}
6190
6191	list->nSupports = 0;
6192	list->minCol = nActiveCols;
6193	list->maxCol = -1;
6194	s1 = nActiveCols;
6195	t1 = -1;
6196	supportArray = mdd_get_bdd_support_ids(mddManager, list->product);
6197	for (j = 0; j < array_n(supportArray); j++) {
6198	index = array_fetch(int, supportArray, j);
6199	if (varPos[index] == 0) {
6200	if ((int)bdd_top_var_id(colInfo[0].data.col.var) != index)
6201	continue;
6202	}
6203	index = varPos[index];
6204	list->supports[index] = 1;
6205	list->nSupports++;
6206	s2 = colInfo[index].pos;
6207	if (s2 < s1) {
6208	s1 = s2;
6209	list->minCol = index;
6210	}
6211	if (s2 > t1) {
6212	t1 = s2;
6213	list->maxCol = index;
6214	}
6215	}
6216	array_free(supportArray);
6217
6218	i++;
6219	if (option->mlpDebug)
6220	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6221	} else {
6222	mdd_free(cluster);
6223	break;
6224	}
6225	}
6226
6227	ncCols = RemoveLocalVarsInCluster(mddManager, xy,
6228	list, nActiveRows, ncCols,
6229	rowInfo, colInfo,
6230	rowOrder, colOrder,
6231	moveFlag, option);
6232	}
6233	}
6234	} else { /* option->mlpCluster == 1 */
6235	if (direction == Img_Forward_c) {
6236	for (i = 0; i < nActiveRows; i++) {
6237	row = rowOrder[i];
6238	list = ALLOC(ClusterList_t, 1);
6239	memset(list, 0, sizeof(ClusterList_t));
6240
6241	if (headCluster && headCluster->flag != 3)
6242	list->flag = 1;
6243	else
6244	list->flag = 2;
6245	list->start = i;
6246	list->end = i;
6247	list->supports = ALLOC(char, nCols);
6248	memcpy(list->supports, xy[row], sizeof(char) * nCols);
6249	list->minCol = rowInfo[row].gMin;
6250	list->maxCol = rowInfo[row].gMax;
6251	list->nSupports = MlpCountSupport(list, colOrder, ncCols);
6252	list->product = bdd_dup(rowInfo[row].data.row.func);
6253	list->nQuantifyVars = MlpNumQuantifyVars(list, rowInfo, colInfo,
6254	colOrder, ncCols);
6255	if (rowInfo[row].data.row.nsVarBddArray)
6256	list->nsVarBddArray = array_dup(rowInfo[row].data.row.nsVarBddArray);
6257	else
6258	list->nsVarBddArray = NIL(array_t);
6259
6260	if (bdd_size(list->product) >= option->clusterSize) {
6261	if (headCluster) {
6262	ncCols = RecursiveCluster(mddManager, headCluster,
6263	clusterSortedList,
6264	xy, rowInfo, colInfo,
6265	rowOrder, colOrder, nActiveRows, ncCols,
6266	direction, varPos, moveFlag, option);
6267	if (option->mlpDebug)
6268	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6269	}
6270	list->flag = 3;
6271	ncCols = RemoveLocalVarsInCluster(mddManager, xy,
6272	list, nActiveRows, ncCols,
6273	rowInfo, colInfo,
6274	rowOrder, colOrder,
6275	moveFlag, option);
6276	if (option->mlpDebug)
6277	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6278	list->affinity = 0.0;
6279	clusterSortedList = NIL(ClusterSortedList_t);
6280	} else if (sccBorder && i > 0 && sccBorder[i] == 1) {
6281	ncCols = RecursiveCluster(mddManager, headCluster,
6282	clusterSortedList,
6283	xy, rowInfo, colInfo,
6284	rowOrder, colOrder, nActiveRows, ncCols,
6285	direction, varPos, moveFlag, option);
6286	if (option->mlpDebug)
6287	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6288	list->flag = 2;
6289	list->affinity = 0.0;
6290	clusterSortedList = NIL(ClusterSortedList_t);
6291	if (option->mlpClusterSortedList) {
6292	clusterSortedList = ClusterSortedListInsert(clusterSortedList, list,
6293	option->mlpClusterQuantifyVars);
6294	}
6295	} else {
6296	if (headCluster && headCluster->flag != 3) {
6297	list->affinity = MlpSupportAffinity(list, headCluster, colInfo,
6298	colOrder, ncCols,
6299	option->mlpCluster);
6300	} else
6301	list->affinity = 0.0;
6302	if (option->mlpClusterSortedList) {
6303	clusterSortedList = ClusterSortedListInsert(clusterSortedList, list,
6304	option->mlpClusterQuantifyVars);
6305	}
6306	}
6307
6308	list->next = headCluster;
6309	list->prev = NIL(ClusterList_t);
6310	if (headCluster) {
6311	if (headCluster->flag == 1)
6312	headCluster->flag = 0;
6313	headCluster->prev = list;
6314	}
6315	headCluster = list;
6316	}
6317	} else {
6318	for (i = nActiveRows - 1; i >= 0; i--) {
6319	row = rowOrder[i];
6320	list = ALLOC(ClusterList_t, 1);
6321	memset(list, 0, sizeof(ClusterList_t));
6322
6323	if (headCluster && headCluster->flag != 3)
6324	list->flag = 1;
6325	else
6326	list->flag = 2;
6327	list->start = i;
6328	list->end = i;
6329	list->supports = ALLOC(char, nCols);
6330	memcpy(list->supports, xy[row], sizeof(char) * nCols);
6331	list->minCol = rowInfo[row].gMin;
6332	list->maxCol = rowInfo[row].gMax;
6333	list->nSupports = MlpCountSupport(list, colOrder, ncCols);
6334	list->product = bdd_dup(rowInfo[row].data.row.func);
6335	list->nQuantifyVars = MlpNumQuantifyVars(list, rowInfo, colInfo,
6336	colOrder, ncCols);
6337	if (rowInfo[row].data.row.nsVarBddArray)
6338	list->nsVarBddArray = array_dup(rowInfo[row].data.row.nsVarBddArray);
6339	else
6340	list->nsVarBddArray = NIL(array_t);
6341
6342	if ( bdd_size(list->product) >= option->clusterSize) {
6343	if (headCluster) {
6344	ncCols = RecursiveCluster(mddManager, headCluster,
6345	clusterSortedList,
6346	xy, rowInfo, colInfo,
6347	rowOrder, colOrder, nActiveRows, ncCols,
6348	direction, varPos, moveFlag, option);
6349	if (option->mlpDebug)
6350	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6351	}
6352	list->flag = 3;
6353	ncCols = RemoveLocalVarsInCluster(mddManager, xy,
6354	list, nActiveRows, ncCols,
6355	rowInfo, colInfo,
6356	rowOrder, colOrder,
6357	moveFlag, option);
6358	if (option->mlpDebug)
6359	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6360	list->affinity = 0.0;
6361	clusterSortedList = NIL(ClusterSortedList_t);
6362	} else if (sccBorder && i < (nActiveRows - 1) && sccBorder[i] == 2) {
6363	ncCols = RecursiveCluster(mddManager, headCluster,
6364	clusterSortedList,
6365	xy, rowInfo, colInfo,
6366	rowOrder, colOrder, nActiveRows, ncCols,
6367	direction, varPos, moveFlag, option);
6368	if (option->mlpDebug)
6369	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6370	list->flag = 2;
6371	list->affinity = 0.0;
6372	clusterSortedList = NIL(ClusterSortedList_t);
6373	if (option->mlpClusterSortedList) {
6374	clusterSortedList = ClusterSortedListInsert(clusterSortedList, list,
6375	option->mlpClusterQuantifyVars);
6376	}
6377	} else {
6378	if (headCluster && headCluster->flag != 3) {
6379	list->affinity = MlpSupportAffinity(list, headCluster, colInfo,
6380	colOrder, ncCols,
6381	option->mlpCluster);
6382	} else
6383	list->affinity = 0.0;
6384	if (option->mlpClusterSortedList) {
6385	clusterSortedList = ClusterSortedListInsert(clusterSortedList, list,
6386	option->mlpClusterQuantifyVars);
6387	}
6388	}
6389
6390	list->next = headCluster;
6391	list->prev = NIL(ClusterList_t);
6392	if (headCluster) {
6393	if (headCluster->flag == 1)
6394	headCluster->flag = 0;
6395	headCluster->prev = list;
6396	}
6397	headCluster = list;
6398
6399	if (option->mlpClusterSortedList && option->mlpDebug) {
6400	int n1, n2;
6401
6402	n1 = CountClusterList(headCluster);
6403	n2 = CountClusterSortedList(clusterSortedList);
6404	assert(n1 == n2);
6405	}
6406	}
6407	}
6408
6409	if (headCluster->flag == 1) {
6410	ncCols = RecursiveCluster(mddManager, headCluster, clusterSortedList,
6411	xy, rowInfo, colInfo,
6412	rowOrder, colOrder, nActiveRows, ncCols,
6413	direction, varPos, moveFlag, option);
6414	if (option->mlpDebug)
6415	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6416	}
6417	}
6418
6419	list = headCluster;
6420	one = bdd_one(mddManager);
6421	while (list) {
6422	if (bdd_equal(list->product, one)) {
6423	assert(list->nSupports == 0);
6424
6425	prevList = list->prev;
6426	nextList = list->next;
6427	if ((!prevList) && (!nextList)) /* unity relation */
6428	break;
6429
6430	mdd_free(list->product);
6431	if (list->nsVarBddArray)
6432	array_free(list->nsVarBddArray);
6433	FREE(list->supports);
6434
6435	if (nextList) {
6436	if (list->start < nextList->start)
6437	nextList->start = list->start;
6438	if (list->end > nextList->end)
6439	nextList->end = list->end;
6440
6441	if (list == headCluster)
6442	headCluster = nextList;
6443
6444	FREE(list);
6445	} else {
6446	if (list->start < prevList->start)
6447	prevList->start = list->start;
6448	if (list->end > prevList->end)
6449	prevList->end = list->end;
6450	FREE(list);
6451	}
6452	if (prevList)
6453	prevList->next = nextList;
6454	if (nextList)
6455	nextList->prev = prevList;
6456	list = nextList;
6457	continue;
6458	}
6459	list = list->next;
6460	}
6461	bdd_free(one);
6462
6463	if (option->mlpVerbosity >= 3 && option->mlpPrintMatrix) {
6464	PrintMatrixWithCluster(xy, headCluster, ncCols, rowOrder, colOrder,
6465	direction);
6466	fprintf(vis_stdout, "****** cluster matrix **********\n");
6467	PrintClusterMatrix(headCluster, ncCols, colOrder, direction);
6468	}
6469	if (option->mlpDebug)
6470	CheckCluster(headCluster, ncCols, colInfo, colOrder);
6471
6472	ncRows = 0;
6473	nonAppearingVarBddArray = NIL(array_t);
6474	if ((direction == Img_Forward_c && option->mlpReorder) \|\|
6475	(direction == Img_Backward_c && option->mlpPreReorder) \|\|
6476	option->mlpPostProcess >= 2) {
6477	list = headCluster;
6478	while (list) {
6479	row = rowOrder[ncRows];
6480
6481	mdd_free(rowInfo[row].data.row.func);
6482	rowInfo[row].data.row.func = list->product;
6483	list->product = NIL(mdd_t);
6484
6485	if (xy[row])
6486	FREE(xy[row]);
6487	xy[row] = list->supports;
6488	list->supports = NIL(char);
6489
6490	rowInfo[row].gNum = list->nSupports;
6491	rowInfo[row].gMin = list->minCol;
6492	rowInfo[row].gMax = list->maxCol;
6493	rowInfo[row].lNum = list->nSupports;
6494	rowInfo[row].lMin = list->minCol;
6495	rowInfo[row].lMax = list->maxCol;
6496	rowInfo[row].prevG = -1;
6497	rowInfo[row].nextG = ncCols;
6498
6499	if (list->nsVarBddArray) {
6500	if (rowInfo[row].data.row.nsVarBddArray)
6501	array_free(rowInfo[row].data.row.nsVarBddArray);
6502	rowInfo[row].data.row.nsVarBddArray = list->nsVarBddArray;
6503	list->nsVarBddArray = NIL(array_t);
6504	}
6505
6506	nextList = list->next;
6507	FREE(list);
6508	ncRows++;
6509	list = nextList;
6510	}
6511
6512	if (direction == Img_Forward_c) {
6513	for (i = 0; i < ncRows; i++) {
6514	cRowOrder[i] = rowOrder[ncRows - i - 1];
6515	rowInfo[rowOrder[ncRows - i - 1]].pos = i;
6516	}
6517	} else {
6518	for (i = 0; i < ncRows; i++) {
6519	cRowOrder[i] = rowOrder[i];
6520	rowInfo[rowOrder[i]].pos = i;
6521	}
6522	}
6523
6524	for (j = 0; j < ncCols; j++) {
6525	col = colOrder[j];
6526	colInfo[col].gNum = 0;
6527	colInfo[col].gMin = ncRows;
6528	colInfo[col].gMax = -1;
6529	for (i = 0; i < ncRows; i++) {
6530	row = cRowOrder[i];
6531	if (xy[row][col]) {
6532	colInfo[col].gNum++;
6533	if (colInfo[col].gMin == ncRows)
6534	colInfo[col].gMin = row;
6535	colInfo[col].gMax = row;
6536	}
6537	}
6538	colInfo[col].lNum = colInfo[col].gNum;
6539	colInfo[col].lMin = colInfo[col].gMin;
6540	colInfo[col].lMax = colInfo[col].gMax;
6541	colInfo[col].prevG = -1;
6542	colInfo[col].nextG = ncRows;
6543	}
6544	} else {
6545	if (direction == Img_Forward_c) {
6546	if (arraySmoothVarBddArray) {
6547	nonAppearingVarBddArray = array_fetch(array_t *,
6548	arraySmoothVarBddArray, 0);
6549	if (nCols > ncCols) {
6550	existFlag = ALLOC(char, nVars);
6551	memset(existFlag, 0, sizeof(char) * nVars);
6552
6553	for (i = 0; i < array_n(nonAppearingVarBddArray); i++) {
6554	nsVar = array_fetch(bdd_t *, nonAppearingVarBddArray, i);
6555	index = (int)bdd_top_var_id(nsVar);
6556	existFlag[index] = 1;
6557	}
6558
6559	for (i = ncCols; i < nCols; i++) {
6560	col = colOrder[i];
6561	index = (int)bdd_top_var_id(colInfo[col].data.col.var);
6562	if (!existFlag[index]) {
6563	array_insert_last(bdd_t *, nonAppearingVarBddArray,
6564	bdd_dup(colInfo[col].data.col.var));
6565	}
6566	}
6567
6568	FREE(existFlag);
6569	}
6570	qVarPos = ncCols - 1;
6571	if (qVarPos >= 0) {
6572	col = colOrder[qVarPos];
6573	while (colInfo[col].gNum == 0) {
6574	array_insert_last(bdd_t *, nonAppearingVarBddArray,
6575	bdd_dup(colInfo[col].data.col.var));
6576	if (qVarPos == 0)
6577	break;
6578	qVarPos--;
6579	col = colOrder[qVarPos];
6580	}
6581	}
6582	} else
6583	qVarPos = 0; /* to avoid warning */
6584	} else {
6585	if (arraySmoothVarBddArray) {
6586	nonAppearingVarBddArray = array_fetch(array_t *,
6587	arraySmoothVarBddArray, 0);
6588	if (nCols > ncCols) {
6589	for (i = ncCols; i < nCols; i++) {
6590	col = colOrder[i];
6591	if (colInfo[col].data.col.type == 2) {
6592	array_insert_last(bdd_t *, nonAppearingVarBddArray,
6593	bdd_dup(colInfo[col].data.col.var));
6594	}
6595	}
6596	}
6597	qVarPos = ncCols - 1;
6598	if (qVarPos >= 0) {
6599	col = colOrder[qVarPos];
6600	while (colInfo[col].gNum == 0) {
6601	if (colInfo[col].data.col.type == 2) {
6602	array_insert_last(bdd_t *, nonAppearingVarBddArray,
6603	bdd_dup(colInfo[col].data.col.var));
6604	}
6605	if (qVarPos == 0)
6606	break;
6607	qVarPos--;
6608	col = colOrder[qVarPos];
6609	}
6610	}
6611
6612	existFlag = ALLOC(char, nVars);
6613	memset(existFlag, 0, sizeof(char) * nVars);
6614
6615	for (i = 0; i < array_n(nonAppearingVarBddArray); i++) {
6616	nsVar = array_fetch(bdd_t *, nonAppearingVarBddArray, i);
6617	index = (int)bdd_top_var_id(nsVar);
6618	existFlag[index] = 1;
6619	}
6620
6621	if (nRows > nActiveRows) {
6622	for (i = nActiveRows; i < nRows; i++) {
6623	row = rowOrder[i];
6624	tmpArray = rowInfo[row].data.row.nsVarBddArray;
6625	for (j = 0; j < array_n(tmpArray); j++) {
6626	nsVar = array_fetch(bdd_t *, tmpArray, j);
6627	index = (int)bdd_top_var_id(nsVar);
6628	existFlag[index] = 1;
6629	}
6630	}
6631	}
6632
6633	list = headCluster;
6634	while (list) {
6635	supportArray = mdd_get_bdd_support_ids(mddManager, list->product);
6636	for (i = 0; i < array_n(supportArray); i++) {
6637	index = array_fetch(int, supportArray, i);
6638	existFlag[index] = 1;
6639	}
6640	array_free(supportArray);
6641	list = list->next;
6642	}
6643
6644	list = headCluster;
6645	while (list) {
6646	for (i = 0; i < array_n(list->nsVarBddArray); i++) {
6647	nsVar = array_fetch(bdd_t *, list->nsVarBddArray, i);
6648	index = (int)bdd_top_var_id(nsVar);
6649	if (!existFlag[index]) {
6650	tmpArray = array_alloc(mdd_t *, 0);
6651	for (j = 0; j < i; j++) {
6652	nsVar = array_fetch(bdd_t *, list->nsVarBddArray, j);
6653	array_insert_last(mdd_t *, tmpArray, nsVar);
6654	}
6655	for (j = i + 1; j < array_n(list->nsVarBddArray); j++) {
6656	nsVar = array_fetch(bdd_t *, list->nsVarBddArray, j);
6657	index = (int)bdd_top_var_id(nsVar);
6658	if (existFlag[index])
6659	array_insert_last(mdd_t *, tmpArray, nsVar);
6660	}
6661	array_free(list->nsVarBddArray);
6662	list->nsVarBddArray = tmpArray;
6663	break;
6664	}
6665	}
6666	list = list->next;
6667	}
6668
6669	for (i = 0; i < array_n(nsVarBddArray); i++) {
6670	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
6671	index = (int)bdd_top_var_id(nsVar);
6672	if (!existFlag[index])
6673	array_insert_last(mdd_t *, nonAppearingVarBddArray, bdd_dup(nsVar));
6674	}
6675
6676	FREE(existFlag);
6677	} else
6678	qVarPos = 0; /* to avoid warning */
6679	}
6680
6681	if (direction == Img_Backward_c && nRows > nActiveRows) {
6682	cluster = bdd_one(mddManager);
6683	if (arraySmoothVarBddArray)
6684	smoothVarBddArray = array_alloc(array_t *, 0);
6685	else
6686	smoothVarBddArray = NIL(array_t);
6687	for (i = nActiveRows; i < nRows; i++) {
6688	row = rowOrder[i];
6689	relation = rowInfo[row].data.row.func;
6690	if (bdd_is_tautology(relation, 1))
6691	continue;
6692	if (smoothVarBddArray) {
6693	tmpArray = rowInfo[row].data.row.nsVarBddArray;
6694	for (j = 0; j < array_n(tmpArray); j++) {
6695	nsVar = array_fetch(bdd_t *, tmpArray, j);
6696	array_insert_last(mdd_t *, smoothVarBddArray, bdd_dup(nsVar));
6697	}
6698	}
6699	tempCluster = bdd_and(cluster, relation, 1, 1);
6700	bdd_free(cluster);
6701	cluster = tempCluster;
6702	}
6703	if (bdd_is_tautology(cluster, 1)) {
6704	mdd_free(cluster);
6705	if (smoothVarBddArray)
6706	mdd_array_free(smoothVarBddArray);
6707	} else {
6708	array_insert_last(bdd_t *, clusterArray, cluster);
6709	if (arraySmoothVarBddArray) {
6710	array_insert_last(array_t *, arraySmoothVarBddArray,
6711	smoothVarBddArray);
6712	}
6713	ncRows++;
6714	}
6715	}
6716
6717	list = headCluster;
6718	while (list) {
6719	array_insert_last(mdd_t *, clusterArray, list->product);
6720	list->product = NIL(mdd_t);
6721
6722	if (arraySmoothVarBddArray) {
6723	if (direction == Img_Forward_c) {
6724	smoothVarBddArray = array_alloc(array_t *, 0);
6725	if (qVarPos >= 0) {
6726	col = colOrder[qVarPos];
6727	while (rowInfo[colInfo[col].gMin].pos >= list->start &&
6728	rowInfo[colInfo[col].gMin].pos <= list->end) {
6729	array_insert_last(bdd_t *, smoothVarBddArray,
6730	bdd_dup(colInfo[col].data.col.var));
6731	if (qVarPos == 0)
6732	break;
6733	qVarPos--;
6734	col = colOrder[qVarPos];
6735	}
6736	}
6737	array_insert_last(array_t *, arraySmoothVarBddArray,
6738	smoothVarBddArray);
6739	} else {
6740	smoothVarBddArray = array_alloc(array_t *, 0);
6741	for (i = 0; i < array_n(list->nsVarBddArray); i++) {
6742	nsVar = array_fetch(bdd_t *, list->nsVarBddArray, i);
6743	array_insert_last(bdd_t *, smoothVarBddArray, bdd_dup(nsVar));
6744	}
6745
6746	if (list->nSupports > 0) {
6747	s1 = colInfo[list->minCol].pos;
6748	t1 = colInfo[list->maxCol].pos;
6749	for (i = s1; i <= t1; i++) {
6750	col = colOrder[i];
6751	if (colInfo[col].data.col.type == 2) {
6752	if (rowInfo[colInfo[col].gMax].pos >= list->start &&
6753	rowInfo[colInfo[col].gMax].pos <= list->end) {
6754	array_insert_last(bdd_t *, smoothVarBddArray,
6755	bdd_dup(colInfo[col].data.col.var));
6756	}
6757	}
6758	}
6759	}
6760	array_insert_last(array_t *, arraySmoothVarBddArray,
6761	smoothVarBddArray);
6762	}
6763	}
6764
6765	nextList = list->next;
6766	if (list->nsVarBddArray)
6767	array_free(list->nsVarBddArray);
6768	FREE(list->supports);
6769	FREE(list);
6770	ncRows++;
6771	list = nextList;
6772	}
6773
6774	if (direction == Img_Forward_c && nRows > nActiveRows) {
6775	cluster = bdd_one(mddManager);
6776	for (i = nActiveRows; i < nRows; i++) {
6777	row = rowOrder[i];
6778	relation = rowInfo[row].data.row.func;
6779	if (bdd_is_tautology(relation, 1))
6780	continue;
6781	tempCluster = bdd_and(cluster, relation, 1, 1);
6782	bdd_free(cluster);
6783	cluster = tempCluster;
6784	}
6785	if (bdd_is_tautology(cluster, 1))
6786	mdd_free(cluster);
6787	else {
6788	array_insert_last(bdd_t *, clusterArray, cluster);
6789	if (arraySmoothVarBddArray) {
6790	smoothVarBddArray = array_alloc(array_t *, 0);
6791	array_insert_last(array_t *, arraySmoothVarBddArray,
6792	smoothVarBddArray);
6793	}
6794	ncRows++;
6795	}
6796	}
6797	}
6798
6799	*nClusterRows = ncRows;
6800	*nClusterCols = ncCols;
6801
6802	if (option->mlpVerbosity) {
6803	finalTime = util_cpu_time();
6804	fprintf(vis_stdout, "time for clustering = %10g\n",
6805	(double)(finalTime - initialTime) / 1000.0);
6806	}
6807	}
6808
6809
6810	/Function******************************************************************
6811
6812	Synopsis [Counts the number of supports of the list.]
6813
6814	Description [Counts the number of supports of the list.]
6815
6816	SideEffects []
6817
6818	******************************************************************************/
6819	static int
6820	MlpCountSupport(ClusterList_t list, int colOrder, int nActiveCols)
6821	{
6822	int i, col;
6823	int nSupports = 0;
6824
6825	for (i = 0; i < nActiveCols; i++) {
6826	col = colOrder[i];
6827	if (list->supports[col])
6828	nSupports++;
6829	}
6830	return(nSupports);
6831	}
6832
6833
6834	/Function******************************************************************
6835
6836	Synopsis [Computes the affinity of two lists.]
6837
6838	Description [Computes the affinity of two lists.]
6839
6840	SideEffects []
6841
6842	******************************************************************************/
6843	static float
6844	MlpSupportAffinity(ClusterList_t curList, ClusterList_t nextList,
6845	RcInfo_t colInfo, int colOrder,
6846	int nActiveCols, int clusterMethod)
6847	{
6848	ClusterList_t minList, maxList;
6849	int i, col, s, t;
6850	int nOverlaps = 0;
6851	float affinity;
6852
6853	if (curList->nSupports <= nextList->nSupports) {
6854	minList = curList;
6855	maxList = nextList;
6856	} else {
6857	minList = nextList;
6858	maxList = curList;
6859	}
6860
6861	s = colInfo[minList->minCol].pos;
6862	t = colInfo[minList->maxCol].pos;
6863	for (i = s; i <= t; i++) {
6864	col = colOrder[i];
6865	if (minList->supports[col] && maxList->supports[col])
6866	nOverlaps++;
6867	}
6868
6869	if (clusterMethod == 1)
6870	affinity = (float)nOverlaps / (float)minList->nSupports;
6871	else {
6872	affinity = (float)nOverlaps /
6873	(float)(minList->nSupports + maxList->nSupports - nOverlaps);
6874	}
6875	return(affinity);
6876	}
6877
6878
6879	/Function******************************************************************
6880
6881	Synopsis [Clusters recursively with affinity.]
6882
6883	Description [Clusters recursively with affinity.]
6884
6885	SideEffects []
6886
6887	******************************************************************************/
6888	static int
6889	RecursiveCluster(mdd_manager mddManager, ClusterList_t headCluster,
6890	ClusterSortedList_t *clusterSortedList,
6891	char *xy, RcInfo_t rowInfo, RcInfo_t *colInfo,
6892	int rowOrder, int colOrder,
6893	int nActiveRows, int nClusterCols,
6894	Img_DirectionType direction, int *varPos,
6895	int moveFlag, ImgTrmOption_t *option)
6896	{
6897	ClusterSortedList_t sortedList, nextSortedList, *prevSortedList;
6898	ClusterSortedList_t firstSortedList, secondSortedList, *saveSortedList;
6899	ClusterSortedList_t tailSortedList1, tailSortedList2;
6900	ClusterList_t list, best;
6901	int i, n1, n2;
6902	int s1, t1, s2;
6903	mdd_t *product;
6904	int merge, index;
6905	array_t *supportArray;
6906
6907	if (headCluster->flag == 3)
6908	return(nClusterCols);
6909
6910	assert(headCluster);
6911	if (option->mlpClusterSortedList && option->mlpDebug) {
6912	n1 = CountClusterList(headCluster);
6913	n2 = CountClusterSortedList(clusterSortedList);
6914	assert(n1 == n2);
6915	}
6916
6917	if (headCluster->flag == 2) {
6918	assert(!headCluster->next \|\| headCluster->next->flag == 3);
6919	headCluster->flag = 3;
6920	nClusterCols = RemoveLocalVarsInCluster(mddManager, xy, headCluster,
6921	nActiveRows, nClusterCols,
6922	rowInfo, colInfo,
6923	rowOrder, colOrder,
6924	moveFlag, option);
6925	if (clusterSortedList) {
6926	assert(!clusterSortedList->next);
6927	FREE(clusterSortedList);
6928	}
6929	return(nClusterCols);
6930	}
6931
6932	merge = 0;
6933	best = NIL(ClusterList_t);
6934	if (option->mlpClusterMerge) {
6935	/* NEED */
6936	}
6937
6938	if (!best) {
6939	if (clusterSortedList)
6940	best = clusterSortedList->list;
6941	else {
6942	best = headCluster;
6943	list = headCluster->next;
6944	while (list) {
6945	if (list->flag == 2)
6946	break;
6947	if (option->mlpClusterQuantifyVars) {
6948	if (list->nQuantifyVars < best->nQuantifyVars \|\|
6949	(list->nQuantifyVars == best->nQuantifyVars &&
6950	list->affinity > best->affinity)) {
6951	best = list;
6952	}
6953	} else {
6954	if (list->affinity < option->mlpAffinityThreshold) {
6955	list = list->next;
6956	continue;
6957	}
6958	if (list->affinity > best->affinity \|\|
6959	(list->affinity == best->affinity &&
6960	list->nQuantifyVars < best->nQuantifyVars)) {
6961	best = list;
6962	}
6963	}
6964	list = list->next;
6965	}
6966	}
6967	}
6968	assert(best->next && best->next->flag != 3);
6969
6970	list = best->next;
6971	product = mdd_and(best->product, list->product, 1, 1);
6972
6973	if (merge == 0 && bdd_size(product) > option->clusterSize) {
6974	mdd_free(product);
6975
6976	firstSortedList = NIL(ClusterSortedList_t);
6977	secondSortedList = NIL(ClusterSortedList_t);
6978	if (option->mlpClusterSortedList) {
6979	tailSortedList1 = NIL(ClusterSortedList_t);
6980	tailSortedList2 = NIL(ClusterSortedList_t);
6981	sortedList = clusterSortedList;
6982	while (sortedList) {
6983	nextSortedList = sortedList->next;
6984	if ((best->start > list->start &&
6985	sortedList->list->start >= best->start) \|\|
6986	(best->start < list->start &&
6987	sortedList->list->start <= best->start)) {
6988	if (tailSortedList1)
6989	tailSortedList1->next = sortedList;
6990	else
6991	firstSortedList = sortedList;
6992	tailSortedList1 = sortedList;
6993	} else {
6994	if (tailSortedList2)
6995	tailSortedList2->next = sortedList;
6996	else
6997	secondSortedList = sortedList;
6998	tailSortedList2 = sortedList;
6999	}
7000	sortedList->next = NIL(ClusterSortedList_t);
7001	sortedList = nextSortedList;
7002	}
7003	}
7004
7005	if (best == headCluster) {
7006	best->flag = 3;
7007	if (option->mlpClusterSortedList) {
7008	sortedList = firstSortedList;
7009	firstSortedList = firstSortedList->next;
7010	FREE(sortedList);
7011	assert(!firstSortedList);
7012	}
7013	nClusterCols = RemoveLocalVarsInCluster(mddManager, xy, best,
7014	nActiveRows, nClusterCols,
7015	rowInfo, colInfo,
7016	rowOrder, colOrder,
7017	moveFlag, option);
7018	} else {
7019	best->flag = 2;
7020	if (option->mlpClusterSortedList) {
7021	sortedList = firstSortedList;
7022	prevSortedList = NIL(ClusterSortedList_t);
7023	saveSortedList = NIL(ClusterSortedList_t);
7024	while (sortedList) {
7025	nextSortedList = sortedList->next;
7026	if (sortedList->list == best) {
7027	if (nextSortedList) {
7028	if (prevSortedList)
7029	prevSortedList->next = sortedList->next;
7030	else
7031	firstSortedList = sortedList->next;
7032	}
7033	saveSortedList = sortedList;
7034	sortedList->next = NIL(ClusterSortedList_t);
7035	sortedList = nextSortedList;
7036	continue;
7037	}
7038	prevSortedList = sortedList;
7039	sortedList = nextSortedList;
7040	}
7041	prevSortedList->next = saveSortedList;
7042	}
7043	nClusterCols = RecursiveCluster(mddManager, headCluster, firstSortedList,
7044	xy, rowInfo, colInfo,
7045	rowOrder, colOrder,
7046	nActiveRows, nClusterCols,
7047	direction, varPos, moveFlag, option);
7048	}
7049	if (option->mlpDebug) {
7050	CheckCluster(headCluster, nClusterCols, colInfo, colOrder);
7051	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nClusterCols,
7052	rowInfo, colInfo, rowOrder, colOrder,
7053	0, nActiveRows - 1, 0, nClusterCols - 1, 0);
7054	}
7055
7056	if (list->flag == 0) {
7057	list->flag = 1;
7058	nClusterCols = RecursiveCluster(mddManager, list, secondSortedList,
7059	xy, rowInfo, colInfo,
7060	rowOrder, colOrder,
7061	nActiveRows, nClusterCols,
7062	direction, varPos, moveFlag, option);
7063	} else {
7064	list->flag = 3;
7065	sortedList = secondSortedList;
7066	secondSortedList = secondSortedList->next;
7067	FREE(sortedList);
7068	assert(!secondSortedList);
7069	nClusterCols = RemoveLocalVarsInCluster(mddManager, xy, list,
7070	nActiveRows, nClusterCols,
7071	rowInfo, colInfo,
7072	rowOrder, colOrder,
7073	moveFlag, option);
7074	}
7075	if (option->mlpDebug) {
7076	CheckCluster(headCluster, nClusterCols, colInfo, colOrder);
7077	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nClusterCols,
7078	rowInfo, colInfo, rowOrder, colOrder,
7079	0, nActiveRows - 1, 0, nClusterCols - 1, 0);
7080	}
7081	} else {
7082	if (merge == 0 && option->mlpClusterSortedList) {
7083	sortedList = clusterSortedList->next;
7084	FREE(clusterSortedList);
7085	clusterSortedList = sortedList;
7086	}
7087
7088	mdd_free(best->product);
7089	best->product = product;
7090
7091	if (list->flag == 2) {
7092	if (best->flag == 1)
7093	best->flag = 3;
7094	else
7095	best->flag = 2;
7096	}
7097
7098	best->nSupports = 0;
7099	best->minCol = nClusterCols;
7100	best->maxCol = -1;
7101	s1 = nClusterCols;
7102	t1 = -1;
7103	supportArray = mdd_get_bdd_support_ids(mddManager, best->product);
7104	for (i = 0; i < array_n(supportArray); i++) {
7105	index = array_fetch(int, supportArray, i);
7106	if (varPos[index] == 0) {
7107	if ((int)bdd_top_var_id(colInfo[0].data.col.var) != index)
7108	continue;
7109	}
7110	index = varPos[index];
7111	best->supports[index] = 1;
7112	best->nSupports++;
7113	s2 = colInfo[index].pos;
7114	if (s2 < s1) {
7115	s1 = s2;
7116	best->minCol = index;
7117	}
7118	if (s2 > t1) {
7119	t1 = s2;
7120	best->maxCol = index;
7121	}
7122	}
7123	array_free(supportArray);
7124
7125	if (best->nsVarBddArray)
7126	array_append(best->nsVarBddArray, list->nsVarBddArray);
7127
7128	if (list->start < best->start)
7129	best->start = list->start;
7130	if (list->end > best->end)
7131	best->end = list->end;
7132
7133	if (option->mlpClusterSortedList) {
7134	sortedList = clusterSortedList;
7135	prevSortedList = NIL(ClusterSortedList_t);
7136	if (merge == 0) {
7137	while (sortedList) {
7138	nextSortedList = sortedList->next;
7139	if (option->mlpClusterDynamic) {
7140	if (sortedList->list == list \|\| sortedList->list == best->prev) {
7141	if (prevSortedList)
7142	prevSortedList->next = sortedList->next;
7143	else
7144	clusterSortedList = sortedList->next;
7145	FREE(sortedList);
7146	sortedList = nextSortedList;
7147	continue;
7148	}
7149	} else {
7150	if (sortedList->list == list) {
7151	best->affinity = list->affinity;
7152	sortedList->list = best;
7153	break;
7154	}
7155	}
7156	prevSortedList = sortedList;
7157	sortedList = nextSortedList;
7158	}
7159	} else {
7160	while (sortedList) {
7161	nextSortedList = sortedList->next;
7162	if (option->mlpClusterDynamic) {
7163	if (sortedList->list == best \|\|
7164	sortedList->list == list \|\| sortedList->list == best->prev) {
7165	if (prevSortedList)
7166	prevSortedList->next = sortedList->next;
7167	else
7168	clusterSortedList = sortedList->next;
7169	FREE(sortedList);
7170	sortedList = nextSortedList;
7171	continue;
7172	}
7173	} else {
7174	if (sortedList->list == best) {
7175	if (prevSortedList)
7176	prevSortedList->next = sortedList->next;
7177	else
7178	clusterSortedList = sortedList->next;
7179	FREE(sortedList);
7180	sortedList = nextSortedList;
7181	continue;
7182	} else if (sortedList->list == list) {
7183	best->affinity = list->affinity;
7184	sortedList->list = best;
7185	break;
7186	}
7187	}
7188	prevSortedList = sortedList;
7189	sortedList = nextSortedList;
7190	}
7191	}
7192	}
7193
7194	best->next = list->next;
7195	if (list->next)
7196	list->next->prev = best;
7197
7198	mdd_free(list->product);
7199	if (list->nsVarBddArray)
7200	array_free(list->nsVarBddArray);
7201	FREE(list->supports);
7202	FREE(list);
7203
7204	if (merge && best->flag != 3) {
7205	nClusterCols = RemoveLocalVarsInCluster(mddManager, xy, best,
7206	nActiveRows, nClusterCols,
7207	rowInfo, colInfo,
7208	rowOrder, colOrder,
7209	moveFlag, option);
7210	}
7211
7212	if (best->flag == 3) {
7213	nClusterCols = RemoveLocalVarsInCluster(mddManager, xy, best,
7214	nActiveRows, nClusterCols,
7215	rowInfo, colInfo,
7216	rowOrder, colOrder,
7217	moveFlag, option);
7218	} else {
7219	if (option->mlpClusterDynamic) {
7220	if (best->flag == 2)
7221	best->affinity = 0.0;
7222	else {
7223	best->affinity = MlpSupportAffinity(best, best->next, colInfo,
7224	colOrder, nClusterCols,
7225	option->mlpCluster);
7226	}
7227	if (best != headCluster) {
7228	best->prev->affinity = MlpSupportAffinity(best->prev, best, colInfo,
7229	colOrder, nClusterCols,
7230	option->mlpCluster);
7231	}
7232	}
7233	if (option->mlpClusterQuantifyVars == 2) {
7234	best->nQuantifyVars = MlpNumQuantifyVars(best, rowInfo, colInfo,
7235	colOrder, nClusterCols);
7236	}
7237	if (option->mlpClusterSortedList && option->mlpClusterDynamic) {
7238	clusterSortedList = ClusterSortedListInsert(clusterSortedList, best,
7239	option->mlpClusterQuantifyVars);
7240	if (best != headCluster) {
7241	clusterSortedList = ClusterSortedListInsert(clusterSortedList,
7242	best->prev,
7243	option->mlpClusterQuantifyVars);
7244	}
7245	}
7246	}
7247
7248	if (headCluster->flag == 1) {
7249	if (option->mlpDebug) {
7250	CheckCluster(headCluster, nClusterCols, colInfo, colOrder);
7251	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nClusterCols,
7252	rowInfo, colInfo, rowOrder, colOrder,
7253	0, nActiveRows - 1, 0, nClusterCols - 1, 0);
7254	}
7255	nClusterCols = RecursiveCluster(mddManager, headCluster,
7256	clusterSortedList,
7257	xy, rowInfo, colInfo,
7258	rowOrder, colOrder,
7259	nActiveRows, nClusterCols,
7260	direction, varPos, moveFlag, option);
7261	} else {
7262	if (!option->mlpClusterDynamic) {
7263	assert(!clusterSortedList->next);
7264	FREE(clusterSortedList);
7265	}
7266	}
7267	}
7268
7269	return(nClusterCols);
7270	}
7271
7272
7273	/Function******************************************************************
7274
7275	Synopsis [Removes local variables in a cluster.]
7276
7277	Description [Removes local variables in a cluster.]
7278
7279	SideEffects []
7280
7281	******************************************************************************/
7282	static int
7283	RemoveLocalVarsInCluster(mdd_manager mddManager, char *xy,
7284	ClusterList_t *list,
7285	int nActiveRows, int nClusterCols,
7286	RcInfo_t rowInfo, RcInfo_t colInfo,
7287	int rowOrder, int colOrder,
7288	int moveFlag, ImgTrmOption_t *option)
7289	{
7290	int i, j, k, row, col, otherCol;
7291	int s1, t1, s2, t2, s3, t3;
7292	mdd_t *product;
7293	array_t *localVarBddArray = NIL(array_t);
7294
7295	s1 = colInfo[list->minCol].pos;
7296	t1 = colInfo[list->maxCol].pos;
7297	for (i = t1; i >= s1; i--) {
7298	col = colOrder[i];
7299	if (colInfo[col].data.col.type == 2 &&
7300	rowInfo[colInfo[col].gMin].pos >= list->start &&
7301	rowInfo[colInfo[col].gMax].pos <= list->end) {
7302	if (!localVarBddArray)
7303	localVarBddArray = array_alloc(bdd_t *, 0);
7304	array_insert_last(bdd_t *, localVarBddArray, colInfo[col].data.col.var);
7305
7306	list->nSupports--;
7307	if (list->nSupports == 0) {
7308	list->minCol = -1;
7309	list->maxCol = -1;
7310	} else if (list->nSupports == 1) {
7311	if (list->minCol == col)
7312	list->minCol = list->maxCol;
7313	else
7314	list->maxCol = list->minCol;
7315	} else if (list->nSupports > 1) {
7316	if (list->minCol == col) {
7317	for (j = i + 1; j <= t1; j++) {
7318	otherCol = colOrder[j];
7319	if (list->supports[otherCol]) {
7320	list->minCol = otherCol;
7321	break;
7322	}
7323	}
7324	} else if (list->maxCol == col) {
7325	for (j = i - 1; j >= s1; j--) {
7326	otherCol = colOrder[j];
7327	if (list->supports[otherCol]) {
7328	list->maxCol = otherCol;
7329	break;
7330	}
7331	}
7332	}
7333	}
7334
7335	s2 = list->start;
7336	t2 = list->end;
7337	for (j = s2; j <= t2; j++) {
7338	row = rowOrder[j];
7339	if (xy[row][col]) {
7340	rowInfo[row].gNum--;
7341	if (rowInfo[row].gNum > 0) {
7342	s3 = colInfo[rowInfo[row].gMin].pos;
7343	t3 = colInfo[rowInfo[row].gMax].pos;
7344	if (rowInfo[row].gMin == col) {
7345	for (k = i + 1; k <= t3; k++) {
7346	otherCol = colOrder[k];
7347	if (xy[row][otherCol]) {
7348	rowInfo[row].gMin = otherCol;
7349	break;
7350	}
7351	}
7352	} else if (rowInfo[row].gMax == col) {
7353	for (k = i - 1; k >= s3; k--) {
7354	otherCol = colOrder[k];
7355	if (xy[row][otherCol]) {
7356	rowInfo[row].gMax = otherCol;
7357	break;
7358	}
7359	}
7360	}
7361	}
7362	}
7363	}
7364
7365	for (j = i; j < nClusterCols - 1; j++) {
7366	colOrder[j] = colOrder[j + 1];
7367	colInfo[colOrder[j]].pos = j;
7368	}
7369	colOrder[nClusterCols - 1] = col;
7370	colInfo[col].pos = nClusterCols - 1;
7371
7372	nClusterCols--;
7373
7374	if (option->mlpDebug) {
7375	CheckCluster(list, nClusterCols, colInfo, colOrder);
7376	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nClusterCols,
7377	rowInfo, colInfo, rowOrder, colOrder,
7378	0, nActiveRows - 1, 0, nClusterCols - 1, 0);
7379	}
7380	}
7381	}
7382
7383	if (localVarBddArray) {
7384	product = bdd_smooth(list->product, localVarBddArray);
7385	mdd_free(list->product);
7386	list->product = product;
7387	array_free(localVarBddArray);
7388	UpdateDisapearingPsVarsInCluster(mddManager, xy,
7389	nActiveRows, nClusterCols,
7390	rowOrder, colOrder, rowInfo, colInfo,
7391	list, moveFlag, option);
7392	}
7393
7394	return(nClusterCols);
7395	}
7396
7397
7398	/Function******************************************************************
7399
7400	Synopsis [Retuns the number of variables to be quantified in a list.]
7401
7402	Description [Retuns the number of variables to be quantified in a list.]
7403
7404	SideEffects []
7405
7406	******************************************************************************/
7407	static int
7408	MlpNumQuantifyVars(ClusterList_t list, RcInfo_t rowInfo, RcInfo_t *colInfo,
7409	int *colOrder, int nClusterCols)
7410	{
7411	int i, s, t, col;
7412	int nQuantifyVars = 0;
7413
7414	s = colInfo[list->minCol].pos;
7415	t = colInfo[list->maxCol].pos;
7416	for (i = t; i >= s; i--) {
7417	col = colOrder[i];
7418	if (rowInfo[colInfo[col].gMin].pos >= list->start &&
7419	rowInfo[colInfo[col].gMin].pos <= list->end) {
7420	nQuantifyVars++;
7421	} else
7422	break;
7423	}
7424
7425	return(nQuantifyVars);
7426	}
7427
7428
7429	/Function******************************************************************
7430
7431	Synopsis [Inserts a cluster in a sorting list.]
7432
7433	Description [Inserts a cluster in a sorting list.]
7434
7435	SideEffects []
7436
7437	******************************************************************************/
7438	static ClusterSortedList_t *
7439	ClusterSortedListInsert(ClusterSortedList_t *clusterSortedList,
7440	ClusterList_t *list, int useQuantifyVars)
7441	{
7442	ClusterSortedList_t sortedList, cur, *prev;
7443
7444	sortedList = ALLOC(ClusterSortedList_t, 1);
7445	sortedList->list = list;
7446
7447	if (!clusterSortedList) {
7448	sortedList->next = NIL(ClusterSortedList_t);
7449	return(sortedList);
7450	}
7451
7452	cur = clusterSortedList;
7453	prev = NIL(ClusterSortedList_t);
7454	while (cur) {
7455	if (list->flag == 2) {
7456	prev = cur;
7457	cur = cur->next;
7458	continue;
7459	}
7460	if (useQuantifyVars) {
7461	if (cur->list->flag == 2 \|\|
7462	list->nQuantifyVars < cur->list->nQuantifyVars \|\|
7463	(list->nQuantifyVars == cur->list->nQuantifyVars &&
7464	list->affinity >= cur->list->affinity)) {
7465	sortedList->next = cur;
7466	if (cur == clusterSortedList)
7467	clusterSortedList = sortedList;
7468	else
7469	prev->next = sortedList;
7470	break;
7471	}
7472	} else {
7473	if (cur->list->flag == 2 \|\|
7474	list->affinity > cur->list->affinity \|\|
7475	(list->affinity == cur->list->affinity &&
7476	list->nQuantifyVars <= cur->list->nQuantifyVars)) {
7477	sortedList->next = cur;
7478	if (cur == clusterSortedList)
7479	clusterSortedList = sortedList;
7480	else
7481	prev->next = sortedList;
7482	break;
7483	}
7484	}
7485	prev = cur;
7486	cur = cur->next;
7487	}
7488	if (!cur) {
7489	prev->next = sortedList;
7490	sortedList->next = NIL(ClusterSortedList_t);
7491	}
7492	return(clusterSortedList);
7493	}
7494
7495
7496	/Function******************************************************************
7497
7498	Synopsis [Returns the number of lists in a cluster list.]
7499
7500	Description [Returns the number of lists in a cluster list.]
7501
7502	SideEffects []
7503
7504	******************************************************************************/
7505	static int
7506	CountClusterList(ClusterList_t *clusterList)
7507	{
7508	ClusterList_t *list;
7509	int n = 0;
7510
7511	list = clusterList;
7512	while (list) {
7513	if (list->flag == 3)
7514	break;
7515	n++;
7516	if (list->flag == 2)
7517	break;
7518	list = list->next;
7519	}
7520
7521	return(n);
7522	}
7523
7524
7525	/Function******************************************************************
7526
7527	Synopsis [Returns the number of lists in a sorted cluster list.]
7528
7529	Description [Returns the number of lists in a sorted cluster list.]
7530
7531	SideEffects []
7532
7533	******************************************************************************/
7534	static int
7535	CountClusterSortedList(ClusterSortedList_t *clusterSortedList)
7536	{
7537	ClusterSortedList_t *sortedList;
7538	int n = 0;
7539
7540	sortedList = clusterSortedList;
7541	while (sortedList) {
7542	n++;
7543	sortedList = sortedList->next;
7544	}
7545
7546	return(n);
7547	}
7548
7549
7550	/Function******************************************************************
7551
7552	Synopsis [Creates an initial cluster using ARDC decomposition.]
7553
7554	Description [Creates an initial cluster using ARDC decomposition.]
7555
7556	SideEffects []
7557
7558	******************************************************************************/
7559	static array_t *
7560	CreateInitialCluster(mdd_manager mddManager, array_t relationArray,
7561	ImgFunctionData_t functionData, array_t nsVarBddArray,
7562	ImgTrmOption_t *option)
7563	{
7564	array_t *clusteredRelationArray;
7565	array_t *partitionArray;
7566	Part_Subsystem_t *partitionSubsystem;
7567	st_table *vertexTable;
7568	int i, j;
7569	int mddId;
7570	long bddId;
7571	Ntk_Node_t *latch;
7572	mdd_t cluster, product, relation, var;
7573	char *latchName;
7574	st_generator *stGen;
7575	st_table *id2relation;
7576	array_t *bddIdArray;
7577	int nVars;
7578	char *nsVarFlag;
7579	array_t *domainVars;
7580
7581	if (array_n(functionData->domainVars) == array_n(functionData->rangeVars))
7582	domainVars = functionData->domainVars;
7583	else {
7584	domainVars = array_alloc(int, 0);
7585	for (i = 0; i < array_n(functionData->rangeVars); i++) {
7586	mddId = array_fetch(int, functionData->domainVars, i);
7587	array_insert_last(int, domainVars, mddId);
7588	}
7589	}
7590	partitionArray = Fsm_ArdcDecomposeStateSpace(functionData->network,
7591	domainVars,
7592	functionData->roots,
7593	NIL(Fsm_ArdcOptions_t));
7594	if (domainVars != functionData->domainVars)
7595	array_free(domainVars);
7596
7597	nVars = bdd_num_vars(mddManager);
7598	nsVarFlag = ALLOC(char, nVars);
7599	memset(nsVarFlag, 0, sizeof(char) * nVars);
7600	for (i = 0; i < array_n(nsVarBddArray); i++) {
7601	var = array_fetch(mdd_t *, nsVarBddArray, i);
7602	bddId = (long) bdd_top_var_id(var);
7603	nsVarFlag[bddId] = 1;
7604	}
7605	clusteredRelationArray = array_alloc(mdd_t *, 0);
7606	id2relation = st_init_table(st_numcmp, st_numhash);
7607	for (i = 0; i < array_n(relationArray); i++) {
7608	relation = array_fetch(mdd_t *, relationArray, i);
7609	bddIdArray = mdd_get_bdd_support_ids(mddManager, relation);
7610	for (j = 0; j < array_n(bddIdArray); j++) {
7611	bddId = (long) array_fetch(int, bddIdArray, j);
7612	if (nsVarFlag[bddId]) {
7613	st_insert(id2relation, (char )bddId, (char )relation);
7614	break;
7615	}
7616	}
7617
7618	/* the relation of intermediate variable */
7619	if (j == array_n(bddIdArray)) {
7620	array_insert_last(mdd_t *, clusteredRelationArray, mdd_dup(relation));
7621	}
7622
7623	array_free(bddIdArray);
7624	}
7625	FREE(nsVarFlag);
7626
7627	arrayForEachItem(Part_Subsystem_t *, partitionArray, i, partitionSubsystem) {
7628	cluster = mdd_one(mddManager);
7629	vertexTable = Part_PartitionSubsystemReadVertexTable(partitionSubsystem);
7630	st_foreach_item(vertexTable, stGen, &latchName, NIL(char *)) {
7631	latch = Ntk_NetworkFindNodeByName(functionData->network, latchName);
7632	mddId = Ntk_NodeReadMddId(Ntk_NodeReadShadow(latch));
7633	bddIdArray = mdd_id_to_bdd_id_array(mddManager, mddId);
7634	for (j = 0; j < array_n(bddIdArray); j++) {
7635	bddId = (long) array_fetch(int, bddIdArray, j);
7636	if (st_lookup(id2relation, (char *)bddId, &relation)) {
7637	st_delete(id2relation, &bddId, NULL);
7638	product = mdd_and(cluster, relation, 1, 1);
7639	mdd_free(cluster);
7640	cluster = product;
7641	}
7642	}
7643	array_free(bddIdArray);
7644	}
7645	Part_PartitionSubsystemFree(partitionSubsystem);
7646	array_insert_last(mdd_t *, clusteredRelationArray, cluster);
7647	}
7648	array_free(partitionArray);
7649
7650	st_foreach_item(id2relation, stGen, &bddId, &relation) {
7651	array_insert_last(mdd_t *, clusteredRelationArray, mdd_dup(relation));
7652	}
7653	st_free_table(id2relation);
7654
7655	/*
7656	if (option->mlpDebug) {
7657	mdd_t tr1, tr2, *tmp;
7658
7659	tr1 = mdd_one(mddManager);
7660	for (i = 0; i < array_n(relationArray); i++) {
7661	relation = array_fetch(mdd_t *, relationArray, i);
7662	tmp = mdd_and(tr1, relation, 1, 1);
7663	mdd_free(tr1);
7664	tr1 = tmp;
7665	}
7666
7667	tr2 = mdd_one(mddManager);
7668	for (i = 0; i < array_n(clusteredRelationArray); i++) {
7669	relation = array_fetch(mdd_t *, clusteredRelationArray, i);
7670	tmp = mdd_and(tr2, relation, 1, 1);
7671	mdd_free(tr2);
7672	tr2 = tmp;
7673	}
7674
7675	assert(mdd_equal(tr1, tr2));
7676	mdd_free(tr1);
7677	mdd_free(tr2);
7678	}
7679	*/
7680
7681	return(clusteredRelationArray);
7682	}
7683
7684
7685	/Function******************************************************************
7686
7687	Synopsis [Updates matrix information properly.]
7688
7689	Description [Updates matrix information properly.]
7690
7691	SideEffects []
7692
7693	******************************************************************************/
7694	static void
7695	SortCol(char **xy, int nRows, int nCols,
7696	RcInfo_t rowInfo, RcInfo_t colInfo, int rowOrder, int colOrder)
7697	{
7698	int x, y, i, j, row, col, lastVar;
7699	int otherRow, otherCol;
7700
7701	lastVar = nCols - 1;
7702
7703	for (x = nRows - 1; x >= 0; x--) {
7704	row = rowOrder[x];
7705	for (y = lastVar; y >= 0; y--) {
7706	col = colOrder[y];
7707	if (colInfo[col].gMin == row) {
7708	if (y == lastVar) {
7709	lastVar--;
7710	continue;
7711	}
7712	for (j = y; j < lastVar; j++) {
7713	colOrder[j] = colOrder[j + 1];
7714	colInfo[colOrder[j]].pos = j;
7715	}
7716	colOrder[lastVar] = col;
7717	colInfo[col].pos = lastVar;
7718	for (i = x; i < nRows; i++) {
7719	otherRow = rowOrder[i];
7720	if (colInfo[rowInfo[otherRow].gMax].pos < lastVar)
7721	rowInfo[otherRow].gMax = col;
7722	if (rowInfo[otherRow].gMin == col) {
7723	for (j = 0; j < nCols; j++) {
7724	otherCol = colOrder[j];
7725	if (xy[otherRow][otherCol]) {
7726	rowInfo[otherRow].gMin = otherCol;
7727	break;
7728	}
7729	}
7730	}
7731	}
7732	lastVar--;
7733	}
7734	}
7735	}
7736	}
7737
7738
7739	/Function******************************************************************
7740
7741	Synopsis [Finds disappearing present state variables in a row.]
7742
7743	Description [Finds disappearing present state variables in a row.]
7744
7745	SideEffects []
7746
7747	******************************************************************************/
7748	static void
7749	UpdateDisapearingPsVars(mdd_manager mddManager, char *xy,
7750	int nActiveRows, int nActiveCols,
7751	int rowOrder, int colOrder,
7752	RcInfo_t rowInfo, RcInfo_t colInfo,
7753	int row, ImgTrmOption_t *option)
7754	{
7755	int i, id, x, y, s, t, col, tmpRow;
7756	mdd_t *relation;
7757	array_t *supportArray;
7758	char *supportIndex;
7759	int nVars;
7760
7761	nVars = bdd_num_vars(mddManager);
7762	relation = rowInfo[row].data.row.func;
7763	supportIndex = ALLOC(char, nVars);
7764	memset(supportIndex, 0, sizeof(char) * nVars);
7765	supportArray = mdd_get_bdd_support_ids(mddManager, relation);
7766	for (i = 0; i < array_n(supportArray); i++) {
7767	id = array_fetch(int, supportArray, i);
7768	supportIndex[id] = 1;
7769	}
7770	array_free(supportArray);
7771
7772	s = colInfo[rowInfo[row].gMin].pos;
7773	t = colInfo[rowInfo[row].gMax].pos;
7774	x = rowInfo[row].pos;
7775	rowInfo[row].gNum = 0;
7776	rowInfo[row].gMin = nActiveCols;
7777	rowInfo[row].gMax = -1;
7778	for (y = s; y <= t; y++) {
7779	col = colOrder[y];
7780	if (!xy[row][col])
7781	continue;
7782	id = (int)bdd_top_var_id(colInfo[col].data.col.var);
7783	if (supportIndex[id]) {
7784	rowInfo[row].gNum++;
7785	if (rowInfo[row].gMin == nActiveCols)
7786	rowInfo[row].gMin = col;
7787	rowInfo[row].gMax = col;
7788	} else {
7789	xy[row][col] = 0;
7790	if (colInfo[col].gNum == 1) {
7791	colInfo[col].gNum = 0;
7792	colInfo[col].gMin = nActiveRows;
7793	colInfo[col].gMax = -1;
7794	} else if (colInfo[col].gNum == 2) {
7795	colInfo[col].gNum = 1;
7796	if (colInfo[col].gMin == row)
7797	colInfo[col].gMin = colInfo[col].gMax;
7798	else
7799	colInfo[col].gMax = colInfo[col].gMin;
7800	} else {
7801	colInfo[col].gNum--;
7802	if (row == colInfo[col].gMin) {
7803	for (i = x + 1; i <= rowInfo[colInfo[col].gMax].pos; i++) {
7804	tmpRow = rowOrder[i];
7805	if (xy[tmpRow][col]) {
7806	colInfo[col].gMin = tmpRow;
7807	break;
7808	}
7809	}
7810	} else if (row == colInfo[col].gMax) {
7811	for (i = x - 1; i >= rowInfo[colInfo[col].gMin].pos; i--) {
7812	tmpRow = rowOrder[i];
7813	if (xy[tmpRow][col]) {
7814	colInfo[col].gMax = tmpRow;
7815	break;
7816	}
7817	}
7818	}
7819	}
7820	}
7821	}
7822
7823	FREE(supportIndex);
7824	}
7825
7826
7827	/Function******************************************************************
7828
7829	Synopsis [Finds disappearing present state variables in a cluster.]
7830
7831	Description [Finds disappearing present state variables in a cluster.]
7832
7833	SideEffects []
7834
7835	******************************************************************************/
7836	static void
7837	UpdateDisapearingPsVarsInCluster(mdd_manager mddManager, char *xy,
7838	int nActiveRows, int nActiveCols,
7839	int rowOrder, int colOrder,
7840	RcInfo_t rowInfo, RcInfo_t colInfo,
7841	ClusterList_t *list, int moveFlag,
7842	ImgTrmOption_t *option)
7843	{
7844	int i, j, k, y, id, row, col, otherRow, otherCol;
7845	int s1, t1, s2, t2, s3, t3, t4;
7846	mdd_t *relation;
7847	array_t *supportArray;
7848	char *supportIndex;
7849	int nVars;
7850	ClusterList_t *otherList;
7851
7852	if (list->nSupports == 0)
7853	return;
7854
7855	nVars = bdd_num_vars(mddManager);
7856	relation = list->product;
7857	supportIndex = ALLOC(char, nVars);
7858	memset(supportIndex, 0, sizeof(char) * nVars);
7859	supportArray = mdd_get_bdd_support_ids(mddManager, relation);
7860	for (i = 0; i < array_n(supportArray); i++) {
7861	id = array_fetch(int, supportArray, i);
7862	supportIndex[id] = 1;
7863	}
7864	array_free(supportArray);
7865
7866	s1 = colInfo[list->minCol].pos;
7867	t1 = colInfo[list->maxCol].pos;
7868	for (y = t1; y >= s1; y--) {
7869	col = colOrder[y];
7870	if (!list->supports[col])
7871	continue;
7872	id = (int)bdd_top_var_id(colInfo[col].data.col.var);
7873	if (!supportIndex[id]) {
7874	list->nSupports--;
7875	list->supports[col] = 0;
7876	if (list->nSupports == 0) {
7877	list->minCol = -1;
7878	list->maxCol = -1;
7879	} else if (list->nSupports == 1) {
7880	if (list->minCol == col)
7881	list->minCol = list->maxCol;
7882	else
7883	list->maxCol = list->minCol;
7884	} else if (list->nSupports > 1) {
7885	if (list->minCol == col) {
7886	for (j = y + 1; j <= t1; j++) {
7887	otherCol = colOrder[j];
7888	if (list->supports[otherCol]) {
7889	list->minCol = otherCol;
7890	break;
7891	}
7892	}
7893	} else if (list->maxCol == col) {
7894	for (j = y - 1; j >= s1; j--) {
7895	otherCol = colOrder[j];
7896	if (list->supports[otherCol]) {
7897	list->maxCol = otherCol;
7898	break;
7899	}
7900	}
7901	}
7902	}
7903
7904	for (j = list->start; j <= list->end; j++) {
7905	row = rowOrder[j];
7906	if (xy[row][col]) {
7907	xy[row][col] = 0;
7908	colInfo[col].gNum--;
7909	rowInfo[row].gNum--;
7910	if (rowInfo[row].gNum > 0) {
7911	s2 = colInfo[rowInfo[row].gMin].pos;
7912	t2 = colInfo[rowInfo[row].gMax].pos;
7913	if (rowInfo[row].gMin == col) {
7914	for (k = y + 1; k <= t2; k++) {
7915	otherCol = colOrder[k];
7916	if (xy[row][otherCol]) {
7917	rowInfo[row].gMin = otherCol;
7918	break;
7919	}
7920	}
7921	} else if (rowInfo[row].gMax == col) {
7922	for (k = y - 1; k >= s2; k--) {
7923	otherCol = colOrder[k];
7924	if (xy[row][otherCol]) {
7925	rowInfo[row].gMax = otherCol;
7926	break;
7927	}
7928	}
7929	}
7930	} else {
7931	rowInfo[row].gMin = -1;
7932	rowInfo[row].gMax = nActiveCols;
7933	}
7934	}
7935	}
7936
7937	if (colInfo[col].gNum == 0) {
7938	colInfo[col].lNum = 0;
7939	colInfo[col].gMin = nActiveRows;
7940	colInfo[col].lMin = nActiveRows;
7941	colInfo[col].gMax = -1;
7942	colInfo[col].lMax = -1;
7943	} else if (colInfo[col].gNum == 1) {
7944	colInfo[col].lNum = 1;
7945	if (rowInfo[colInfo[col].gMax].pos > list->end) {
7946	colInfo[col].gMin = colInfo[col].gMax;
7947	colInfo[col].lMin = colInfo[col].gMax;
7948	} else {
7949	colInfo[col].gMax = colInfo[col].gMin;
7950	colInfo[col].lMax = colInfo[col].gMin;
7951	}
7952	} else {
7953	colInfo[col].lNum = colInfo[col].gNum;
7954	if (rowInfo[colInfo[col].gMin].pos >= list->start &&
7955	rowInfo[colInfo[col].gMin].pos <= list->end) {
7956	for (i = list->end + 1; i <= rowInfo[colInfo[col].gMax].pos; i++) {
7957	otherRow = rowOrder[i];
7958	if (xy[otherRow][col]) {
7959	colInfo[col].gMin = otherRow;
7960	colInfo[col].lMin = otherRow;
7961	break;
7962	}
7963	}
7964	} else if (rowInfo[colInfo[col].gMax].pos >= list->start &&
7965	rowInfo[colInfo[col].gMax].pos <= list->end) {
7966	for (i = list->start - 1; i >= rowInfo[colInfo[col].gMin].pos; i--) {
7967	otherRow = rowOrder[i];
7968	if (xy[otherRow][col]) {
7969	colInfo[col].gMax = otherRow;
7970	colInfo[col].lMax = otherRow;
7971	break;
7972	}
7973	}
7974	}
7975	}
7976
7977	if (moveFlag) {
7978	if (colInfo[col].gNum == 0) {
7979	if (y < nActiveCols - 1) {
7980	for (j = y; j < nActiveCols - 1; j++) {
7981	colOrder[j] = colOrder[j + 1];
7982	colInfo[colOrder[j]].pos = j;
7983	}
7984	colOrder[nActiveCols - 1] = col;
7985	colInfo[col].pos = nActiveCols - 1;
7986	}
7987	} else if (rowInfo[colInfo[col].gMin].pos > list->end) {
7988	if (list->prev && list->prev->start > list->start) {
7989	/* Image */
7990	otherList = list->prev;
7991	while (!otherList->supports[col])
7992	otherList = otherList->prev;
7993	} else if (list->next && list->next->start > list->start) {
7994	/* Preimage */
7995	otherList = list->next;
7996	while (!otherList->supports[col])
7997	otherList = otherList->next;
7998	} else
7999	otherList = NIL(ClusterList_t);
8000
8001	if (otherList) {
8002	t2 = colInfo[otherList->maxCol].pos;
8003	if (y != t2) {
8004	for (j = y; j < t2; j++) {
8005	colOrder[j] = colOrder[j + 1];
8006	colInfo[colOrder[j]].pos = j;
8007	}
8008	colOrder[t2] = col;
8009	colInfo[col].pos = t2;
8010	otherList->maxCol = col;
8011	if (otherList->minCol == col) {
8012	for (j = y; j < t2; j++) {
8013	otherCol = colOrder[j];
8014	if (otherList->supports[otherCol]) {
8015	otherList->minCol = otherCol;
8016	break;
8017	}
8018	}
8019	}
8020
8021	s3 = rowInfo[colInfo[col].gMin].pos;
8022	t3 = rowInfo[colInfo[col].gMax].pos;
8023	for (j = s3; j <= t3; j++) {
8024	otherRow = rowOrder[j];
8025	if (xy[otherRow][col]) {
8026	if (rowInfo[otherRow].gNum > 1) {
8027	t4 = colInfo[rowInfo[otherRow].gMax].pos;
8028	if (t4 <= t2)
8029	rowInfo[otherRow].gMax = col;
8030	if (rowInfo[otherRow].gMin == col) {
8031	for (k = y; k <= t4; k++) {
8032	otherCol = colOrder[k];
8033	if (xy[otherRow][otherCol]) {
8034	rowInfo[otherRow].gMin = col;
8035	break;
8036	}
8037	}
8038	}
8039	}
8040	}
8041	}
8042	}
8043	}
8044	}
8045	}
8046
8047	if (option->mlpDebug) {
8048	CheckCluster(list, nActiveCols, colInfo, colOrder);
8049	CheckMatrix(xy, NIL(SccList_t), nActiveRows, nActiveCols,
8050	rowInfo, colInfo, rowOrder, colOrder,
8051	0, nActiveRows - 1, 0, nActiveCols - 1, 0);
8052	}
8053	}
8054	}
8055
8056	FREE(supportIndex);
8057	}
8058
8059
8060	/Function******************************************************************
8061
8062	Synopsis [Finds non-appearing next state variables.]
8063
8064	Description [Finds non-appearing next state variables.]
8065
8066	SideEffects []
8067
8068	******************************************************************************/
8069	static void
8070	UpdateNonappearingNsVars(mdd_manager mddManager, array_t nsVarBddArray,
8071	int nRows, RcInfo_t rowInfo, int rowOrder,
8072	array_t *nonAppearingVarBddArray)
8073	{
8074	int i, j, k, row, index, nVars;
8075	mdd_t nsVar, relation;
8076	char *existFlag;
8077	array_t supportArray, tmpArray;
8078
8079	nVars = bdd_num_vars(mddManager);
8080	existFlag = ALLOC(char, nVars);
8081	memset(existFlag, 0, sizeof(char) * nVars);
8082
8083	for (i = 0; i < nRows; i++) {
8084	row = rowOrder[i];
8085	relation = rowInfo[row].data.row.func;
8086	supportArray = mdd_get_bdd_support_ids(mddManager, relation);
8087	for (j = 0; j < array_n(supportArray); j++) {
8088	index = array_fetch(int, supportArray, j);
8089	existFlag[index] = 1;
8090	}
8091	array_free(supportArray);
8092	}
8093
8094	for (i = 0; i < nRows; i++) {
8095	row = rowOrder[i];
8096	for (j = 0; j < array_n(rowInfo[row].data.row.nsVarBddArray); j++) {
8097	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, j);
8098	index = (int)bdd_top_var_id(nsVar);
8099	if (!existFlag[index]) {
8100	tmpArray = array_alloc(mdd_t *, 0);
8101	for (k = 0; k < j; k++) {
8102	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, k);
8103	array_insert_last(mdd_t *, tmpArray, nsVar);
8104	}
8105	for (k = j + 1; k < array_n(rowInfo[row].data.row.nsVarBddArray); k++) {
8106	nsVar = array_fetch(bdd_t *, rowInfo[row].data.row.nsVarBddArray, k);
8107	index = (int)bdd_top_var_id(nsVar);
8108	if (existFlag[index])
8109	array_insert_last(mdd_t *, tmpArray, nsVar);
8110	}
8111	array_free(rowInfo[row].data.row.nsVarBddArray);
8112	rowInfo[row].data.row.nsVarBddArray = tmpArray;
8113	break;
8114	}
8115	}
8116	}
8117
8118	for (i = 0; i < array_n(nsVarBddArray); i++) {
8119	nsVar = array_fetch(bdd_t *, nsVarBddArray, i);
8120	index = (int)bdd_top_var_id(nsVar);
8121	if (!existFlag[index])
8122	array_insert_last(mdd_t *, nonAppearingVarBddArray, bdd_dup(nsVar));
8123	}
8124
8125	FREE(existFlag);
8126	}
8127
8128
8129	/Function******************************************************************
8130
8131	Synopsis [Writes variable order in coulumn of the matrix.]
8132
8133	Description [Writes variable order in coulumn of the matrix.]
8134
8135	SideEffects []
8136
8137	******************************************************************************/
8138	static void
8139	WriteOrder(FILE fout, int nCols, int colOrder, RcInfo_t *colInfo)
8140	{
8141	int i, col;
8142	mdd_t *var;
8143	char *name;
8144
8145	for (i = 0; i < nCols; i++) {
8146	col = colOrder[i];
8147	var = colInfo[col].data.col.var;
8148	name = mdd_read_var_name(var);
8149	fprintf(fout, "%s\n", name);
8150	}
8151	}

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

Context Navigation

source: vis_dev/vis-2.3/src/img/imgMlp.c @ 31

Download in other formats: