pntool-developers Mailing List for A Concurrency Tool Suite (Page 8)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 93
          http://pntool.svn.sourceforge.net/pntool/?rev=93&view=rev
Author:   StephenCamp
Date:     2009-06-22 22:12:37 +0000 (Mon, 22 Jun 2009)

Log Message:
-----------
Changed private subroutines declarations in ilpadm.c, isadm.c, linenf.c, msplit.c, nltrans.c to 'static' to hide the routines from each other when linking.
Fixed a bug in nltrans: linear programming problem constraint types were inverted.
Extended functionality of the StructuredIO test functions: added support for an array-of-arrays type.
pn2eacpn.c is PARTIALLY tested. The test script, test-pn2eacpn.txt, does not yet contain complete tests.
test-pn2eacpn, the test routine for pn2eacpn, is functional.

Modified Paths:
--------------
    spnbox/ilpadm.c
    spnbox/isadm.c
    spnbox/linenf.c
    spnbox/msplit.c
    spnbox/nltrans.c
    spnbox/pn2acpn.c
    spnbox/spnbox.h
    spnbox/tests/StructuredIO.c
    spnbox/tests/test-nltrans.txt
    spnbox/tests/test-pn2acpn.mak

Added Paths:
-----------
    spnbox/pn2eacpn.c
    spnbox/tests/test-pn2eacpn.c
    spnbox/tests/test-pn2eacpn.mak
    spnbox/tests/test-pn2eacpn.txt

Property Changed:
----------------
    spnbox/tests/

Modified: spnbox/ilpadm.c
===================================================================

--- spnbox/ilpadm.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/ilpadm.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -4,7 +4,7 @@
 #include "matrixmath.h"
 #include "MemoryManager.h"
 
-void disp(char* beginning, char* parameter, char* end, int i, int p, int verbose);
+static void disp(char* beginning, char* parameter, char* end, int i, int p, int verbose);
 
 ilpadm_r ilpadm(matrix* L, int* b, matrix* D, int TucCount, int* Tuc, int TuoCount, int* Tuo, int* m0, int verbose)
 {

Modified: spnbox/isadm.c
===================================================================
--- spnbox/isadm.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/isadm.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -5,11 +5,11 @@
 /*CheckParam checks most of the parameters passed to isadm to make sure they are valid and
 returns the number of constraints or zero for bad parameters. It displays all necessary
 error messages if bad parameters are encountered.*/
-int CheckParam(matrix* Dm,  matrix* Dp, matrix* L, matrix* F, matrix* C);
+static int CheckParam(matrix* Dm,  matrix* Dp, matrix* L, matrix* F, matrix* C);
 
 /*StructuralAnalysis does the actual analysis to determine constraint admissibility.
 It returns v as an array of integers.*/
-int* StructuralAnalysis(matrix* D, matrix* L, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo);
+static int* StructuralAnalysis(matrix* D, matrix* L, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo);
 
 int* isadm(matrix* Dm, matrix* Dp, matrix* L, int* b, int* m0, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo)
 {

Modified: spnbox/linenf.c
===================================================================
--- spnbox/linenf.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/linenf.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -5,7 +5,7 @@
 #include "matrixmath.h"
 
 
-typedef struct InitTransformedNet_r
+ typedef struct InitTransformedNet_r
 {
 	int RowsAddedC;
 	int* CColumns;
@@ -16,35 +16,35 @@
 
 /*This function does some basic checking to make sure parameters are as they should be.
 It returns the number of constraints or -1 in case any parameters are invalid.*/
-int CheckParams(matrix* Dm, matrix* Dp, matrix* L, int* b, int* m0, matrix* F, matrix* C);
+static int CheckParams(matrix* Dm, matrix* Dp, matrix* L, int* b, int* m0, matrix* F, matrix* C);
 
 /*This function checks to see if the constraint row specified by Row is inadmissible. It returns
 a logic 1 if the constraint is inadmissible and a 0 otherwise.*/
-int Inadmissible(int Row, matrix* D, matrix* L, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo);
+static int Inadmissible(int Row, matrix* D, matrix* L, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo);
 
 /*InitTransformedNet counts how many rows and columns will need to be added to the i/o matrices of the
 Petri net to account for the new constraints being added, alloces the space, and pre-copies the existing
 i/o matrices into the appropriate places in the new ones.*/
-InitTransformedNet_r InitTransformedNet(int Row, MemoryManager* memory, matrix* Dm, matrix* Dp, matrix* OldDm, matrix* OldDp,  matrix* F, matrix* C, int TucCount, int* Tuc);
+static InitTransformedNet_r InitTransformedNet(int Row, MemoryManager* memory, matrix* Dm, matrix* Dp, matrix* OldDm, matrix* OldDp,  matrix* F, matrix* C, int TucCount, int* Tuc);
 
 /*TransformC2L transforms the C constraints into marking constraints which it adds to the current
 marking constraint row. It adds new places to the Petri net for the new constraints to refer to, and
 establishes a few transition/place links.*/
-void TransformC2L(int Row, matrix* C, matrix* LRow, matrix* Dp, int FirstDRow);
+static void TransformC2L(int Row, matrix* C, matrix* LRow, matrix* Dp, int FirstDRow);
 
 /*TransformF2L transforms the F constraints into marking constraints which it adds to the current 
 marking constraint row. It adds new places to the Petri net for the new constraints to refer to, and 
 establishes a few transition/place links.*/
-void TransformF2L(int Row, matrix* F, matrix* LRow, matrix* Dm, matrix* Dp, int TucCount, int* Tuc, int StartRow, int StartCol);
+static void TransformF2L(int Row, matrix* F, matrix* LRow, matrix* Dm, matrix* Dp, int TucCount, int* Tuc, int StartRow, int StartCol);
 
 /*FindInSet returns the index of the integer find in the array pointed to by set.
 If find is not found, -1 is returned.*/
-int FindInSet(int find, int* set, int SetSize);
+static int FindInSet(int find, int* set, int SetSize);
 
 /*CollapseNet takes the results of enforcing (and transformation, if it was done) the current
 constraint row and collapses it back into the Petri net that will be returned. It also copies
 transformed constraints to the structure to be returned.*/
-void CollapseNet(int ConstraintRow, linenf_r *Enforced, InitTransformedNet_r *Transform, linenf_r *Final, int Places, int Transitions);
+static void CollapseNet(int ConstraintRow, linenf_r *Enforced, InitTransformedNet_r *Transform, linenf_r *Final, int Places, int Transitions);
 
 linenf_r linenf(matrix* Dm, matrix* Dp, matrix* L, int* b, int* m0, matrix* F, matrix* C, int TucCount, int* Tuc, int TuoCount, int* Tuo)
 {

Modified: spnbox/msplit.c
===================================================================
--- spnbox/msplit.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/msplit.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -6,26 +6,26 @@
 matrices for the given transition, based on the
 current number of transitions and places and the number
 of transitions that are being added.*/
-void ModifyD(msplit_r* Ret, int Places, int Transitions, int NewTransitions, int Transition);
+static void ModifyD(msplit_r* Ret, int Places, int Transitions, int NewTransitions, int Transition);
 
 /*ModifyTD fills out the elements of array of dead-transition arrays for the 
 current transition.*/
-void ModifyTD(msplit_r* Ret, int Transition, int NewTransitions, int TDCount);
+static void ModifyTD(msplit_r* Ret, int Transition, int NewTransitions, int TDCount);
 
 /*ModifyML0 modifies ML0 for the current transition.*/
-void ModifyML0(msplit_r* Ret, int* ipl, int ipCount, int* dpl, int MColCount, int L0ColCount, int Transition, int NewTransitions);
+static void ModifyML0(msplit_r* Ret, int* ipl, int ipCount, int* dpl, int MColCount, int L0ColCount, int Transition, int NewTransitions);
 
 /*AllocateTransition space allocates space for and initializes some of the 
 data that will be returned.*/
-void AllocateTransitionSpace(msplit_r* Ret, matrix* Dm, matrix* Dp, int* mask, matrix* M, matrix* L0, matrix* L, int** TD, int* TDCount, int* ipl, int ipCount);
+static void AllocateTransitionSpace(msplit_r* Ret, matrix* Dm, matrix* Dp, int* mask, matrix* M, matrix* L0, matrix* L, int** TD, int* TDCount, int* ipl, int ipCount);
 
 /*CountNewTransitions returns an integer corresponding to the number of places
 and transitions that will need to be added to split the given transition.*/
-int CountNewTransitions(matrix* Dm, int Transition);
+static int CountNewTransitions(matrix* Dm, int Transition);
 
 /*CheckParams checks the validity of the parameters and initializes some of them
 to default values.*/
-int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** mask, matrix* M, matrix* L0, matrix* L, int** ipl, int* ipCount, int** dpl, int* dpCount, int*** TD, int** TDCount);
+static int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** mask, matrix* M, matrix* L0, matrix* L, int** ipl, int* ipCount, int** dpl, int* dpCount, int*** TD, int** TDCount);
 
 msplit_r msplit(matrix* Dm, matrix* Dp, int* mask, matrix* M, matrix* L0, matrix* L, int* ipl, int ipCount, int* dpl, int dpCount, int** TD, int* TDCount)
 {

Modified: spnbox/nltrans.c
===================================================================
--- spnbox/nltrans.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/nltrans.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -1,8 +1,8 @@
 #include "MemoryManager.h"
 #include "spnbox.h"
 
-int CheckParams(matrix* D, int** URT, int* urtCount);
-int BuildIntegerProblem(MemoryManager* mem, matrix* D, int* URT, int urtCount, matrix* M, double** F, double** B, short int** IntList, short int** ctype);
+static int CheckParams(matrix* D, int** URT, int* urtCount);
+static int BuildIntegerProblem(MemoryManager* mem, matrix* D, int* URT, int urtCount, matrix* M, double** F, double** B, short int** IntList, short int** ctype);
 
 nltrans_r nltrans(matrix* D, int* UnraisableTransitions, int urtCount)
 {
@@ -143,28 +143,13 @@
 	(*B) = mcalloc(mem, Constraints, sizeof(double));
 	(*B)[Constraints - 1] = 1.0;
 	
-	/*The intlist should be ones for all but the items corresponding to already 
-	unraisable transitions.*/
+	/*The intlist should be zeros - nothing should be constrained as an integer.*/
 	(*IntList) = mcalloc(mem, Vars, sizeof(short int));
-	for (i = 0; i < Vars; i++)
-	{
-		//See if the current intlist element corresponds to a URT.
-		for (j = 0; j < urtCount; j++)
-		{
-			if (i == URT[j]) break;
-		}
-		/*If it does not, set the current element to 1.*/
-		if (urtCount && j == urtCount)
-		{
-			(*IntList)[i] = 1;
-		}
-	}
-	/*All constraints but the last are >=. The last is an equality.*/
+
+	/*All constraints but the last are =. The last is >=*/
 	(*ctype) = mcalloc(mem, Constraints, sizeof(short int));
-	for (i = 0; i < Constraints - 1; i++)
-	{
-		(*ctype)[i] = 1;
-	}
+	(*ctype)[Constraints - 1] = 1;
+
 	/*The return value is the number of variables that will be used for cov.*/
 	return NumberOfColumns(*D);
 }

Modified: spnbox/pn2acpn.c
===================================================================
--- spnbox/pn2acpn.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/pn2acpn.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -3,19 +3,19 @@
 #include "matrixmath.h"
 
 /*Subroutine declarations. See subroutine implementation for descriptions.*/
-void AddPlaces(pn2acpn_r* result, matrix* Dm, int Transition, int* Qflag, int QLength, int* ipl, int ipCount, int* dpl, int dpCount);
+static void AddPlaces(pn2acpn_r* result, matrix* Dm, int Transition, int* Qflag, int QLength, int* ipl, int ipCount, int* dpl, int dpCount);
 
-int GetQPlace(matrix* U, int Pair, int* Qflag, int* mask, pn2acpn_r* result);
+static int GetQPlace(matrix* U, int Pair, int* Qflag, int* mask, pn2acpn_r* result);
 
-matrix GetU(int* cardbt, pn2acpn_r* result, int Transition, int OriginalPlaces);
+static matrix GetU(int* cardbt, pn2acpn_r* result, int Transition, int OriginalPlaces);
 
-int InitParts(MemoryManager* mem, pn2acpn_r* result, int** cardbt, int** cardbtx, int** Qflag, matrix* Dm, matrix* Dp, matrix* MX, matrix* L0);
+static int InitParts(MemoryManager* mem, pn2acpn_r* result, int** cardbt, int** cardbtx, int** Qflag, matrix* Dm, matrix* Dp, matrix* MX, matrix* L0);
 
-int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount);
+static int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount);
 
-int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount);
+static int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount);
 
