#include <equation.h>
 | 
|   | checker () | 
|   | 
|   | ~checker () | 
|   | 
| void  | collectDependencies (void) | 
|   | 
| void  | collectDependencies (node *) | 
|   | 
| void  | setEquations (node *) | 
|   | 
| node *  | getEquations (void) | 
|   | 
| void  | list (void) | 
|   | 
| int  | findUndefined (int) | 
|   | 
| strlist *  | getVariables (void) | 
|   | 
| int  | findDuplicate (void) | 
|   | 
| int  | detectCycles (void) | 
|   | 
| node *  | appendEquation (node *, node *) | 
|   | 
| void  | dropEquation (node *) | 
|   | 
| void  | reorderEquations (void) | 
|   | 
| int  | applyTypes (void) | 
|   | 
| int  | checkExport (void) | 
|   | 
| void  | constants (void) | 
|   | 
| int  | check (int noundefined=1) | 
|   | 
| strlist *  | variables (void) | 
|   | 
| node *  | addDouble (const char *, const char *, nr_double_t) | 
|   | 
| node *  | createDouble (const char *, const char *, nr_double_t) | 
|   | 
| node *  | addComplex (const char *, const char *, nr_complex_t) | 
|   | 
| node *  | createComplex (const char *, const char *, nr_complex_t) | 
|   | 
| node *  | addReference (const char *, const char *, char *) | 
|   | 
| node *  | createReference (const char *, const char *, char *) | 
|   | 
| void  | appendEquation (node *) | 
|   | 
| void  | addEquation (node *) | 
|   | 
| node *  | findEquation (char *) | 
|   | 
| bool  | containsVariable (char *) | 
|   | 
| nr_double_t  | getDouble (char *) | 
|   | 
| void  | setDouble (char *, nr_double_t) | 
|   | 
| qucs::vector  | getVector (char *) | 
|   | 
| void  | setDefinitions (struct definition_t *d) | 
|   | 
| struct definition_t *  | getDefinitions (void) | 
|   | 
| node *  | findProperty (char *) | 
|   | 
|   | checker () | 
|   | 
|   | ~checker () | 
|   | 
| void  | collectDependencies (void) | 
|   | 
| void  | collectDependencies (node *) | 
|   | 
| void  | setEquations (node *) | 
|   | 
| node *  | getEquations (void) | 
|   | 
| void  | list (void) | 
|   | 
| int  | findUndefined (int) | 
|   | 
| strlist *  | getVariables (void) | 
|   | 
| int  | findDuplicate (void) | 
|   | 
| int  | detectCycles (void) | 
|   | 
| node *  | appendEquation (node *, node *) | 
|   | 
| void  | dropEquation (node *) | 
|   | 
| void  | reorderEquations (void) | 
|   | 
| int  | applyTypes (void) | 
|   | 
| int  | checkExport (void) | 
|   | 
| void  | constants (void) | 
|   | 
| int  | check (int noundefined=1) | 
|   | 
| strlist *  | variables (void) | 
|   | 
| node *  | addDouble (const char *, const char *, nr_double_t) | 
|   | 
| node *  | createDouble (const char *, const char *, nr_double_t) | 
|   | 
| node *  | addComplex (const char *, const char *, nr_complex_t) | 
|   | 
| node *  | createComplex (const char *, const char *, nr_complex_t) | 
|   | 
| node *  | addReference (const char *, const char *, char *) | 
|   | 
| node *  | createReference (const char *, const char *, char *) | 
|   | 
| void  | appendEquation (node *) | 
|   | 
| void  | addEquation (node *) | 
|   | 
| node *  | findEquation (char *) | 
|   | 
| bool  | containsVariable (char *) | 
|   | 
| nr_double_t  | getDouble (char *) | 
|   | 
| void  | setDouble (char *, nr_double_t) | 
|   | 
| qucs::vector  | getVector (char *) | 
|   | 
| void  | setDefinitions (struct definition_t *d) | 
|   | 
| struct definition_t *  | getDefinitions (void) | 
|   | 
| node *  | findProperty (char *) | 
|   | 
Definition at line 270 of file equation.h.
 
      
        
          | qucs::checker::checker  | 
          ( | 
           | ) | 
           | 
        
      
 
 
      
        
          | qucs::checker::~checker  | 
          ( | 
           | ) | 
           | 
        
      
 
 
      
        
          | qucs::eqn::checker::checker  | 
          ( | 
           | ) | 
           | 
        
      
 
 
      
        
          | qucs::eqn::checker::~checker  | 
          ( | 
           | ) | 
           | 
        
      
 
 
      
        
          | node * qucs::checker::addComplex  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          nr_complex_t  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::addComplex  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          nr_complex_t  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::addDouble  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          nr_double_t  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::addDouble  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          nr_double_t  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | void qucs::eqn::checker::addEquation  | 
          ( | 
          node *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::addEquation  | 
          ( | 
          node *  | 
          eqn | ) | 
           | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::addReference  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          char *  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::addReference  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          char *  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::appendEquation  | 
          ( | 
          node *  | 
          root,  | 
        
        
           | 
           | 
          node *  | 
          last  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::appendEquation  | 
          ( | 
          node *  | 
          ,  | 
        
        
           | 
           | 
          node *  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | void qucs::eqn::checker::appendEquation  | 
          ( | 
          node *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::appendEquation  | 
          ( | 
          node *  | 
          eqn | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::applyTypes  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::eqn::checker::applyTypes  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::check  | 
          ( | 
          int  | 
          noundefined = 1 | ) | 
           | 
        
      
 
 
      
        
          | int qucs::eqn::checker::check  | 
          ( | 
          int  | 
          noundefined = 1 | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::checkExport  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::eqn::checker::checkExport  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::collectDependencies  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::collectDependencies  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::collectDependencies  | 
          ( | 
          node *  | 
          eqn | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::collectDependencies  | 
          ( | 
          node *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::constants  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::constants  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | bool qucs::checker::containsVariable  | 
          ( | 
          char *  | 
          ident | ) | 
           | 
        
      
 
 
      
        
          | bool qucs::eqn::checker::containsVariable  | 
          ( | 
          char *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::createComplex  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          nr_complex_t  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::createComplex  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          nr_complex_t  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::createDouble  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          nr_double_t  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::createDouble  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          nr_double_t  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::createReference  | 
          ( | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          const char *  | 
          ,  | 
        
        
           | 
           | 
          char *  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | node * qucs::checker::createReference  | 
          ( | 
          const char *  | 
          type,  | 
        
        
           | 
           | 
          const char *  | 
          ident,  | 
        
        
           | 
           | 
          char *  | 
          value  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | int qucs::eqn::checker::detectCycles  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::detectCycles  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::dropEquation  | 
          ( | 
          node *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::dropEquation  | 
          ( | 
          node *  | 
          eqn | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::findDuplicate  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::eqn::checker::findDuplicate  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | node * qucs::checker::findEquation  | 
          ( | 
          node *  | 
          root,  | 
         
        
           | 
           | 
          char *  | 
          n  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | static node* qucs::eqn::checker::findEquation  | 
          ( | 
          node *  | 
          ,  | 
         
        
           | 
           | 
          char *  | 
            | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
static   | 
  
 
 
      
        
          | node* qucs::eqn::checker::findEquation  | 
          ( | 
          char *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | node * qucs::checker::findEquation  | 
          ( | 
          char *  | 
          n | ) | 
           | 
        
      
 
 
      
        
          | node* qucs::eqn::checker::findProperty  | 
          ( | 
          char *  | 
           | ) | 
           | 
        
      
 
 
      
        
          | node * qucs::checker::findProperty  | 
          ( | 
          char *  | 
          var | ) | 
           | 
        
      
 
 
      
        
          | int qucs::eqn::checker::findUndefined  | 
          ( | 
          int  | 
           | ) | 
           | 
        
      
 
 
      
        
          | int qucs::checker::findUndefined  | 
          ( | 
          int  | 
          noundefined | ) | 
           | 
        
      
 
 
  
  
      
        
          | static strlist* qucs::eqn::checker::foldDependencies  | 
          ( | 
          strlist *  | 
           | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | strlist * qucs::checker::foldDependencies  | 
          ( | 
          strlist *  | 
          deps | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | struct definition_t* qucs::eqn::checker::getDefinitions  | 
          ( | 
          void  | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
  
  
      
        
          | struct definition_t* qucs::eqn::checker::getDefinitions  | 
          ( | 
          void  | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
      
        
          | nr_double_t qucs::checker::getDouble  | 
          ( | 
          char *  | 
          ident | ) | 
           | 
        
      
 
 
      
        
          | nr_double_t qucs::eqn::checker::getDouble  | 
          ( | 
          char *  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | node* qucs::eqn::checker::getEquations  | 
          ( | 
          void  | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
  
  
      
        
          | node* qucs::eqn::checker::getEquations  | 
          ( | 
          void  | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
      
        
          | strlist* qucs::eqn::checker::getVariables  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | strlist * qucs::checker::getVariables  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | static int qucs::eqn::checker::isGenerated  | 
          ( | 
          char *  | 
           | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | int qucs::checker::isGenerated  | 
          ( | 
          char *  | 
          var | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | static node* qucs::eqn::checker::lastEquation  | 
          ( | 
          node *  | 
           | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | node * qucs::checker::lastEquation  | 
          ( | 
          node *  | 
          root | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
      
        
          | void qucs::eqn::checker::list  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::list  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::checker::reorderEquations  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::reorderEquations  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | void qucs::eqn::checker::setDefinitions  | 
          ( | 
          struct definition_t *  | 
          d | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
  
  
      
        
          | void qucs::eqn::checker::setDefinitions  | 
          ( | 
          struct definition_t *  | 
          d | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
      
        
          | void qucs::eqn::checker::setDouble  | 
          ( | 
          char *  | 
          ,  | 
        
        
           | 
           | 
          nr_double_t  | 
            | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | void qucs::checker::setDouble  | 
          ( | 
          char *  | 
          ident,  | 
        
        
           | 
           | 
          nr_double_t  | 
          val  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
      
        
          | void qucs::checker::setEquations  | 
          ( | 
          node *  | 
          eqns | ) | 
           | 
        
      
 
 
      
        
          | void qucs::eqn::checker::setEquations  | 
          ( | 
          node *  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | static const char* qucs::eqn::checker::tag2key  | 
          ( | 
          int  | 
           | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | static const char* qucs::eqn::checker::tag2key  | 
          ( | 
          int  | 
           | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
      
        
          | strlist* qucs::eqn::checker::variables  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
      
        
          | strlist * qucs::checker::variables  | 
          ( | 
          void  | 
           | ) | 
           | 
        
      
 
 
  
  
      
        
          | bool qucs::eqn::checker::consts | 
         
       
   | 
  
private   | 
  
 
 
      
        
          | node * qucs::eqn::checker::equations | 
        
      
 
 
The documentation for this class was generated from the following files: