regularity_internal.h

Go to the documentation of this file.

#ifndef CMR_REGULAR_INTERNAL_H
#define CMR_REGULAR_INTERNAL_H
 
#include <time.h>
 
#include <cmr/regular.h>
 
#include "matroid_internal.h"
 
typedef struct DecompositionTask
{
  CMR_MATROID_DEC* dec;           
  struct DecompositionTask* next; 
  CMR_REGULAR_PARAMS* params;     
  CMR_REGULAR_STATS* stats;       
  clock_t startClock;             
  double timeLimit;               
} DecompositionTask;
 
CMR_ERROR CMRregularityTaskCreateRoot(
  CMR* cmr,                       
  CMR_MATROID_DEC* dec,           
  DecompositionTask** ptask,      
  CMR_REGULAR_PARAMS* params,     
  CMR_REGULAR_STATS* stats,       
  clock_t startClock,             
  double timeLimit                
);
 
CMR_ERROR CMRregularityTaskFree(
  CMR* cmr,                       
  DecompositionTask** ptask       
);
 
typedef struct DecompositionQueue
{
  DecompositionTask* head;    
  bool foundIrregularity;     
  bool foundNongraphicness;   
  bool foundNoncographicness; 
} DecompositionQueue;
 
CMR_ERROR CMRregularityQueueCreate(
  CMR* cmr,                   
  DecompositionQueue** pqueue 
);
 
CMR_ERROR CMRregularityQueueFree(
  CMR* cmr,                   
  DecompositionQueue** pqueue 
);
 
bool CMRregularityQueueEmpty(
  DecompositionQueue* queue 
);
 
DecompositionTask* CMRregularityQueueRemove(
  DecompositionQueue* queue 
);
 
 
void CMRregularityQueueAdd(
  DecompositionQueue* queue,  
  DecompositionTask* task     
);
 
CMR_ERROR
CMRregularityDecomposeThreeSum(
  CMR* cmr,                   
  DecompositionTask* task,    
  DecompositionQueue* queue,  
  CMR_SEPA* separation        
);
 
CMR_ERROR
CMRregularityNestedMinorSequenceSearchThreeSeparation(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR
CMRregularityNestedMinorSequenceGraphicness(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR
CMRregularityNestedMinorSequenceCographicness(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR
CMRregularityExtendNestedMinorSequence(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularityTestR10(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularityInitNestedMinorSequence(
  CMR* cmr,                   
  DecompositionTask* task,    
  CMR_SUBMAT* wheelSubmatrix  
);
 
CMR_ERROR CMRregularityDecomposeSeriesParallel(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularityTestGraphicness(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularityTestCographicness(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularitySearchOneSum(
  CMR* cmr,                 
  DecompositionTask* task,  
  DecompositionQueue* queue 
);
 
CMR_ERROR CMRregularityTest(
  CMR* cmr,                   
  CMR_CHRMAT* matrix,         
  bool ternary,               
  bool *pisRegular,           
  CMR_MATROID_DEC** pdec,     
  CMR_MINOR** pminor,         
  CMR_REGULAR_PARAMS* params, 
  CMR_REGULAR_STATS* stats,   
  double timeLimit            
);
 
CMR_ERROR CMRregularityCompleteDecomposition(
  CMR* cmr,                   
  CMR_MATROID_DEC* subtree,   
  CMR_REGULAR_PARAMS* params, 
  CMR_REGULAR_STATS* stats,   
  double timeLimit            
);
 
#endif /* CMR_REGULAR_INTERNAL_H */