cxtest2.cpp

VC环境下的实用的复数库函数,编译后可作为库函数使用.

      CE(i,j) = CA(i,j) + CX(0,1);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) - _I_;
      CD(i,j) = _I_ - CA(i,j);
      CE(i,j) = CA(i,j) - CX(0,1);
      CF(i,j) = CX(0,1) - CA(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) * _I_;
      CD(i,j) = _I_ * CA(i,j);
      CE(i,j) = CA(i,j) * CX(0,1);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) / _I_;
      CE(i,j) = CA(i,j) / CX(0,1);
      if (CA(i,j) != 0.0)
      {
         CF(i,j) = CX(0,1) / CA(i,j);
         CD(i,j) = _I_ / CA(i,j);
      }
      else { CD(i,j) = 0; CF(i,j) = 0; }
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   cout << "check real op imag, imag op real" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) + IB(i,j);
      CD(i,j) = IB(i,j) + RA(i,j);
      CE(i,j) = CX(RA(i,j)) + CX(IB(i,j));
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) - IB(i,j);
      CD(i,j) = IB(i,j) - RA(i,j);
      CE(i,j) = CX(RA(i,j)) - CX(IB(i,j));
      CF(i,j) = CX(IB(i,j)) - CX(RA(i,j));
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      IE(i,j) = RA(i,j) * IB(i,j);
      IF(i,j) = IB(i,j) * RA(i,j);
      CE(i,j) = CX(RA(i,j)) * CX(IB(i,j));
   }
   PrintMaxDiff(IE,CE);  PrintMaxDiff(IF,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      if (IB(i,j) != 0.0)
      {
         IE(i,j) = RA(i,j) / IB(i,j);
         CE(i,j) = CX(RA(i,j)) / CX(IB(i,j));
      }
      else { IE(i,j) = Imag(0.0); CE(i,j) = 0; }
      if (RA(i,j) != 0.0)
      {
         IF(i,j) = IB(i,j) / RA(i,j);
         CF(i,j) = CX(IB(i,j)) / CX(RA(i,j));
      }
      else { IF(i,j) = Imag(0.0); CF(i,j) = 0; }
   }
   PrintMaxDiff(IE,CE);  PrintMaxDiff(IF,CF);

   cout << "check imag op imag" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      IE(i,j) = IA(i,j) + IB(i,j);
      CE(i,j) = CX(IA(i,j)) + CX(IB(i,j));
   }
   PrintMaxDiff(IE,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      IE(i,j) = IA(i,j) - IB(i,j);
      CE(i,j) = CX(IA(i,j)) - CX(IB(i,j));
   }
   PrintMaxDiff(IE,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      RE(i,j) = IA(i,j) * IB(i,j);
      CE(i,j) = CX(IA(i,j)) * CX(IB(i,j));
   }
   PrintMaxDiff(RE,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      if (IB(i,j) != 0.0)
      {
         RE(i,j) = IA(i,j) / IB(i,j);
         CE(i,j) = CX(IA(i,j)) / CX(IB(i,j));
      }
      else { RE(i,j) = 0; CE(i,j) = 0; }
   }
   PrintMaxDiff(RE,CE);

   cout << "check imag op _I_, _I_ op imag" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      IC(i,j) = IA(i,j) + _I_;
      ID(i,j) = _I_ + IA(i,j);
      CE(i,j) = CX(IA(i,j)) + CX(0,1);
   }
   PrintMaxDiff(IC,CE);  PrintMaxDiff(ID,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      IC(i,j) = IA(i,j) - _I_;
      ID(i,j) = _I_ - IA(i,j);
      CE(i,j) = CX(IA(i,j)) - CX(0,1);
      CF(i,j) = CX(0,1) - CX(IA(i,j));
   }
   PrintMaxDiff(IC,CE);  PrintMaxDiff(ID,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = IA(i,j) * _I_;
      CD(i,j) = _I_ * IA(i,j);
      CE(i,j) = CX(IA(i,j)) * CX(0,1);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = IA(i,j) / _I_;
      CE(i,j) = CX(IA(i,j)) / CX(0,1);
      if (IA(i,j) != 0.0)
      {
         CF(i,j) = CX(0,1) / CX(IA(i,j));
         CD(i,j) = _I_ / IA(i,j);
      }
      else { CD(i,j) = 0; CF(i,j) = 0; }
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   cout << "check real op _I_, _I_ op real" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) + _I_;
      CD(i,j) = _I_ + RA(i,j);
      CE(i,j) = CX(RA(i,j)) + CX(0,1);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) - _I_;
      CD(i,j) = _I_ - RA(i,j);
      CE(i,j) = CX(RA(i,j)) - CX(0,1);
      CF(i,j) = CX(0,1) - CX(RA(i,j));
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) * _I_;
      CD(i,j) = _I_ * RA(i,j);
      CE(i,j) = CX(RA(i,j)) * CX(0,1);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) / _I_;
      CE(i,j) = CX(RA(i,j)) / CX(0,1);
      if (RA(i,j) != 0.0)
      {
         CF(i,j) = CX(0,1) / CX(RA(i,j));
         CD(i,j) = _I_ / RA(i,j);
      }
      else { CD(i,j) = 0; CF(i,j) = 0; }
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   cout << "check polar op polar" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) + CB(i,j); PC(i,j) = PA(i,j) + PB(i,j);
      PC(i,j).AssertIsValid();
   }
   PrintMaxDiff(CC,PC);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) - CB(i,j); PC(i,j) = PA(i,j) - PB(i,j);
      PC(i,j).AssertIsValid();
   }
   PrintMaxDiff(CC,PC);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      //cout << i << " " << j << endl;
      CC(i,j) = CA(i,j) * CB(i,j); PC(i,j) = PA(i,j) * PB(i,j);
      PC(i,j).AssertIsValid();
   }
   PrintMaxDiff(CC,PC);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      if (j != 0)
      {
         CC(i,j) = CA(i,j) / CB(i,j); PC(i,j) = PA(i,j) / PB(i,j);
         PC(i,j).AssertIsValid();
      }
      else { CC(i,j) = 0.0; PC(i,j) = 0.0; }
   }
   PrintMaxDiff(CC,PC);

   cout << "check complex op Polar, Polar op complex" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) + PB(i,j);
      CD(i,j) = PB(i,j) + CA(i,j);
      CE(i,j) = CA(i,j) + CB(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = CA(i,j) - PB(i,j);
      CD(i,j) = PB(i,j) - CA(i,j);
      CE(i,j) = CA(i,j) - CB(i,j);
      CF(i,j) = CB(i,j) - CA(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   cout << "check imag op Polar, Polar op imag" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = IA(i,j) + PB(i,j);
      CD(i,j) = PB(i,j) + IA(i,j);
      CE(i,j) = IA(i,j) + CB(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = IA(i,j) - PB(i,j);
      CD(i,j) = PB(i,j) - IA(i,j);
      CE(i,j) = IA(i,j) - CB(i,j);
      CF(i,j) = CB(i,j) - IA(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      PC(i,j) = PA(i,j) * IB(i,j);  PC(i,j).AssertIsValid();
      PD(i,j) = IB(i,j) * PA(i,j);  PD(i,j).AssertIsValid();
      CE(i,j) = CA(i,j) * CX(IB(i,j));
   }
   PrintMaxDiff(PC,CE);  PrintMaxDiff(PD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      if (IB(i,j) != 0.0)
      {
         PC(i,j) = PA(i,j) / IB(i,j);  PC(i,j).AssertIsValid();
         CE(i,j) = CA(i,j) / CX(IB(i,j));
      }
      else { CC(i,j) = 0; CE(i,j) = 0; }
      if (CA(i,j) != 0.0)
      {
         CF(i,j) = CX(IB(i,j)) / CA(i,j);
         PD(i,j) = IB(i,j) / PA(i,j);  PD(i,j).AssertIsValid();
      }
      else { PD(i,j) = 0; CF(i,j) = 0; }
   }
   PrintMaxDiff(PC,CE);  PrintMaxDiff(PD,CF);

   cout << "check real op Polar, Polar op real" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) + PB(i,j);
      CD(i,j) = PB(i,j) + RA(i,j);
      CE(i,j) = RA(i,j) + CB(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = RA(i,j) - PB(i,j);
      CD(i,j) = PB(i,j) - RA(i,j);
      CE(i,j) = RA(i,j) - CB(i,j);
      CF(i,j) = CB(i,j) - RA(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      PC(i,j) = PA(i,j) * RB(i,j);  PC(i,j).AssertIsValid();
      PD(i,j) = RB(i,j) * PA(i,j);  PD(i,j).AssertIsValid();
      CE(i,j) = CA(i,j) * CX(RB(i,j));
   }
   PrintMaxDiff(PC,CE);  PrintMaxDiff(PD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      if (RB(i,j) != 0.0)
      {
         PC(i,j) = PA(i,j) / RB(i,j);  PC(i,j).AssertIsValid();
         CE(i,j) = CA(i,j) / CX(RB(i,j));
      }
      else { CC(i,j) = 0; CE(i,j) = 0; }
      if (CA(i,j) != 0.0)
      {
         CF(i,j) = CX(RB(i,j)) / CA(i,j);
         PD(i,j) = RB(i,j) / PA(i,j);  PD(i,j).AssertIsValid();
      }
      else { PD(i,j) = 0; CF(i,j) = 0; }
   }
   PrintMaxDiff(PC,CE);  PrintMaxDiff(PD,CF);

   cout << "check imag op Polar, Polar op imag" << endl;

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = _I_ + PB(i,j);
      CD(i,j) = PB(i,j) + _I_;
      CE(i,j) = _I_ + CB(i,j);
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      CC(i,j) = _I_ - PB(i,j);
      CD(i,j) = PB(i,j) - _I_;
      CE(i,j) = _I_ - CB(i,j);
      CF(i,j) = CB(i,j) - _I_;
   }
   PrintMaxDiff(CC,CE);  PrintMaxDiff(CD,CF);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      PC(i,j) = PA(i,j) * _I_;  PC(i,j).AssertIsValid();
      PD(i,j) = _I_ * PA(i,j);  PD(i,j).AssertIsValid();
      CE(i,j) = CA(i,j) * CX(_I_);
   }
   PrintMaxDiff(PC,CE);  PrintMaxDiff(PD,CE);

   for (i = 0; i < n; i++) for (j = 0; j < n; j++)
   {
      PC(i,j) = PA(i,j) / _I_; PC(i,j).AssertIsValid();
      CE(i,j) = CA(i,j) / CX(_I_);
      if (CA(i,j) != 0.0)
      {