-void FinalizeResult(pn2acpn_r* result, matrix* L, matrix* Dm, int* ipl, int ipCount);
+static void FinalizeResult(pn2acpn_r* result, matrix* L, matrix* Dm, int* ipl, int ipCount);
 
 /*The function itself. pn2acpn transforms a Petri net to an asymmetric choice
 Petri net*/

Added: spnbox/pn2eacpn.c
===================================================================
--- spnbox/pn2eacpn.c	                        (rev 0)
+++ spnbox/pn2eacpn.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -0,0 +1,754 @@
+#include "MemoryManager.h"
+#include "spnbox.h"
+#include "matrixmath.h"
+
+/*Subroutine declarations. See subroutine implementation for descriptions.*/
+static void AddPlaces(pn2eacpn_r* result, matrix* Dm, int Transition, int* Qflag, int QLength, int* ipl, int ipCount, int* dpl, int dpCount);
+
+static int GetQPlace(matrix* U, int Pair, int* Qflag, int* mask, pn2eacpn_r* result);
+
+static matrix GetU(int* cardbt, pn2eacpn_r* result, int Transition, int **TD, int *TDCount);
+
+static int InitParts(MemoryManager* mem, pn2eacpn_r* result, int** cardbt, int** cardbtx, int** Qflag, matrix* Dm, matrix* Dp, matrix* MX, matrix* L0, int** TD, int *TDCount);
+
+static int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount, int*** TD, int** TDCount);
+
+static void FinalizeResult(pn2eacpn_r* result, matrix* L, matrix* Dm, int* ipl, int ipCount);
+
+static int ProcessPlace(int Transition, int Place, matrix* Dm, matrix* Dp, int** TD, int* TDCount);
+
+/*The function itself. pn2acpn transforms a Petri net to an asymmetric choice
+Petri net*/
+pn2eacpn_r pn2eacpn(matrix* Dm, matrix* Dp, int* Mask, matrix* MX, matrix* L0, matrix* L, int *ipl, int ipCount, int* dpl, int dpCount, int** TD, int* TDCount)
+{
+	int Transition, Transitions, Places, i, j, x;
+	int *cardbt, *cardbtx, *Qflag;
+	MemoryManager mem;
+	matrix U;
+	pn2eacpn_r result;
+	
+	/*Initialize the value to be returned to an error value.*/
+	memset(&result, 0, sizeof(pn2eacpn_r));
+	
+	/*Initialize the memory manager.*/
+	mem = CreateMemoryManager(10, 5, 0, 0);
+	
+	if (! CheckParams(&mem, Dm, Dp, &Mask, MX, L0, L, &ipl, &ipCount, &dpl, &dpCount, &TD, &TDCount))
+	{
+		return result;
+	}
+	Places = NumberOfRows(*Dm);
+	Transitions = NumberOfColumns(*Dm);
+	
+	/*Initialize parts of the return value and the flag matrices cardbt and 
+	cardbtx. This function returns the index of the first transition which should 
+	be processed.*/
+	Transition = InitParts(&mem, &result, &cardbt, &cardbtx, &Qflag, Dm, Dp, MX, L0, TD, TDCount);
+	
+	/*Loop until there are no more transitions to be processed. This will be when
+	Transition has been set to -1 by either of the functions responsible for 
+	finding the next transition to be processed.*/
+	while (Transition >= 0)
+	{
+		
+		cardbtx[Transition] = 0;
+		/*Get U, a 2xn matrix each column of which contains a pair of place
+		indices for which a particular relationship holds.*/
+		U = GetU(cardbt, &result, Transition, TD, TDCount);
+				
+		/*Iterate through each of the place pairs. From each pair we will develop
+		the index of a single place, for which we will set the Q-flag and with
+		which we will make an alteration to the cardbtx flag array.*/
+		/*The Q-flag array defaults to all cleared.*/
+		memset(Qflag, 0, sizeof(int) * Places);		
+		for (i = 0; i < NumberOfColumns(U); i++)
+		{
+			/*Get the index of some particular place algorithmically.*/
+			if ((x = GetQPlace(&U, i, Qflag, Mask, &result)) >= 0)
+			{
+				/*Set the corresponding q flag.*/
+				Qflag[x] = 1;
+				/*We OR cardbtx with cardbt AND the place from Dm*/
+				for (j = 0; j < NumberOfColumns(*Dm); j++)
+				{
+					cardbtx[j] = cardbtx[j] || (cardbt[j] && GetMatrixEl(Dm, x, j));
+				}				
+			}
+		}
+		/*Free the memory allocated for the U vector now that we don't need it
+		anymore.*/
+		DeallocateMatrix(&U);
+		/*Fill in the new places and transitions we reserved memory for above. Fill 
+		in the unraisable transition arrays for the new transitions.*/
+		AddPlaces(&result, Dm, Transition, Qflag, Places, ipl, ipCount, dpl, dpCount);
+		/*Clear the current element of cardbtx in case it was reset some how.*/
+		cardbtx[Transition] = 0;
+		/*Find the next transition to be processed. This will be the first one with
+		a set cardbtx flag. The next transition number defaults to -1 to indicate
+		that there are no more transitions to be processed.*/
+		Transition = -1;
+		for (i = 0; i < Transitions; i++)
+		{
+			if (cardbtx[i])
+			{
+				Transition = i;
+				break;
+			}
+		}		
+	}
+	/*Finalize the result structure; fill in the last few values.*/
+	FinalizeResult(&result, L, Dm, ipl, ipCount);
+	FreeMemory(&mem);
+	return result;
+}
+
+
+/**************************************************
+                   Subroutines
+**************************************************/
+/*
+FinalizeResult takes the result structure and fills in values that are not
+computed during the main processing loop: the incidence matrix Df, the new 
+marking constraint matrix Lf, and the new independent place list iplf.
+*/
+void FinalizeResult(pn2eacpn_r* result, matrix* L, matrix* Dm, int* ipl, int ipCount)
+{
+	int places, oldplaces, i, place, newplaces;
+	/*Fill the incidence matrix.*/
+	result->Df = SubtractMatrix(&result->Dpf, &result->Dmf, (matrix*) 2);
+	
+	oldplaces = NumberOfRows(*Dm);
+	places = NumberOfRows(result->Df);
+	newplaces = places - oldplaces;
+	
+	/*The new L matrix should be the same as the old with columns of zeros added
+	for all the new places.*/
+	if (L)
+	{
+		AllocateMatrixType(2, &result->LF, NumberOfRows(*L), NumberOfColumns(*L) + newplaces);
+		CopyBlock(NumberOfRows(*L), NumberOfColumns(*L), L, 0, 0, &result->LF, 0, 0);
+	}
+	
+	/*The new independent place list should contain all the places that were 
+	added and each of the old places.*/
+	result->iplfCount = ipCount + (places - oldplaces);
+	result->iplf = tcalloc(result->iplfCount, sizeof(int));
+	for (i = 0; i < ipCount; i++)
+	{
+		result->iplf[i] = ipl[i];
+	}
+	place = oldplaces;
+	for (; i < result->iplfCount; i++)
+	{
+		result->iplf[i] = place++;
+	}	
+	
+}
+
+/*
+AddPlaces is responsible for filling in the values in the transitions and 
+places that are added during each iteration of the main processing loop. It 
+fills in values in the Petri net matrices, in the initial marking constraint 
+matrix L0f, in the independent-to-dependent marking transformation matrix MXf, 
+and in the unraisable transition arrays for the newly-created transitions.
+It requires the result vector, the original output matrix, the transition
+currently being processed by the main processing loop, the vector of Q flags,
+the length of the vector of Q flags, and the lists of dependent and independent
+places.
+*/
+void AddPlaces(pn2eacpn_r* result, matrix* Dm, int Transition, int* Qflag, int Qlength, int* ipl, int ipCount, int* dpl, int dpCount)
+{
+	int Rows, Cols, i, j, x, ToAdd = 0;
+	matrix Dmf, Dpf, MX, L0;
+	int **TD;
+	int *TDCount;
+	
+	/*We will be adding a place and transition for each set Qflag. Count them.*/
+	for (i = 0; i < Qlength; i++)
+	{
+		if (Qflag[i]) ToAdd++;
+	}	
+	
+	/*We will be adding new columns to MX and L0. Reseve space and copy
+	existing columns.*/
+	if (NumberOfRows(result->MXF))	
+	{	
+		AllocateMatrixType(2, &MX, NumberOfRows(result->MXF), NumberOfColumns(result->MXF) + ToAdd);
+		CopyBlock(NumberOfRows(result->MXF), NumberOfColumns(result->MXF), &result->MXF, 0, 0, &MX, 0, 0);
+	}
+	else
+	{
+		/*Zero MX.*/
+		AllocateMatrix(&MX, 0, 0);
+	}
+	if (NumberOfRows(result->L0F))
+	{
+		AllocateMatrixType(2, &L0, NumberOfRows(result->L0F), NumberOfColumns(result->L0F) + ToAdd);
+		CopyBlock(NumberOfRows(result->L0F), NumberOfColumns(result->L0F), &result->L0F, 0, 0, &L0, 0, 0);
+	}
+	else
+	{
+		AllocateMatrix(&L0, 0, 0);
+	}
+
+	/*We add rows and columns to the Petri net matrices. Store them temporarily 
+	in the local Dmf and Dpf matrices. Allocate space and copy the existing 
+	matrices into the new space.*/	
+	Rows = NumberOfRows(result->Dmf);
+	Cols = NumberOfColumns(result->Dmf);
+	AllocateMatrixType(2, &Dmf, Rows + ToAdd, Cols + ToAdd);
+	AllocateMatrixType(2, &Dpf, Rows + ToAdd, Cols + ToAdd);
+	CopyBlock(Rows, Cols, &result->Dmf, 0, 0, &Dmf, 0, 0);
+	CopyBlock(Rows, Cols, &result->Dpf, 0, 0, &Dpf, 0, 0);
+	
+	/*We will be adding a new unraisable transition array for each transition
+	being added. Allocate space for the addresses of the new arrays and copy
+	the addresses of the existing arrays, which will be reused.*/
+	TD = tcalloc(Cols + ToAdd, sizeof(int*));
+	TDCount = tcalloc(Cols + ToAdd, sizeof(int));
+	for (i = 0; i < Cols; i++)
+	{
+		TDCount[i] = result->TDCount[i];
+		TD[i] = result->TD[i];
+	}
+	/*The new unraisable transition array for each transition consists of the
+	unraisable transition array from the transition that got it added (the
+	current transition) plus the new transition itself. Fill in the new
+	unraisable transition arrays.*/
+	for (i = Cols; i < Cols + ToAdd; i++)
+	{
+		TDCount[i] = result->TDCount[Transition] + 1;
+		TD[i] = tcalloc(TDCount[i], sizeof(int));
+		for (j = 0; j < result->TDCount[Transition]; j++)
+		{
+			TD[i][j] = result->TD[Transition][j];
+		}
+		TD[i][result->TDCount[Transition]] = i;
+	}
+	/*Free the old memory used by the structure and replace it with the new.*/
+	free(result->TD);
+	free(result->TDCount);
+	result->TD = TD;
+	result->TDCount = TDCount;
+		
+	/*Iterate through the places which have been Q-flagged. At each one add a new
+	place and transition. Use j to keep track of which place or transition is
+	being added.*/	
+	j = 0;
+	for (i = 0; i < Qlength; i++)
+	{
+		if (! Qflag[i]) continue;
+		/*Zero the output arc at the place and transition of interest*/
+		SetMatrixEl(&Dmf, i, Transition, 0);		
+		/*The place gets an output arc added at the new transition*/
+		SetMatrixEl(&Dmf, i, Cols + j, 1);
+		/*The new place gets an input arc added at the new transition*/
+		SetMatrixEl(&Dpf, Rows + j, Cols + j, 1);
+		/*The new place gets an output arc added to the current transition, with 
+		the same weight as the original output arc at the place and transition of
+		interest.*/
+		SetMatrixEl(&Dmf, Rows + j, Transition, GetMatrixEl(Dm, i, Transition));
+		/*Modify MX and L0 if they exist.*/
+		if (NumberOfRows(MX) || NumberOfRows(L0))
+		{
+			/*Find out if the current place is independent..*/		
+			for (x = 0; x < ipCount; x++)
+			{
+				if (ipl[x] == i)
+				{				
+					break;
+				}
+			}
+			/*If it is, we want to copy to the new columns of MX and L0 the values 
+			in their respective existing columns corresponding to the independent 
+			place just found. (if they exist)*/
+			if (x < ipCount)
+			{					
+				if (NumberOfRows(MX))
+				{
+					CopyBlock(NumberOfRows(MX), 1, &MX, 0, x, &MX, 0, NumberOfColumns(MX) - ToAdd + j);
+				}
+				if (NumberOfRows(L0))
+				{
+					CopyBlock(NumberOfRows(L0), 1, &L0, 0, x, &L0, 0, NumberOfColumns(L0) - ToAdd + j);
+				}
+			}
+			/*If not, we fill the new column of MX with a -1 in the row corresponding
+			to the dependent place indexed to by i. The new column of L0 remains zeroed.*/
+			else
+			{
+				/*Get the index of the place.*/
+				for (x = 0; x < dpCount; x++)
+				{
+					if (dpl[x] == i) break;
+				}
+				if (x < dpCount && NumberOfRows(MX))
+				{
+					SetMatrixEl(&MX, x, NumberOfColumns(MX) - ToAdd + j, -1);
+				}			
+			}
+		}		
+		/*Increment the added-place counter.*/
+		j++;
+	}
+	/*Now deallocate the old matrices and replace them with the new.*/
+	DeallocateMatrix(&result->Dmf);
+	result->Dmf = Dmf;
+	DeallocateMatrix(&result->Dpf);
+	result->Dpf = Dpf;
+	if (NumberOfRows(MX))
+	{
+		DeallocateMatrix(&result->MXF);
+		result->MXF = MX;
+	}
+	if (NumberOfRows(L0))
+	{
+		DeallocateMatrix(&result->L0F);
+		result->L0F = L0;
+	}
+}
+
+/*GetQPlace examines the pair of place indices in the U matrix that is
+currently being processed and selects and returns on of the indicies, to be used
+to set a Q-flag and perform operations on the cardbtx flag vector.
+It requires the U matrix, the pair number ot process, the vector of Q-flags,
+the mask provided to pn2acpn, and the result structure for read access to Dmf
+and Dpf.*/
+int GetQPlace(matrix* U, int Pair, int* Qflag, int* mask, pn2eacpn_r* result)
+{
+	int U1, U2, i, arcCount1, arcCount2;
+	U1 = GetMatrixEl(U, 0, Pair);
+	U2 = GetMatrixEl(U, 1, Pair);
+	
+	/*If neither U1 nor U2 indexes a place that has a high mask bit, there is no
+	valid Q index. Return -1.*/
+	if (! (mask[U1] || mask[U2]))
+	{
+		return -1;
+	}
+	/*If only one of U1 or U2 index a place with a high mask bit, that place is
+	the Q index.*/
+	if (mask[U1] && (! mask[U2]))
+	{
+		return U1;
+	}
+	if ((! mask[U1]) && mask[U2])
+	{
+		return U2;
+	}
+	/*Otherwise, we do some other tests to eliminate one of the numbers.*/
+	/*If the qflags for both of the U indices are still 0...*/
+	if (! (Qflag[U1] || Qflag[U2]))
+	{
+		//If we are examining any but the last pair of place indexes:
+		if (Pair < NumberOfColumns(*U) - 1)
+		{
+			/*If the first index in the next pair is the same as the first index in this pair, return that index.*/
+			if (U1 == GetMatrixEl(U, 0, Pair + 1))
+			{
+				return U1;
+			}
+			else
+			{
+				/*Otherwise, if there exist any pairs after the current one such that one of their indicies is the same as the second index of the current pair, return the second index of the current pair.*/
+				for (i = Pair + 1; i < NumberOfColumns(*U); i++)
+				{
+					if (GetMatrixEl(U, 0, i) == U2 || GetMatrixEl(U, 1, i) == U2)
+					{
+						return U2;
+					}
+				}
+			}
+		}
+		/*If we get here, then we count the number of nonzero output arcs in the places specified by U1 and U2. We return the index of the place with the most nonzero output arcs.*/
+		arcCount1 = 0;
+		arcCount2 = 0;
+		for (i = 0; i < NumberOfColumns(result->Dmf); i++)
+		{
+			if (GetMatrixEl(&result->Dmf, U1, i)) arcCount1++;
+			if (GetMatrixEl(&result->Dmf, U2, i)) arcCount2++;
+		}
+		if (arcCount1 >= arcCount2)
+		{
+			return U1;
+		}
+		else
+		{
+			return U2;
+		}
+	}
+	//If we get here, no valid place number was found. Return -1.
+	return -1;
+}
+
+/*GetU creates and returns a 2 x n matrix, each column of which is a pair of
+place indices such that the places exhibit some special relationship. The U
+matrix is specific to the transition currently being investigated. Its 
+calculation requires the cardbt flag vector, the result structure for access
+to the Petri net matrices, the index of the transition currently being processed,
+and a count of the number of places in the original Petri net.*/
+matrix GetU(int* cardbt, pn2eacpn_r* result, int Transition, int **TD, int *TDCount)
+{
+	int *Row0, *Row1, *PlaceFlag;
+	int NextCol, ColCapacity, i, j, k, flag0, flag1, Transitions, Places, dmi, dmj;	
+	int iCount, jCount;
+	matrix U;
+	
+	Transitions = NumberOfColumns(result->Dmf);
+	Places = NumberOfRows(result->Dmf);
+	
+	/*U will be a 2xn matrix, where each column contains a pair of place
+	indices. The pairs are determined algorithmically by examining all places in
+	the current transition that are nonzero.*/	
+	
+	/*It is hard to predict the number of pairs that will be found. Store pairs
+	in an array that will be reallocated periodically if necessary. Allocated
+	in blocks the size of the number of places.*/
+	Row0 = tcalloc(Places, sizeof(int));
+	Row1 = tcalloc(Places, sizeof(int));
+	NextCol = 0;
+	ColCapacity = Places;
+	
+	/*We will be processing only a subset of places. Find that subset now
+	to reduce processing time. Use the ProcessPlace function.*/
+	PlaceFlag = tcalloc(Places, sizeof(int));
+	for (i = 0; i < Places; i++)
+	{		
+		PlaceFlag[i] = ProcessPlace(Transition, i, &result->Dmf, &result->Dpf, TD, TDCount);
+	}
+	
+	/*Iterate through all but the last place in the transition of interest. 
+	Process only those places for which ProcessPlace returns a nonzero value.*/	
+	for (i = 0; i < Places - 1; i++)
+	{
+		if (! PlaceFlag[i]) continue;
+		/*Iterate through all the remaining places for which ProcessTransition
+		returns true.*/
+		for (j = i + 1; j < Places; j++)
+		{
+			if (! PlaceFlag[j]) continue;
+			/*The original Matlab algorithm set a flag according to this
+			algorithm: (some variable	names changed to make it apparent in terms 
+			of variables already used):
+			prj = Dmf(i,:) ~= 0; % p_j\bullet 
+			prk = Dmf(j,:) ~= 0; % p_k\bullet 
+			flag = sum((~prj) & (prj | prk)) & sum((~prk) & (prj | prk));
+			The same operation can be reduced to a pair of examinations, one
+			to get the results of the operation logical of 
+			sum((~prj) & (prj | prk)) and the	next to get the results of the 
+			operation logical of sum((~prk) & (prj | prk))*/
+			flag0 = 0;
+			flag1 = 0;
+			for (k = 0; k < Transitions; k++)
+			{
+				dmi = GetMatrixEl(&result->Dmf, i, k);
+				dmj = GetMatrixEl(&result->Dmf, j, k);
+				if ((! dmi) && dmj)
+				{
+					flag0 = 1;							
+				}
+				if ((! dmj) && dmi)
+				{
+					flag1 = 1;
+				}						
+			}
+			/*If both flags are set, we add the current pair of places to the
+			U-matrix.*/
+			if (flag0 && flag1)
+			{
+				/*If there is space left in the temporary holding places, use it. If
+				not, reallocate with more space.*/
+				if (NextCol == ColCapacity)
+				{
+					Row0 = realloc(Row0, (ColCapacity += Places) * sizeof(int));
+					Row1 = realloc(Row1, (ColCapacity += Places) * sizeof(int));
+				}
+				Row0[NextCol] = i;
+				Row1[NextCol++] = j;						
+			}
+		}
+	}
+	/*Copy the contents of Row0 and Row1 into the U-matrix.*/
+	AllocateMatrixType(2, &U, 2, NextCol);
+	for (i = 0; i < NextCol; i++)
+	{
+		SetMatrixEl(&U, 0, i, Row0[i]);
+		SetMatrixEl(&U, 1, i, Row1[i]);
+	}
+	free(Row0);
+	free(Row1);
+	free(PlaceFlag);
+	
+	return U;
+}
+
+/*
+ProcessPlace returns a nonzero value for a place that should be processed in the
+current transition. Any place should be processed which is both a parent and a
+grandparent of the current transition, where the grandparent status is via a 
+transition that is raisable even if the current transition is dead.
+*/
+int ProcessPlace(int Transition, int Place, matrix* Dm, matrix* Dp, int** TD, int* TDCount)
+{
+	int i, j, k;
+	
+	/*Check to see if the place is a parent of the transition. If not, fail.*/
+	if (! GetMatrixEl(Dm, Place, Transition)) return 0;
+	
+	/*Iterate through all child transitions of the place.*/
+	for (i = 0; i < NumberOfColumns(*Dm); i++)
+	{		
+		/*If the current transition is not a child of the place, skip it.*/
+		if (! GetMatrixEl(Dm, Place, i)) continue;
+
+		/*If the current transition is unraisable skip it.*/		
+		k = 0;
+		for (j = 0; j < TDCount[Transition]; j++)
+		{
+			if (TD[Transition][j] == i)
+			{
+				k = 1;
+				break;
+			}
+		}
+		if (k) continue;
+		
+		/*Otherwise iterate through each the transition's child places.*/
+		for (j = 0; j < NumberOfRows(*Dm); j++)
+		{
+			/*If the place is a child of the transition being examined in the loop
+			and a parent of the transition of interest, then the current place 
+			satisfies the requirements. Return true.*/
+			if (GetMatrixEl(Dp, j, i) && GetMatrixEl(Dm, j, Transition)) return 1;
+		}
+	}
+	return 0;
+}
+
+/*
+InitParts initializes intermediate variables cardbt and cardbtx, flag arrays,
+Qflag, a flag array, and the Petri net matrices in the result structure.
+*/
+int InitParts(MemoryManager* mem, pn2eacpn_r* result, int** cardbt, int** cardbtx, int** Qflag, matrix* Dm, matrix* Dp, matrix* MX, matrix* L0, int** TD, int *TDCount)
+{
+	int Places, Transitions, i, j, res = -1;
+	Places = NumberOfRows(*Dm);
+	Transitions = NumberOfColumns(*Dp);
+	
+	/*The result Petri net matrices should default to the same as the passed
+	matrices. The result MX and L0 should also default to the same as the passed
+	MX and L0, if they were given.*/
+	AllocateMatrixType(2, &result->Dmf, Places, Transitions);
+	CopyMatrix(Dm, &result->Dmf);
+	AllocateMatrixType(2, &result->Dpf, Places, Transitions);
+	CopyMatrix(Dp, &result->Dpf);	
+	if (MX)
+	{
+		AllocateMatrixType(2, &result->MXF, NumberOfRows(*MX), NumberOfColumns(*MX));
+		CopyMatrix(MX, &result->MXF);
+	}
+	if (L0)
+	{
+		AllocateMatrixType(2, &result->L0F, NumberOfRows(*L0), NumberOfColumns(*L0));
+		CopyMatrix(L0, &result->L0F);
+	}
+	
+	/*The Q-flag array has an element for each place.*/
+	*Qflag = mcalloc(mem, Places, sizeof(int));
+	
+	/*cardbt and cardbts are flag arrays with elements for each transition. They
+	default to containing a count of the number of nonzero output arcs associated 
+	with the appropriate transition.*/
+	*cardbt = mcalloc(mem, Transitions, sizeof(int));
+	*cardbtx = mcalloc(mem, Transitions, sizeof(int));
+	/*The return value should be the index of the first transition which will be
+	processed. This is the index of the first transition such that the associated
+	value of cardbt is greater than one.*/
+	for (i = 0; i < Transitions; i++)
+	{
+		for (j = 0; j < Places; j++)
+		{
+			if (GetMatrixEl(Dm, j, i))
+			{
+				(*cardbt)[i]++;
+				(*cardbtx)[i]++;
+			}
+			if (res < 0 && (*cardbt)[i] > 1)
+			{
+				res = i;
+			}
+		}
+	}
+	
+	/*The return TD and TDCount default to what they were. We will be adding
+	new transitions, but we will not be modifying any unraisabilities of the
+	original transitions, so the new transitions will get their own unraisability
+	arrays.*/
+	result->TD = tcalloc(Transitions, sizeof(int*));
+	result->TDCount = tcalloc(Transitions, sizeof(int));
+	for (i = 0; i < Transitions; i++)
+	{
+		result->TD[i] = tcalloc(TDCount[i], sizeof(int));
+		result->TDCount[i] = TDCount[i];
+		for (j = 0; j < TDCount[i]; j++)
+		{
+			result->TD[i][j] = TD[i][j];
+		}
+	}		
+	
+	return res;
+}
+	
+/*
+CheckParams examines the parameters to make sure that required parameters are
+present and dimensions and array counts are consistent. It also fills in default
+values where appropriate.
+*/
+int CheckParams(MemoryManager* mem, matrix* Dm, matrix* Dp, int** Mask, matrix* MX, matrix* L0, matrix* L, int **ipl, int *ipCount, int **dpl, int *dpCount, int*** TD, int** TDCount)
+{
+	int Places, Transitions, i, j, k;
+	nltrans_r URT;
+	matrix D;
+	/*Dm - output matrix. Required. Same size as Dp.
+	Dp - input matrix. Required. Same size as Dm. */
+	if (! (Dm && Dp))
+	{
+		merror(0, "PN2ACPN: One of the required parameters Dm or Dp was null");
+		return 0;
+	}
+	Places = NumberOfRows(*Dm);
+	Transitions = NumberOfColumns(*Dm);
+	if (NumberOfRows(*Dp) != Places || NumberOfColumns(*Dm) != Transitions)
+	{
+		merror(0, "PN2ACPN: The sizes of the input and output matrices Dp and Dm do not agree");
+		return 0;
+	}
+	
+	/*Mask = array of int flags. Not required. Defaults to array of 1s, one for 
+	each place (row of D).*/
+	if (! *Mask)
+	{
+		(*Mask) = mcalloc(mem, Places, sizeof(int));
+		for (i = 0; i < Places; i++)
+		{
+			(*Mask)[i] = 1;
+		}
+	}
+	
+	/*ipl, dpl: unpredictable-length int arrays, holding indices of independent 
+	and dependent places. Not required. If either array pointer is null the count
+	should be set to zero and vice-versa.
+	Total number of ipl and dpl must be same as number of places if given. ipl 
+	defaults to indexes of all places, dpl defaults to empty set.*/
+	if (! *ipl) 
+	{
+		*ipCount = 0;
+	}
+	else if (! ipCount)
+	{
+		*ipl = 0;
+	}
+	if (! *dpl) 
+	{
+		*dpCount = 0;
+	}
+	else if (! (*dpCount))
+	{
+		*dpl = 0;
+	}
+	
+	if (! (*ipCount))
+	{
+		*ipl = mcalloc(mem, Places, sizeof(int));
+		for (i = 0; i < Places; i++)
+		{
+			(*ipl)[i] = i;
+		}
+		*ipCount = Places;
+	}
+	
+	if (*ipCount + *dpCount != Places)
+	{
+		FreeMemory(mem);
+		merror(0, "PN2ACPN: The independent and dependent place list lengths do not agree with the number of places");
+		return 0;
+	}
+
+	/*L0 - matrix, initial marking constraint. Not required. If present must have
+	the same number of columns as there are independent places.*/
+	if (L0)
+	{
+		if (NumberOfColumns(*L0) != *ipCount)
+		{
+			FreeMemory(mem);
+			merror(0, "PN2ACPN: The size of L0 and the independent place list do not agree");
+			return 0;
+		}
+	}
+	
+	/*L - matrix, marking constraint. Not required. If present must have the same
+	number of columns as there are independent places.*/
+	if (L)
+	{
+		if (NumberOfColumns(*L) != *ipCount)
+		{
+			FreeMemory(mem);
+			merror(0, "PN2ACPN: The size of L and the independent place list do not agree");
+			return 0;
+		}
+	}
+	
+	/*MX - matrix, same meaning as in msplit: is the transformation matrix from 
+	the independent marking to the dependent marking. Not required. If present, 
+	must have the same number of rows as there are dependent places and the same
+	number of columns as there are independent places (if those counts are given)*/	
+	if (MX && ipCount && dpCount)
+	{
+		if (NumberOfRows(*MX) != *dpCount || NumberOfColumns(*MX) != *ipCount)
+		{
+			FreeMemory(mem);
+			merror(0, "PN2ACPN: The size of the transformation matrix MX and the dependent and independent place lists do not agree");
+			return 0;
+		}
+	}
+	
+	/*TD, TDCount - TD is an array of arrays. It has one element (array) for each
+	transition. Each element is an index array that lists the indices of
+	transitions that cannot be brought to life if the transition corresponding to
+	the element is dead. TDCount is an array that gives the length of the arrays
+	in each element of TD.
+	If these have not been provided, compute them using nltrans:
+	nltrans_r nltrans(matrix* D, int* UnraisableTransitions, int urtCount)*/
+	if (! (*TDCount && *TD))
+	{
+		/*Get the incidence matrix - needed by nltrans.*/
+		D = SubtractMatrix(Dp, Dm, (matrix*) 2);		
+		
+		/*Allocate space for the TD and TDCount arrays.*/
+		*TD = mcalloc(mem, Transitions, sizeof(int*));
+		*TDCount = mcalloc(mem, Transitions, sizeof(int));
+		for (i = 0; i < Transitions; i++)
+		{
+			/*Get a list of transitions which are unraisable if the transition we are
+			currently examining is dead.*/
+			URT = nltrans(&D, &i, 1);
+			/*Count the number of transitions that are flagged in the flag array
+			returned by nltrans.*/			
+			for (j = 0; j < URT.dtrCount; j++)
+			{
+				if (URT.dtr[j]) (*TDCount)[i]++;
+			}
+			/*Now put their indices in the appropriate element of TD.*/
+			(*TD)[i] = mcalloc(mem, (*TDCount)[i], sizeof(int));
+			k = 0;
+			for (j = 0; j < URT.dtrCount; j++)
+			{
+				if (URT.dtr[j]) (*TD)[i][k++] = j;
+			}
+			free(URT.dtr);
+		}
+		
+		DeallocateMatrix(&D);
+	}			
+	return 1;
+}

