//  Electrical quantities classes  

//  These classes define the real numeric quantities in electric circuits
//  and the operations on meaningful combinations of them.

//  Voltage (potential difference) class
//  ------------------------------------

ClassStart(EPotential)
  Addition(EPotential)
  EPower      operator*  (ECURRENT i)    const;
  EResistance operator/  (ECURRENT i)    const;
  ECurrent    operator/  (ERESISTANCE r) const;
  Relationals(EPotential)
  OutputStream(EPotential)
};
//%SPACE 2
//  Resistance class
//  ----------------

ClassStart(EResistance)
  EResistance operator& (ERESISTANCE rs)  const  //  Series connection
              {return value + rs.value;}
  EResistance operator| (ERESISTANCE rs)  const  //  Parallel connection
              {return value * rs.value / (value + rs.value);}
  EPotential  operator*  (ECURRENT    rs) const; //  Ohm's law
  Relationals(EResistance)
  OutputStream(EResistance)
};
//%SPACE 2
//  Current class
//  -------------

ClassStart(ECurrent)
  Addition(ECurrent)
  EPower     operator* (EPOTENTIAL  v) const ;
  EPotential operator* (ERESISTANCE r) const ;
  Relationals(ECurrent)
  OutputStream(ECurrent)
};
//%SPACE 2
//  Power class
//  -----------

ClassStart(EPower)
  Addition(EPower)
  EPotential operator/(ECURRENT   i) const ;
  ECurrent   operator/(EPOTENTIAL v) const ;
  Relationals(EPower)
  OutputStream(EPower)
};
//%EJECT
//  The following code will be moved later to a separately compiled
//  implementation file:

//  Unit names
//  ----------

 const char EPotential ::unitName [10] = "volts";
 const char ECurrent   ::unitName [10] = "amperes";
 const char EResistance::unitName [10] = "ohms";
 const char EPower     ::unitName [10] = "watts";
//%SPACE 3
//  Arithmetic involving mixed classes
//  ----------------------------------

 inline EPower      EPotential ::operator* (ECURRENT   rs)    const
                                            {return  value * rs.value;}
 inline EPower      ECurrent   ::operator* (EPOTENTIAL rs)    const
                                            {return  value * rs.value;}
 inline EPotential  EPower     ::operator/ (ECURRENT   rs)    const
                                            {return  value / rs.value;}
 inline ECurrent    EPower     ::operator/ (EPOTENTIAL rs)    const
                                            {return  value / rs.value;}
 inline EPotential  EResistance::operator* (ECURRENT rs)    const
                                            {return  value * rs.value;}
 inline EPotential  ECurrent   ::operator* (ERESISTANCE rs) const
                                            {return  value * rs.value;}
 inline ECurrent    EPotential ::operator/ (ERESISTANCE rs) const
                                            {return  value / rs.value;}
 inline EResistance EPotential ::operator/ (ECURRENT    rs) const
                                            {return  value / rs.value;}

//  Left side scalar multiplications: (commutative)

 EPotential  operator* (const EQuanP ls, EPOTENTIAL rs) {return  rs * ls;}
 EPower      operator* (const EQuanP ls, EPOWER     rs) {return  rs * ls;}
 ECurrent    operator* (const EQuanP ls, ECURRENT   rs) {return  rs * ls;}

#undef MutualFriends
#undef ClassStart
#undef Addition
#undef Relationals
#undef OutputStream
#endif