Changeset 207


Ignore:
Timestamp:
02/19/10 16:28:58 (14 years ago)
Author:
bernard
Message:

Modifications for managing the error cases (cf. former commits) had introducting a bug that leads to errors in some cases as in the 3D_EX7.d file, this commit fix the bug by making some changes in the getImposed() functions

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/yao/src/YAOObjects/Order.cpp

    r206 r207  
    15391539                        case 7:  
    15401540 
    1541                         cout << endl << "Error : no common value in a compnent including moduls "; 
     1541                        cout << endl << "Error : no common value in the component including moduls "; 
    15421542                        for(tie(vertexIterOne, vertexIterTwo) = vertices(myGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne)  
    15431543                                if(get(boost::vertex_affected_comp_t(), myGraph, *vertexIterOne) == noComponent)  
    … …  
    15491549                        case 8:  
    15501550 
    1551                         cout << endl << "Error : cyclic dependency in a compnent including moduls "; 
     1551                        cout << endl << "Error : cyclic dependency in the component including moduls "; 
    15521552                                for(tie(vertexIterOne, vertexIterTwo) = vertices(myGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne)  
    15531553                                        if(get(boost::vertex_affected_comp_t(), myGraph, *vertexIterOne) == noComponent)  
    … …  
    17211721 
    17221722        // Insert all vertices of the graph inside a vector of vertex 
    1723                                                                                    // ---------------------------------------------------------- 
     1723        // ---------------------------------------------------------- 
    17241724 
    17251725        for(tie(vertexIterOne, vertexIterTwo) = vertices(componentGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) vertexIterVector.push_back(vertexIterOne); 
    … …  
    22542254        } 
    22552255 
    2256         // ****  ETAPE 3 DE LA PROCEDURE A UNE DIMENSION  ****** 
     2256        // ETAPE 3 DE LA PROCEDURE A UNE DIMENSION   
     2257        // --------------------------------------- 
    22572258 
    22582259        fixGraph(currentGraph, freeDim); 
    22592260 
    2260         // ****  ETAPE 4 DE LA PROCEDURE A UNE DIMENSION  ****** 
     2261        // ETAPE 4 DE LA PROCEDURE A UNE DIMENSION   
     2262        // ---------------------------------------  
    22612263 
    22622264        // Perform a topological sort on the graph  
    … …  
    22682270        for(int i = 0; i < topoOrder.size(); i++) put(get(boost::vertex_topo_order_t(), currentGraph), topoOrder[i], i); 
    22692271 
    2270         // ****  ETAPE 5.2 DE LA PROCEDURE A UNE DIMENSION  ****** 
     2272        // ETAPE 5.2 DE LA PROCEDURE A UNE DIMENSION  
     2273        // ----------------------------------------- 
    22712274 
    22722275        // Sort the moduls inside the components (internal sort)   
    … …  
    22922295        } 
    22932296 
    2294         // ****  ETAPE 5.3 DE LA PROCEDURE A UNE DIMENSION  ****** 
     2297        // ETAPE 5.3 DE LA PROCEDURE A UNE DIMENSION  
     2298        // -----------------------------------------  
    22952299 
    22962300        // Create a reduced graph whose vertices are the components of the current graph 
    … …  
    23992403        fixGraph(fixedGraph, fixedDim); 
    24002404 
    2401  
    2402         // ***************************************************** 
    2403         // ****                                           ****** 
    2404         // ****  ETAPE 3 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2405         // ****                                           ****** 
    2406         // ***************************************************** 
     2405        // ETAPE 3 DE LA PROCEDURE A DEUX DIMENSION  
     2406        // ---------------------------------------- 
    24072407 
    24082408        // Create data structures used by boost to perform the strong component search  
    … …  
    24162416        // --------------------------------------------------------- 
    24172417 
    2418 for(tie(vertexIterOne, vertexIterTwo) = vertices(fixedGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) put(get(boost::vertex_affected_comp_t(), fixedGraph), *vertexIterOne, -1); 
    2419  
    2420 // Perform a strong components search on the 2D graph  
    2421 // -------------------------------------------------- 
    2422  
    2423 boost::strong_components(fixedGraph, &middleComponentsList[0], boost::root_map(&verticesDiscoverList[0])); 
    2424  
    2425 // Update vertices properties of the 2D graph : set a component Id on each vertex 
    2426 // ------------------------------------------------------------------------------ 
    2427  
    2428 for(int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]); 
    2429  
    2430 // Setting the number of components that have been detected 
    2431 // -------------------------------------------------------- 
    2432  
    2433 int nbComponents = *max_element(middleComponentsList.begin(), middleComponentsList.end()) + 1; 
    2434  
    2435 // Setting the third dimension size of innerComp array 
    2436 // --------------------------------------------------- 
    2437  
    2438 innerComp[noComp][fixedDim] = new cfcStructTableType*[nbComponents];  
    2439  
    2440 // Setting the fourth dimension size of the innerComp array 
    2441 // -------------------------------------------------------- 
    2442  
    2443 for(int noCompD2 = 0; noCompD2 < nbComponents; noCompD2++) innerComp[noComp][fixedDim][noCompD2] = new cfcStructTableType[3]; 
    2444  
    2445  
    2446 // ***************************************************** 
    2447 // ****                                           ****** 
    2448 // ****  ETAPE 5 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2449 // ****                                           ****** 
    2450 // ***************************************************** 
    2451  
    2452 // Resize the middleComp array with the size of 2D components that have been detected 
    2453 // ---------------------------------------------------------------------------------- 
    2454  
    2455 middleComp[noComp][fixedDim].resize(nbComponents); 
    2456  
    2457 // Set up the array that will be used to register the informations about imposed values for the axis 
    2458 // ------------------------------------------------------------------------------------------------- 
    2459  
    2460 int ** isImposed2D = new int*[nbComponents]; 
    2461  
    2462 for(int i = 0; i < nbComponents; i++) isImposed2D[i] = new int[2]; 
    2463  
    2464 // For each component, set the sign for the first and second dimensions then register this sign in the cfcSign attribute 
    2465 // --------------------------------------------------------------------------------------------------------------------- 
    2466  
    2467 for(int noComponent = 0; noComponent < nbComponents; noComponent++) { 
    2468  
    2469         // Setting inial imposed values (0 mean no imposed) 
    2470         // ------------------------------------------------ 
    2471  
    2472         isImposed2D[noComponent][0] = 0; 
    2473         isImposed2D[noComponent][1] = 0; 
    2474  
    2475         middleComp[noComp][fixedDim][noComponent].cfcSign.resize(2); 
    2476  
    2477         middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = dimOne; 
    2478         middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = dimTwo; 
    2479  
    2480         middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = 0; 
    2481         middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0; 
    2482  
    2483         middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = getCommonSign(dimOne, noComponent, fixedGraph);  
    2484         middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = getCommonSign(dimTwo, noComponent, fixedGraph); 
    2485  
    2486         // Detecting all possible axis combinations  
     2418        for(tie(vertexIterOne, vertexIterTwo) = vertices(fixedGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) put(get(boost::vertex_affected_comp_t(), fixedGraph), *vertexIterOne, -1); 
     2419 
     2420        // Perform a strong components search on the 2D graph  
     2421        // -------------------------------------------------- 
     2422 
     2423        boost::strong_components(fixedGraph, &middleComponentsList[0], boost::root_map(&verticesDiscoverList[0])); 
     2424 
     2425        // Update vertices properties of the 2D graph : set a component Id on each vertex 
     2426        // ------------------------------------------------------------------------------ 
     2427 
     2428        for(int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]); 
     2429 
     2430        // Setting the number of components that have been detected 
     2431        // -------------------------------------------------------- 
     2432 
     2433        int nbComponents = *max_element(middleComponentsList.begin(), middleComponentsList.end()) + 1; 
     2434 
     2435        // Setting the third dimension size of innerComp array 
     2436        // --------------------------------------------------- 
     2437 
     2438        innerComp[noComp][fixedDim] = new cfcStructTableType*[nbComponents];  
     2439 
     2440        // Setting the fourth dimension size of the innerComp array 
     2441        // -------------------------------------------------------- 
     2442 
     2443        for(int noCompD2 = 0; noCompD2 < nbComponents; noCompD2++) innerComp[noComp][fixedDim][noCompD2] = new cfcStructTableType[3]; 
     2444 
     2445        // ETAPE 5 DE LA PROCEDURE A DEUX DIMENSION  
    24872446        // ---------------------------------------- 
    24882447 
    2489         int noConf = -1; 
    2490  
    2491         int sign0 = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second; 
    2492         int sign1 = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second;  
    2493  
    2494  
    2495 int axis0 = dimOne;  
    2496 int axis1 = dimTwo; 
    2497  
    2498 if(sign0 != 2 && sign1 != 2)  noConf = 0;       // axis0 -> axis1 (axis1 free) 
    2499 if(sign0 != 2 && sign1 == 2)  noConf = 1;       // axis0 -> axis1  
    2500 if(sign0 == 2 && sign1 == 2)  noConf = 2;       // axis0 -> axis1 
    2501 if(sign0 == 2 && sign1 != 2)  noConf = 3;       // axis1 -> axis0  
    2502  
    2503 // Looking at combinations to set imposed values for the second axis  
    2504 // ----------------------------------------------------------------- 
    2505  
    2506 if(noConf < 3) isImposed2D[noComponent][1] = getImposed(axis1, noComponent, fixedGraph); 
    2507  
    2508 if(noConf == 3) isImposed2D[noComponent][1] = getImposed(axis0, noComponent, fixedGraph); 
    2509  
    2510 // Sort the axis then set their values accordignly to the combination available for the current 2D component 
    2511 // --------------------------------------------------------------------------------------------------------- 
    2512  
    2513 if(noConf == 0) {  
    2514  
     2448        // Resize the middleComp array with the size of 2D components that have been detected 
     2449        // ---------------------------------------------------------------------------------- 
     2450 
     2451        middleComp[noComp][fixedDim].resize(nbComponents); 
     2452 
     2453        // Set up the array that will be used to register the informations about imposed values for the axis 
     2454        // ------------------------------------------------------------------------------------------------- 
     2455 
     2456        int ** isImposed2D = new int*[nbComponents]; 
     2457 
     2458        for(int i = 0; i < nbComponents; i++) isImposed2D[i] = new int[2]; 
     2459 
     2460        // For each component, set the sign for the first and second dimensions then register this sign in the cfcSign attribute 
     2461        // --------------------------------------------------------------------------------------------------------------------- 
     2462 
     2463        for(int noComponent = 0; noComponent < nbComponents; noComponent++) { 
     2464 
     2465                // Setting inial imposed values (0 mean no imposed) 
     2466                // ------------------------------------------------ 
     2467 
     2468                isImposed2D[noComponent][0] = 0; 
     2469                isImposed2D[noComponent][1] = 0; 
     2470 
     2471                middleComp[noComp][fixedDim][noComponent].cfcSign.resize(2); 
     2472 
     2473                middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = dimOne; 
     2474                middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = dimTwo; 
     2475 
     2476                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = 0; 
    25152477                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0; 
    25162478 
    2517                 if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0]; 
    2518                 if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1];  
    2519 } 
    2520  
    2521 if(noConf > 0 && noConf < 3) { 
    2522  
    2523                 if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0]; 
    2524                 if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1]; 
    2525 } 
    2526  
    2527 if(noConf == 3) {  
    2528  
    2529                 int tmpVal = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second; 
    2530                 middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second; 
    2531                 middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = tmpVal; 
    2532                 middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = axis1; 
    2533                 middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = axis0; 
    2534  
    2535                 if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][0]; 
    2536                 if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][1]; 
    2537 } 
    2538  
    2539  
    2540 }  
    2541  
    2542  
    2543  
    2544 // ***************************************************** 
    2545 // ****                                           ****** 
    2546 // ****  ETAPE 6 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2547 // ****                                           ****** 
    2548 // ***************************************************** 
    2549  
    2550 myGraphType cfcGraph; 
    2551  
    2552 reduceGraph(fixedGraph, cfcGraph, nbComponents); 
    2553  
    2554 // ***************************************************** 
    2555 // ****                                           ****** 
    2556 // ****  ETAPE 7 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2557 // ****                                           ****** 
    2558 // ***************************************************** 
    2559  
    2560 std::deque<int> topoOrder; 
    2561  
    2562 if(boost::num_vertices(cfcGraph) > 1) { 
    2563  
    2564 // Perform a topological sort on the graph whose vertices are the components (reduced graph) 
    2565 // ----------------------------------------------------------------------------------------- 
    2566  
    2567 boost::topological_sort(cfcGraph, std::front_inserter(topoOrder), boost::vertex_index_map(boost::identity_property_map())); 
    2568  
    2569 // ***************************************************** 
    2570 // ****                                           ****** 
    2571 // ****  ETAPE 8 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2572 // ****                                           ****** 
    2573 // ***************************************************** 
    2574  
    2575 // Sort the middle structure table elements (2D graph components) accordignly to the sorting performed on the reduced graph  
    2576 // ------------------------------------------------------------------------------------------------------------------------ 
    2577  
    2578 vector<cfcStruct> sortedCfcStructTable; 
    2579  
    2580 for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]); 
    2581  
    2582 middleComp[noComp][fixedDim].clear(); 
    2583  
    2584 for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]); 
    2585  
    2586 } 
    2587  
    2588 else { topoOrder[0] = 0; } 
    2589  
    2590  
    2591 // ***************************************************** 
    2592 // ****                                           ****** 
    2593 // ****  ETAPE 9 DE LA PROCEDURE A DEUX DIMENSION ****** 
    2594 // ****                                           ****** 
    2595 // ***************************************************** 
    2596  
    2597  
    2598 // Create a graph that just keep the current 2D component egdes and vertices  
    2599 // ------------------------------------------------------------------------- 
    2600  
    2601 for(int noComp2D = 0; noComp2D < nbComponents; noComp2D++) {  
    2602  
    2603 myGraphType outputGraph; 
    2604  
    2605 copyGraph(fixedGraph, outputGraph);  
    2606  
    2607 keepComponent(topoOrder[noComp2D], outputGraph); 
    2608  
    2609  
    2610 // Create the two 1D component vectors corresponding to the two third dimensions availables 
    2611 // ---------------------------------------------------------------------------------------- 
    2612  
    2613 switch(fixedDim) { 
    2614  
    2615         case 0: 
    2616  
    2617                 setInner(noComp, fixedDim, noComp2D, 1, 2, outputGraph);    // jk     
     2479                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = getCommonSign(dimOne, noComponent, fixedGraph);  
     2480                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = getCommonSign(dimTwo, noComponent, fixedGraph); 
     2481 
     2482 
     2483                int sign0 = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second; 
     2484                int sign1 = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second; 
     2485 
     2486                int axis0 = dimOne; 
     2487                int axis1 = dimTwo;  
     2488 
     2489                // If there is just one vertex in the component without reflexive edge 
     2490                // ------------------------------------------------------------------- 
     2491 
     2492                bool isConnected = true; 
     2493 
     2494                if(sign0 == 3 && sign1 == 3) { 
     2495 
     2496                        middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = 0; 
     2497                        middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0; 
     2498 
     2499                        isConnected = false; 
     2500                } 
     2501 
     2502                if(isConnected) {  
     2503 
     2504                        // Detecting all possible axis combinations  
     2505                        // ---------------------------------------- 
     2506 
     2507                        int noConf = -1; 
     2508 
     2509                        // int sign0 = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second; 
     2510                        // int sign1 = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second;  
     2511 
     2512                        if(sign0 != 2 && sign1 != 2)  noConf = 0;       // axis0 -> axis1 (axis1 free) 
     2513                        if(sign0 != 2 && sign1 == 2)  noConf = 1;       // axis0 -> axis1  
     2514                        if(sign0 == 2 && sign1 == 2)  noConf = 2;       // axis0 -> axis1 
     2515                        if(sign0 == 2 && sign1 != 2)  noConf = 3;       // axis1 -> axis0  
     2516 
     2517                        // Looking at combinations to set imposed values for the second axis  
     2518                        // ----------------------------------------------------------------- 
     2519 
     2520                        if(noConf < 3) isImposed2D[noComponent][1] = getImposed(axis1, noComponent, fixedGraph); 
     2521 
     2522                        if(noConf == 3) isImposed2D[noComponent][1] = getImposed(axis0, noComponent, fixedGraph); 
     2523 
     2524                        // Sort the axis then set their values accordignly to the combination available for the current 2D component 
     2525                        // --------------------------------------------------------------------------------------------------------- 
     2526 
     2527                        if(noConf == 0) {  
     2528 
     2529                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0; 
     2530 
     2531                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0]; 
     2532                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1];  
     2533                        } 
     2534 
     2535                        if(noConf > 0 && noConf < 3) { 
     2536 
     2537                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0]; 
     2538                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1]; 
     2539                        } 
     2540 
     2541                        if(noConf == 3) {  
     2542 
     2543                                int tmpVal = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second; 
     2544                                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second; 
     2545                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = tmpVal; 
     2546                                middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = axis1; 
     2547                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = axis0; 
     2548 
     2549                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][0]; 
     2550                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][1]; 
     2551                        } 
     2552                }  
     2553        } 
     2554 
     2555 
     2556 
     2557        // ETAPE 6 DE LA PROCEDURE A DEUX DIMENSION  
     2558        // ------------------------------------- 
     2559 
     2560        myGraphType cfcGraph; 
     2561 
     2562        reduceGraph(fixedGraph, cfcGraph, nbComponents); 
     2563 
     2564        // ETAPE 7 DE LA PROCEDURE A DEUX DIMENSION  
     2565        // ---------------------------------------- 
     2566 
     2567        std::deque<int> topoOrder; 
     2568 
     2569        if(boost::num_vertices(cfcGraph) > 1) { 
     2570 
     2571                // Perform a topological sort on the graph whose vertices are the components (reduced graph) 
     2572                // ----------------------------------------------------------------------------------------- 
     2573 
     2574                boost::topological_sort(cfcGraph, std::front_inserter(topoOrder), boost::vertex_index_map(boost::identity_property_map())); 
     2575 
     2576                // ETAPE 8 DE LA PROCEDURE A DEUX DIMENSION  
     2577                // ---------------------------------------- 
     2578 
     2579                // Sort the middle structure table elements (2D graph components) accordignly to the sorting performed on the reduced graph  
     2580                // ------------------------------------------------------------------------------------------------------------------------ 
     2581 
     2582                vector<cfcStruct> sortedCfcStructTable; 
     2583 
     2584                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]); 
     2585 
     2586                middleComp[noComp][fixedDim].clear(); 
     2587 
     2588                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]); 
     2589 
     2590        } 
     2591 
     2592        else { topoOrder[0] = 0; } 
     2593 
     2594 
     2595        // ETAPE 9 DE LA PROCEDURE A DEUX DIMENSION  
     2596        // ---------------------------------------- 
     2597 
     2598        // Create a graph that just keep the current 2D component egdes and vertices  
     2599        // ------------------------------------------------------------------------- 
     2600 
     2601        for(int noComp2D = 0; noComp2D < nbComponents; noComp2D++) {  
     2602 
     2603                myGraphType outputGraph; 
     2604 
     2605                copyGraph(fixedGraph, outputGraph);  
     2606 
     2607                keepComponent(topoOrder[noComp2D], outputGraph); 
     2608 
     2609 
     2610                // Create the two 1D component vectors corresponding to the two third dimensions availables 
     2611                // ---------------------------------------------------------------------------------------- 
     2612 
     2613                switch(fixedDim) { 
     2614 
     2615                        case 0: 
     2616 
     2617                                setInner(noComp, fixedDim, noComp2D, 1, 2, outputGraph);    // jk     
    26182618         
    2619                 setInner(noComp, fixedDim, noComp2D, 2, 1, outputGraph);    // kj 
    2620  
    2621         break; 
    2622  
    2623         case 1: 
    2624  
    2625                 setInner(noComp, fixedDim, noComp2D, 0, 2, outputGraph);    // ik 
    2626  
    2627                 setInner(noComp, fixedDim, noComp2D, 2, 0, outputGraph);    // ki 
    2628  
    2629                 break; 
    2630  
    2631         case 2: 
    2632  
    2633                 setInner(noComp, fixedDim, noComp2D, 0, 1, outputGraph);    // ij 
    2634  
    2635                 setInner(noComp, fixedDim, noComp2D, 1, 0, outputGraph);    // ji 
    2636  
    2637         break; 
    2638 } 
    2639 } 
     2619                                setInner(noComp, fixedDim, noComp2D, 2, 1, outputGraph);    // kj 
     2620 
     2621                        break; 
     2622 
     2623                        case 1: 
     2624 
     2625                                setInner(noComp, fixedDim, noComp2D, 0, 2, outputGraph);    // ik 
     2626 
     2627                                setInner(noComp, fixedDim, noComp2D, 2, 0, outputGraph);    // ki 
     2628 
     2629                        break; 
     2630 
     2631                        case 2: 
     2632 
     2633                                setInner(noComp, fixedDim, noComp2D, 0, 1, outputGraph);    // ij 
     2634 
     2635                                setInner(noComp, fixedDim, noComp2D, 1, 0, outputGraph);    // ji 
     2636 
     2637                        break; 
     2638                } 
     2639        } 
    26402640}; 
    26412641 
    … …  
    30953095        fixGraph(fixedGraph, fixedDim); 
    30963096 
    3097         // Return the sign for the free dimension and the component given as parameter  
     3097        // If there is just one vertex without reflexive edge in the component, then hide the returned value by setting it as free (ie 0 instead of 3) 
     3098        // ------------------------------------------------------------------------------------------------------------------------------------------- 
     3099 
     3100        int value = getCommonSign(freeDim, noComp, fixedGraph); 
     3101 
     3102        if(value == 3) value = 0; 
     3103 
     3104        // Return the sign for the free dimension and the component given as parameter  
    30983105        // --------------------------------------------------------------------------- 
    30993106 
    3100         return(getCommonSign(freeDim, noComp, fixedGraph)); 
     3107        return(value); 
    31013108 
    31023109}; 
    … …  
    32283235        if(freeDim == 2) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 1); }  // i == 0, j == 0 
    32293236 
     3237        // If there is just one vertex without reflexive edge in the component, then hide the returned value by setting it as free (ie 0 instead of 3) 
     3238        // ------------------------------------------------------------------------------------------------------------------------------------------- 
     3239 
     3240        int value = getCommonSign(freeDim, noComp, fixedGraph); 
     3241 
     3242        if(value == 3) value = 0; 
     3243 
    32303244        // Return the sign for the free dimension and the component given as parameter  
    32313245        // --------------------------------------------------------------------------- 
    32323246 
    3233         return(getCommonSign(freeDim, noComp, fixedGraph)); 
     3247        return(value); 
    32343248 
    32353249}; 
Note: See TracChangeset for help on using the changeset viewer.