Modified: spnbox/spnbox.h
===================================================================
--- spnbox/spnbox.h	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/spnbox.h	2009-06-22 22:12:37 UTC (rev 93)
@@ -83,6 +83,20 @@
 	int iplfCount;
 } pn2acpn_r;
 
+typedef struct pn2eacpn_r
+{
+	matrix Df;
+	matrix Dmf;
+	matrix Dpf;
+	matrix MXF;
+	matrix L0F;
+	matrix LF;
+	int *iplf;
+	int iplfCount;
+	int **TD;
+	int *TDCount;
+} pn2eacpn_r;
+
 /*Constants returned in by functions to indicate the nature of the result.*/
 #define HOW_ERROR			  "error"
 #define HOW_OK				  "OK"
@@ -364,4 +378,46 @@
 Converted to C by Marian V. Iordache and Stephen Camp, ste...@le...
 Stephen Camp -- Jun. 18, 2009
 */
+
+pn2eacpn_r pn2eacpn(matrix* Dm, matrix* Dp, int* Mask, matrix* MX, matrix* L0, matrix* L, int *ipl, int ipCount, int* dpl, int dpCount, int** TD, int* TDCount);
+/*
+PN2EACPN - Transforms a Petri net to an extended asymmetric choice Petri net
+
+[Df, Dmf, Dpf] = pn2eacpn(D)
+
+[Df, Dmf, Dpf] = pn2eacpn(Dm, Dp)
+
+[Df, Dmf, Dpf] = pn2eacpn(Dm, Dp, mask)
+
+[Df, Dmf, Dpf, MF, L0F, LF, iplf, TDf] = pn2eacpn(Dm, Dp, mask, M, L0, L, ipl, dpl, TD)
+
+mask is an optional argument: mask(i) = 1 if the place i is 
+in the set M of the technical report. (M in the tech. report has 
+a different meaning than M in the DP program.)
+ 
+The last five parameters are optional. See DP code for meaning. 
+Their updated values are given as output. In particular, TD{t} lists  
+transitions that cannot be made live when t is dead (including t itself).
+TD will typically be an underestimate of the total set. If not given,
+TD is computed here (this computation takes time). The output TDf is so
+that this computation may not be repeated again in the next iterations.
+The use of TD differentiates PN2EACPN from PN2ACPN.
+
+If called before the first iteration, take LF = MF, as the computation 
+of LF does not consider this case!
+
+See MSPLIT.
+
+Written for Matlab by Marian V. Iordache, mio...@nd...
+Original Matlab code extended the Matlab pn2acpn code written on
+M. Iordache -- Sep. 4, 2000
+and revised on Oct. 24, 2001
+
+This is the extension for extended asymmetric choice nets;
+M. Iordache, July 2003
+
+Converted to C by M. Iordache and Stephen Camp, Ste...@le....
+Matlab code was under construction at time of conversion to C.
+Stephen Camp, June 2009
+*/
 #endif


