ComplexNumber.int

/***
 -------------------------------------------------------------------------------
 |                                                                             |
 | NASA Glenn Research Center                                                  |
 | 21000 Brookpark Rd 		                                                     |
 | Cleveland, OH 44135 	                                                       |
 |                                                                             |
 | File Name:     ComplexNumber.int                                            |
 | Author(s):     Jeffrey Csank, David Sadey, Tom Lavelle       			         |
 | Date(s):       April 2018                                                   |
 |                                                                             |
 -------------------------------------------------------------------------------
***/

#ifndef __COMPLEX_NUMBER__
#define	__COMPLEX_NUMBER__

class ComplexNumber extends VariableContainer {
  
  //----------------------------
  // ****** DOCUMENTATION ******
  //----------------------------  
  // title = "";
  // description = "The " + isA() + "";
  // usageNotes = isA() + "- NOTE TO USERS: This file....";
  // background = "";
  
  //----------------------------
  // ****** FUNCTIONALITY ******
  //----------------------------

  string IOstatus {
    value ="unset";  units = "none";
    description = "Display variable to mimic variable's IOstatus.";
  }
  
  int lock {
    value = FALSE;
    description = "Determines if value can be set (used to control how port values are set).";	
  }
  
  string get_units() {  
    return _units;
  }
  
  void set_units(string userValue)   { 
    _units = userValue; 
    r.units = userValue;
    j.units = userValue;
    abs.units = userValue;
    _abs.units = userValue;
  }
  
  FunctVariable units {
    units = "none"; 
    IOstatus = "input"; 
    description = "Units of the complex number.";
    getFunction = "get_units";
    setFunction = "set_units";
  }
  
  string _units = "";
  
  FunctVariable r {
    IOstatus = "unset";  units = "none";
    description = "Real part of the complex plane.";
    getFunction = "get_r";
  }
  real get_r(){
    return _r;	
  }
  real _r;
  
    
  FunctVariable j {
    IOstatus = "unset";  units = "none";
    description = "Real part of the complex plane.";
    getFunction = "get_j";
  }
  real get_j() {
    return _j;	
  }
  real _j;
  
  FunctVariable rRMS {
    IOstatus = "unset";  units = "none";
    description = "Real part of the complex plane.";
    getFunction = "get_rRMS";
  }
  
  real get_rRMS() {
    // return _r/sqrt(2.); ??
    return _r;	
  }
  
  FunctVariable rPEAK {
    IOstatus = "unset";  units = "none";
    description = "Real part of the complex plane.";
    getFunction = "get_rPEAK";
  }
  
  real get_rPEAK() {	
    return _r * sqrt(2);	
  }
  
  FunctVariable jRMS {
    IOstatus = "unset";  
    units = "none";
    description = "Imaginary part of the complex plane.";
    getFunction = "get_jRMS";
  }
  
  real get_jRMS() {
    return _j;	
  }
     
  FunctVariable jPEAK {
    IOstatus = "unset";  units = "none";
    description = "Real part of the complex plane.";
    getFunction = "get_jPEAK";
  }
  
  real get_jPEAK() {
    return _j*sqrt(2);	
  }
  
  FunctVariable mag {
    units = "none"; 
    IOstatus = "unset"; 
    description = "Magnitude of the complex plane polar representation.";
    getFunction = "get_mag"; 
    setFunction = "set_mag";
  }
  
  real get_mag() { 
    _mag = sqrt(r**2 + j**2); 
    return _mag;
  }
  real _mag;
  
  FunctVariable RMS {
    units = "none"; 
    IOstatus = "unset"; 
    description = "RMS value for electric purposes."; 
    getFunction = "get_rms"; 
  }

  real get_rms() { return get_mag();}
  
  FunctVariable phase {
    units = "rad"; 
    IOstatus = "unset"; 
    description = "Phase Angle value of the complex plane polar representation.";
    getFunction = "get_phase"; 
  }

  real get_phase() { 
    _phase = atan(j / r);
    if (r < 0) { _phase += PI; }
    if (_phase > PI)  { _phase -= 2*PI; }
    else if (_phase < -PI) { _phase += 2*PI; }
    if (j == 0 && r == 0) { _phase = 0 ;}
    return _phase;
  }
  real _phase;
  
  FunctVariable phaseDeg {
    units = "deg"; 
    IOstatus = "unset"; 
    description = "Phase angle (deg) value of the polar representation of the complex plane.";
    getFunction = "get_phaseDeg"; 
  }

  real get_phaseDeg() { 
    return phase * 180./PI;
  }
  
  void scale(real scale){
    _r = _r*scale;
    _j = _j*scale;
  }
  
  void setrj(real r_in, real j_in) {
    if (!lock) {
      _r = r_in;
      _j = j_in;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  void setrjRMS(real r_in, real j_in) {
    if (!lock) {
      _r = r_in;
      _j = j_in;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  // change to mag
  void setMagPhase(real mag, real phase) {
    if (!lock) {
      _r = mag * cos(phase); 
      _j = mag * sin(phase);
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  
  // change to mag
  void setMagPhaseDeg(real mag, real phase) {
    if (!lock) {
      _r = mag * cos(phase * PI/180.); 
      _j = mag * sin(phase * PI/180.);
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  
  void copy(string cNumName) {
    _r = cNumName->_r;
    _j = cNumName->_j;
  }
  
  void plus(string cNumName) {
    if (!lock) {
      _r = _r + cNumName->_r;
      _j = _j + cNumName->_j;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  void minus(string cNumName) {
    if (!lock) {
      _r = _r - cNumName->_r;
      _j = _j - cNumName->_j;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  void times(string cNumName) {
    if (!lock) {
      real rLoc, jLoc, jExt, rExt;
      rLoc = r; 
      jLoc = j; 
      rExt = cNumName->r;
      jExt = cNumName->j;
      _r = rLoc*rExt - jLoc*jExt;
      _j = rLoc*jExt + jLoc*rExt;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  void timesRMS(string cNumName) {
    if (!lock) {
      times(cNumName);
      // scale( 1/sqrt(2) ); // peak to RMS
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
  void div(string cNumName) {
    if (!lock) {
      real denom;
      real rLoc, jLoc, jExt, rExt;
      rLoc = _r; rExt = cNumName->r;
      jLoc = _j; jExt = cNumName->j;
      denom = rExt**2 + jExt**2;
      _r = ((rLoc * rExt) + (jLoc * jExt)) / denom;
      _j = ((jLoc * rExt) - (rLoc * jExt)) / denom;
    }
  }
  
  void conjugate() {
    if (!lock) {
      _j *= -1;
    } else {
      cerr << "[ERROR]: Cannot set variable during lock!\n";		
    }
  }
  
void ll2ln() {
    setMagPhase( sqrt(1. / 3.) * mag, phase - (30. * PI/180.) );
}

void ln2ll() {
    setMagPhase( sqrt(3.) * mag, phase + (30. * PI/180.) );
}
  
}
#endif