/*
void operator<(complexmp cwpolyleft[cmaxsizepad],cwpoly)
extern cwpoly csolvpoly(int cynpoly,complexmp cwyapoly[cmaxsizepad]);
cwpoly cmultpolys(int cyn1in,complexmp cwypoly1in[cmaxsizepad],unsigned int cyn2in,complexmp cwypoly2in[cmaxsizepad])
cwpoly cconstructpoly(int cyynpoly,complexmp cwroot[cmaxsizepad])
*/

extern void operator<(complexmp cwpolyleft[cmaxsizepad],cwpoly);

//extern void operator<(cwpoly cwpolyleft,cwpoly cwpolyright);

extern cwpoly csolvpoly(int cynpoly,complexmp cwyapoly[cmaxsizepad]);
//extern cwpoly cmultiplyout(int cyynpoly);
extern cwpoly cmultpolys(int cyn1in,complexmp cwypoly1in[cmaxsizepad],unsigned int cyn2in,complexmp cwypoly2in[cmaxsizepad]);

realmp rotationangle;

void operator<(complexmp cwpolyleft[cmaxsizepad],cwpoly)
  {int zi,zj;
   for (zi=0;zi<cmaxsize+1;zi++)
    {for (zj=0;zj<prec+2;zj++)
       {cwpolyleft[zi].sv(0,zj,cwpolyout[zi].gv(0,zj));
        cwpolyleft[zi].sv(1,zj,cwpolyout[zi].gv(1,zj));
       }
    }
  }

/* appears identical to above
void operator<(realmp polyleft[cmaxsizepad],wpoly)
  {int zi,zj;
   for (zi=0;zi<zmaxsize+1;zi++)  
    {for (zj=0;zj<prec+2;zj++) polyleft[zi].sv(zj,wpolyout[zi].gv(zj));
    }
   }
*/

cwpoly csolvpoly(int cynpoly,complexmp cwyapoly[cmaxsizepad],realmp rotationangle)
  {int zi,zj;
   for (zi=0;zi<prec+2;zi++) cy[zi]=rotationangle.gv(zi);  //here today
   for (zi=0;zi<cynpoly+1;zi++)
      {for (zj=0;zj<prec+2;zj++)
         {cyapoly[zi][0][zj]=cwyapoly[zi].gv(0,zj);
          cyapoly[zi][1][zj]=cwyapoly[zi].gv(1,zj);
         }
      }
   csolvpoly(cynpoly,cyapoly,cy);         //here today
   for (zi=0;zi<cynpoly+1;zi++)
     {for (zj=0;zj<prec+2;zj++)
       {cwpolyout[zi].sv(0,zj,croot[zi][0][zj]);
        cwpolyout[zi].sv(1,zj,croot[zi][1][zj]);
       }
     }
   return cwzpolyout;
  }

/*
cwpoly cmultiplyout(int cyynpoly)
 {int zi,zj;
  cynpoly=cyynpoly;  //oh, expects croot available which is not the
                     //case if roots are from complexified roots
  cmultiplyout();
  for (zi=0;zi<cynpoly+1;zi++)
     {for (zj=0;zj<prec+2;zj++)
       {cwpolyout[zi].sv(0,zj,cyb[zi][0][zj]);
        cwpolyout[zi].sv(1,zj,cyb[zi][1][zj]);
       }
     }
  return cwzpolyout;
 }
*/

cwpoly cmultpolys(int cyn1in,complexmp cwypoly1in[cmaxsizepad],unsigned int cyn2in,complexmp cwypoly2in[cmaxsizepad])
 {int zi,zj;
  for (zi=0;zi<cyn1in+1;zi++)
   {for (zj=0;zj<prec+2;zj++)
      {cypoly1in[zi][0][zj]=cwypoly1in[zi].gv(0,zj);
       cypoly1in[zi][1][zj]=cwypoly1in[zi].gv(1,zj);
      }
   }
  for (zi=0;zi<cyn2in+1;zi++)
   {for (zj=0;zj<prec+2;zj++)
      {cypoly2in[zi][0][zj]=cwypoly2in[zi].gv(0,zj);
       cypoly2in[zi][1][zj]=cwypoly2in[zi].gv(1,zj);
      }
   }
  cmultpolys(cyn1in,cypoly1in,cyn2in,cypoly2in);
  for (zi=0;zi<cyn1in+cyn2in+1;zi++)      //will need oversere.hc
    {for (zj=0;zj<prec+2;zj++)
       {cwpolyout[zi].sv(0,zj,cyb[zi][0][zj]);
        cwpolyout[zi].sv(1,zj,cyb[zi][1][zj]);
       }
    }
  return cwzpolyout;
 }

cwpoly cconstructpoly(int cyynpoly,complexmp cwroot[cmaxsizepad])
 {int zi,zj;
  cynpoly=cyynpoly;  //oh, expects croot available which is not the
                     //case if roots are from complexified roots
  for (zi=1;zi<cynpoly+1;zi++) cymess[zi]=3;
  cynpasses=cynpoly;
  for (zi=0;zi<cynpoly+1;zi++)
     {for (zj=0;zj<prec+2;zj++)
       {croot[zi][0][zj]=cwroot[zi].gv(0,zj);
        croot[zi][1][zj]=cwroot[zi].gv(1,zj);
       }
     }
  cmultiplyout();
  for (zi=0;zi<cynpoly+1;zi++)
     {for (zj=0;zj<prec+2;zj++)
       {cwpolyout[zi].sv(0,zj,cyb[zi][0][zj]);
        cwpolyout[zi].sv(1,zj,cyb[zi][1][zj]);
       }
     }
  return cwzpolyout;
 }

wpoly realify(int cpm,complexmp cwypoly2in[cmaxsizepad])
{int zi,zj;
 for (zi=0;zi<cpm+1;zi++)
  {for (zj=0;zj<prec+2;zj++)
    {wpolyout[zi].sv(zj,cwypoly2in[zi].gv(0,zj));}
  }
 return zwpolyout;
}

/*
extern void operator<(cwpoly cwpolyleft,cwpoly cwpolyright)
{int zi;
 for (zi=0;zi<cmaxsize+1;zi++)
   {cwpolyleft[zi]=cwpolyright[zi];}
}
*/

/*
crotatepoly(int cynpoly,unsigned int * * *cyapoly,unsigned int *cy)  //cy=angle
  {cexpitheta(cy);
   cstore(cyr);
   cconinttomp(1,0);
   cstore(cyrpr);
   for (cykk=0;cykk<cynpoly+1;cykk++)
     {cmult(cyapoly[cykk],cyrpr);
      cstore(cyapoly[cykk]);
      cmult(cyrpr,cyr);
      cstore(cyrpr);
     }
   return 0;
  }

crotateroots(int cynpoly, unsigned int * * *croot,unsigned int *cy)
  {cexpitheta(cy);
   cstore(cyr);
   for (cykk=1;cykk<cynpoly+1;cykk++)
     {cmult(croot[cykk],cyr);
      cstore(croot[cykk]);
     }
   return 0;
  }

crotaterealpoly(int cynpoly, unsigned int * *cyxrot,unsigned int *cy)
  {cexpitheta(cy);
   cstore(cyr);
   cconinttomp(1,0);
   cstore(cyrpr);
   for (cykk=0;cykk<cynpoly+1;cykk++)
     {cmultcbyr(cyrpr,cyxrot[cykk]);      //result is complex
      cstore(ccpolyout[cykk]);           //output
      cmult(cyr,cyrpr);
      cstore(cyrpr);
     }
   return 0;
  }
*/