Property changes on: spnbox/tests
___________________________________________________________________
Modified: svn:ignore
   - *.bsh
*.exe
out.txt
test-pn2acpn-03.txt

   + *.bsh
*.exe
*.stackdump
out.txt
*part.txt


Modified: spnbox/tests/StructuredIO.c
===================================================================
--- spnbox/tests/StructuredIO.c	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/tests/StructuredIO.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -11,6 +11,7 @@
 	matrix*				A pointer to a matrix.	
 	arrayi				An array of integers stored as a pointer.	
 	arrayd				An array of doubles stored as a pointer.
+	arraya				An array of arrays of integers.
 	int						An integer.
 	double				A double.
 	string				A pointer to characters. Reads a single line.
@@ -134,7 +135,7 @@
 					if (! NumberOfRows(*((matrix*)Data[Param[PID].Start])))
 					{
 						FreeMemory(&memory);
-						merror(0, "Parse: There was an error reading a matrix.");
+						merror(0, "PARSESTRUCTURE: There was an error reading a matrix.");
 						return 0;
 					}
 					ManageMatrix(Memory, (matrix*)Data[Param[PID].Start]);
@@ -156,6 +157,21 @@
 					*((int*) Data[Param[PID].Start + 1]) = Length;
 					ManageMemory(Memory, *((void**) Data[Param[PID].Start]));
 				}
