neq               125 src/CalculiX.h 	     ITG *icol,ITG *jq,ITG **irowp,ITG *neq,ITG *nzl, 
neq               161 src/CalculiX.h 	     ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq               192 src/CalculiX.h 	     ITG *icol,ITG *jq,ITG **irowp,ITG *neq,ITG *nzl, 
neq               286 src/CalculiX.h void FORTRAN(calcmac,(ITG *neq,double *z,double *zz,ITG *nev,double *mac,
neq               296 src/CalculiX.h void calcresidual(ITG *nmethod,ITG *neq,double *b,double *fext,double *f,
neq               306 src/CalculiX.h void calcresidual_em(ITG *nmethod,ITG *neq,double *b,double *fext,double *f,
neq               335 src/CalculiX.h                       ITG *neq,ITG *nef));
neq               407 src/CalculiX.h ITG cgsolver(double *A,double *x,double *b,ITG neq,ITG len,ITG *ia,ITG *iz, 
neq               485 src/CalculiX.h void FORTRAN(complete_hel,(ITG *neq,double *b,double *hel,double *ad,
neq               494 src/CalculiX.h 	       ITG **nactdofp,ITG *neq,ITG *nzl,ITG *icol,ITG *irow, 
neq               545 src/CalculiX.h                               ITG *jq,ITG *ja,ITG *nzs,ITG *neq,double *aua));
neq               553 src/CalculiX.h 			 char *lakon,ITG *ne,ITG *neq));
neq               603 src/CalculiX.h void dfdbj(double *bcont,double **dbcontp,ITG *neq,ITG *nope,
neq               632 src/CalculiX.h              double *workev,char *bmat,ITG *neq,char *which, 
neq               638 src/CalculiX.h 	     ITG *ldz,double *sigma,char *bmat,ITG *neq,char *which, 
neq               651 src/CalculiX.h 	       ITG **nactdofp,ITG *neq,ITG *nzl,ITG *icol,ITG *irow, 
neq               688 src/CalculiX.h 	      ITG *nactdof,ITG *neq,ITG *nzl,ITG *icol,ITG *irow, 
neq               747 src/CalculiX.h              double *aub,ITG *icol,ITG *irow,ITG *neq,ITG *nzs,
neq               761 src/CalculiX.h void FORTRAN(effectivemodalmass,(ITG *neq,ITG *nactdof,ITG *mi,double *adb,
neq               771 src/CalculiX.h              ITG *neq,ITG *nzl, ITG *nmethod,ITG **ikmpcp,ITG **ilmpcp,
neq               829 src/CalculiX.h              ITG *nload,ITG *nactdof,ITG *neq, 
neq               919 src/CalculiX.h 	     ITG *iter,double *d,ITG *neq,double *z,ITG *istartnmd,
neq              1165 src/CalculiX.h 	     ITG **icolp,ITG *jq,ITG **irowp,ITG *neq,ITG *nzl, 
neq              1201 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1225 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1251 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1298 src/CalculiX.h 	     ITG *neq,ITG *nzs,double *hfa,double *gradpel,
neq              1309 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1342 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1376 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1407 src/CalculiX.h 	       ITG *icol,ITG *jq,ITG *irow,ITG *neq,ITG *nzl, 
neq              1436 src/CalculiX.h                ITG *ifabou,ITG *nbody,ITG *neq,double *dtimef,double *velo,
neq              1446 src/CalculiX.h 	     ITG *ielfa,char *lakon,ITG *ifabou,ITG *nbody,ITG *neq,
neq              1454 src/CalculiX.h 	      ITG *jq,ITG **mast1p,ITG **irowp,ITG *isolver,ITG *neq,
neq              1463 src/CalculiX.h 	       ITG **irowp,ITG *isolver,ITG *neq,
neq              1471 src/CalculiX.h 	      ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq,
neq              1478 src/CalculiX.h 	       ITG *isolver, ITG *neq,ITG *ipointer, ITG *nzs,
neq              1515 src/CalculiX.h 	     ITG **icolp,ITG *jq,ITG **irowp,ITG *neq,ITG *nzl, 
neq              1611 src/CalculiX.h 	     ITG *neq,ITG *nzs,ITG *isolver,ITG *iperturb);
neq              1691 src/CalculiX.h void FORTRAN(readforce,(double *zc,ITG *neq,ITG *nev,ITG *nactdof,
neq              1702 src/CalculiX.h void FORTRAN(rearrange,(double *au,ITG *irow,ITG *icol,ITG *ndim,ITG *neq));
neq              1730 src/CalculiX.h               ITG *neq,ITG *nzs,ITG *nmethod,double **fp,
neq              1743 src/CalculiX.h               ITG *neq,ITG *nzs,ITG *nmethod,ITG *ithermal,
neq              1754 src/CalculiX.h               ITG *neq,ITG *nzs,ITG *nmethod,double **fp,
neq              1838 src/CalculiX.h              double *vmax,ITG *neq,double *veold,double *accold,
neq              1883 src/CalculiX.h        char *labmpc,ITG *nmpc,ITG *nmethod,double *cam,ITG *neq,
neq              1893 src/CalculiX.h        char *labmpc,ITG *nmpc,ITG *nmethod,double *cam,ITG *neq,
neq              1968 src/CalculiX.h              double *vmax,ITG *neq,double *veold,double *accold,
neq              1995 src/CalculiX.h 	     ITG *neq,ITG *nzs,double *hfa,double *bp,
neq              2033 src/CalculiX.h                ITG *nbody,double *cgr,double *bb,ITG *nactdof,ITG *neq, 
neq              2069 src/CalculiX.h 	     ITG *icol,ITG *irow,ITG *neq,ITG *nzs,ITG *symmtryflag,
neq              2094 src/CalculiX.h 	  ITG **nactdof,ITG *neq,ITG *nzl,ITG *icol,ITG *irow, 
neq              2337 src/CalculiX.h              double *workev,char *bmat,ITG *neq,char *which, 
neq                49 src/arpack.c   	     ITG *icol, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, 
neq               337 src/arpack.c   		 neq,nzs,nmethod,ithermal,iperturb,mass,mi,ics,cs,
neq               354 src/arpack.c     NNEW(f,double,neq[1]);
neq               376 src/arpack.c   	     nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               394 src/arpack.c   	     nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               416 src/arpack.c     NNEW(ad,double,neq[1]);
neq               419 src/arpack.c     NNEW(adb,double,neq[1]);
neq               422 src/arpack.c     NNEW(fext,double,neq[1]);
neq               428 src/arpack.c   	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               446 src/arpack.c   	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               470 src/arpack.c   		  nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq               519 src/arpack.c       spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq               529 src/arpack.c       sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],token);
neq               537 src/arpack.c       tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1]);
neq               545 src/arpack.c       matrixstorage(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1],
neq               555 src/arpack.c       pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq               568 src/arpack.c     ldz=neq[1];
neq               576 src/arpack.c     NNEW(resid,double,neq[1]);
neq               577 src/arpack.c     NNEW(z,double,(long long)ncv*neq[1]);
neq               578 src/arpack.c     NNEW(workd,double,3*neq[1]);
neq               583 src/arpack.c         FORTRAN(dnaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,iparam,ipntr,workd,
neq               588 src/arpack.c         FORTRAN(dsaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,iparam,ipntr,workd,
neq               592 src/arpack.c     NNEW(temp_array,double,neq[1]);
neq               597 src/arpack.c   	    FORTRAN(opas,(&neq[1],&workd[ipntr[0]-1],temp_array,adb,aub,jq,irow,nzs));
neq               599 src/arpack.c   	    FORTRAN(op,(&neq[1],&workd[ipntr[0]-1],temp_array,adb,aub,jq,irow));
neq               609 src/arpack.c             spooles_solve(temp_array,&neq[1]);
neq               619 src/arpack.c             tau_solve(temp_array,&neq[1]);
neq               624 src/arpack.c             pardiso_solve(temp_array,&neq[1],&symmetryflag);
neq               627 src/arpack.c           for(jrow=0;jrow<neq[1];jrow++){
neq               634 src/arpack.c             spooles_solve(&workd[ipntr[2]-1],&neq[1]);
neq               644 src/arpack.c             tau_solve(&workd[ipntr[2]-1],&neq[1]);
neq               649 src/arpack.c             pardiso_solve(&workd[ipntr[2]-1],&neq[1],&symmetryflag);
neq               652 src/arpack.c           for(jrow=0;jrow<neq[1];jrow++){
neq               661 src/arpack.c   	    FORTRAN(opas,(&neq[1],&workd[ipntr[0]-1],&workd[ipntr[1]-1],
neq               664 src/arpack.c   	    FORTRAN(op,(&neq[1],&workd[ipntr[0]-1],&workd[ipntr[1]-1],
neq               670 src/arpack.c   	FORTRAN(dnaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,
neq               673 src/arpack.c   	FORTRAN(dsaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,
neq               702 src/arpack.c         pardiso_cleanup(&neq[1],&symmetryflag);
neq               718 src/arpack.c             workev,bmat,&neq[1],which,&nev,&tol,resid,
neq               734 src/arpack.c         FORTRAN(dseupd,(&rvec,howmny,select,d,z,&ldz,&sigma,bmat,&neq[1],which,
neq               784 src/arpack.c         if(fwrite(ad,sizeof(double),neq[1],f1)!=neq[1]){
neq               795 src/arpack.c         if(fwrite(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               809 src/arpack.c         FORTRAN(effectivemodalmass,(neq,nactdof,mi,adb,aub,jq,irow,&nev,z,co,nk));
neq               832 src/arpack.c     NNEW(temp_array,double,neq[1]);
neq               837 src/arpack.c       lfin=lfin+neq[1];
neq               842 src/arpack.c       for(k=0;k<neq[1];++k)
neq               845 src/arpack.c   	FORTRAN(opas,(&neq[1],&z[lint],temp_array,adb,aub,jq,irow,nzs));
neq               847 src/arpack.c   	FORTRAN(op,(&neq[1],&z[lint],temp_array,adb,aub,jq,irow));
neq               849 src/arpack.c       for(k=0;k<neq[1];++k)
neq               851 src/arpack.c       for(k=0;k<neq[1];++k)
neq               855 src/arpack.c   	if(fwrite(&z[lint],sizeof(double),neq[1],f1)!=neq[1]){
neq               888 src/arpack.c   	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               908 src/arpack.c   	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq                46 src/arpackbu.c 	     ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, 
neq               131 src/arpackbu.c   NNEW(f,double,neq[0]);
neq               151 src/arpackbu.c 	     nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,
neq               169 src/arpackbu.c 	     nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,
neq               187 src/arpackbu.c   NNEW(ad,double,neq[0]);
neq               189 src/arpackbu.c   NNEW(fext,double,neq[0]);
neq               195 src/arpackbu.c 	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               213 src/arpackbu.c 	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               230 src/arpackbu.c   NNEW(b,double,neq[0]);
neq               231 src/arpackbu.c   for(k=0;k<neq[0];++k){
neq               266 src/arpackbu.c     spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],&symmetryflag,
neq               276 src/arpackbu.c     sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],token);
neq               284 src/arpackbu.c     tau(ad,&au,adb,aub,&sigma,b,icol,&irow,&neq[0],&nzs[0]);
neq               292 src/arpackbu.c     pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq               326 src/arpackbu.c 	    nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,&bet,
neq               344 src/arpackbu.c 	    nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,&bet,
neq               390 src/arpackbu.c   NNEW(adb,double,neq[0]);
neq               392 src/arpackbu.c   NNEW(fext,double,neq[0]);
neq               398 src/arpackbu.c 	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               416 src/arpackbu.c 	      ad,au,fext,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               450 src/arpackbu.c     spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[0],&nzs[0],
neq               457 src/arpackbu.c     sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[0],&nzs[0],token);
neq               462 src/arpackbu.c     tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[0],&nzs[0]);
neq               467 src/arpackbu.c     pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[0],&nzs[0],
neq               477 src/arpackbu.c   dz=neq[0];
neq               486 src/arpackbu.c   NNEW(resid,double,neq[0]);
neq               487 src/arpackbu.c   NNEW(z,double,ncv*neq[0]);
neq               488 src/arpackbu.c   NNEW(workd,double,3*neq[0]);
neq               491 src/arpackbu.c   FORTRAN(dsaupd,(&ido,bmat,&neq[0],which,&nev,&tol,resid,&ncv,z,&dz,iparam,ipntr,workd,
neq               494 src/arpackbu.c   NNEW(temp_array,double,neq[0]);
neq               498 src/arpackbu.c       FORTRAN(op,(&neq[0],&workd[ipntr[0]-1],temp_array,ad,au,jq,irow));
neq               507 src/arpackbu.c           spooles_solve(temp_array,&neq[0]);
neq               518 src/arpackbu.c 	  tau_solve(temp_array,&neq[0]);
neq               523 src/arpackbu.c           pardiso_solve(temp_array,&neq[0],&symmetryflag);
neq               526 src/arpackbu.c         for(jrow=0;jrow<neq[0];jrow++){
neq               533 src/arpackbu.c           spooles_solve(&workd[ipntr[2]-1],&neq[0]);
neq               544 src/arpackbu.c           tau_solve(&workd[ipntr[2]-1],&neq[0]);
neq               549 src/arpackbu.c           pardiso_solve(&workd[ipntr[2]-1],&neq[0],
neq               553 src/arpackbu.c         for(jrow=0;jrow<neq[0];jrow++){
neq               561 src/arpackbu.c       FORTRAN(op,(&neq[0],&workd[ipntr[0]-1],&workd[ipntr[1]-1],ad,au,jq,irow));
neq               564 src/arpackbu.c     FORTRAN(dsaupd,(&ido,bmat,&neq[0],which,&nev,&tol,resid,&ncv,z,&dz,iparam,ipntr,workd,
neq               592 src/arpackbu.c     pardiso_cleanup(&neq[0],&symmetryflag);
neq               604 src/arpackbu.c   FORTRAN(dseupd,(&rvec,howmny,select,d,z,&dz,&sigma,bmat,&neq[0],which,&nev,&tol,resid,
neq               647 src/arpackbu.c     lfin=lfin+neq[0];
neq               661 src/arpackbu.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,&bet,
neq               680 src/arpackbu.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[0],veold,accold,&bet,
neq                49 src/arpackcs.c 	     ITG *icol, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, 
neq               340 src/arpackcs.c 		       neq,nzs,nmethod,ithermal,iperturb,&mass,mi,ics,cs,
neq               357 src/arpackcs.c   NNEW(f,double,neq[1]);
neq               376 src/arpackcs.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               394 src/arpackcs.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               485 src/arpackcs.c       NNEW(ad,double,neq[1]);
neq               488 src/arpackcs.c       NNEW(adb,double,neq[1]);
neq               491 src/arpackcs.c       NNEW(fext,double,neq[1]);
neq               496 src/arpackcs.c 		ad,au,fext,nactdof,icol,jq,irow,&neq[1],nzl,nmethod,
neq               513 src/arpackcs.c 		ad,au,fext,nactdof,icol,jq,irow,&neq[1],nzl,nmethod,
neq               536 src/arpackcs.c 		ad,au,fext,nactdof,icol,jq,irow,&neq[1],nzl,nmethod,
neq               583 src/arpackcs.c 	  spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],nzs,&symmetryflag,
neq               593 src/arpackcs.c 	  sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],nzs,token);
neq               601 src/arpackcs.c 	  tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],nzs);
neq               609 src/arpackcs.c 	  matrixstorage(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1],
neq               619 src/arpackcs.c 	  pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],nzs,
neq               634 src/arpackcs.c       ldz=neq[1];
neq               643 src/arpackcs.c       NNEW(resid,double,neq[1]);
neq               644 src/arpackcs.c       NNEW(z,double,(long long)ncv*neq[1]);
neq               645 src/arpackcs.c       NNEW(workd,double,3*neq[1]);
neq               650 src/arpackcs.c 	  FORTRAN(dnaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,iparam,ipntr,workd,
neq               662 src/arpackcs.c 	  FORTRAN(dsaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,
neq               666 src/arpackcs.c       NNEW(temp_array,double,neq[1]);
neq               671 src/arpackcs.c 		  FORTRAN(opas,(&neq[1],&workd[ipntr[0]-1],temp_array,adb,aub,jq,irow,nzs));
neq               679 src/arpackcs.c 		  FORTRAN(op,(&neq[1],&workd[ipntr[0]-1],temp_array,adb,aub,
neq               691 src/arpackcs.c 		      spooles_solve(temp_array,&neq[1]);
neq               701 src/arpackcs.c 		      tau_solve(temp_array,&neq[1]);
neq               706 src/arpackcs.c 		      pardiso_solve(temp_array,&neq[1],&symmetryflag);
neq               715 src/arpackcs.c 		  for(jrow=0;jrow<neq[1];jrow++){
neq               753 src/arpackcs.c 		      spooles_solve(&workd[ipntr[2]-1],&neq[1]);
neq               763 src/arpackcs.c 		      tau_solve(&workd[ipntr[2]-1],&neq[1]);
neq               768 src/arpackcs.c 		      pardiso_solve(&workd[ipntr[2]-1],&neq[1],&symmetryflag);
neq               771 src/arpackcs.c 		  for(jrow=0;jrow<neq[1];jrow++){
neq               781 src/arpackcs.c 		  FORTRAN(opas,(&neq[1],&workd[ipntr[0]-1],&workd[ipntr[1]-1],
neq               794 src/arpackcs.c 		  FORTRAN(op,(neq,&workd[ipntr[0]-1],&workd[ipntr[1]-1],
neq               800 src/arpackcs.c 	      FORTRAN(dnaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,z,&ldz,
neq               805 src/arpackcs.c 	      FORTRAN(dsaupd,(&ido,bmat,&neq[1],which,&nev,&tol,resid,&ncv,
neq               834 src/arpackcs.c 	  pardiso_cleanup(&neq[1],&symmetryflag);
neq               850 src/arpackcs.c 			  workev,bmat,&neq[1],which,&nev,&tol,resid,
neq               908 src/arpackcs.c 	  FORTRAN(dseupd,(&rvec,howmny,select,d,z,&ldz,&sigma,bmat,&neq[1],which,&nev,
neq               917 src/arpackcs.c       neq2=neq[1]/2;
neq               922 src/arpackcs.c 	      amp=z[2*j*neq[1]+k]*z[2*j*neq[1]+k]+
neq               923 src/arpackcs.c 		  z[2*j*neq[1]+neq2+k]*z[2*j*neq[1]+neq2+k];
neq               929 src/arpackcs.c 	      amp=z[(2*j+1)*neq[1]+k]*z[(2*j+1)*neq[1]+k]+
neq               930 src/arpackcs.c 		  z[(2*j+1)*neq[1]+neq2+k]*z[(2*j+1)*neq[1]+neq2+k];
neq               936 src/arpackcs.c 	      NNEW(zstorage,double,neq[1]);
neq               937 src/arpackcs.c 	      memcpy(zstorage,&z[2*j*neq[1]],sizeof(double)*neq[1]);
neq               938 src/arpackcs.c 	      memcpy(&z[2*j*neq[1]],&z[(2*j+1)*neq[1]],sizeof(double)*neq[1]);
neq               939 src/arpackcs.c 	      memcpy(&z[(2*j+1)*neq[1]],zstorage,sizeof(double)*neq[1]);
neq              1006 src/arpackcs.c 	      if(fwrite(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq              1021 src/arpackcs.c 	  FORTRAN(effectivemodalmass,(neq,nactdof,mi,adb,aub,jq,irow,&nev,z,co,nk));
neq              1044 src/arpackcs.c       NNEW(temp_array,double,neq[1]);
neq              1215 src/arpackcs.c 	  lfin=lfin+neq[1];
neq              1218 src/arpackcs.c 	      if(fwrite(&z[lint],sizeof(double),neq[1],f1)!=neq[1]){
neq              1244 src/arpackcs.c 	  for(k=0;k<neq[1];k+=neq[1]/2){
neq              1284 src/arpackcs.c 			  else{xreal=z[lint+idof];ximag=z[lint+idof+neq[1]/2];}
neq              1306 src/arpackcs.c 		    nodempc,coefmpcnew,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1325 src/arpackcs.c 		    nodempc,coefmpcnew,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq                33 src/calcresidual.c void calcresidual(ITG *nmethod, ITG *neq, double *b, double *fext, double *f,
neq                48 src/calcresidual.c 	for(k=0;k<neq[1];++k){
neq                64 src/calcresidual.c 	    FORTRAN(op,(&neq[1],aux2,b,adb,aub,jq,irow)); 
neq                66 src/calcresidual.c 	    FORTRAN(opas,(&neq[1],aux2,b,adb,aub,jq,irow,nzs)); 
neq                69 src/calcresidual.c 	for(k=0;k<neq[0];++k){
neq                72 src/calcresidual.c 	for(k=neq[0];k<neq[1];++k){
neq                87 src/calcresidual.c 		FORTRAN(op,(&neq[1],aux2,cv,adc,auc,jq,irow));
neq                89 src/calcresidual.c 		FORTRAN(opas,(&neq[1],aux2,cv,adc,auc,jq,irow,nzs)); 
neq                91 src/calcresidual.c 	    for(k=0;k<neq[0];++k){
neq               108 src/calcresidual.c 	for(k=0;k<neq[0];++k){
neq               112 src/calcresidual.c 	for(k=neq[0];k<neq[1];++k){
neq                33 src/calcresidual_em.c void calcresidual_em(ITG *nmethod, ITG *neq, double *b, double *fext, double *f,
neq                46 src/calcresidual_em.c 	for(k=0;k<neq[1];++k){
neq                72 src/calcresidual_em.c 	    FORTRAN(op,(&neq[1],aux2,b,adb,aub,jq,irow)); 
neq                74 src/calcresidual_em.c 	    FORTRAN(opas,(&neq[1],aux2,b,adb,aub,jq,irow,nzs)); 
neq                77 src/calcresidual_em.c 	for(k=0;k<neq[1];++k){
neq                77 src/ccx_2.8.c    nmethod,neq[3]={0,0,0},i,mpcfree=1,mei[4],j,nzl,nam,nbounold=0,
neq               998 src/ccx_2.8.c  		   nodempc,&nmpc,nactdof,icol,jq,&mast1,&irow,&isolver,neq,
neq              1002 src/ccx_2.8.c        else{neq[0]=1;neq[1]=1;neq[2]=1;}
neq              1012 src/ccx_2.8.c  		 neq,ikmpc,ilmpc,ipointer,nzs,&nmethod,
neq              1035 src/ccx_2.8.c  	     nactdof,&icol,jq,&irow,neq,&nzl,&nmethod,ikmpc, 
neq              1059 src/ccx_2.8.c  	     nactdof,&icol,jq,&irow,neq,&nzl,&nmethod,&ikmpc, 
neq              1097 src/ccx_2.8.c  	     nactdof,icol,jq,&irow,neq,&nzl,&nmethod,ikmpc, 
neq              1130 src/ccx_2.8.c  	     nactdof,icol,jq,&irow,neq,&nzl,&nmethod,ikmpc, 
neq              1160 src/ccx_2.8.c  	     nactdof,icol,jq,irow,neq,&nzl,&nmethod,ikmpc, 
neq              1189 src/ccx_2.8.c  	    &nactdof,neq,&nzl,icol,irow,&nmethod,&ikmpc,&ilmpc,&ikboun,&ilboun,
neq              1219 src/ccx_2.8.c  	    &nactdof,neq,&nzl,icol,irow,&nmethod,&ikmpc,&ilmpc,&ikboun,&ilboun,
neq              1242 src/ccx_2.8.c  	    &nactdof,neq,&nzl,icol,irow,&nmethod,&ikmpc,&ilmpc,&ikboun,&ilboun,
neq              1267 src/ccx_2.8.c  	     nactdof,&icol,jq,&irow,neq,&nzl,&nmethod,&ikmpc, 
neq                76 src/compfluid.c       nzs=20000000,neq,kode,compressible,*ifabou=NULL,*ja=NULL,
neq               210 src/compfluid.c 	    isolver,&neq,ipointer,&nzs,ipnei,neiel,mi);
neq               384 src/compfluid.c   NNEW(au,double,2*nzs+neq);
neq               385 src/compfluid.c   NNEW(aua,double,nzs+neq);
neq               387 src/compfluid.c   NNEW(ad,double,neq);
neq               388 src/compfluid.c   NNEW(b,double,neq);
neq               390 src/compfluid.c   NNEW(auv,double,2*nzs+neq);
neq               392 src/compfluid.c   NNEW(adv,double,neq);
neq               393 src/compfluid.c   NNEW(bv,double,3*neq);
neq               394 src/compfluid.c   NNEW(hel,double,3*neq);
neq               395 src/compfluid.c   NNEW(sel,double,3*neq);
neq               397 src/compfluid.c   NNEW(rwork,double,neq);
neq               544 src/compfluid.c       DMEMSET(adv,0,neq,0.);
neq               546 src/compfluid.c       DMEMSET(bv,0,3*neq,0.);
neq               550 src/compfluid.c 		       body,volume,&compressible,ielfa,lakonf,ifabou,nbody,&neq,
neq               609 src/compfluid.c       memcpy(&auv[2*nzs],adv,sizeof(double)*neq);
neq               610 src/compfluid.c       nelt=2*nzs+neq;
neq               616 src/compfluid.c       lrgw=131+16*neq;
neq               625 src/compfluid.c       for(i=0;i<neq;i++){rwork[i]=1./adv[i];}
neq               626 src/compfluid.c       FORTRAN(predgmres,(&neq,&bv[0],&vel[neq],&nelt,irow,jq,auv,
neq               632 src/compfluid.c       FORTRAN(predgmres,(&neq,&bv[neq],&vel[2*neq],&nelt,irow,jq,auv,
neq               638 src/compfluid.c       FORTRAN(predgmres,(&neq,&bv[2*neq],&vel[3*neq],&nelt,irow,jq,auv,
neq               659 src/compfluid.c 	  memcpy(&hel[0],&sel[0],sizeof(double)*(3*neq));
neq               663 src/compfluid.c           FORTRAN(complete_hel,(&neq,&vel[neq],hel,adv,auv,jq,irow,&nzs));
neq               673 src/compfluid.c 	  DMEMSET(b,0,neq,0.);
neq               679 src/compfluid.c 	      DMEMSET(ad,0,neq,0.);
neq               684 src/compfluid.c                                ielfa,ifabou,xle,b,xxn,&compressible,&neq,
neq               687 src/compfluid.c 	      FORTRAN(convert2slapcol,(au,ad,irow,ia,jq,ja,&nzs,&neq,aua));
neq               725 src/compfluid.c 		      b,xxn,&compressible,&neq,&nzs,hfa,bp,neij,xxi,
neq               747 src/compfluid.c 	  nelt=nzs+neq;
neq               754 src/compfluid.c 	  lenw=131+17*neq+2*nelt;
neq               756 src/compfluid.c 	  leniw=32+4*neq+2*nelt;
neq               759 src/compfluid.c 	  FORTRAN(dslugm,(&neq,&b[0],&vel[4*neq],&nelt,ia,ja,aua,
neq               790 src/compfluid.c 	  FORTRAN(correctvel,(hel,adv,vfa,ipnei,area,&vel[neq],xxn,neifa,
neq               791 src/compfluid.c 			      lakonf,nef,&neq));
neq               841 src/compfluid.c 	  DMEMSET(ad,0,neq,0.);
neq               843 src/compfluid.c 	  DMEMSET(b,0,neq,0.);
neq               847 src/compfluid.c 	       body,volume,&compressible,ielfa,lakonf,ifabou,nbody,&neq,
neq               890 src/compfluid.c 	  memcpy(&au[2*nzs],ad,sizeof(double)*neq);
neq               891 src/compfluid.c 	  nelt=2*nzs+neq;
neq               897 src/compfluid.c 	  lrgw=131+16*neq;
neq               906 src/compfluid.c 	  for(i=0;i<neq;i++){rwork[i]=1./ad[i];}
neq               907 src/compfluid.c 	  FORTRAN(predgmres,(&neq,&b[0],&vel[0],&nelt,irow,jq,au,
neq                42 src/complexfreq.c 	       ITG **nactdofp,ITG *neq, ITG *nzl,ITG *icol, ITG *irow, 
neq               156 src/complexfreq.c   for(i=neq[1];i>0;i--){
neq               222 src/complexfreq.c       NNEW(ad,double,neq[1]);
neq               223 src/complexfreq.c       NNEW(adb,double,neq[1]);
neq               229 src/complexfreq.c       if(fread(ad,sizeof(double),neq[1],f1)!=neq[1]){
neq               241 src/complexfreq.c       if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               254 src/complexfreq.c 	  NNEW(z,double,neq[1]*nev);
neq               255 src/complexfreq.c 	  if(fread(z,sizeof(double),neq[1]*nev,f1)!=neq[1]*nev){
neq               260 src/complexfreq.c 	  NNEW(z,double,2*neq[1]*nev);
neq               261 src/complexfreq.c 	  if(fread(z,sizeof(double),2*neq[1]*nev,f1)!=2*neq[1]*nev){
neq               312 src/complexfreq.c 	      NNEW(adb,double,neq[1]);
neq               315 src/complexfreq.c 	      if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               327 src/complexfreq.c 	      NNEW(z,double,neq[1]*nevd);
neq               329 src/complexfreq.c 	      RENEW(z,double,(long long)neq[1]*(nev+nevd));
neq               332 src/complexfreq.c 	  if(fread(&z[neq[1]*nev],sizeof(double),neq[1]*nevd,f1)!=neq[1]*nevd){
neq               351 src/complexfreq.c 	      for(k=0;k<neq[1];k++){
neq               352 src/complexfreq.c 		  z[j*neq[1]+k]=z[i*neq[1]+k];
neq               359 src/complexfreq.c       RENEW(z,double,neq[1]*nev);
neq               483 src/complexfreq.c       neqact=neq[1];
neq               501 src/complexfreq.c       NNEW(adc,double,neq[1]);
neq               507 src/complexfreq.c 	      adc,auc,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               518 src/complexfreq.c       NNEW(zc,double,neq[1]*nev);
neq               520 src/complexfreq.c 	  FORTRAN(op_corio,(&neq[1],&z[i*neq[1]],&zc[i*neq[1]],adc,auc,
neq               531 src/complexfreq.c 	      for(k=0;k<neq[1];k++){
neq               532 src/complexfreq.c 		  cc[i*nev+j]+=z[j*neq[1]+k]*zc[i*neq[1]+k];
neq               569 src/complexfreq.c 	  neqact=neq[1]/2;
neq               571 src/complexfreq.c 	  neqact=neq[1];
neq               587 src/complexfreq.c       		&neq[1],z,istartnmd,iendnmd,&nmd,&cyclicsymmetry,
neq               680 src/complexfreq.c       FORTRAN(calcmac,(&neq[1],z,zz,&nev,xmac,xmaccpx,istartnmd,
neq               689 src/complexfreq.c       NNEW(z,double,neq[1]);
neq               692 src/complexfreq.c 	  DMEMSET(z,0,neq[1],0.);
neq               693 src/complexfreq.c 	  FORTRAN(op,(&neq[1],&zz[l*neq[1]],z,adb,aub,jq,irow));
neq               694 src/complexfreq.c 	  for(k=0;k<neq[1];k++){
neq               695 src/complexfreq.c 	      sum+=zz[l*neq[1]+k]*z[k];
neq               699 src/complexfreq.c 	  for(k=0;k<neq[1];k++){
neq               700 src/complexfreq.c 	      zz[l*neq[1]+k]/=sum;
neq               714 src/complexfreq.c 	  NNEW(z,double,neq[1]);
neq               715 src/complexfreq.c 	  NNEW(zi,double,neq[1]);
neq               718 src/complexfreq.c 	      DMEMSET(z,0,neq[1],0.);
neq               719 src/complexfreq.c 	      FORTRAN(op,(&neq[1],&zz[l*neq[1]],z,adb,aub,jq,irow));
neq               721 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               722 src/complexfreq.c 		      xmr[l*nev+m]+=zz[m*neq[1]+k]*z[k];
neq               728 src/complexfreq.c 	      DMEMSET(z,0,neq[1],0.);
neq               729 src/complexfreq.c 	      FORTRAN(op,(&neq[1],zi,z,adb,aub,jq,irow));
neq               731 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               732 src/complexfreq.c 		      xmi[l*nev+m]+=zz[m*neq[1]+k]*z[k];
neq               768 src/complexfreq.c       NNEW(zz,double,2*nev*neq[1]);
neq               771 src/complexfreq.c 	      for(i=0;i<neq[1];i++){
neq               773 src/complexfreq.c 		      zz[(2*l+j)*neq[1]+i]+=xx[2*l*nev+2*k+j]*
neq               774 src/complexfreq.c                             z[(long long)k*neq[1]+i];
neq               787 src/complexfreq.c       FORTRAN(calcmac,(&neq[1],z,zz,&nev,xmac,xmaccpx,istartnmd,
neq               796 src/complexfreq.c       NNEW(z,double,neq[1]);
neq               802 src/complexfreq.c 	  DMEMSET(z,0,neq[1],0.);
neq               803 src/complexfreq.c 	  FORTRAN(op,(&neq[1],&zz[2*l*neq[1]],z,adb,aub,jq,irow));
neq               804 src/complexfreq.c 	  for(k=0;k<neq[1];k++){
neq               805 src/complexfreq.c 	      sum+=zz[2*l*neq[1]+k]*z[k];
neq               810 src/complexfreq.c 	  DMEMSET(z,0,neq[1],0.);
neq               811 src/complexfreq.c 	  FORTRAN(op,(&neq[1],&zz[(2*l+1)*neq[1]],z,adb,aub,jq,irow));
neq               812 src/complexfreq.c 	  for(k=0;k<neq[1];k++){
neq               813 src/complexfreq.c 	      sum+=zz[(2*l+1)*neq[1]+k]*z[k];
neq               817 src/complexfreq.c 	  for(k=0;k<2*neq[1];k++){
neq               818 src/complexfreq.c 	      zz[2*l*neq[1]+k]/=sum;
neq               832 src/complexfreq.c 	  NNEW(z,double,neq[1]);
neq               839 src/complexfreq.c 	      DMEMSET(z,0,neq[1],0.);
neq               840 src/complexfreq.c 	      FORTRAN(op,(&neq[1],&zz[2*l*neq[1]],z,adb,aub,jq,irow));
neq               845 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               846 src/complexfreq.c 		      xmr[l*nev+m]+=zz[2*m*neq[1]+k]*z[k];
neq               848 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               849 src/complexfreq.c 		      xmi[l*nev+m]-=zz[(2*m+1)*neq[1]+k]*z[k];
neq               855 src/complexfreq.c 	      DMEMSET(z,0,neq[1],0.);
neq               856 src/complexfreq.c 	      FORTRAN(op,(&neq[1],&zz[(2*l+1)*neq[1]],z,adb,aub,jq,irow));
neq               861 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               862 src/complexfreq.c 		      xmr[l*nev+m]+=zz[(2*m+1)*neq[1]+k]*z[k];
neq               864 src/complexfreq.c 		  for(k=0;k<neq[1];k++){
neq               865 src/complexfreq.c 		      xmi[l*nev+m]+=zz[2*m*neq[1]+k]*z[k];
neq               950 src/complexfreq.c 	  if(fwrite(ad,sizeof(double),neq[1],f1)!=neq[1]){
neq               961 src/complexfreq.c 	  if(fwrite(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               976 src/complexfreq.c 	      lfin=lfin+2*neq[1];
neq               977 src/complexfreq.c 	      if(fwrite(&zz[lint],sizeof(double),2*neq[1],f1)!=2*neq[1]){
neq              1045 src/complexfreq.c 	  if(fwrite(adb,sizeof(double),*neq,f1)!=*neq){
neq              1059 src/complexfreq.c 	      lfin=lfin+neq[1];
neq              1060 src/complexfreq.c 	      if(fwrite(&zz[lint],sizeof(double),neq[1],f1)!=neq[1]){
neq              1263 src/complexfreq.c   if(!cyclicsymmetry) (neq[1])*=2;
neq              1268 src/complexfreq.c     lfin=lfin+neq[1];
neq              1287 src/complexfreq.c     for(k=0;k<neq[1];k+=neq[1]/2){
neq              1327 src/complexfreq.c             else{xreal=zz[lint+idof];ximag=zz[lint+idof+neq[1]/2];}
neq              1349 src/complexfreq.c 	    nodempc,coefmpcnew,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1368 src/complexfreq.c 	    nodempc,coefmpcnew,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1796 src/complexfreq.c       (neq[1])/=2;
neq                28 src/dfdbj.c    void dfdbj(double *bcont,double **dbcontp,ITG *neq,ITG *nope,ITG *konl,
neq                85 src/dfdbj.c    			      dbcont[i4+l]-=sl*z[(long long)l**neq+kdof-1];
neq               117 src/dfdbj.c    					    dbcont[i4+l]+=d1*z[(long long)l**neq+kdof-1];
neq               195 src/dfdbj.c    					      dbcont[i4+l]+=d1*z[(long long)l**neq+kdof-1];
neq               227 src/dfdbj.c    							      dbcont[i4+l]-=d1*z[(long long)l**neq+kdof-1];
neq                42 src/dyna.c     	       ITG **nactdofp,ITG *neq, ITG *nzl,ITG *icol, ITG *irow, 
neq               186 src/dyna.c       for(i=neq[1];i>0;i--){
neq               329 src/dyna.c           NNEW(ad,double,neq[1]);
neq               330 src/dyna.c           NNEW(adb,double,neq[1]);
neq               334 src/dyna.c           if(fread(ad,sizeof(double),neq[1],f1)!=neq[1]){
neq               344 src/dyna.c           if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               354 src/dyna.c           NNEW(z,double,neq[1]*nev);
neq               356 src/dyna.c           if(fread(z,sizeof(double),neq[1]*nev,f1)!=neq[1]*nev){
neq               391 src/dyna.c     	      NNEW(adb,double,neq[1]);
neq               394 src/dyna.c     	      if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               406 src/dyna.c     	      NNEW(z,double,neq[1]*nevd);
neq               408 src/dyna.c     	      RENEW(z,double,(long long)neq[1]*(nev+nevd));
neq               411 src/dyna.c     	  if(fread(&z[(long long)neq[1]*nev],sizeof(double),neq[1]*nevd,f1)!=neq[1]*nevd){
neq               540 src/dyna.c           RENEW(imddof,ITG,neq[1]/2*nsectors);
neq               549 src/dyna.c             nforc,nelemload,sideload,xload,nload,nactdof,neq,
neq               650 src/dyna.c           NNEW(adc,double,neq[1]);
neq               655 src/dyna.c     	      adc,auc,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               667 src/dyna.c           NNEW(zc,double,neq[1]*nev);
neq               669 src/dyna.c     	  FORTRAN(op,(&neq[1],&z[i*neq[1]],&zc[i*neq[1]],adc,auc,
neq               679 src/dyna.c     	      for(k=0;k<neq[1];k++){
neq               680 src/dyna.c     		  cc[i*nev+j]+=z[j*neq[1]+k]*zc[i*neq[1]+k];
neq               756 src/dyna.c           NNEW(bcontini,double,neq[1]);
neq               757 src/dyna.c           NNEW(bcont,double,neq[1]);
neq               809 src/dyna.c         NNEW(temp_array1,double,neq[1]);
neq               810 src/dyna.c         NNEW(temp_array2,double,neq[1]);
neq               811 src/dyna.c         for(i=0;i<neq[1];i++){temp_array1[i]=0;temp_array2[i]=0;}
neq               824 src/dyna.c         FORTRAN(op,(&neq[1],temp_array1,temp_array2,adb,aub,jq,irow));
neq               826 src/dyna.c         for(i=0;i<neq[1];i++){
neq               828 src/dyna.c     	cd[k]+=z[k*neq[1]+i]*temp_array2[i];
neq               834 src/dyna.c         for(i=0;i<neq[1];i++){temp_array1[i]=0;temp_array2[i]=0;}
neq               844 src/dyna.c         FORTRAN(op,(&neq[1],temp_array1,temp_array2,adb,aub,jq,irow));
neq               846 src/dyna.c         for(i=0;i<neq[1];i++){
neq               848 src/dyna.c     	cv[k]+=z[k*neq[1]+i]*temp_array2[i];
neq               884 src/dyna.c       NNEW(b,double,neq[1]); /* load rhs vector and displacement solution vector */
neq               885 src/dyna.c       NNEW(bp,double,neq[1]); /* velocity solution vector */
neq               956 src/dyna.c           if(iabsload==2) NNEW(bold,double,neq[1]);
neq               960 src/dyna.c       NNEW(ikactmech,ITG,neq[1]);
neq               965 src/dyna.c            cgr,b,nactdof,&neq[1],nmethod,
neq               991 src/dyna.c     	  spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq              1001 src/dyna.c     	  sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],token);
neq              1009 src/dyna.c     	  tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1]);
neq              1017 src/dyna.c     	  pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq              1025 src/dyna.c           NNEW(bact,double,neq[1]);
neq              1026 src/dyna.c           NNEW(bmin,double,neq[1]);
neq              1027 src/dyna.c           NNEW(bv,double,neq[1]);
neq              1028 src/dyna.c           NNEW(bprev,double,neq[1]);
neq              1029 src/dyna.c           NNEW(bdiff,double,neq[1]);
neq              1034 src/dyna.c     	      aub,icol,irow,neq,nzs,&sigma,b,isolver,
neq              1044 src/dyna.c           DMEMSET(bcont,0,neq[1],0.);
neq              1098 src/dyna.c     	  i2=(long long)i*neq[1];
neq              1100 src/dyna.c     	  if(nactmech<neq[1]/2){
neq              1105 src/dyna.c     	      for(j=0;j<neq[1];j++){
neq              1284 src/dyna.c     		    ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq              1296 src/dyna.c     		    ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq              1312 src/dyna.c     		      aub,icol,irow,neq,nzs,&sigma,b,isolver,
neq              1320 src/dyna.c     	      if(nactmech<neq[1]/2){
neq              1325 src/dyna.c     		  for(i=0;i<neq[1];i++){
neq              1333 src/dyna.c     	      if(nactmech<neq[1]/2){
neq              1339 src/dyna.c     		  for(i=0;i<neq[1];i++){
neq              1346 src/dyna.c     	      if(nactmech<neq[1]/2){
neq              1351 src/dyna.c     		  memcpy(&bold[0],&b[0],sizeof(double)*neq[1]);
neq              1400 src/dyna.c     		    ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq              1412 src/dyna.c     		    ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq              1428 src/dyna.c     		      aub,icol,irow,neq,nzs,&sigma,b,isolver,
neq              1452 src/dyna.c     	      i2=(long long)i*neq[1];
neq              1455 src/dyna.c     	      if(nactmech<neq[1]/2){
neq              1460 src/dyna.c     		  for(j=0;j<neq[1];j++){
neq              1630 src/dyna.c     	      memcpy(&b[0],&bmin[0],sizeof(double)*neq[1]);
neq              1631 src/dyna.c     	      memcpy(&bp[0],&bv[0],sizeof(double)*neq[1]);
neq              1641 src/dyna.c     	      DMEMSET(b,0,neq[1],0.);
neq              1642 src/dyna.c     	      DMEMSET(bp,0,neq[1],0.);
neq              1653 src/dyna.c     	      for(i=0;i<neq[1];i++){
neq              1655 src/dyna.c     		      b[i]+=bj[j]*z[(long long)j*neq[1]+i];
neq              1656 src/dyna.c     		      bp[i]+=bjp[j]*z[(long long)j*neq[1]+i];
neq              1662 src/dyna.c     		      b[imddof[i]]+=bj[j]*z[(long long)j*neq[1]+imddof[i]];
neq              1663 src/dyna.c     		      bp[imddof[i]]+=bjp[j]*z[(long long)j*neq[1]+imddof[i]];
neq              1705 src/dyna.c     	      nforc,nelemload,sideload,xload,nload,nactdof,neq,nzl,icol,
neq              1784 src/dyna.c     		ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              1869 src/dyna.c           DMEMSET(b,0,neq[1],0.);
neq              1870 src/dyna.c           DMEMSET(bp,0,neq[1],0.);
neq              1872 src/dyna.c           for(i=0;i<neq[1];i++){
neq              1874 src/dyna.c     	      b[i]+=bj[j]*z[(long long)j*neq[1]+i];
neq              1875 src/dyna.c     	      bp[i]+=bjp[j]*z[(long long)j*neq[1]+i];
neq              1949 src/dyna.c     	  pardiso_cleanup(&neq[1],&symmetryflag);
neq              1995 src/dyna.c           neq[1]=neq[1]*2/nsectors;
neq                44 src/dynacont.c 	      ITG *nactdof,ITG *neq, ITG *nzl,ITG *icol, ITG *irow, 
neq               331 src/dynacont.c 		   ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq               343 src/dynacont.c 		   ipobody,nbody,cgr,b,nactdof,&neq[1],nmethod,
neq               359 src/dynacont.c 		  aub,icol,irow,neq,nzs,&sigma,b,isolver,
neq               368 src/dynacont.c 	      i2=(long long)i*neq[1];
neq               371 src/dynacont.c 	      if(*nactmech<neq[1]/2){
neq               376 src/dynacont.c 		  for(j=0;j<neq[1];j++){
neq               623 src/dynacont.c 	      memcpy(&b[0],&bmin[0],sizeof(double)*neq[1]);
neq               624 src/dynacont.c 	      memcpy(&bp[0],&bv[0],sizeof(double)*neq[1]);
neq               634 src/dynacont.c 	      DMEMSET(b,0,neq[1],0.);
neq               635 src/dynacont.c 	      DMEMSET(bp,0,neq[1],0.);
neq               646 src/dynacont.c 	      for(i=0;i<neq[1];i++){
neq               648 src/dynacont.c 		      b[i]+=bj[j]*z[(long long)j*neq[1]+i];
neq               649 src/dynacont.c 		      bp[i]+=bjp[j]*z[(long long)j*neq[1]+i];
neq               655 src/dynacont.c 		      b[imddof[i]]+=bj[j]*z[(long long)j*neq[1]+imddof[i]];
neq               656 src/dynacont.c 		      bp[imddof[i]]+=bjp[j]*z[(long long)j*neq[1]+imddof[i]];
neq               749 src/dynacont.c 	dfdbj(bcont,&dbcont,&neq[1],&nope,konl,nactdof,
neq               773 src/dynacont.c 		  zl=z[(long long)j*neq[1]+i1];
neq               892 src/dynacont.c 	  i2=(long long)i*neq[1];
neq                41 src/dynboun.c               double *aub, ITG *icol, ITG *irow, ITG *neq, ITG *nzs,
neq                97 src/dynboun.c    NNEW(bplus,double,neq[1]);
neq                98 src/dynboun.c    NNEW(ba,double,neq[1]);
neq                99 src/dynboun.c    NNEW(b1,double,neq[1]);
neq               100 src/dynboun.c    NNEW(b2,double,neq[1]);
neq               107 src/dynboun.c  	  ic=neq[1]+i;
neq               115 src/dynboun.c  	  spooles_solve(bmin,&neq[1]);
neq               125 src/dynboun.c  	  tau_solve(bmin,&neq[1]);
neq               130 src/dynboun.c  	  pardiso_solve(bmin,&neq[1],&symmetryflag);
neq               147 src/dynboun.c  	  ic=neq[1]+i;
neq               155 src/dynboun.c  	  spooles_solve(bact,&neq[1]);
neq               165 src/dynboun.c  	  tau_solve(bact,&neq[1]);
neq               170 src/dynboun.c  	  pardiso_solve(bact,&neq[1],&symmetryflag);
neq               187 src/dynboun.c  	  ic=neq[1]+i;
neq               195 src/dynboun.c  	  spooles_solve(bplus,&neq[1]);
neq               205 src/dynboun.c  	  tau_solve(bplus,&neq[1]);
neq               210 src/dynboun.c  	  pardiso_solve(bplus,&neq[1],&symmetryflag);
neq               220 src/dynboun.c  	  for(i=0;i<neq[1];i++){bplus[i]=bact[i];}
neq               222 src/dynboun.c        for(i=0;i<neq[1];i++){
neq               238 src/dynboun.c        NNEW(bnew,double,neq[1]);
neq               239 src/dynboun.c        FORTRAN(op,(&neq[1],b1,bplus,adb,aub,jq,irow));
neq               240 src/dynboun.c        for(i=0;i<neq[1];i++){bnew[i]=-bplus[i];}
neq               241 src/dynboun.c        FORTRAN(op,(&neq[1],b2,bplus,ad,au,jq,irow));
neq               243 src/dynboun.c  	  for(i=0;i<neq[1];i++){
neq               248 src/dynboun.c  	  for(i=0;i<neq[1];i++){
neq               254 src/dynboun.c  	  memcpy(&bprev[0],&bnew[0],sizeof(double)*neq[1]);
neq               256 src/dynboun.c  	  for(i=0;i<neq[1];i++){
neq               261 src/dynboun.c  	  memcpy(&bprev[0],&bnew[0],sizeof(double)*neq[1]);
neq               264 src/dynboun.c        *nactmech=neq[1];
neq               271 src/dynboun.c  	  for(i=0;i<neq[1];i++){
neq               277 src/dynboun.c  	  DMEMSET(bprev,0,neq[1],0.);
neq               279 src/dynboun.c  	  for(i=0;i<neq[1];i++){
neq               284 src/dynboun.c  	  DMEMSET(bprev,0,neq[1],0.);
neq               286 src/dynboun.c        *nactmech=neq[1];
neq                44 src/electromagnetics.c 	     ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, 
neq               191 src/electromagnetics.c   NNEW(f,double,neq[1]);
neq               192 src/electromagnetics.c   NNEW(fext,double,neq[1]);
neq               194 src/electromagnetics.c   NNEW(b,double,neq[1]);
neq               294 src/electromagnetics.c   NNEW(fini,double,neq[1]);
neq               301 src/electromagnetics.c       NNEW(aux2,double,neq[1]);
neq               302 src/electromagnetics.c       NNEW(fextini,double,neq[1]);
neq               303 src/electromagnetics.c       NNEW(cv,double,neq[1]);
neq               304 src/electromagnetics.c       NNEW(cvini,double,neq[1]);
neq               306 src/electromagnetics.c       NNEW(adb,double,neq[1]);
neq               400 src/electromagnetics.c 	     neq,nzs,&nmethodact,&f,&fext,&b,&aux2,&fini,&fextini,
neq               424 src/electromagnetics.c 	  labmpc,nmpc,&nmethodact,cam,&neq[1],veold,accold,&bet,
neq               440 src/electromagnetics.c   NNEW(ad,double,neq[1]);
neq               446 src/electromagnetics.c 		    &null,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq               479 src/electromagnetics.c   for(k=0;k<neq[1];++k){
neq               485 src/electromagnetics.c       spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq               493 src/electromagnetics.c       preiter(ad,&au,b,&icol,&irow,&neq[1],&nzs[1],isolver,iperturb);
neq               498 src/electromagnetics.c       sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],token);
neq               506 src/electromagnetics.c       tau(ad,&au,adb,aub,&sigma,b,icol,&irow,&neq[1],&nzs[1]);
neq               514 src/electromagnetics.c       pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq               536 src/electromagnetics.c 	  nodempc,coefmpc,labmpc,nmpc,&nmethodact,cam,&neq[1],veold,accold,
neq               738 src/electromagnetics.c 	     neq,nzs,nmethod,&f,&fext,&b,&aux2,&fini,&fextini,
neq               797 src/electromagnetics.c 	  for(k=0;k<neq[1];++k){
neq               804 src/electromagnetics.c 	      for(k=0;k<neq[1];++k){
neq               903 src/electromagnetics.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1004 src/electromagnetics.c 	  NNEW(ad,double,neq[1]);
neq              1011 src/electromagnetics.c 		  nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq              1031 src/electromagnetics.c 	  calcresidual_em(nmethod,neq,b,fext,f,iexpl,nactdof,aux1,aux2,vold,
neq              1064 src/electromagnetics.c 		  for(k=0;k<neq[0];++k){
neq              1083 src/electromagnetics.c 		  for(k=neq[0];k<neq[1];++k){
neq              1103 src/electromagnetics.c 		  spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq              1106 src/electromagnetics.c 		  spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq              1119 src/electromagnetics.c 	      preiter(ad,&au,b,&icol,&irow,&neq[1],&nzs[1],isolver,iperturb);
neq              1129 src/electromagnetics.c 		  sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],token);
neq              1131 src/electromagnetics.c 		  sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],token);
neq              1144 src/electromagnetics.c 	      tau(ad,&au,adb,aub,&sigma,b,icol,&irow,&neq[1],&nzs[1]);
neq              1153 src/electromagnetics.c 		  pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq              1156 src/electromagnetics.c 		  pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq              1180 src/electromagnetics.c 		  nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1215 src/electromagnetics.c 	  calcresidual_em(nmethod,neq,b,fext,f,iexpl,nactdof,aux1,aux2,vold,
neq              1231 src/electromagnetics.c 	      for(k=neq[0];k<neq[1];++k){
neq              1299 src/electromagnetics.c 	  for(k=0;k<neq[1];++k){
neq              1306 src/electromagnetics.c 	      for(k=0;k<neq[1];++k){
neq              1340 src/electromagnetics.c 		  nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1413 src/electromagnetics.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq                38 src/expand.c                ITG *nload, ITG *nactdof, ITG *neq, 
neq               100 src/expand.c       neqh=neq[1]/2;
neq               119 src/expand.c       NNEW(temp_array,double,neq[1]);
neq               936 src/expand.c       neq[1]=neqh**nsectors;
neq                43 src/linstatic.c 	     ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, 
neq               161 src/linstatic.c   NNEW(f,double,*neq);
neq               178 src/linstatic.c 	  nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,veold,accold,
neq               194 src/linstatic.c   NNEW(ad,double,*neq);
neq               195 src/linstatic.c   NNEW(fext,double,*neq);
neq               210 src/linstatic.c 	    nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,&nmethodl,
neq               226 src/linstatic.c   NNEW(b,double,*neq);
neq               227 src/linstatic.c   for(k=0;k<*neq;++k){
neq               238 src/linstatic.c       if(*neq>0){
neq               241 src/linstatic.c 	      spooles_factor(ad,au,adb,aub,&sigma,icol,irow,neq,nzs,&symmetryflag,
neq               250 src/linstatic.c 	      pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,neq,nzs,
neq               285 src/linstatic.c 	DMEMSET(b,0,*neq,0.);
neq               286 src/linstatic.c 	ic=*neq+iretain[i]-1;
neq               294 src/linstatic.c 	if(*neq>0){
neq               297 src/linstatic.c 		spooles_solve(b,neq);
neq               302 src/linstatic.c 		pardiso_solve(b,neq,&symmetryflag);
neq               334 src/linstatic.c 	    nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,veold,accold,&bet,
neq               386 src/linstatic.c       spooles(ad,au,adb,aub,&sigma,b,icol,irow,neq,nzs,&symmetryflag,
neq               394 src/linstatic.c       preiter(ad,&au,b,&icol,&irow,neq,nzs,isolver,iperturb);
neq               399 src/linstatic.c       sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,neq,nzs,token);
neq               407 src/linstatic.c       tau(ad,&au,adb,aub,&sigma,b,icol,&irow,neq,nzs);
neq               415 src/linstatic.c       pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,neq,nzs,
neq               448 src/linstatic.c 	    nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,veold,accold,&bet,
neq                30 src/mastruct.c 	      ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq,
neq               175 src/mastruct.c   neq[0]=0;
neq               180 src/mastruct.c           ++neq[0];
neq               181 src/mastruct.c           nactdof[mt*i+j]=neq[0];
neq               189 src/mastruct.c   neq[1]=neq[0];
neq               193 src/mastruct.c         ++neq[1];
neq               194 src/mastruct.c         nactdof[mt*i]=neq[1];
neq               202 src/mastruct.c       neq[2]=neq[1]+*nboun;
neq               204 src/mastruct.c   else{neq[2]=neq[1];}
neq               307 src/mastruct.c 		icolumn=neq[1]+ilboun[id-1];
neq               474 src/mastruct.c 		icolumn=neq[1]+ilboun[id-1];
neq               555 src/mastruct.c     for(i=0;i<neq[2];++i){
neq               557 src/mastruct.c 	    if(i>=neq[1]) continue;
neq               582 src/mastruct.c     if(neq[1]==0){
neq               596 src/mastruct.c 	FORTRAN(nident,(irow,&neq[1],&nmast,&id));
neq               597 src/mastruct.c 	if((id>0)&&(irow[id-1]==neq[1])) nmast=id;
neq               603 src/mastruct.c     printf(" %" ITGFORMAT "\n",neq[1]);
neq               605 src/mastruct.c     printf(" %" ITGFORMAT "\n",nmast-neq[1]);
neq               630 src/mastruct.c     for(i=0;i<neq[1];++i){icol[i]=0;}
neq               645 src/mastruct.c     for(l=k;l<neq[1]+1;++l){jq[l]=nmast+1;}
neq               649 src/mastruct.c     for(i=0;i<neq[1];++i){
neq               656 src/mastruct.c     if(neq[0]==0){nzs[0]=0;}
neq               657 src/mastruct.c     else{nzs[0]=jq[neq[0]]-1;}
neq               658 src/mastruct.c     nzs[1]=jq[neq[1]]-1;
neq               664 src/mastruct.c 	for(i=neq[1];i<neq[2];++i){icol[i]=0;}
neq               681 src/mastruct.c 	for(l=k;l<neq[2]+1;++l){jq[l]=nmastboun+1;}
neq               682 src/mastruct.c 	for(i=neq[1];i<neq[2];++i){
neq               688 src/mastruct.c 	nzs[2]=jq[neq[2]]-1;
neq                30 src/mastructcs.c 	      ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq,
neq               127 src/mastructcs.c   neq[0]=0;
neq               131 src/mastructcs.c 	++neq[0];
neq               132 src/mastructcs.c 	nactdof[mt*i+j]=neq[0];
neq               195 src/mastructcs.c 	  kdof1=jdof1+neq[0];kdof2=jdof2+neq[0];
neq               244 src/mastructcs.c 		  kdof1=idof1+neq[0];kdof2=idof2+neq[0];
neq               325 src/mastructcs.c 		    kdof1=idof1+neq[0];kdof2=idof2+neq[0];
neq               401 src/mastructcs.c 		    kdof1=idof1+neq[0];kdof2=idof2+neq[0];
neq               424 src/mastructcs.c   neq[0]=2*neq[0];
neq               425 src/mastructcs.c   neq[1]=neq[0];
neq               457 src/mastructcs.c   for(i=0;i<neq[0];++i){
neq               459 src/mastructcs.c 	  if(i>=neq[1]) continue;
neq               472 src/mastructcs.c   if(neq[0]==0){
neq               478 src/mastructcs.c   printf(" %" ITGFORMAT "\n",neq[0]);
neq               480 src/mastructcs.c   printf(" %" ITGFORMAT "\n",ifree-neq[0]);
neq               502 src/mastructcs.c   for(i=0;i<neq[0];++i){icol[i]=0;}
neq               517 src/mastructcs.c   for(l=k;l<neq[0]+1;++l){jq[l]=nmast+1;}
neq               519 src/mastructcs.c   for(i=0;i<neq[0];++i){
neq               526 src/mastructcs.c   nzs[0]=jq[neq[0]-1]-1;
neq                30 src/mastructem.c 	      ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq,
neq               176 src/mastructem.c   neq[0]=0;
neq               181 src/mastructem.c           ++neq[0];
neq               182 src/mastructem.c           nactdof[mt*i+j]=neq[0];
neq               190 src/mastructem.c   neq[1]=neq[0];
neq               194 src/mastructem.c         ++neq[1];
neq               195 src/mastructem.c         nactdof[mt*i]=neq[1];
neq               202 src/mastructem.c   neq[2]=neq[1];
neq               521 src/mastructem.c     for(i=0;i<neq[2];++i){
neq               523 src/mastructem.c 	    if(i>=neq[1]) continue;
neq               548 src/mastructem.c     if(neq[1]==0){
neq               557 src/mastructem.c     printf(" %" ITGFORMAT "\n",neq[1]);
neq               559 src/mastructem.c     printf(" %" ITGFORMAT "\n",nmast-neq[1]);
neq               584 src/mastructem.c     for(i=0;i<neq[1];++i){icol[i]=0;}
neq               599 src/mastructem.c     for(l=k;l<neq[1]+1;++l){jq[l]=nmast+1;}
neq               603 src/mastructem.c     for(i=0;i<neq[1];++i){
neq               610 src/mastructem.c     if(neq[0]==0){nzs[0]=0;}
neq               611 src/mastructem.c     else{nzs[0]=jq[neq[0]]-1;}
neq               612 src/mastructem.c     nzs[1]=jq[neq[1]]-1;
neq                29 src/mastructf.c 	       ITG *isolver, ITG *neq,ITG *ipointer, ITG *nzs,
neq                43 src/mastructf.c   *neq=*ne;
neq                72 src/mastructf.c   for(i=0;i<*neq;++i){
neq                87 src/mastructf.c   if(*neq==0){
neq                96 src/mastructf.c   printf(" %" ITGFORMAT "\n",*neq);
neq                98 src/mastructf.c   printf(" %" ITGFORMAT "\n",nmast-(*neq));
neq               123 src/mastructf.c   for(i=0;i<*neq;++i){icol[i]=0;}
neq               138 src/mastructf.c   for(l=k;l<*neq+1;++l){jq[l]=nmast+1;}
neq               142 src/mastructf.c   for(i=0;i<*neq;++i){
neq               149 src/mastructf.c   *nzs=jq[*neq]-1;
neq                27 src/matrixstorage.c                 ITG *neq, ITG *nzs, ITG *ntrans, ITG *inotr,
neq                69 src/matrixstorage.c   ndim=*neq+*nzs;
neq                92 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq                99 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               120 src/matrixstorage.c     ndim2=*neq+2**nzs;
neq               133 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               140 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               157 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               175 src/matrixstorage.c     npoint_=*neq;
neq               180 src/matrixstorage.c     neq3=*neq/3;
neq               282 src/matrixstorage.c   for(i=0;i<*neq;i++){
neq               322 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               329 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               344 src/matrixstorage.c     ndim2=*neq+2**nzs;
neq               357 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               364 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               381 src/matrixstorage.c     for(i=0;i<*neq;i++){
neq               399 src/matrixstorage.c     npoint_=*neq;
neq               404 src/matrixstorage.c     neq3=*neq/3;
neq               506 src/matrixstorage.c   for(i=0;i<*neq;i++){
neq               554 src/matrixstorage.c       for(i=0;i<*neq;i++){
neq               560 src/matrixstorage.c       for(i=0;i<*neq/2;i++){
neq                19 src/matrixstorage.h                    double *sigma,ITG *icol,ITG **irowp,ITG *neq,ITG *nzs,
neq                44 src/nonlingeo.c 	     ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, 
neq               268 src/nonlingeo.c   NNEW(f,double,neq[1]);
neq               269 src/nonlingeo.c   NNEW(fext,double,neq[1]);
neq               271 src/nonlingeo.c   NNEW(b,double,neq[1]);
neq               501 src/nonlingeo.c   NNEW(fini,double,neq[1]);
neq               508 src/nonlingeo.c       NNEW(aux2,double,neq[1]);
neq               510 src/nonlingeo.c       NNEW(fextini,double,neq[1]);
neq               513 src/nonlingeo.c       NNEW(adb,double,neq[1]);
neq               515 src/nonlingeo.c       NNEW(cvini,double,neq[1]);
neq               516 src/nonlingeo.c       NNEW(cv,double,neq[1]);
neq               635 src/nonlingeo.c 	      neq,nzs,nmethod,&f,&fext,&b,&aux2,&fini,&fextini,
neq               657 src/nonlingeo.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,&bet,
neq               692 src/nonlingeo.c       NNEW(ad,double,neq[1]);
neq               698 src/nonlingeo.c 	      nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq               742 src/nonlingeo.c       for(k=0;k<neq[0];++k){
neq               754 src/nonlingeo.c 	  for(k=0;k<neq[0];++k){
neq               762 src/nonlingeo.c 	      spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq               770 src/nonlingeo.c 	      preiter(ad,&au,b,&icol,&irow,&neq[0],&nzs[0],isolver,iperturb);
neq               775 src/nonlingeo.c 	      sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],token);
neq               783 src/nonlingeo.c 	      tau(ad,&au,adb,aub,&sigma,b,icol,&irow,&neq[0],&nzs[0]);
neq               791 src/nonlingeo.c 	      pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq               801 src/nonlingeo.c 	  for(k=0;k<neq[0];++k){
neq               808 src/nonlingeo.c       for(k=neq[0];k<neq[1];++k){
neq               828 src/nonlingeo.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq               887 src/nonlingeo.c 	  for(k=0;k<neq[1];++k){
neq               895 src/nonlingeo.c 	      for(k=0;k<neq[1];++k){
neq              1164 src/nonlingeo.c 	  neq,nzs,nmethod,&f,&fext,&b,&aux2,&fini,&fextini,
neq              1249 src/nonlingeo.c 	  for(k=0;k<neq[1];++k){b[k]=f[k];}
neq              1257 src/nonlingeo.c 		  nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1273 src/nonlingeo.c 	  for(k=0;k<neq[1];++k){f[k]=f[k]+b[k];}
neq              1285 src/nonlingeo.c 		  nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1323 src/nonlingeo.c 	for(k=0;k<nzs[1]-nzs[0];k++) iruc[k]=irow[k+nzs[0]]-neq[0];
neq              1443 src/nonlingeo.c 		neq,nzs,nmethod,&f,&fext,&b,&aux2,&fini,&fextini,
neq              1470 src/nonlingeo.c 		nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1497 src/nonlingeo.c 	NNEW(ad,double,neq[1]);
neq              1503 src/nonlingeo.c 		  nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq              1527 src/nonlingeo.c 		  nbody,cgr,ad,au,fext,nactdof,icol,jq,irow,neq,nzl,
neq              1560 src/nonlingeo.c 		  nbody,cgr,fext,nactdof,&neq[1],
neq              1583 src/nonlingeo.c 	  NNEW(adc,double,neq[1]);
neq              1584 src/nonlingeo.c 	  for(k=0;k<neq[0];k++){adc[k]=alpham*adb[k]+betam*ad[k];}
neq              1600 src/nonlingeo.c 	      adc,auc,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq              1613 src/nonlingeo.c       calcresidual(nmethod,neq,b,fext,f,iexpl,nactdof,aux2,vold,
neq              1658 src/nonlingeo.c 		  for(k=0;k<neq[0];++k){
neq              1677 src/nonlingeo.c 		      for(k=0;k<neq[0];++k){
neq              1698 src/nonlingeo.c 		  for(k=neq[0];k<neq[1];++k){
neq              1718 src/nonlingeo.c 		  spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq              1721 src/nonlingeo.c 		  n1=neq[1]-neq[0];
neq              1723 src/nonlingeo.c 		  spooles(&ad[neq[0]],&au[nzs[0]],&adb[neq[0]],&aub[nzs[0]],
neq              1724 src/nonlingeo.c 			  &sigma,&b[neq[0]],&icol[neq[0]],iruc,
neq              1727 src/nonlingeo.c 		  spooles(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq              1740 src/nonlingeo.c 	      preiter(ad,&au,b,&icol,&irow,&neq[1],&nzs[1],isolver,iperturb);
neq              1750 src/nonlingeo.c 		  sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],token);
neq              1752 src/nonlingeo.c 		  n1=neq[1]-neq[0];
neq              1754 src/nonlingeo.c 		  sgi_main(&ad[neq[0]],&au[nzs[0]],&adb[neq[0]],&aub[nzs[0]],
neq              1755 src/nonlingeo.c 			   &sigma,&b[neq[0]],&icol[neq[0]],iruc,
neq              1758 src/nonlingeo.c 		  sgi_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],token);
neq              1771 src/nonlingeo.c 	      tau(ad,&au,adb,aub,&sigma,b,icol,&irow,&neq[1],&nzs[1]);
neq              1780 src/nonlingeo.c 		  pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[0],&nzs[0],
neq              1783 src/nonlingeo.c 		  n1=neq[1]-neq[0];
neq              1785 src/nonlingeo.c 		  pardiso_main(&ad[neq[0]],&au[nzs[0]],&adb[neq[0]],&aub[nzs[0]],
neq              1786 src/nonlingeo.c 			       &sigma,&b[neq[0]],&icol[neq[0]],iruc,
neq              1789 src/nonlingeo.c 		  pardiso_main(ad,au,adb,aub,&sigma,b,icol,irow,&neq[1],&nzs[1],
neq              1805 src/nonlingeo.c 	      for(k=0;k<neq[0];++k){
neq              1810 src/nonlingeo.c 	      for(k=neq[0];k<neq[1];++k){
neq              1831 src/nonlingeo.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              1878 src/nonlingeo.c       calcresidual(nmethod,neq,b,fext,f,iexpl,nactdof,aux2,vold,
neq              1893 src/nonlingeo.c 	  for(k=0;k<neq[0];++k){
neq              1899 src/nonlingeo.c 	  for(k=neq[0];k<neq[1];++k){
neq              2025 src/nonlingeo.c       for(k=0;k<neq[1];++k){
neq              2033 src/nonlingeo.c 	for(k=0;k<neq[1];++k){
neq              2133 src/nonlingeo.c 	      nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq              2235 src/nonlingeo.c 	    nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],veold,accold,
neq                35 src/pardiso.c  		ITG *neq, ITG *nzs, ITG *symmetryflag, ITG *inputformat,
neq                87 src/pardiso.c        ndim=*neq+*nzs;
neq                89 src/pardiso.c        NNEW(pointers,ITG,*neq+1);
neq                97 src/pardiso.c  	  pointers[*neq]=ndim+1;
neq                98 src/pardiso.c  	  for(i=*neq-1;i>=0;--i){
neq               109 src/pardiso.c  	  pointers[*neq]=ndim+1;
neq               110 src/pardiso.c  	  for(i=*neq-1;i>=0;--i){
neq               129 src/pardiso.c  	  ndim=*neq+*nzs;
neq               130 src/pardiso.c  	  NNEW(pointers,ITG,*neq+1);
neq               137 src/pardiso.c  	  for(i=0;i<*neq;i++){
neq               149 src/pardiso.c  	  for(i=0;i<*neq;i++){
neq               168 src/pardiso.c  	  for(i=0;i<*neq;i++){
neq               190 src/pardiso.c  	  pointers[*neq]=ndim+1;
neq               202 src/pardiso.c  	  NNEW(pointers,ITG,*neq+1);
neq               208 src/pardiso.c  	  for(i=0;i<*neq;i++){
neq               228 src/pardiso.c  	  for(i=0;i<*neq;i++){
neq               259 src/pardiso.c  	  pointers[*neq]=ndim+1;
neq               264 src/pardiso.c  	  ndim=*neq+2**nzs;
neq               268 src/pardiso.c  	  for(i=*neq-1;i>=0;i--){
neq               286 src/pardiso.c    FORTRAN(pardiso,(pt,&maxfct,&mnum,&mtype,&phase,neq,aupardiso,
neq               293 src/pardiso.c  void pardiso_solve(double *b, ITG *neq,ITG *symmetryflag){
neq               318 src/pardiso.c    NNEW(x,double,*neq);
neq               320 src/pardiso.c    FORTRAN(pardiso,(pt,&maxfct,&mnum,&mtype,&phase,neq,aupardiso,
neq               324 src/pardiso.c    for(i=0;i<*neq;i++){b[i]=x[i];}
neq               330 src/pardiso.c  void pardiso_cleanup(ITG *neq,ITG *symmetryflag){
neq               342 src/pardiso.c    FORTRAN(pardiso,(pt,&maxfct,&mnum,&mtype,&phase,neq,aupardiso,
neq               355 src/pardiso.c  	 ITG *neq, ITG *nzs,ITG *symmetryflag,ITG *inputformat,
neq               358 src/pardiso.c    if(*neq==0) return;
neq               361 src/pardiso.c  		 neq,nzs,symmetryflag,inputformat,jq,nzs3);
neq               363 src/pardiso.c    pardiso_solve(b,neq,symmetryflag);
neq               365 src/pardiso.c    pardiso_cleanup(neq,symmetryflag);
neq                19 src/pardiso.h  	 ITG *neq, ITG *nzs,ITG *symmetryflag,ITG *inputformat,ITG *jq,ITG *nzs3);
neq                23 src/pardiso.h  		ITG *neq, ITG *nzs,ITG *symmetryflag,ITG *inputformat,
neq                26 src/pardiso.h  void pardiso_solve(double *b,ITG *neq,ITG *symmetryflag);
neq                28 src/pardiso.h  void pardiso_cleanup(ITG *neq,ITG *symmetryflag);
neq                31 src/pardiso.h                     ITG *neq,double *aupardiso,ITG *pointers,ITG *irowpardiso,
neq                36 src/pardiso_as.c                 ITG *neq, ITG *nzs, ITG *jq){
neq                74 src/pardiso_as.c   ndim=*neq+(long long)2**nzs;
neq                76 src/pardiso_as.c   NNEW(pointersas,ITG,*neq+1);
neq                90 src/pardiso_as.c     for(i=0;i<*neq;i++){
neq               123 src/pardiso_as.c     pointersas[*neq]=k+1;
neq               125 src/pardiso_as.c     for(i=0;i<*neq;i++){
neq               158 src/pardiso_as.c     pointersas[*neq]=k+1;
neq               161 src/pardiso_as.c   FORTRAN(pardiso,(ptas,&maxfct,&mnum,&mtype,&phase,neq,aupardisoas,
neq               168 src/pardiso_as.c void pardiso_solve_as(double *b, ITG *neq){
neq               182 src/pardiso_as.c   NNEW(x,double,*neq);
neq               184 src/pardiso_as.c   FORTRAN(pardiso,(ptas,&maxfct,&mnum,&mtype,&phase,neq,aupardisoas,
neq               188 src/pardiso_as.c   for(i=0;i<*neq;i++){b[i]=x[i];}
neq               194 src/pardiso_as.c void pardiso_cleanup_as(ITG *neq){
neq               200 src/pardiso_as.c   FORTRAN(pardiso,(ptas,&maxfct,&mnum,&mtype,&phase,neq,aupardisoas,
neq               213 src/pardiso_as.c          ITG *neq, ITG *nzs, ITG *jq){
neq               215 src/pardiso_as.c   if(*neq==0) return;
neq               218 src/pardiso_as.c              neq,nzs,jq);
neq               220 src/pardiso_as.c   pardiso_solve_as(b,neq);
neq               222 src/pardiso_as.c   pardiso_cleanup_as(neq);
neq                32 src/pcgsolver.c ITG cgsolver (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, 
neq                34 src/pcgsolver.c void PCG (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, 
neq                37 src/pcgsolver.c void CG (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, 
neq                39 src/pcgsolver.c void Scaling (double *A, double *b, ITG neq, ITG *ia, ITG *iz, double *d);
neq                40 src/pcgsolver.c void MatVecProduct (double *A, double *p, ITG neq, ITG *ia, ITG *iz, 
neq                42 src/pcgsolver.c void PreConditioning (double *A, ITG neq, ITG len, ITG *ia, ITG *iz, 
neq                44 src/pcgsolver.c void Mrhor (double *C, ITG neq, ITG *ia, ITG *iz, double *r, double *rho);
neq                70 src/pcgsolver.c ITG cgsolver (double *A, double *x, double *b, ITG neq, ITG len, 
neq                79 src/pcgsolver.c   for (i=0; i<neq; i++)	--iz[i];
neq                84 src/pcgsolver.c   NNEW(Factor,double,neq);
neq                85 src/pcgsolver.c   Scaling(A,b,neq,ia,iz,Factor);
neq                93 src/pcgsolver.c       NNEW(r,double,neq);
neq                94 src/pcgsolver.c       NNEW(p,double,neq);
neq                95 src/pcgsolver.c       NNEW(z,double,neq);
neq                96 src/pcgsolver.c       CG(A,x,b,neq,len,ia,iz,eps,niter,r,p,z);
neq               105 src/pcgsolver.c       NNEW(rho,double,neq);
neq               106 src/pcgsolver.c       NNEW(r,double,neq);
neq               107 src/pcgsolver.c       NNEW(g,double,neq);
neq               109 src/pcgsolver.c       NNEW(z,double,neq);
neq               110 src/pcgsolver.c       PCG(A,x,b,neq,len,ia,iz,eps,niter,precFlg,rho,r,g,C,z);
neq               116 src/pcgsolver.c   for (i=0; i<neq; i++)	x[i] *= Factor[i];
neq               147 src/pcgsolver.c void PCG (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, 
neq               160 src/pcgsolver.c   for (i=0; i<neq; i++)
neq               175 src/pcgsolver.c   PreConditioning(A,neq,len,ia,iz,alpha,precFlg,C,&ier);
neq               181 src/pcgsolver.c       PreConditioning(A,neq,len,ia,iz,alpha,precFlg,C,&ier);
neq               195 src/pcgsolver.c       Mrhor(C,neq,ia,iz,r,rho);
neq               199 src/pcgsolver.c       InnerProduct(r,rho,neq,&rrho);
neq               212 src/pcgsolver.c 	  for (i=0; i<neq; i++)	g[i] = ekm1*g[i]-rho[i];
neq               219 src/pcgsolver.c 	  for (i=0; i<neq; i++)	g[i] = -rho[i];
neq               224 src/pcgsolver.c       MatVecProduct(A,g,neq,ia,iz,z);
neq               228 src/pcgsolver.c       InnerProduct(g,z,neq,&gz);
neq               231 src/pcgsolver.c       for (i=0; i<neq; i++)
neq               281 src/pcgsolver.c void Scaling (double *A, double *b, ITG neq, ITG *ia, ITG *iz, double *d)
neq               287 src/pcgsolver.c   for (i=0; i<neq; i++)		d[i] =  1.0/sqrt(A[iz[i]]);
neq               291 src/pcgsolver.c   for (i=0; i<neq; i++)	b[i] *= -d[i];
neq               296 src/pcgsolver.c   for (i=1; i<neq; i++)
neq               323 src/pcgsolver.c void MatVecProduct (double *A, double *p, ITG neq, ITG *ia, ITG *iz, 
neq               331 src/pcgsolver.c   for (i=1; i<neq; i++)
neq               373 src/pcgsolver.c void PreConditioning (double *A, ITG neq, ITG len, ITG *ia, ITG *iz, 
neq               383 src/pcgsolver.c 	for (i=1; i<neq; i++)
neq               391 src/pcgsolver.c 	nILU = neq;		/*..ILU on full matrix.................	*/
neq               445 src/pcgsolver.c void Mrhor (double *C, ITG neq, ITG *ia, ITG *iz, double *r, double *rho)
neq               451 src/pcgsolver.c 	for (i=1; i<neq; i++)
neq               460 src/pcgsolver.c 	for (i=neq-1; i>0; i--)
neq               504 src/pcgsolver.c void CG (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, ITG *iz,
neq               518 src/pcgsolver.c 	for (i=0; i<neq; i++)
neq               526 src/pcgsolver.c 	if(iam>0) qam=qam/neq;
neq               533 src/pcgsolver.c 		InnerProduct(r,r,neq,&rr);
neq               544 src/pcgsolver.c 			for (i=0; i<neq; i++)	p[i] = ekm1*p[i]-r[i];
neq               547 src/pcgsolver.c 		MatVecProduct(A,p,neq,ia,iz,z);
neq               549 src/pcgsolver.c 		InnerProduct(p,z,neq,&pz);
neq               554 src/pcgsolver.c 		for (i=0; i<neq; i++)
neq                24 src/preiter.c  	     ITG *neq, ITG *nzs, ITG *isolver, ITG *iperturb){
neq                30 src/preiter.c    if(*neq==0) return;
neq                44 src/preiter.c      NNEW(icol_save,ITG,*neq);
neq                48 src/preiter.c      for(i=0;i<*neq;++i){
neq                56 src/preiter.c    ndim=*neq+*nzs;
neq                63 src/preiter.c    for(i=*neq-1;i>=0;--i){
neq                71 src/preiter.c    for(i=0;i<*neq;++i){
neq                80 src/preiter.c    FORTRAN(rearrange,(au,irow,icol,&ndim,neq));
neq                82 src/preiter.c    RENEW(irow,ITG,*neq);
neq                84 src/preiter.c    NNEW(u,double,*neq);
neq                86 src/preiter.c    ier=cgsolver(au,u,b,*neq,ndim,icol,irow,&eps,&niter,precFlg);
neq                91 src/preiter.c    for(i=0;i<*neq;++i){
neq                99 src/preiter.c      RENEW(icol,ITG,*neq);
neq               103 src/preiter.c      for(i=0;i<*neq;++i){
neq                31 src/remastruct.c               ITG *neq, ITG *nzs,ITG *nmethod, double **fp,
neq                73 src/remastruct.c 	     nodempc,nmpc,nactdof,icol,jq,&mast1,&irow,isolver,neq,
neq                84 src/remastruct.c     RENEW(f,double,neq[1]);DMEMSET(f,0,neq[1],0.);
neq                85 src/remastruct.c     RENEW(fext,double,neq[1]);DMEMSET(fext,0,neq[1],0.);
neq                86 src/remastruct.c     RENEW(b,double,neq[1]);DMEMSET(b,0,neq[1],0.);
neq                87 src/remastruct.c     RENEW(fini,double,neq[1]);
neq                94 src/remastruct.c     if((*nmethod!=4)&&(*iit==-1)) DMEMSET(fini,0,neq[1],0.);
neq                97 src/remastruct.c 	RENEW(aux2,double,neq[1]);DMEMSET(aux2,0,neq[1],0.);
neq                98 src/remastruct.c 	RENEW(cv,double,neq[1]);
neq                99 src/remastruct.c 	RENEW(cvini,double,neq[1]);
neq               100 src/remastruct.c 	RENEW(fextini,double,neq[1]);
neq               109 src/remastruct.c 	    RENEW(adb,double,neq[1]);for(i=0;i<neq[1];i++) adb[i]=0.;
neq                31 src/remastructar.c               ITG *neq, ITG *nzs,ITG *nmethod, ITG *ithermal,
neq                73 src/remastructar.c 	     nodempc,nmpc,nactdof,icol,jq,&mast1,&irow,isolver,neq,
neq                83 src/remastructar.c 		 neq,ikmpc,ilmpc,ipointer,nzs,nmethod,
neq                31 src/remastructem.c               ITG *neq, ITG *nzs,ITG *nmethod, double **fp,
neq                73 src/remastructem.c 	     nodempc,nmpc,nactdof,icol,jq,&mast1,&irow,isolver,neq,
neq                84 src/remastructem.c     RENEW(f,double,neq[1]);for(i=0;i<neq[1];i++) f[i]=0.;
neq                85 src/remastructem.c     RENEW(fext,double,neq[1]);for(i=0;i<neq[1];i++) fext[i]=0.;
neq                86 src/remastructem.c     RENEW(b,double,neq[1]);for(i=0;i<neq[1];i++) b[i]=0.;
neq                87 src/remastructem.c     RENEW(fini,double,neq[1]);for(i=0;i<neq[1];i++) fini[i]=0.;
neq                90 src/remastructem.c 	RENEW(aux2,double,neq[1]);for(i=0;i<neq[1];i++) aux2[i]=0.;
neq                91 src/remastructem.c 	RENEW(fextini,double,neq[1]);for(i=0;i<neq[1];i++) fextini[i]=0.;
neq                92 src/remastructem.c 	RENEW(adb,double,neq[1]);for(i=0;i<neq[1];i++) adb[i]=0.;
neq                52 src/results.c         char *labmpc,ITG *nmpc,ITG *nmethod,double *cam,ITG *neq,double *veold,
neq               160 src/results.c         xboun,nboun,ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,
neq                53 src/resultsinduction.c        char *labmpc,ITG *nmpc,ITG *nmethod,double *cam,ITG *neq,double *veold,
neq               161 src/resultsinduction.c        xboun,nboun,ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,
neq                31 src/sgi.c                      ITG *neq, ITG *nzs, ITG token){
neq                43 src/sgi.c        ndim=*neq+*nzs;
neq                45 src/sgi.c        NNEW(pointers,ITG,*neq+1);
neq                53 src/sgi.c          pointers[*neq]=ndim;
neq                54 src/sgi.c          for(i=*neq-1;i>=0;--i){
neq                65 src/sgi.c          pointers[*neq]=ndim;
neq                66 src/sgi.c          for(i=*neq-1;i>=0;--i){
neq                80 src/sgi.c        DPSLDLT_Preprocess(token,*neq,pointers,irowsgi,&ndim,&ops);
neq                82 src/sgi.c        if(*neq>200000){
neq                86 src/sgi.c          DPSLDLT_FactorOOC(token,*neq,pointers,irowsgi,ausgi);
neq                89 src/sgi.c          DPSLDLT_Factor(token,*neq,pointers,irowsgi,ausgi);
neq               115 src/sgi.c               ITG *neq, ITG *nzs, ITG token){
neq               117 src/sgi.c        if(*neq==0) return;
neq               120 src/sgi.c                   neq,nzs,token);
neq                21 src/sgi.h               ITG *neq, ITG *nzs, ITG token);
neq                25 src/sgi.h                      ITG *neq, ITG *nzs, ITG token);
neq               460 src/spooles.c               double *sigma,ITG *icol, ITG *irow, ITG *neq, ITG *nzs, 
neq               463 src/spooles.c  	int size = *neq;
neq               492 src/spooles.c  		nent = *nzs + *neq;	/* estimated # of nonzero entries */
neq               494 src/spooles.c  		nent=2**nzs+*neq;
neq               497 src/spooles.c  		for(i=0;i<*neq;i++){
neq               498 src/spooles.c  		    for(j=0;j<*neq;j++){
neq               576 src/spooles.c  		for(i=0;i<*neq;i++){
neq               577 src/spooles.c  		    for(j=0;j<*neq;j++){
neq               708 src/spooles.c  void spooles_solve(double *b, ITG *neq)
neq               714 src/spooles.c  	int size = *neq;
neq               785 src/spooles.c  	     ITG *neq, ITG *nzs, ITG *symmetryflag, ITG *inputformat)
neq               788 src/spooles.c  	int size = *neq;
neq               812 src/spooles.c  		nent = *nzs + *neq;	/* estimated # of nonzero entries */
neq               814 src/spooles.c  		nent=2**nzs+*neq;
neq               817 src/spooles.c  		for(i=0;i<*neq;i++){
neq               818 src/spooles.c  		    for(j=0;j<*neq;j++){
neq               891 src/spooles.c  		for(i=0;i<*neq;i++){
neq               892 src/spooles.c  		    for(j=0;j<*neq;j++){
neq              1023 src/spooles.c  void spooles_solve_rad(double *b, ITG *neq)
neq              1029 src/spooles.c  	int size = *neq;
neq              1100 src/spooles.c               double *b, ITG *icol, ITG *irow, ITG *neq, ITG *nzs, 
neq              1104 src/spooles.c    if(*neq==0) return;
neq              1106 src/spooles.c    spooles_factor(ad,au,adb,aub,sigma,icol,irow,neq,nzs,symmetryflag,
neq              1109 src/spooles.c    spooles_solve(b,neq);
neq                52 src/spooles.h                      ITG *neq, ITG *nzs, ITG *symmetryflag,
neq                55 src/spooles.h  void spooles_solve(double *b, ITG *neq);
neq                61 src/spooles.h                      ITG *neq, ITG *nzs, ITG *symmetryflag,
neq                64 src/spooles.h  void spooles_solve_rad(double *b, ITG *neq);
neq                43 src/steadystate.c 	       ITG **nactdofp,ITG *neq, ITG *nzl,ITG *icol, ITG *irow, 
neq               164 src/steadystate.c   for(i=neq[1];i>0;i--){
neq               307 src/steadystate.c       NNEW(ad,double,neq[1]);
neq               308 src/steadystate.c       NNEW(adb,double,neq[1]);
neq               314 src/steadystate.c       if(fread(ad,sizeof(double),neq[1],f1)!=neq[1]){
neq               326 src/steadystate.c       if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               339 src/steadystate.c 	  NNEW(z,double,neq[1]*nev);
neq               340 src/steadystate.c 	  if(fread(z,sizeof(double),neq[1]*nev,f1)!=neq[1]*nev){
neq               345 src/steadystate.c 	  NNEW(z,double,2*neq[1]*nev);
neq               346 src/steadystate.c 	  if(fread(z,sizeof(double),2*neq[1]*nev,f1)!=2*neq[1]*nev){
neq               415 src/steadystate.c 	      NNEW(adb,double,neq[1]);
neq               418 src/steadystate.c 	      if(fread(adb,sizeof(double),neq[1],f1)!=neq[1]){
neq               432 src/steadystate.c 	      NNEW(z,double,neq[1]*nevd);
neq               434 src/steadystate.c 	      RENEW(z,double,(long long)neq[1]*(nev+nevd));
neq               437 src/steadystate.c 	  if(fread(&z[(long long)neq[1]*nev],sizeof(double),neq[1]*nevd,f1)!=neq[1]*nevd){
neq               534 src/steadystate.c       RENEW(imddof,ITG,neq[1]/2*nsectors);
neq               543 src/steadystate.c         nforc,nelemload,sideload,xload,nload,nactdof,neq,
neq               662 src/steadystate.c       NNEW(ikactmechr,ITG,neq[1]);
neq               663 src/steadystate.c       NNEW(ikactmechi,ITG,neq[1]);
neq               880 src/steadystate.c       NNEW(br,double,neq[1]); /* load rhs vector */
neq               881 src/steadystate.c       NNEW(bi,double,neq[1]); /* load rhs vector */
neq               887 src/steadystate.c 	  NNEW(fr,double,neq[1]); /* force corresponding to real particular solution */
neq               888 src/steadystate.c 	  NNEW(fi,double,neq[1]); /* force corresponding to imaginary particular solution */
neq               890 src/steadystate.c 	  NNEW(ubr,double,neq[1]); /* real particular solution */
neq               891 src/steadystate.c 	  NNEW(ubi,double,neq[1]); /* imaginary particular solution */
neq               893 src/steadystate.c 	  NNEW(mubr,double,neq[1]); /* mass times real particular solution */
neq               894 src/steadystate.c 	  NNEW(mubi,double,neq[1]); /* mass times imaginary particular solution */
neq               921 src/steadystate.c 	      spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq               931 src/steadystate.c 	      sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],token);
neq               939 src/steadystate.c 	      tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1]);
neq               947 src/steadystate.c 	      pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq               965 src/steadystate.c 	      NNEW(adc,double,neq[1]);
neq               971 src/steadystate.c 	        adc,auc,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq               983 src/steadystate.c 	      NNEW(zc,double,neq[1]*nev);
neq               985 src/steadystate.c 		  FORTRAN(op,(&neq[1],&z[(long long)i*neq[1]],&zc[i*neq[1]],adc,auc,
neq               995 src/steadystate.c 		      for(k=0;k<neq[1];k++){
neq               996 src/steadystate.c 			  cc[i*nev+j]+=z[(long long)j*neq[1]+k]*zc[i*neq[1]+k];
neq              1050 src/steadystate.c 		       ipobody,nbody,cgr,br,nactdof,&neq[1],nmethod,
neq              1066 src/steadystate.c 			  i2=(long long)i*neq[1];
neq              1068 src/steadystate.c 			  if(nactmechr<neq[1]/2){
neq              1073 src/steadystate.c 			      for(j=0;j<neq[1];j++){
neq              1095 src/steadystate.c 			  if(nactmechr<neq[1]/2){
neq              1097 src/steadystate.c 				  aa[2*i]+=z[(long long)2*i*neq[1]+ikactmechr[j]]*br[ikactmechr[j]];
neq              1098 src/steadystate.c 				  aa[2*i+1]+=z[(long long)(2*i+1)*neq[1]+ikactmechr[j]]*br[ikactmechr[j]];
neq              1101 src/steadystate.c 			      for(j=0;j<neq[1];j++){
neq              1102 src/steadystate.c 				  aa[2*i]+=z[(long long)2*i*neq[1]+j]*br[j];
neq              1103 src/steadystate.c 				  aa[2*i+1]+=z[(long long)(2*i+1)*neq[1]+j]*br[j];
neq              1129 src/steadystate.c 	      nactmechr=neq[1];
neq              1137 src/steadystate.c 	      for(j=0;j<neq[1];j++){fr[j]=0.;ubr[j]=0.;}
neq              1139 src/steadystate.c 		  ic=neq[1]+i;
neq              1148 src/steadystate.c 		  spooles_solve(ubr,&neq[1]);
neq              1158 src/steadystate.c 		  tau_solve(ubr,&neq[1]);
neq              1163 src/steadystate.c 		  pardiso_solve(ubr,&neq[1],&symmetryflag);
neq              1166 src/steadystate.c 	      FORTRAN(op,(&neq[1],ubr,mubr,adb,aub,jq,irow));
neq              1195 src/steadystate.c 		       ipobody,nbody,cgr,bi,nactdof,&neq[1],nmethod,
neq              1211 src/steadystate.c 			  i2=(long long)i*neq[1];
neq              1213 src/steadystate.c 			  if(nactmechi<neq[1]/2){
neq              1218 src/steadystate.c 			      for(j=0;j<neq[1];j++){
neq              1240 src/steadystate.c 			  if(nactmechi<neq[1]/2){
neq              1242 src/steadystate.c 				  bb[2*i]+=z[(long long)2*i*neq[1]+ikactmechi[j]]*bi[ikactmechi[j]];
neq              1243 src/steadystate.c 				  bb[2*i+1]+=z[(long long)(2*i+1)*neq[1]+ikactmechi[j]]*bi[ikactmechi[j]];
neq              1246 src/steadystate.c 			      for(j=0;j<neq[1];j++){
neq              1247 src/steadystate.c 				  bb[2*i]+=z[(long long)2*i*neq[1]+j]*bi[j];
neq              1248 src/steadystate.c 				  bb[2*i+1]+=z[(long long)(2*i+1)*neq[1]+j]*bi[j];
neq              1275 src/steadystate.c 	      nactmechi=neq[1];
neq              1283 src/steadystate.c 	      for(j=0;j<neq[1];j++){fi[j]=0.;ubi[j]=0.;}
neq              1285 src/steadystate.c 		  ic=neq[1]+i;
neq              1294 src/steadystate.c 		  spooles_solve(ubi,&neq[1]);
neq              1304 src/steadystate.c 		  tau_solve(ubi,&neq[1]);
neq              1309 src/steadystate.c 		  pardiso_solve(ubi,&neq[1],&symmetryflag);
neq              1312 src/steadystate.c 	      FORTRAN(op,(&neq[1],ubi,mubi,adb,aub,jq,irow));
neq              1316 src/steadystate.c 	      for(i=0;i<neq[1];i++){
neq              1325 src/steadystate.c 		  for(j=0;j<neq[1];j++){
neq              1326 src/steadystate.c 		      aa[i]+=z[(long long)i*neq[1]+j]*br[j];
neq              1332 src/steadystate.c 		  for(j=0;j<neq[1];j++){
neq              1333 src/steadystate.c 		      bb[i]+=z[(long long)i*neq[1]+j]*bi[j];
neq              1467 src/steadystate.c 		  memcpy(&br[0],&ubr[0],sizeof(double)*neq[1]);
neq              1476 src/steadystate.c 		  DMEMSET(br,0,neq[1],0.);
neq              1486 src/steadystate.c 		  for(i=0;i<neq[1];i++){
neq              1488 src/steadystate.c 			  br[i]+=bjr[j]*z[(long long)j*neq[1]+i];
neq              1494 src/steadystate.c 			  br[imddof[i]]+=bjr[j]*z[(long long)j*neq[1]+imddof[i]];
neq              1526 src/steadystate.c 		  memcpy(&bi[0],&ubi[0],sizeof(double)*neq[1]);
neq              1535 src/steadystate.c 		  DMEMSET(bi,0,neq[1],0.);
neq              1545 src/steadystate.c 		  for(i=0;i<neq[1];i++){
neq              1547 src/steadystate.c 			  bi[i]+=bji[j]*z[(long long)j*neq[1]+i];
neq              1553 src/steadystate.c 			  bi[imddof[i]]+=bji[j]*z[(long long)j*neq[1]+imddof[i]];
neq              1599 src/steadystate.c 		      ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              1627 src/steadystate.c 		      ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              1642 src/steadystate.c 		  DMEMSET(br,0,neq[1],0.);
neq              1685 src/steadystate.c 		      ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              1713 src/steadystate.c 		      ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              1728 src/steadystate.c 		  DMEMSET(bi,0,neq[1],0.);
neq              1927 src/steadystate.c 	      pardiso_cleanup(&neq[1],&symmetryflag);
neq              1953 src/steadystate.c       NNEW(ikactmech,ITG,neq[1]);
neq              2097 src/steadystate.c 	      spooles_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq              2107 src/steadystate.c 	      sgi_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],token);
neq              2115 src/steadystate.c 	      tau_factor(ad,&au,adb,aub,&sigma,icol,&irow,&neq[1],&nzs[1]);
neq              2123 src/steadystate.c 	      pardiso_factor(ad,au,adb,aub,&sigma,icol,irow,&neq[1],&nzs[1],
neq              2199 src/steadystate.c 	      NNEW(fr,double,neq[1]); /* force corresponding to real particular solution */
neq              2200 src/steadystate.c 	      NNEW(ubr,double,neq[1]); /* real particular solution */
neq              2201 src/steadystate.c 	      NNEW(mubr,double,neq[1]); /* mass times real particular solution */
neq              2217 src/steadystate.c 	  NNEW(br,double,neq[1]); /* load rhs vector (real part) */
neq              2218 src/steadystate.c 	  NNEW(bi,double,neq[1]); /* load rhs vector (imaginary part) */
neq              2219 src/steadystate.c 	  NNEW(btot,double,nfour*neq[1]);
neq              2220 src/steadystate.c 	  NNEW(bp,double,nfour*neq[1]);
neq              2241 src/steadystate.c 		  NNEW(adc,double,neq[1]);
neq              2247 src/steadystate.c                     nbody,cgr,adc,auc,nactdof,icol,jq,irow,neq,nzl,nmethod,
neq              2259 src/steadystate.c 		  NNEW(zc,double,neq[1]*nev);
neq              2261 src/steadystate.c 		      FORTRAN(op,(&neq[1],&z[(long long)i*neq[1]],&zc[i*neq[1]],
neq              2271 src/steadystate.c 			  for(k=0;k<neq[1];k++){
neq              2272 src/steadystate.c 			      cc[i*nev+j]+=z[(long long)j*neq[1]+k]*zc[i*neq[1]+k];
neq              2306 src/steadystate.c 		ipobody,nbody,cgr,br,nactdof,&neq[1],nmethod,
neq              2320 src/steadystate.c 			  i2=(long long)i*neq[1];
neq              2322 src/steadystate.c 			  if(nactmech<neq[1]/2){
neq              2327 src/steadystate.c 			      for(j=0;j<neq[1];j++){
neq              2359 src/steadystate.c 		  nactmech=neq[1];
neq              2361 src/steadystate.c 		  for(i=0;i<neq[1];i++){bi[i]=0.;}
neq              2367 src/steadystate.c 		  for(j=0;j<neq[1];j++){fr[j]=0.;ubr[j]=0.;}
neq              2369 src/steadystate.c 		      ic=neq[1]+i;
neq              2378 src/steadystate.c 		      spooles_solve(ubr,&neq[1]);
neq              2388 src/steadystate.c 		      tau_solve(ubr,&neq[1]);
neq              2393 src/steadystate.c 		      pardiso_solve(ubr,&neq[1],&symmetryflag);
neq              2396 src/steadystate.c 		  FORTRAN(op,(&neq[1],ubr,mubr,adb,aub,jq,irow));
neq              2398 src/steadystate.c 		  for(i=0;i<neq[1];i++){
neq              2407 src/steadystate.c 		      for(j=0;j<neq[1];j++){
neq              2408 src/steadystate.c 			  aa[i]+=z[(long long)i*neq[1]+j]*br[j];
neq              2414 src/steadystate.c 		      for(j=0;j<neq[1];j++){
neq              2415 src/steadystate.c 			  bb[i]+=z[(long long)i*neq[1]+j]*bi[j];
neq              2481 src/steadystate.c 		      memcpy(&br[0],&ubr[0],sizeof(double)*neq[1]);
neq              2490 src/steadystate.c 		      DMEMSET(br,0,neq[1],0.);
neq              2500 src/steadystate.c 		      for(i=0;i<neq[1];i++){
neq              2502 src/steadystate.c 			      br[i]+=bjr[j]*z[(long long)j*neq[1]+i];
neq              2508 src/steadystate.c 			      br[imddof[i]]+=bjr[j]*z[(long long)j*neq[1]+imddof[i]];
neq              2528 src/steadystate.c 		  DMEMSET(bi,0,neq[1],0.);
neq              2537 src/steadystate.c 		      for(i=0;i<neq[1];i++){
neq              2539 src/steadystate.c 			      bi[i]+=bji[j]*z[(long long)j*neq[1]+i];
neq              2545 src/steadystate.c 			      bi[imddof[i]]+=bji[j]*z[(long long)j*neq[1]+imddof[i]];
neq              2566 src/steadystate.c 		  for(i=0;i<neq[1];i++){
neq              2582 src/steadystate.c 		      for(i=0;i<neq[1];i++){
neq              2591 src/steadystate.c 		      for(i=0;i<neq[1];i++){
neq              2592 src/steadystate.c 			  btot[j*neq[1]+i]+=br[i]*cos(freq[l]*time+bi[i]);
neq              2593 src/steadystate.c 			  bp[j*neq[1]+i]-=freq[l]*br[i]*sin(freq[l]*time+bi[i]);
neq              2629 src/steadystate.c 			  btot[j*neq[1]+i]+=br[i]*cos(freq[l]*time+bi[i]);
neq              2630 src/steadystate.c 			  bp[j*neq[1]+i]-=freq[l]*br[i]*sin(freq[l]*time+bi[i]);
neq              2640 src/steadystate.c 		      DMEMSET(br,0,neq[1],0.);
neq              2702 src/steadystate.c                     coefmpc,labmpc,nmpc,&btot[l*neq[1]],&bp[l*neq[1]],veold,&dtime,mi,
neq              2711 src/steadystate.c 		      vold,&btot[l*neq[1]],nodeboun,ndirboun,
neq              2713 src/steadystate.c 		      ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,&neq[1],
neq              2782 src/steadystate.c 	      pardiso_cleanup(&neq[1],&symmetryflag);
neq              2801 src/steadystate.c       neq[1]=neq[1]*2/nsectors;
neq                43 src/tau.c                      ITG *neq, ITG *nzs){
neq                59 src/tau.c        ndim=*neq+*nzs;
neq                63 src/tau.c        NNEW(pointtau,ITG,*neq+1);
neq                69 src/tau.c          pointtau[*neq]=ndim;
neq                70 src/tau.c          for(i=*neq-1;i>=0;--i){
neq                81 src/tau.c          pointtau[*neq]=ndim;
neq                82 src/tau.c          for(i=*neq-1;i>=0;--i){
neq                95 src/tau.c        aa->n = *neq;
neq                96 src/tau.c        aa->m = *neq;
neq               102 src/tau.c        if(*neq<50000){
neq               126 src/tau.c      void tau_solve(double *b,ITG *neq){
neq               133 src/tau.c        NNEW(x,double,*neq);
neq               135 src/tau.c        if(*neq<150){
neq               148 src/tau.c        for(i=0;i<=*neq-1;++i){
neq               174 src/tau.c               ITG *neq, ITG *nzs){
neq               176 src/tau.c        if(*neq==0) return;
neq               180 src/tau.c                   neq,nzs);
neq               182 src/tau.c        tau_solve(b,neq);
neq                19 src/tau.h               ITG *neq, ITG *nzs);
neq                23 src/tau.h                      ITG *neq, ITG *nzs);
neq                25 src/tau.h      void tau_solve(double *b,ITG *neq);
neq                40 src/tiedcontact.c       *ilmpc=NULL,*nodempc=NULL,ismallsliding=0,neq,neqterms,
neq               115 src/tiedcontact.c       neq=4;
neq               117 src/tiedcontact.c       neq=5;
neq               121 src/tiedcontact.c       neq=3;
neq               123 src/tiedcontact.c       neq=1;
neq               125 src/tiedcontact.c       neq=4;
neq               128 src/tiedcontact.c   neq*=(ncone+nconf);
neq               134 src/tiedcontact.c   RENEW(ipompc,ITG,*nmpc_+neq);
neq               135 src/tiedcontact.c   RENEW(labmpc,char,20*(*nmpc_+neq)+1);
neq               136 src/tiedcontact.c   RENEW(ikmpc,ITG,*nmpc_+neq);
neq               137 src/tiedcontact.c   RENEW(ilmpc,ITG,*nmpc_+neq);
neq               138 src/tiedcontact.c   RENEW(fmpc,double,*nmpc_+neq);
neq               144 src/tiedcontact.c   neqterms=9*neq;