+				/*Array of arrays of integers*/
+				else if (! strcmp(Param[PID].Type, "arraya"))
+				{
+					/*ReadArrayA takes as its third parameter a pointer to the array
+					pointer destined to hold the array of arrays, as its fourth parameter
+					a pointer to the array pointer destined to hold a count of the number
+					of elements in each subarray, and as its fifth parameter a pointer to
+					the number of arrays.*/
+					if (! ReadArrayA(file, Memory, (int***) Data[Param[PID].Start], (int**) Data[Param[PID].Start + 1], (int*) Data[Param[PID].Start + 2]))
+					{
+						FreeMemory(&memory);
+						merror(0, "PARSESTRUCTURE: There was an error reading an array of arrays");
+						return 0;
+					}
+				}
 				/*A single integer.*/
 				else if (! strcmp(Param[PID].Type, "int"))
 				{
@@ -202,6 +218,7 @@
 	MemoryManager memory;
 	
 	matrix* Matrix;
+	int** IntAP;
 	int* IntP;
 	int Int, Length;
 	double* DblP;
@@ -296,6 +313,28 @@
 				printf("\n");
 			}
 		}
+		else if (! strcmp(Params[i].Type, "arraya"))
+		{
+			/*The first parameter is the pointer to the array of arrays, the second
+			to the array of counts, and the third to the count of arrays.*/
+			IntAP = va_arg(args, int**);
+			IntP = va_arg(args, int*);
+			Length = va_arg(args, int);
+			/*Display only if the array is nonzero*/
+			if ((Mask ? Mask[i] : 1) && IntAP && IntP && Length)
+			{
+				printf("%s: %d subarrays:\n", Params[i].Name, Length);
+				for (j = 0; j < Length; j++)
+				{
+					printf("%s %d:\t", Params[i].Name, j);
+					for (k = 0; k < IntP[j]; k++)
+					{
+						printf("%d\t", IntAP[j][k]);
+					}
+					printf("\n");
+				}
+			}
+		}
 		else if (! strcmp(Params[i].Type, "int"))
 		{
 			Int = va_arg(args, int);
@@ -467,6 +506,14 @@
 				{
 					ToAdd = 2;
 				}
+				/*If the type is an array of arrays, there will be three items in 
+				ParseStructure's parameter list: the array pointer, the array of counts
+				pointer, and the pointer to the integer destined to hold the overall 
+				count.*/
+				else if (! strcmp("arraya ", Type2))
+				{
+					ToAdd = 3;
+				}
 				/*If the parameter was recognized...*/
 				if (ToAdd)
 				{
@@ -522,3 +569,39 @@
 		return 0;
 	}
 }
+
+/*ReadArrayA takes as its third parameter a pointer to the array
+pointer destined to hold the array of arrays, as its fourth parameter
+a pointer to the array pointer destined to hold a count of the number
+of elements in each subarray, and as its fifth parameter a pointer to
+the number of arrays.*/
+int ReadArrayA(FILE* file, MemoryManager* mem, int*** array, int** arraycount, int* count)
+{
+	int i;
+	/*Arrays of arrays will be formatted thus:
+	Number of arrays
+	Array0Length Array0Contents
+	Array1Length Array1Contents
+	...*/
+	/*Try to read the number of arrays. If successful, allocate space for the
+	array of arrays and for the array of counts.*/
+	if (! fscanf(file, "%d", count)) return 0;
+	*arraycount = mcalloc(mem, *count, sizeof(int));
+	*array = mcalloc(mem, *count, sizeof(int**));
+	/*Read all the arrays.*/
+	for (i = 0; i < *count; i++)
+	{		
+		/*Attempt to read the array. On success (indicated by a non-null pointer),
+		manage the memory for the array.*/
+		if ((*array)[i] = ReadIntArray(file, (*arraycount) + i))
+		{
+			ManageMemory(mem, (*array)[i]);
+		}
+		/*On failure, fail.*/
+		else
+		{
+			return 0;
+		}
+	}
+	return 1;
+}

Modified: spnbox/tests/test-nltrans.txt
===================================================================
--- spnbox/tests/test-nltrans.txt	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/tests/test-nltrans.txt	2009-06-22 22:12:37 UTC (rev 93)
@@ -7,7 +7,6 @@
 -1	2		-1
 -3	1		0
 
-
 done
 
 echo Problem 2
@@ -22,5 +21,49 @@
 
 done
 
+echo Problem 3.0
+echo This problem has no predefined unraisable transitions. Each of the next
+echo three problems will use this same incidence matrix but define different
+echo sets of unraisable transitions.
+D 3 5
+-1	1		0		1		-1
+-1	0		1		-1	1
+1		-2	-2	0		0
+
+done
+
+echo Problem 3.1
+D 3 5
+-1	1		0		1		-1
+-1	0		1		-1	1
+1		-2	-2	0		0
+
+URT 1
+2
+
+done
+
+echo Problem 3.2
+D 3 5
+-1	1		0		1		-1
+-1	0		1		-1	1
+1		-2	-2	0		0
+
+URT 1
+4
+
+done
+
+echo Problem 3.3
+D 3 5
+-1	1		0		1		-1
+-1	0		1		-1	1
+1		-2	-2	0		0
+
+URT 3
+0	2	3
+
+done
+
 quit
 		
\ No newline at end of file

Modified: spnbox/tests/test-pn2acpn.mak
===================================================================
--- spnbox/tests/test-pn2acpn.mak	2009-06-21 19:27:39 UTC (rev 92)
+++ spnbox/tests/test-pn2acpn.mak	2009-06-22 22:12:37 UTC (rev 93)
@@ -1,6 +1,6 @@
 COMPILER=gcc -g -ggdb
 
-test-mpsplit: test-pn2acpn.o matrix.o StructuredIO.o MemoryManager.o general.o pns.o matrixmath.o pn2acpn.o
+test-pn2acpn: test-pn2acpn.o matrix.o StructuredIO.o MemoryManager.o general.o pns.o matrixmath.o pn2acpn.o
 	$(COMPILER) -o test-pn2acpn.exe test-pn2acpn.o matrix.o StructuredIO.o MemoryManager.o general.o pns.o pn2acpn.o matrixmath.o ../lp_solve_5.5/lpsolve55/liblpsolve55.a 
 
 general.o: ../../pnheaders/general.c ../../pnheaders/general.h

Added: spnbox/tests/test-pn2eacpn.c
===================================================================
--- spnbox/tests/test-pn2eacpn.c	                        (rev 0)
+++ spnbox/tests/test-pn2eacpn.c	2009-06-22 22:12:37 UTC (rev 93)
@@ -0,0 +1,159 @@
+#include <stdio.h>
+#include "../../pnheaders/pns.h"
+#include "../../pnheaders/matrix.h"
+#include "../matrixmath.h"
+#include "../spnbox.h"
+#include "../MemoryManager.h"
+#include "StructuredIO.h"
+
+/*Reference materil:
+
+pn2eacpn function definition:
+pn2eacpn_r pn2eacpn(matrix* Dm, matrix* Dp, int* Mask, matrix* MX, matrix* L0, matrix* L, int *ipl, int ipCount, int* dpl, int dpCount, int** TD, int* TDCount)
+
+pn2eacpn_r structure definition:
+typedef struct pn2eacpn_r
+{
+	matrix Df;
+	matrix Dmf;
+	matrix Dpf;
+	matrix MXF;
+	matrix L0F;
+	matrix LF;
+	int *iplf;
+	int iplfCount;
+	int **TD;
+	int *TDCount;
+} pn2eacpn_r;
+
+ParseStructure test function definition:
+int ParseStructure(FILE *file, char* DataDescription, int** FilledMask, MemoryManager* Memory, ...);
+
+DisplayStructure test function definition:
+void DisplayStructure(char* DataDescription, int* Mask, ...);
+*/
+
+void FillDmDp(int* Filled, matrix* D, matrix* Dm, matrix* Dp);
+int HasSelfLoops(matrix* Dm, matrix* Dp);
+int* BuildTDVector(int**TD, int *TDCount, int* VectorLength);
+int** BuildTD(int* TDVector, int VectorLength, int* TDCount, int* Places);
+
+int main(int argc, char* argv[])
+{
+	char InputDesc[] = "matrix D, matrix Dm, matrix Dp, matrix MX, matrix L0, matrix L, arrayi Mask, arrayi ipl, arrayi dpl, arraya TD";
+	char OutputDesc[] = "matrix Df, matrix Dmf, matrix Dpf, matrix MXF, matrix L0F, matrix LF, arrayi ipl, arraya TD";
+	FILE* input;
+	MemoryManager mem;
+	matrix Dm, Dp, MX, L0, L, D;
+	int** TD;
+	int *Mask, *ipl, *dpl, *Filled, *TDCount;	
+	int MaskCount, ipCount, dpCount, ResFilled[9], i;
+	pn2eacpn_r result;
+	
+	/*Initialize the filled mask that will be used with the result display*/
+	for (i = 0; i < 9; i++)
+	{
+		ResFilled[i] = 1;
+	}
+	
+	/*Get the input stream. If there was a command line argument, treat it as a 
+	filename and attempt to open it for read access, terminating on failure.
+	Otherwise set stdin as the input stream.*/
+	if (argc > 1)
+	{
+		if (input = fopen(argv[1], "r"))
+		{
+			printf("Taking input from file '%s'...\n", argv[1]);
+		}
+		else
+		{
+			printf("Failed to open file '%s' for read access! Terminating.\n", argv[1]);
+			return 1;
+		}
+	}
+	else
+	{
+		input = stdin;
+		printf("Taking input from console...\n");
+	}
+	
+	/*Initialize the memory manager. We don't know how many matrices and arrays
+	we'll need so just pick a nice round number as the initial address block size
+	and use the default additional block size.*/
+	mem = CreateMemoryManager(5, 5, 0, 0);
+	
+	/*Attempt to parse a problem from the file and fill all the problem parts.
+	Continue doing so until a fatal input error or a quit command is encountered.*/
+	while(ParseStructure(input, InputDesc, &Filled, &mem, &D, &Dm, &Dp, &MX, &L0, &L, &Mask, &MaskCount, &ipl, &ipCount, &dpl, &dpCount, &TD, &TDCount, &i))
+	{
+		/*If D was given, fill Dm and Dp appropriately.*/
+		FillDmDp(Filled, &D, &Dm, &Dp);
+		/*Display the problem.*/		
+		DisplayStructure(InputDesc, Filled, &D, &Dm, &Dp, &MX, &L0, &L, Mask, MaskCount, ipl, ipCount, dpl, dpCount, TD, TDCount, i);
+		
+		/*Get the solution.*/
+		result = pn2eacpn(Filled[1] ? &Dm : 0, Filled[2] ? &Dp : 0, Filled[6] ? Mask : 0, Filled[3] ? &MX : 0, Filled[4] ? &L0 : 0, Filled[5] ? &L : 0, Filled[7] ? ipl : 0, ipCount, Filled[8] ? dpl : 0, dpCount, Filled[9] ? TD : 0, TDCount);
+		
+		/*Display the solution. Show Dm and Dp only if there are self-loops and
+		D only if there are not self-loops.*/
+		if (HasSelfLoops(&Dm, &Dp))
+		{
+			ResFilled[0] = 0;
+			ResFilled[1] = 1;
+			ResFilled[2] = 1;
+		}
+		else
+		{
+			ResFilled[0] = 1;
+			ResFilled[1] = 0;
+			ResFilled[2] = 0;
+		}
+		printf("Solution:\n");
+		DisplayStructure(OutputDesc, ResFilled, &result.Df, &result.Dmf, &result.Dpf, &result.MXF, &result.L0F, &result.LF, result.iplf, result.iplfCount, result.TD, result.TDCount, NumberOfColumns(result.Df));
+		printf("---------------------------------------------------------------------------\n");
+		FreeMemory(&mem);
+		mem = CreateMemoryManager(5, 5, 0, 0);
+	}	
+	FreeMemory(&mem);
+	return 0;
+}
+
+int HasSelfLoops(matrix* Dm, matrix* Dp)
+{
+	int i, j;
+	for (i = 0; i < NumberOfRows(*Dm); i++)
+	{
+		for (j = 0; j < NumberOfColumns(*Dm); j++)
+		{
+			if (GetMatrixEl(Dm, i, j) && GetMatrixEl(Dp, i, j))
+			{
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+void FillDmDp(int* Filled, matrix* D, matrix* Dm, matrix* Dp)
+{
+	/*If D has been filled...*/
+	if (Filled[0])
+	{
+		/*We want to ignore any given Dm and Dp and instead fill Dm and Dp with
+		matrices developed from D.*/
+		if (Filled[1])
+		{
+			DeallocateMatrix(Dm);
+		}
+		if (Filled[2])
+		{
+			DeallocateMatrix(Dp);
+		}
+		AllocateMatrixType(2, Dm, NumberOfRows(*D), NumberOfColumns(*D));
+		AllocateMatrixType(2, Dp, NumberOfRows(*D), NumberOfColumns(*D));
+		d2dd(D, Dm, Dp);
+		Filled[0] = 0;
+		Filled[1] = 1;
+		Filled[2] = 1;		
+	}		
+}

Added: spnbox/tests/test-pn2eacpn.mak
===================================================================
--- spnbox/tests/test-pn2eacpn.mak	                        (rev 0)
+++ spnbox/tests/test-pn2eacpn.mak	2009-06-22 22:12:37 UTC (rev 93)
@@ -0,0 +1,42 @@
+COMPILER=gcc -g -ggdb
+
+test-pn2eacpn: test-pn2eacpn.o matrix.o StructuredIO.o MemoryManager.o general.o pns.o matrixmath.o pn2eacpn.o nltrans.o ipsolve.o ipslv.o
+	$(COMPILER) -o test-pn2eacpn.exe test-pn2eacpn.o matrix.o StructuredIO.o MemoryManager.o general.o pns.o pn2eacpn.o matrixmath.o nltrans.o ipsolve.o ipslv.o ../lp_solve_5.5/lpsolve55/liblpsolve55.a 
+
+general.o: ../../pnheaders/general.c ../../pnheaders/general.h
+	$(COMPILER) -c ../../pnheaders/general.c
+	
+pns.o:  ../../pnheaders/pns.c ../../pnheaders/pns.h
+	$(COMPILER) -c  ../../pnheaders/pns.c
+	
+matrix.o:  ../../pnheaders/matrix.c  ../../pnheaders/matrix.h ../../pnheaders/pns.h
+	$(COMPILER) -c  ../../pnheaders/matrix.c
+	
+reader.o: ../spnbox.h ../MemoryManager.h reader.c
+	$(COMPILER) -c reader.c
+
+MemoryManager.o: ../MemoryManager.h ../MemoryManager.c ../../pnheaders/general.h  ../../pnheaders/matrix.h
+	$(COMPILER) -c ../MemoryManager.c
+	
+StructuredIO.o: ../MemoryManager.h  ../../pnheaders/matrix.h StructuredIO.h StructuredIO.c
+	$(COMPILER) -c StructuredIO.c
+
+test-pn2eacpn.o: test-pn2eacpn.c ../spnbox.h ../MemoryManager.h StructuredIO.h ../matrixmath.h
+	$(COMPILER) -c test-pn2eacpn.c
+	
+matrixmath.o: ../matrixmath.c ../matrixmath.h  ../../pnheaders/matrix.h
+	$(COMPILER) -c ../matrixmath.c
+	
+pn2eacpn.o: ../spnbox.h  ../../pnheaders/matrix.h ../MemoryManager.h ../pn2eacpn.c
+	$(COMPILER) -c ../pn2eacpn.c
+	
+ipsolve.o: ../spnbox.h ../matrixmath.h ../../pnheaders/general.h  ../../pnheaders/matrix.h ../MemoryManager.h ../ipsolve.c
+	$(COMPILER) -c ../ipsolve.c
+	
+ipslv.o: ../spnbox.h ../ipslv.c
+	$(COMPILER) -c ../ipslv.c
+
+nltrans.o: ../nltrans.c ../spnbox.h ../../pnheaders/matrix.h ../matrixmath.h ../MemoryManager.h
+	$(COMPILER) -c ../nltrans.c
+
+	
\ No newline at end of file

Added: spnbox/tests/test-pn2eacpn.txt
===================================================================
--- spnbox/tests/test-pn2eacpn.txt	                        (rev 0)
+++ spnbox/tests/test-pn2eacpn.txt	2009-06-22 22:12:37 UTC (rev 93)
@@ -0,0 +1,86 @@
+rem Acceptable problem parts:
+rem D      incidence matrix
+rem Dm     output matrix
+rem Dp     input matrix
+rem MX     Transformation matrix from independent to dependent marking
+rem L0     Initial marking constraint matrix
+rem L      Marking constraint matrix.
+rem Mask   An integer array, one element for each place of the Petri net. Serves
+rem        as a mask on which places will be processed.
+rem ipl    An array of the indices of independent places.
+rem dpl    An array of the indices of dependent places.
+rem TD     An array of arrays, one subarray for each transition. Each subarray
+rem        contains a list of the indices of transitions that cannot be made
+rem 			 live if the corresponding transition is dead.
+rem As always, matrices are defined by the keyword followed by the matrix
+rem dimensions followed by the elements of the matrix. Arrays are defined by the
+rem keyword followed by the length of the array followed by the array elements.
+rem If D is given Dm and Dp are ignored.
+
+rem ----------------------------------------------------------------------------
+echo Problem 1
+echo Example 5.2 from the thesis.
+echo The first three test problems are the problems of the original matlab test
+echo file pn2ecdem.m.
+Dp 3 5
+0	1	0	1	0
+0	0	1	0	1
+1	0	0	0	0
+
+Dm 3 5
+1	0	0	0	1
+1	0	0	1	0
+0	2	2	0	0
+
+done
+
+rem ----------------------------------------------------------------------------
+echo Problem 2
+echo Example 5.1 from the thesis.
+Dm 4 5
+1	0	1	0	1
+0	0	0	1	0
+0	1	0	0	1
+1	0	1	0	0
+
+Dp 4 5
+0	0	0	1	0
+0	0	2	0	1
+3	0	0	0	0
+0	1	0	0	0
+
+done
+
+rem ----------------------------------------------------------------------------
+echo Problem 3
+
+D 5 6
+-1	-1	0		0		0		0
+0		-1	-1	0		0		0
+0		0		-1	-1	0		0
+0		0		0		-1	-1	0
+0		0		0		-1	0		-1
+
+done
+
+rem ----------------------------------------------------------------------------
+echo Problem 4.
+echo This is the EAC-net example of the dissertation, therefore the EAC-net
+echo transformation should have no effect.
+Dm 4 5
+1	0	0	1	1
+1	1	0	0	0	
+0	0	1	1	0
+0	0	0	1	0
+
+Dp 4 5
+0	0	0	2	0
+0	1	1	0	0
+2	0	0	0	1
+0	0	1	0	0
+
+done
+
+quit
+
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2009	Jan	Feb	Mar	Apr	May	Jun (69)	Jul (86)	Aug (33)	Sep	Oct	Nov	Dec
2011	Jan	Feb	Mar	Apr (3)	May (3)	Jun (1)	Jul (10)	Aug (2)	Sep (1)	Oct	Nov	Dec
2012	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (2)	Sep	Oct	Nov	Dec

pntool-developers Mailing List for A Concurrency Tool Suite (Page 8)

pntool-developers — Developers