
config/argdb.py,440
argdb.py:^?argdb.py^A,1
class ArgDB:ArgDB13,415
  def __init__(self,argv):__init__15,429
  def UsedArgs(self):UsedArgs35,1217
  def PopString(self,keyword):PopString38,1272
  def PopPath(self,keyword):PopPath55,1686
  def PopUrl(self,keyword):PopUrl72,2130
  def PopBool(self,keyword):PopBool92,2639
  def PopHelp(self):PopHelp109,3056
  def ErrorPetscOptions(self):ErrorPetscOptions125,3431
  def ErrorIfNotEmpty(self):ErrorIfNotEmpty142,4162

config/configure.py,3159
configure.py:^?configure.py^A,1
def AddDefine(conffile,name,value,prefix='SLEPC_'):AddDefine15,489
def CreateFile(basedir,fname,log):CreateFile18,600
def CreateDir(basedir,dirname,log):CreateDir27,865
def CreateDirTwo(basedir,dir1,dir2,log):CreateDirTwo37,1172
def CreateDirTest(basedir,dirname,log):CreateDirTest53,1684
def WriteModulesFile(modules,version,sdir):WriteModulesFile66,2071
def WritePkgconfigFile(pkgconfig,version,pversion,sdir,isinstall,prefixdir,singlelib):WritePkgconfigFile78,2721
def WriteReconfigScript(reconfig,slepcdir,usedargs):WriteReconfigScript97,3613
configdir = os.path.abspath('config')configdir118,4837
argdb = argdb.ArgDB(sys.argv)argdb126,5113
log   = log.Log()log127,5143
slepc   = slepc.SLEPc(argdb,log)slepc131,5307
petsc   = petsc.PETSc(argdb,log)petsc132,5340
arpack  = arpack.Arpack(argdb,log)arpack133,5373
blopex  = blopex.Blopex(argdb,log)blopex134,5408
blzpack = blzpack.Blzpack(argdb,log)blzpack135,5443
primme  = primme.Primme(argdb,log)primme136,5480
trlan   = trlan.Trlan(argdb,log)trlan137,5515
sowing  = sowing.Sowing(argdb,log)sowing138,5548
lapack  = lapack.Lapack(argdb,log)lapack139,5583
slicot  = slicot.Slicot(argdb,log)slicot140,5618
externalpackages = [arpack, blopex, blzpack, primme, slicot, trlan]externalpackages142,5654
optionspackages  = [slepc, arpack, blopex, blzpack, primme, slicot, trlan, sowing]optionspackages143,5722
checkpackages    = [arpack, blopex, blzpack, primme, slicot, trlan, lapack]checkpackages144,5805
emptyarch = not ('PETSC_ARCH' in os.environ and os.environ['PETSC_ARCH'])emptyarch171,6673
  archname = petsc.archarchname182,7063
libdir  = CreateDir(archdir,'lib',log)libdir186,7197
confdir = CreateDirTwo(libdir,'slepc','conf',log)confdir187,7236
      f = open(os.path.join(confdir,'slepcvariables'),'r')f211,8067
      searchlines = f.readlines()searchlines212,8126
includedir = CreateDir(archdir,'include',log)includedir235,9032
modulesdir = CreateDirTwo(confdir,'modules','slepc',log)modulesdir236,9078
pkgconfdir = CreateDir(libdir,'pkgconfig',log)pkgconfdir237,9135
slepcvars  = CreateFile(confdir,'slepcvariables',log)slepcvars238,9182
slepcconf  = CreateFile(includedir,'slepcconf.h',log)slepcconf239,9236
pkgconfig  = CreateFile(pkgconfdir,'SLEPc.pc',log)pkgconfig240,9290
  modules  = CreateFile(modulesdir,slepc.lversion,log)modules242,9361
  modules  = CreateFile(modulesdir,slepc.lversion+'-'+archname,log)modules244,9422
  reconfig = CreateFile(confdir,'reconfigure-'+archname+'.py',log)reconfig245,9490
  reconfigpath = os.path.join(confdir,'reconfigure-'+archname+'.py')reconfigpath246,9557
  globconf = CreateFile(os.path.join(slepc.dir,'lib','slepc','conf'),'slepcvariables',log)globconf272,10624
slflag = ''slflag312,12627
bfort = petsc.bfortbfort332,13298
  bfort = sowing.Install(archdir,petsc.make)bfort334,13345
      bfort = os.path.join(archdir,'bin','bfort')bfort339,13467
      bfort = sowing.Install(archdir,petsc.make)bfort341,13551
      petscdate = dateutil.parser.parse(petsc.gitdate)petscdate374,14742
      slepcdate = dateutil.parser.parse(slepc.gitdate)slepcdate375,14797

config/install.py,1693
install.py:^?install.py^A,1
  getstatusoutput = commands.getstatusoutputgetstatusoutput6,129
  getstatusoutput = subprocess.getstatusoutputgetstatusoutput9,200
  WindowsError = NoneWindowsError14,286
class Installer:Installer16,309
  def __init__(self, args = None):__init__17,326
  def readInstallDir(self, src):readInstallDir42,1439
  def setupDirectories(self):setupDirectories58,1957
  def checkDestdir(self):checkDestdir79,3329
  def copyfile(self, src, dst, symlinks = False, copyFunc = shutil.copy2):copyfile103,4779
  def copyexamplefiles(self, src, dst, copyFunc = shutil.copy2):copyexamplefiles128,5604
  def fixExamplesMakefile(self, src):fixExamplesMakefile137,5944
  def copyExamples(self, src, dst):copyExamples162,6960
  def copyConfig(self, src, dst):copyConfig190,8107
  def copytree(self, src, dst, symlinks = False, copyFunc = shutil.copy2, exclude = [], exclude_ext= ['.DSYM','.o','.pyc','.html'], recurse = 1):copytree204,8642
  def fixConfFile(self, src):fixConfFile256,10871
  def fixConf(self):fixConf279,12128
  def createUninstaller(self):createUninstaller287,12454
  def installIncludes(self):installIncludes319,13355
  def installConf(self):installConf325,13647
  def installBin(self):installBin330,14010
  def installShare(self):installShare337,14278
  def copyLib(self, src, dst):copyLib349,14790
  def installLib(self):installLib374,15929
  def outputInstallDone(self):outputInstallDone380,16276
  def outputDestDirDone(self):outputDestDirDone392,16658
  def runsetup(self):runsetup401,16927
  def runcopy(self):runcopy406,17013
  def runfix(self):runfix426,17752
  def rundone(self):rundone430,17803
  def run(self):run438,17977

config/log.py,276
log.py:^?log.py^A,1
class Log:Log14,453
  def Open(self,confdir,fname):Open16,465
  def Println(self,string):Println28,871
  def Print(self,string):Print32,949
  def NewSection(self,string):NewSection36,1033
  def write(self,string):write41,1167
  def Exit(self,string):Exit44,1225

config/package.py,863
package.py:^?package.py^A,1
class Package:Package27,751
  def __init__(self,argdb,log):__init__29,767
  def RunCommand(self,instr):RunCommand42,1162
  def ProcessArgs(self,argdb):ProcessArgs51,1440
  def Process(self,conf,vars,petsc,archdir=''):Process76,2320
  def Precondition(self,petsc):Precondition94,2966
  def Download(self,externdir,builddir,prefix=None):Download112,3948
  def ShowHelp(self):ShowHelp173,6196
  def ShowInfo(self):ShowInfo184,6922
  def TestRuns(self,petsc):TestRuns189,7093
  def LinkWithOutput(self,functions,callbacks,flags,givencode=''):LinkWithOutput195,7213
  def Link(self,functions,callbacks,flags):Link249,9130
  def FortranLink(self,functions,callbacks,flags):FortranLink254,9290
  def GenerateGuesses(self,name):GenerateGuesses283,10197
  def FortranLib(self,conf,vars,dirs,libs,functions,callbacks = []):FortranLib302,10789

config/packages/arpack.py,249
arpack.py:^?arpack.py^A,1
class Arpack(package.Package):Arpack13,424
  def __init__(self,argdb,log):__init__15,456
  def Functions(self,petsc):Functions28,969
  def Check(self,conf,vars,petsc):Check54,1778
  def Install(self,conf,vars,petsc,archdir):Install72,2335

config/packages/blopex.py,153
blopex.py:^?blopex.py^A,1
class Blopex(package.Package):Blopex13,432
  def __init__(self,argdb,log):__init__15,464
  def Install(self,conf,vars,petsc,archdir):Install25,846

config/packages/blzpack.py,143
blzpack.py:^?blzpack.py^A,1
class Blzpack(package.Package):Blzpack13,420
  def __init__(self,argdb,log):__init__15,453
  def Check(self,conf,vars,petsc):Check23,692

config/packages/lapack.py,326
lapack.py:^?lapack.py^A,1
class Lapack(package.Package):Lapack13,420
  def __init__(self,argdb,log):__init__15,452
  def ShowInfo(self):ShowInfo19,562
  def Process(self,conf,vars,petsc,archdir=''):Process29,978
  def LinkBlasLapack(self,functions,callbacks,flags,petsc):LinkBlasLapack37,1247
  def Check(self,conf,vars,petsc):Check52,1714

config/packages/petsc.py,253
petsc.py:^?petsc.py^A,1
class PETSc(package.Package):PETSc13,424
  def __init__(self,argdb,log):__init__15,455
  def Check(self):Check19,564
  def InitDir(self,prefixdir):InitDir22,627
  def LoadVersion(self):LoadVersion34,1025
  def LoadConf(self):LoadConf65,2304

config/packages/primme.py,202
primme.py:^?primme.py^A,1
class Primme(package.Package):Primme13,432
  def __init__(self,argdb,log):__init__15,464
  def Check(self,conf,vars,petsc):Check28,936
  def Install(self,conf,vars,petsc,archdir):Install74,2428

config/packages/slepc.py,211
slepc.py:^?slepc.py^A,1
class SLEPc(package.Package):SLEPc14,469
  def __init__(self,argdb,log):__init__16,500
  def ShowHelp(self):ShowHelp23,757
  def InitDir(self):InitDir29,1061
  def LoadVersion(self):LoadVersion41,1617

config/packages/slicot.py,202
slicot.py:^?slicot.py^A,1
class Slicot(package.Package):Slicot13,424
  def __init__(self,argdb,log):__init__15,456
  def Check(self,conf,vars,petsc):Check29,923
  def Install(self,conf,vars,petsc,archdir):Install44,1244

config/packages/sowing.py,142
sowing.py:^?sowing.py^A,1
class Sowing(package.Package):Sowing13,429
  def __init__(self,argdb,log):__init__15,461
  def Install(self,archdir,make):Install22,698

config/packages/trlan.py,200
trlan.py:^?trlan.py^A,1
class Trlan(package.Package):Trlan13,424
  def __init__(self,argdb,log):__init__15,455
  def Check(self,conf,vars,petsc):Check28,969
  def Install(self,conf,vars,petsc,archdir):Install46,1359

configure,0
configure:^?configure^A,1

include/makefile,343
makefile:^?makefile^A,1
CFLAGS   =CFLAGS11,399
FFLAGS   =FFLAGS12,410
SOURCEC  =SOURCEC13,421
SOURCEF  =SOURCEF14,432
SOURCEH  = slepc.h slepcsys.h slepcmath.h slepcversion.h slepcblaslapack.h \SOURCEH15,443
LIBBASE  = libslepcsysLIBBASE20,784
DIRS     = slepc/finclude slepc/privateDIRS21,807
LOCDIR   = include/LOCDIR22,847
MANSEC   =MANSEC23,867

include/slepc.h,0
slepc.h:^?slepc.h^A,1

include/slepc/finclude/makefile,325
makefile:^?makefile^A,1
CFLAGS    =CFLAGS13,474
FFLAGS    =FFLAGS14,486
SOURCEC   =SOURCEC15,498
SOURCEF   =SOURCEF16,510
SOURCEH   = slepc.h slepceps.h slepcst.h slepcsvd.h slepcpep.h \SOURCEH17,522
LIBBASE   = libslepcsysLIBBASE19,683
DIRS      =DIRS20,707
MANSEC    =MANSEC21,719
LOCDIR    = include/slepc/finclude/LOCDIR22,731

include/slepc/finclude/slepc.h,86
slepc.h:^?slepc.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145

include/slepc/finclude/slepcbv.h,535
slepcbv.h:^?slepcbv.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCBVDEF_HSLEPCBVDEF_H13,485
#define BV BV17,545
#define BVType BVType19,567
#define BVOrthogType BVOrthogType20,609
#define BVOrthogRefineType BVOrthogRefineType21,646
#define BVOrthogBlockType BVOrthogBlockType22,683
#define BVMatMultType BVMatMultType23,720
#define BVMAT BVMAT25,758
#define BVSVEC BVSVEC26,785
#define BVVECS BVVECS27,813
#define BVCONTIGUOUS BVCONTIGUOUS28,841
#define BVTENSOR BVTENSOR29,875

include/slepc/finclude/slepcds.h,537
slepcds.h:^?slepcds.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCDSDEF_HSLEPCDSDEF_H13,485
#define DS DS18,581
#define DSType DSType20,603
#define DSStateType DSStateType21,641
#define DSMatType DSMatType22,674
#define DSParallelType DSParallelType23,707
#define DSHEP DSHEP25,741
#define DSNHEP DSNHEP26,767
#define DSGHEP DSGHEP27,794
#define DSGHIEP DSGHIEP28,821
#define DSGNHEP DSGNHEP29,849
#define DSSVD DSSVD30,877
#define DSPEP DSPEP31,903
#define DSNEP DSNEP32,929

include/slepc/finclude/slepceps.h,1361
slepceps.h:^?slepceps.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCEPSDEF_HSLEPCEPSDEF_H13,487
#define EPS EPS22,730
#define EPSType EPSType24,754
#define EPSConvergedReason EPSConvergedReason25,800
#define EPSErrorType EPSErrorType26,841
#define EPSProblemType EPSProblemType27,882
#define EPSWhich EPSWhich28,923
#define EPSExtraction EPSExtraction29,964
#define EPSBalance EPSBalance30,1005
#define EPSConv EPSConv31,1046
#define EPSStop EPSStop32,1087
#define EPSPowerShiftType EPSPowerShiftType33,1128
#define EPSLanczosReorthogType EPSLanczosReorthogType34,1169
#define EPSPRIMMEMethod EPSPRIMMEMethod35,1210
#define EPSCISSQuadRule EPSCISSQuadRule36,1251
#define EPSCISSExtraction EPSCISSExtraction37,1292
#define EPSPOWER EPSPOWER39,1334
#define EPSSUBSPACE EPSSUBSPACE40,1365
#define EPSARNOLDI EPSARNOLDI41,1399
#define EPSLANCZOS EPSLANCZOS42,1432
#define EPSKRYLOVSCHUR EPSKRYLOVSCHUR43,1465
#define EPSGD EPSGD44,1502
#define EPSJD EPSJD45,1530
#define EPSRQCG EPSRQCG46,1558
#define EPSLOBPCG EPSLOBPCG47,1588
#define EPSCISS EPSCISS48,1620
#define EPSLAPACK EPSLAPACK49,1650
#define EPSARPACK EPSARPACK50,1682
#define EPSBLZPACK EPSBLZPACK51,1714
#define EPSTRLAN EPSTRLAN52,1747
#define EPSBLOPEX EPSBLOPEX53,1778
#define EPSPRIMME EPSPRIMME54,1810

include/slepc/finclude/slepcfn.h,493
slepcfn.h:^?slepcfn.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCFNDEF_HSLEPCFNDEF_H13,485
#define FN FN17,545
#define FNType FNType19,567
#define FNCombineType FNCombineType20,605
#define FNParallelType FNParallelType21,638
#define FNCOMBINE FNCOMBINE23,672
#define FNRATIONAL FNRATIONAL24,701
#define FNEXP FNEXP25,731
#define FNLOG FNLOG26,756
#define FNPHI FNPHI27,781
#define FNSQRT FNSQRT28,806
#define FNINVSQRT FNINVSQRT29,832

include/slepc/finclude/slepclme.h,321
slepclme.h:^?slepclme.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCLMEDEF_HSLEPCLMEDEF_H13,487
#define LME LME18,584
#define LMEType LMEType20,608
#define LMEConvergedReason LMEConvergedReason21,650
#define LMEProblemType LMEProblemType22,687
#define LMEKRYLOV LMEKRYLOV24,725

include/slepc/finclude/slepcmfn.h,313
slepcmfn.h:^?slepcmfn.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCMFNDEF_HSLEPCMFNDEF_H13,487
#define MFN MFN19,620
#define MFNType MFNType21,644
#define MFNConvergedReason MFNConvergedReason22,686
#define MFNKRYLOV MFNKRYLOV24,724
#define MFNEXPOKIT MFNEXPOKIT25,756

include/slepc/finclude/slepcnep.h,725
slepcnep.h:^?slepcnep.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCNEPDEF_HSLEPCNEPDEF_H13,487
#define NEP NEP22,729
#define NEPType NEPType24,753
#define NEPProblemType NEPProblemType25,795
#define NEPConvergedReason NEPConvergedReason26,832
#define NEPErrorType NEPErrorType27,869
#define NEPWhich NEPWhich28,906
#define NEPConv NEPConv29,943
#define NEPStop NEPStop30,980
#define NEPRefine NEPRefine31,1017
#define NEPRefineScheme NEPRefineScheme32,1054
#define NEPRII NEPRII34,1092
#define NEPSLP NEPSLP35,1119
#define NEPNARNOLDI NEPNARNOLDI36,1146
#define NEPCISS NEPCISS37,1178
#define NEPINTERPOL NEPINTERPOL38,1206
#define NEPNLEIGS NEPNLEIGS39,1238

include/slepc/finclude/slepcpep.h,843
slepcpep.h:^?slepcpep.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCPEPDEF_HSLEPCPEPDEF_H13,487
#define PEP PEP21,692
#define PEPType PEPType23,716
#define PEPProblemType PEPProblemType24,758
#define PEPWhich PEPWhich25,795
#define PEPBasis PEPBasis26,832
#define PEPScale PEPScale27,869
#define PEPRefine PEPRefine28,906
#define PEPRefineScheme PEPRefineScheme29,943
#define PEPExtract PEPExtract30,980
#define PEPConv PEPConv31,1017
#define PEPStop PEPStop32,1054
#define PEPErrorType PEPErrorType33,1091
#define PEPConvergedReason PEPConvergedReason34,1128
#define PEPJDProjection PEPJDProjection35,1165
#define PEPLINEAR PEPLINEAR37,1203
#define PEPQARNOLDI PEPQARNOLDI38,1233
#define PEPTOAR PEPTOAR39,1265
#define PEPSTOAR PEPSTOAR40,1293
#define PEPJD PEPJD41,1322

include/slepc/finclude/slepcrg.h,319
slepcrg.h:^?slepcrg.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCRGDEF_HSLEPCRGDEF_H13,485
#define RG RG17,545
#define RGType RGType19,567
#define RGINTERVAL RGINTERVAL21,603
#define RGPOLYGON RGPOLYGON22,634
#define RGELLIPSE RGELLIPSE23,664
#define RGRING RGRING24,694

include/slepc/finclude/slepcst.h,419
slepcst.h:^?slepcst.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCSTDEF_HSLEPCSTDEF_H13,485
#define ST ST18,581
#define STType STType20,603
#define STMatMode STMatMode21,637
#define STSHELL STSHELL23,667
#define STSHIFT STSHIFT24,694
#define STSINVERT STSINVERT25,721
#define STCAYLEY STCAYLEY26,750
#define STPRECOND STPRECOND27,778
#define STFILTER STFILTER28,807

include/slepc/finclude/slepcsvd.h,651
slepcsvd.h:^?slepcsvd.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCSVDDEF_HSLEPCSVDDEF_H13,487
#define SVD SVD19,620
#define SVDType SVDType21,644
#define SVDConvergedReason SVDConvergedReason22,686
#define SVDErrorType SVDErrorType23,723
#define SVDWhich SVDWhich24,760
#define SVDConv SVDConv25,797
#define SVDStop SVDStop26,834
#define SVDPRIMMEMethod SVDPRIMMEMethod27,871
#define SVDCROSS SVDCROSS29,909
#define SVDCYCLIC SVDCYCLIC30,938
#define SVDLAPACK SVDLAPACK31,968
#define SVDLANCZOS SVDLANCZOS32,998
#define SVDTRLANCZOS SVDTRLANCZOS33,1029
#define SVDPRIMME SVDPRIMME34,1062

include/slepc/finclude/slepcsys.h,211
slepcsys.h:^?slepcsys.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
#define SLEPCSYSDEF_HSLEPCSYSDEF_H13,487
#define SlepcSC SlepcSC19,594
#define SlepcConvMonitor SlepcConvMonitor21,626

include/slepc/private/bvimpl.h,13712
bvimpl.h:^?bvimpl.h^A,1
#define SLEPCBVIMPL_HSLEPCBVIMPL_H12,428
SLEPC_EXTERN PetscBool BVRegisterAllCalled;BVRegisterAllCalled17,510
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Create20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Copy20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Mult20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_MultVec20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_MultInPlace20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Dot20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_DotVec20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Orthogonalize20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_OrthogonalizeVec20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Scale20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_Norm20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_NormVec20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_SetRandom20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_MatMult20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_MatMultVec20,604
SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject;BV_MatProject20,604
typedef struct _BVOps *BVOps;BVOps22,819
struct _BVOps {_BVOps24,850
  PetscErrorCode (*mult)(BV,PetscScalar,PetscScalar,BV,Mat);mult25,866
  PetscErrorCode (*multvec)(BV,PetscScalar,PetscScalar,Vec,PetscScalar*);multvec26,927
  PetscErrorCode (*multinplace)(BV,Mat,PetscInt,PetscInt);multinplace27,1001
  PetscErrorCode (*multinplacetrans)(BV,Mat,PetscInt,PetscInt);multinplacetrans28,1060
  PetscErrorCode (*dot)(BV,BV,Mat);dot29,1124
  PetscErrorCode (*dotvec)(BV,Vec,PetscScalar*);dotvec30,1160
  PetscErrorCode (*dotvec_local)(BV,Vec,PetscScalar*);dotvec_local31,1209
  PetscErrorCode (*dotvec_begin)(BV,Vec,PetscScalar*);dotvec_begin32,1264
  PetscErrorCode (*dotvec_end)(BV,Vec,PetscScalar*);dotvec_end33,1319
  PetscErrorCode (*scale)(BV,PetscInt,PetscScalar);scale34,1372
  PetscErrorCode (*norm)(BV,PetscInt,NormType,PetscReal*);norm35,1424
  PetscErrorCode (*norm_local)(BV,PetscInt,NormType,PetscReal*);norm_local36,1483
  PetscErrorCode (*norm_begin)(BV,PetscInt,NormType,PetscReal*);norm_begin37,1548
  PetscErrorCode (*norm_end)(BV,PetscInt,NormType,PetscReal*);norm_end38,1613
  PetscErrorCode (*matmult)(BV,Mat,BV);matmult39,1676
  PetscErrorCode (*copy)(BV,BV);copy40,1716
  PetscErrorCode (*copycolumn)(BV,PetscInt,PetscInt);copycolumn41,1749
  PetscErrorCode (*resize)(BV,PetscInt,PetscBool);resize42,1803
  PetscErrorCode (*getcolumn)(BV,PetscInt,Vec*);getcolumn43,1854
  PetscErrorCode (*restorecolumn)(BV,PetscInt,Vec*);restorecolumn44,1903
  PetscErrorCode (*getarray)(BV,PetscScalar**);getarray45,1956
  PetscErrorCode (*restorearray)(BV,PetscScalar**);restorearray46,2004
  PetscErrorCode (*getarrayread)(BV,const PetscScalar**);getarrayread47,2056
  PetscErrorCode (*restorearrayread)(BV,const PetscScalar**);restorearrayread48,2114
  PetscErrorCode (*restoresplit)(BV,BV*,BV*);restoresplit49,2176
  PetscErrorCode (*gramschmidt)(BV,PetscInt,Vec,PetscBool*,PetscScalar*,PetscScalar*,PetscReal*,PetscReal*);gramschmidt50,2222
  PetscErrorCode (*duplicate)(BV,BV);duplicate51,2331
  PetscErrorCode (*create)(BV);create52,2369
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,BV);setfromoptions53,2401
  PetscErrorCode (*view)(BV,PetscViewer);view54,2459
  PetscErrorCode (*destroy)(BV);destroy55,2501
struct _p_BV {_p_BV58,2538
  Vec                t;            /* template vector */t61,2658
  PetscInt           n,N;          /* dimensions of vectors (local, global) */n62,2715
  PetscInt           n,N;          /* dimensions of vectors (local, global) */N62,2715
  PetscInt           m;            /* number of vectors */m63,2794
  PetscInt           l;            /* number of leading columns */l64,2853
  PetscInt           k;            /* number of active columns */k65,2920
  PetscInt           nc;           /* number of constraints */nc66,2986
  BVOrthogType       orthog_type;  /* the method of vector orthogonalization */orthog_type67,3049
  BVOrthogRefineType orthog_ref;   /* refinement method */orthog_ref68,3129
  PetscReal          orthog_eta;   /* refinement threshold */orthog_eta69,3188
  BVOrthogBlockType  orthog_block; /* the method of block orthogonalization */orthog_block70,3250
  Mat                matrix;       /* inner product matrix */matrix71,3329
  PetscBool          indef;        /* matrix is indefinite */indef72,3391
  BVMatMultType      vmm;          /* version of matmult operation */vmm73,3453
  PetscBool          rrandom;      /* reproducible random vectors */rrandom74,3523
  Vec                buffer;       /* buffer vector used in orthogonalization */buffer77,3668
  Mat                Abuffer;      /* auxiliary seqdense matrix that wraps the buffer */Abuffer78,3749
  Vec                Bx;           /* result of matrix times a vector x */Bx79,3838
  PetscObjectId      xid;          /* object id of vector x */xid80,3913
  PetscObjectState   xstate;       /* state of vector x */xstate81,3976
  Vec                cv[2];        /* column vectors obtained with BVGetColumn() */cv82,4035
  PetscInt           ci[2];        /* column indices of obtained vectors */ci83,4119
  PetscObjectState   st[2];        /* state of obtained vectors */st84,4195
  PetscObjectId      id[2];        /* object id of obtained vectors */id85,4262
  PetscScalar        *h,*c;        /* orthogonalization coefficients */h86,4333
  PetscScalar        *h,*c;        /* orthogonalization coefficients */c86,4333
  Vec                omega;        /* signature matrix values for indefinite case */omega87,4405
  PetscBool          defersfo;     /* deferred call to setfromoptions */defersfo88,4490
  BV                 cached;       /* cached BV to store result of matrix times BV */cached89,4563
  PetscObjectState   bvstate;      /* state of BV when BVApplyMatrixBV() was called */bvstate90,4649
  BV                 L,R;          /* BV objects obtained with BVGetSplit() */L91,4736
  BV                 L,R;          /* BV objects obtained with BVGetSplit() */R91,4736
  PetscObjectState   lstate,rstate;/* state of L and R when BVGetSplit() was called */lstate92,4815
  PetscObjectState   lstate,rstate;/* state of L and R when BVGetSplit() was called */rstate92,4815
  PetscInt           lsplit;       /* the value of l when BVGetSplit() was called */lsplit93,4902
  PetscInt           issplit;      /* >0 if this BV has been created by splitting (1=left, 2=right) */issplit94,4987
  BV                 splitparent;  /* my parent if I am a split BV */splitparent95,5090
  PetscRandom        rand;         /* random number generator */rand96,5160
  Mat                Acreate;      /* matrix given at BVCreateFromMat() */Acreate97,5225
  Mat                Aget;         /* matrix returned for BVGetMat() */Aget98,5300
  Mat                Amult;        /* matrix argument of last call to BVMatMult() */Amult99,5372
  PetscObjectState   Amultstate;   /* state of Amult */Amultstate100,5457
  PetscBool          cuda;         /* true if GPU must be used in SVEC */cuda101,5513
  PetscScalar        *work;work102,5587
  PetscInt           lwork;lwork103,5615
  void               *data;data104,5643
PETSC_STATIC_INLINE PetscErrorCode BV_SafeSqrt(BV bv,PetscScalar alpha,PetscReal *res)BV_SafeSqrt113,5916
PETSC_STATIC_INLINE PetscErrorCode BV_IPMatMult(BV bv,Vec x)BV_IPMatMult140,7057
PETSC_STATIC_INLINE PetscErrorCode BV_IPMatMultBV(BV bv)BV_IPMatMultBV161,7767
PETSC_STATIC_INLINE PetscErrorCode BV_AllocateCoeffs(BV bv)BV_AllocateCoeffs182,8417
PETSC_STATIC_INLINE PetscErrorCode BV_AllocateSignature(BV bv)BV_AllocateSignature197,8830
#define BVAvailableVec BVAvailableVec222,9601
#define BVCheckSizes(BVCheckSizes229,9761
#define BVCheckOp(BVCheckOp230,9805
#define BVCheckSizes(BVCheckSizes234,9857
#define BVCheckOp(BVCheckOp239,10048
SLEPC_EXTERN MPI_Op MPIU_TSQR;MPIU_TSQR266,12066
#define WaitForGPU(WaitForGPU271,12212
#define cublasXgemm(cublasXgemm276,12372
#define cublasXgemv(cublasXgemv277,12550
#define cublasXscal(cublasXscal278,12716
#define cublasXnrm2(cublasXnrm2279,12804
#define cublasXaxpy(cublasXaxpy280,12879
#define cublasXdotc(cublasXdotc281,12991
#define cublasXgemm(cublasXgemm283,13145
#define cublasXgemv(cublasXgemv284,13353
#define cublasXscal(cublasXscal285,13549
#define cublasXnrm2(cublasXnrm2286,13649
#define cublasXaxpy(cublasXaxpy287,13730
#define cublasXdotc(cublasXdotc288,13860
#define cublasXgemm cublasXgemm292,14071
#define cublasXgemv cublasXgemv293,14103
#define cublasXscal cublasXscal294,14135
#define cublasXnrm2 cublasXnrm2295,14167
#define cublasXaxpy cublasXaxpy296,14199
#define cublasXdotc cublasXdotc297,14231
#define cublasXgemm cublasXgemm299,14286
#define cublasXgemv cublasXgemv300,14318
#define cublasXscal cublasXscal301,14350
#define cublasXnrm2 cublasXnrm2302,14382
#define cublasXaxpy cublasXaxpy303,14414
#define cublasXdotc cublasXdotc304,14446
PETSC_STATIC_INLINE PetscErrorCode BV_CleanCoefficients_Default(BV bv,PetscInt j,PetscScalar *h)BV_CleanCoefficients_Default321,15234
PETSC_STATIC_INLINE PetscErrorCode BV_AddCoefficients_Default(BV bv,PetscInt j,PetscScalar *h,PetscScalar *c)BV_AddCoefficients_Default341,15797
PETSC_STATIC_INLINE PetscErrorCode BV_SetValue_Default(BV bv,PetscInt j,PetscInt k,PetscScalar *h,PetscScalar value)BV_SetValue_Default361,16371
PETSC_STATIC_INLINE PetscErrorCode BV_SquareSum_Default(BV bv,PetscInt j,PetscScalar *h,PetscReal *sum)BV_SquareSum_Default380,16919
PETSC_STATIC_INLINE PetscErrorCode BV_ApplySignature_Default(BV bv,PetscInt j,PetscScalar *h,PetscBool inverse)BV_ApplySignature_Default399,17598
PETSC_STATIC_INLINE PetscErrorCode BV_SquareRoot_Default(BV bv,PetscInt j,PetscScalar *h,PetscReal *beta)BV_SquareRoot_Default421,18435
PETSC_STATIC_INLINE PetscErrorCode BV_StoreCoefficients_Default(BV bv,PetscInt j,PetscScalar *h,PetscScalar *dest)BV_StoreCoefficients_Default437,18996
PETSC_STATIC_INLINE PetscErrorCode BV_GetEigenvector(BV V,PetscInt k,PetscScalar eigi,Vec Vr,Vec Vi)BV_GetEigenvector457,19608
#define BV_CleanCoefficients(BV_CleanCoefficients484,20514
#define BV_AddCoefficients(BV_AddCoefficients485,20632
#define BV_SetValue(BV_SetValue486,20750
#define BV_SquareSum(BV_SquareSum487,20858
#define BV_ApplySignature(BV_ApplySignature488,20964
#define BV_SquareRoot(BV_SquareRoot489,21080
#define BV_StoreCoefficients(BV_StoreCoefficients490,21188
#define BV_CleanCoefficients(BV_CleanCoefficients492,21316
#define BV_AddCoefficients(BV_AddCoefficients493,21396
#define BV_SetValue(BV_SetValue494,21478
#define BV_SquareSum(BV_SquareSum495,21557
#define BV_ApplySignature(BV_ApplySignature496,21633
#define BV_SquareRoot(BV_SquareRoot497,21714
#define BV_StoreCoefficients(BV_StoreCoefficients498,21791

include/slepc/private/dsimpl.h,4440
dsimpl.h:^?dsimpl.h^A,1
#define SLEPCDSIMPL_HSLEPCDSIMPL_H12,428
SLEPC_EXTERN PetscBool DSRegisterAllCalled;DSRegisterAllCalled17,510
SLEPC_EXTERN PetscLogEvent DS_Solve,DS_Vectors,DS_Synchronize,DS_Other;DS_Solve19,603
SLEPC_EXTERN PetscLogEvent DS_Solve,DS_Vectors,DS_Synchronize,DS_Other;DS_Vectors19,603
SLEPC_EXTERN PetscLogEvent DS_Solve,DS_Vectors,DS_Synchronize,DS_Other;DS_Synchronize19,603
SLEPC_EXTERN PetscLogEvent DS_Solve,DS_Vectors,DS_Synchronize,DS_Other;DS_Other19,603
SLEPC_INTERN const char *DSMatName[];DSMatName20,675
typedef struct _DSOps *DSOps;DSOps22,714
struct _DSOps {_DSOps24,745
  PetscErrorCode (*allocate)(DS,PetscInt);allocate25,761
  PetscErrorCode (*view)(DS,PetscViewer);view26,804
  PetscErrorCode (*vectors)(DS,DSMatType,PetscInt*,PetscReal*);vectors27,846
  PetscErrorCode (*solve[DS_MAX_SOLVE])(DS,PetscScalar*,PetscScalar*);solve28,910
  PetscErrorCode (*sort)(DS,PetscScalar*,PetscScalar*,PetscScalar*,PetscScalar*,PetscInt*);sort29,981
  PetscErrorCode (*sortperm)(DS,PetscInt*,PetscScalar*,PetscScalar*);sortperm30,1073
  PetscErrorCode (*truncate)(DS,PetscInt);truncate31,1143
  PetscErrorCode (*update)(DS);update32,1186
  PetscErrorCode (*cond)(DS,PetscReal*);cond33,1218
  PetscErrorCode (*transharm)(DS,PetscScalar,PetscReal,PetscBool,PetscScalar*,PetscReal*);transharm34,1259
  PetscErrorCode (*transrks)(DS,PetscScalar);transrks35,1350
  PetscErrorCode (*destroy)(DS);destroy36,1396
  PetscErrorCode (*matgetsize)(DS,DSMatType,PetscInt*,PetscInt*);matgetsize37,1429
  PetscErrorCode (*hermitian)(DS,DSMatType,PetscBool*);hermitian38,1495
  PetscErrorCode (*synchronize)(DS,PetscScalar*,PetscScalar*);synchronize39,1551
struct _p_DS {_p_DS42,1618
  DSStateType    state;              /* the current state */state45,1738
  PetscInt       method;             /* identifies the variant to be used */method46,1799
  PetscBool      compact;            /* whether the matrices are stored in compact form */compact47,1876
  PetscBool      refined;            /* get refined vectors instead of regular vectors */refined48,1967
  PetscBool      extrarow;           /* assume the matrix dimension is (n+1) x n */extrarow49,2057
  PetscInt       ld;                 /* leading dimension */ld50,2141
  PetscInt       l;                  /* number of locked (inactive) leading columns */l51,2202
  PetscInt       n;                  /* current dimension */n52,2289
  PetscInt       m;                  /* current column dimension (for SVD only) */m53,2350
  PetscInt       k;                  /* intermediate dimension (e.g. position of arrow) */k54,2433
  PetscInt       t;                  /* length of decomposition when it was truncated */t55,2524
  PetscInt       bs;                 /* block size */bs56,2613
  SlepcSC        sc;                 /* sorting criterion */sc57,2667
  DSParallelType pmode;              /* parallel mode (redundant or synchronized) */pmode58,2728
  PetscScalar    *mat[DS_NUM_MAT];   /* the matrices */mat61,2889
  PetscReal      *rmat[DS_NUM_MAT];  /* the matrices (real) */rmat62,2945
  Mat            omat[DS_NUM_MAT];   /* the matrices (PETSc object) */omat63,3008
  PetscInt       *perm;              /* permutation */perm64,3079
  void           *data;              /* placeholder for solver-specific stuff */data65,3134
  PetscBool      scset;              /* the sc was provided by the user */scset66,3215
  PetscScalar    *work;work67,3290
  PetscReal      *rwork;rwork68,3314
  PetscBLASInt   *iwork;iwork69,3339
  PetscInt       lwork,lrwork,liwork;lwork70,3364
  PetscInt       lwork,lrwork,liwork;lrwork70,3364
  PetscInt       lwork,lrwork,liwork;liwork70,3364
#define DSCheckAlloc(DSCheckAlloc78,3481
#define DSCheckSolved(DSCheckSolved79,3525
#define DSCheckValidMat(DSCheckValidMat80,3570
#define DSCheckValidMatReal(DSCheckValidMatReal81,3620
#define DSCheckAlloc(DSCheckAlloc85,3682
#define DSCheckSolved(DSCheckSolved90,3872
#define DSCheckValidMat(DSCheckValidMat95,4081
#define DSCheckValidMatReal(DSCheckValidMatReal101,4423
PETSC_STATIC_INLINE PetscErrorCode DSAllocateMat_Private(DS ds,DSMatType m) {return DSAllocateMatrix_Private(ds,m,PETSC_FALSE);}DSAllocateMat_Private110,4856
PETSC_STATIC_INLINE PetscErrorCode DSAllocateMatReal_Private(DS ds,DSMatType m) {return DSAllocateMatrix_Private(ds,m,PETSC_TRUE);}DSAllocateMatReal_Private111,4985

include/slepc/private/epsimpl.h,8148
epsimpl.h:^?epsimpl.h^A,1
#define SLEPCEPSIMPL_HSLEPCEPSIMPL_H12,429
SLEPC_EXTERN PetscBool EPSRegisterAllCalled;EPSRegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent EPS_SetUp,EPS_Solve;EPS_SetUp19,608
SLEPC_EXTERN PetscLogEvent EPS_SetUp,EPS_Solve;EPS_Solve19,608
typedef struct _EPSOps *EPSOps;EPSOps21,657
struct _EPSOps {_EPSOps23,690
  PetscErrorCode (*solve)(EPS);solve24,707
  PetscErrorCode (*setup)(EPS);setup25,739
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,EPS);setfromoptions26,771
  PetscErrorCode (*publishoptions)(EPS);publishoptions27,830
  PetscErrorCode (*destroy)(EPS);destroy28,871
  PetscErrorCode (*reset)(EPS);reset29,905
  PetscErrorCode (*view)(EPS,PetscViewer);view30,937
  PetscErrorCode (*backtransform)(EPS);backtransform31,980
  PetscErrorCode (*computevectors)(EPS);computevectors32,1020
  PetscErrorCode (*setdefaultst)(EPS);setdefaultst33,1061
#define MAXEPSMONITORS MAXEPSMONITORS39,1170
typedef enum { EPS_STATE_INITIAL,EPS_STATE_INITIAL44,1254
               EPS_STATE_SETUP,EPS_STATE_SETUP45,1288
               EPS_STATE_SOLVED,EPS_STATE_SOLVED46,1320
               EPS_STATE_EIGENVECTORS } EPSStateType;EPS_STATE_EIGENVECTORS47,1353
               EPS_STATE_EIGENVECTORS } EPSStateType;EPSStateType47,1353
typedef enum { EPS_CATEGORY_KRYLOV,      /* Krylov solver: relies on STApply and STBackTransform (same as OTHER) */EPS_CATEGORY_KRYLOV52,1467
               EPS_CATEGORY_PRECOND,     /* Preconditioned solver: uses ST only to manage preconditioner */EPS_CATEGORY_PRECOND53,1583
               EPS_CATEGORY_CONTOUR,     /* Contour integral: ST used to solve linear systems at integration points */EPS_CATEGORY_CONTOUR54,1691
               EPS_CATEGORY_OTHER } EPSSolverType;EPS_CATEGORY_OTHER55,1810
               EPS_CATEGORY_OTHER } EPSSolverType;EPSSolverType55,1810
struct _p_EPS {_p_EPS60,1902
  PetscInt       max_it;           /* maximum number of iterations */max_it63,2025
  PetscInt       nev;              /* number of eigenvalues to compute */nev64,2095
  PetscInt       ncv;              /* number of basis vectors */ncv65,2169
  PetscInt       mpd;              /* maximum dimension of projected problem */mpd66,2234
  PetscInt       nini;             /* number of initial vectors (negative means not copied yet) */nini67,2314
  PetscInt       nds;              /* number of basis vectors of deflation space */nds68,2413
  PetscScalar    target;           /* target value */target69,2497
  PetscReal      tol;              /* tolerance */tol70,2551
  EPSConv        conv;             /* convergence test */conv71,2602
  EPSStop        stop;             /* stopping test */stop72,2660
  EPSWhich       which;            /* which part of the spectrum to be sought */which73,2715
  PetscReal      inta,intb;        /* interval [a,b] for spectrum slicing */inta74,2796
  PetscReal      inta,intb;        /* interval [a,b] for spectrum slicing */intb74,2796
  EPSProblemType problem_type;     /* which kind of problem to be solved */problem_type75,2873
  EPSExtraction  extraction;       /* which kind of extraction to be applied */extraction76,2949
  EPSBalance     balance;          /* the balancing method */balance77,3029
  PetscInt       balance_its;      /* number of iterations of the balancing method */balance_its78,3091
  PetscReal      balance_cutoff;   /* cutoff value for balancing */balance_cutoff79,3177
  PetscBool      trueres;          /* whether the true residual norm must be computed */trueres80,3245
  PetscBool      trackall;         /* whether all the residuals must be computed */trackall81,3334
  PetscBool      purify;           /* whether eigenvectors need to be purified */purify82,3418
  PetscBool      twosided;         /* whether to compute left eigenvectors (two-sided solver) */twosided83,3500
  PetscErrorCode (*converged)(EPS,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);converged86,3674
  PetscErrorCode (*convergeduser)(EPS,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);convergeduser87,3761
  PetscErrorCode (*convergeddestroy)(void*);convergeddestroy88,3852
  PetscErrorCode (*stopping)(EPS,PetscInt,PetscInt,PetscInt,PetscInt,EPSConvergedReason*,void*);stopping89,3897
  PetscErrorCode (*stoppinguser)(EPS,PetscInt,PetscInt,PetscInt,PetscInt,EPSConvergedReason*,void*);stoppinguser90,3994
  PetscErrorCode (*stoppingdestroy)(void*);stoppingdestroy91,4095
  PetscErrorCode (*arbitrary)(PetscScalar,PetscScalar,Vec,Vec,PetscScalar*,PetscScalar*,void*);arbitrary92,4139
  void           *convergedctx;convergedctx93,4235
  void           *stoppingctx;stoppingctx94,4267
  void           *arbitraryctx;arbitraryctx95,4298
  PetscErrorCode (*monitor[MAXEPSMONITORS])(EPS,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*);monitor96,4330
  PetscErrorCode (*monitordestroy[MAXEPSMONITORS])(void**);monitordestroy97,4450
  void           *monitorcontext[MAXEPSMONITORS];monitorcontext98,4510
  PetscInt       numbermonitors;numbermonitors99,4560
  ST             st;               /* spectral transformation object */st102,4669
  DS             ds;               /* direct solver object */ds103,4741
  DS             dsts;             /* auxiliary direct solver object used in two-sided case */dsts104,4803
  BV             V;                /* set of basis vectors and computed eigenvectors */V105,4898
  BV             W;                /* left basis vectors (if left eigenvectors requested) */W106,4986
  RG             rg;               /* optional region for filtering */rg107,5079
  SlepcSC        sc;               /* sorting criterion data */sc108,5150
  Vec            D;                /* diagonal matrix for balancing */D109,5214
  Vec            *IS;              /* references to user-provided initial space */IS110,5285
  Vec            *defl;            /* references to user-provided deflation space */defl111,5368
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigr112,5453
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigi112,5453
  PetscReal      *errest;          /* error estimates */errest113,5534
  PetscScalar    *rr,*ri;          /* values computed by user's arbitrary selection function */rr114,5591
  PetscScalar    *rr,*ri;          /* values computed by user's arbitrary selection function */ri114,5591
  PetscInt       *perm;            /* permutation for eigenvalue ordering */perm115,5687
  PetscInt       nwork;            /* number of work vectors */nwork116,5764
  Vec            *work;            /* work vectors */work117,5828
  void           *data;            /* placeholder for solver-specific stuff */data118,5882
  EPSStateType   state;            /* initial -> setup -> solved -> eigenvectors */state121,6037
  EPSSolverType  categ;            /* solver category */categ122,6121
  PetscInt       nconv;            /* number of converged eigenvalues */nconv123,6178
  PetscInt       its;              /* number of iterations so far computed */its124,6251
  PetscInt       n,nloc;           /* problem dimensions (global, local) */n125,6329
  PetscInt       n,nloc;           /* problem dimensions (global, local) */nloc125,6329
  PetscReal      nrma,nrmb;        /* computed matrix norms */nrma126,6405
  PetscReal      nrma,nrmb;        /* computed matrix norms */nrmb126,6405
  PetscBool      useds;            /* whether the solver uses the DS object or not */useds127,6468
  PetscBool      hasts;            /* whether the solver has two-sided variant */hasts128,6554
  PetscBool      isgeneralized;isgeneralized129,6636
  PetscBool      ispositive;ispositive130,6668
  PetscBool      ishermitian;ishermitian131,6697
  EPSConvergedReason reason;reason132,6727
#define EPSCheckSolved(EPSCheckSolved140,6836
#define EPSCheckSolved(EPSCheckSolved144,6890
PETSC_STATIC_INLINE PetscErrorCode EPS_SetInnerProduct(EPS eps)EPS_SetInnerProduct154,7184
PETSC_STATIC_INLINE PetscErrorCode EPS_Purify(EPS eps,PetscInt k)EPS_Purify174,7789

include/slepc/private/fnimpl.h,1722
fnimpl.h:^?fnimpl.h^A,1
#define SLEPCFNIMPL_HSLEPCFNIMPL_H12,428
SLEPC_EXTERN PetscBool FNRegisterAllCalled;FNRegisterAllCalled17,510
SLEPC_EXTERN PetscLogEvent FN_Evaluate;FN_Evaluate19,603
typedef struct _FNOps *FNOps;FNOps21,644
struct _FNOps {_FNOps23,675
  PetscErrorCode (*evaluatefunction)(FN,PetscScalar,PetscScalar*);evaluatefunction24,691
  PetscErrorCode (*evaluatederivative)(FN,PetscScalar,PetscScalar*);evaluatederivative25,758
  PetscErrorCode (*evaluatefunctionmat[FN_MAX_SOLVE])(FN,Mat,Mat);evaluatefunctionmat26,827
  PetscErrorCode (*evaluatefunctionmatvec[FN_MAX_SOLVE])(FN,Mat,Vec);evaluatefunctionmatvec27,894
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,FN);setfromoptions28,964
  PetscErrorCode (*view)(FN,PetscViewer);view29,1022
  PetscErrorCode (*duplicate)(FN,MPI_Comm,FN*);duplicate30,1064
  PetscErrorCode (*destroy)(FN);destroy31,1112
#define FN_MAX_W FN_MAX_W34,1149
struct _p_FN {_p_FN36,1169
  PetscScalar    alpha;          /* inner scaling (argument) */alpha39,1289
  PetscScalar    beta;           /* outer scaling (result) */beta40,1353
  PetscInt       method;         /* the method to compute matrix functions */method41,1415
  FNParallelType pmode;          /* parallel mode (redundant or synchronized) */pmode42,1493
  Mat            W[FN_MAX_W];    /* workspace matrices */W45,1650
  PetscInt       nw;             /* number of allocated W matrices */nw46,1708
  PetscInt       cw;             /* current W matrix */cw47,1778
  void           *data;data48,1834
PETSC_STATIC_INLINE PetscErrorCode FN_AllocateWorkMat(FN fn,Mat A,Mat *M)FN_AllocateWorkMat56,2041
PETSC_STATIC_INLINE PetscErrorCode FN_FreeWorkMat(FN fn,Mat *M)FN_FreeWorkMat90,3046

include/slepc/private/lmeimpl.h,2959
lmeimpl.h:^?lmeimpl.h^A,1
#define SLEPCLMEIMPL_HSLEPCLMEIMPL_H12,429
SLEPC_EXTERN PetscBool LMERegisterAllCalled;LMERegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent LME_SetUp,LME_Solve,LME_ComputeError;LME_SetUp19,608
SLEPC_EXTERN PetscLogEvent LME_SetUp,LME_Solve,LME_ComputeError;LME_Solve19,608
SLEPC_EXTERN PetscLogEvent LME_SetUp,LME_Solve,LME_ComputeError;LME_ComputeError19,608
typedef struct _LMEOps *LMEOps;LMEOps21,674
struct _LMEOps {_LMEOps23,707
  PetscErrorCode (*solve[sizeof(LMEProblemType)])(LME);solve24,724
  PetscErrorCode (*setup)(LME);setup25,780
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,LME);setfromoptions26,812
  PetscErrorCode (*publishoptions)(LME);publishoptions27,871
  PetscErrorCode (*destroy)(LME);destroy28,912
  PetscErrorCode (*reset)(LME);reset29,946
  PetscErrorCode (*view)(LME,PetscViewer);view30,978
#define MAXLMEMONITORS MAXLMEMONITORS36,1093
struct _p_LME {_p_LME41,1160
  Mat            A,B,D,E;        /* the coefficient matrices */A44,1283
  Mat            A,B,D,E;        /* the coefficient matrices */B44,1283
  Mat            A,B,D,E;        /* the coefficient matrices */D44,1283
  Mat            A,B,D,E;        /* the coefficient matrices */E44,1283
  Mat            C;              /* the right-hand side */C45,1347
  Mat            X;              /* the solution */X46,1406
  LMEProblemType problem_type;   /* which kind of equation to be solved */problem_type47,1458
  PetscInt       max_it;         /* maximum number of iterations */max_it48,1533
  PetscInt       ncv;            /* number of basis vectors */ncv49,1601
  PetscReal      tol;            /* tolerance */tol50,1664
  PetscBool      errorifnotconverged;    /* error out if LMESolve() does not converge */errorifnotconverged51,1713
  PetscErrorCode (*monitor[MAXLMEMONITORS])(LME,PetscInt,PetscReal,void*);monitor54,1879
  PetscErrorCode (*monitordestroy[MAXLMEMONITORS])(void**);monitordestroy55,1954
  void           *monitorcontext[MAXLMEMONITORS];monitorcontext56,2014
  PetscInt       numbermonitors;numbermonitors57,2064
  BV             V;              /* set of basis vectors */V60,2173
  PetscInt       nwork;          /* number of work vectors */nwork61,2233
  Vec            *work;          /* work vectors */work62,2295
  void           *data;          /* placeholder for solver-specific stuff */data63,2347
  PetscInt       its;            /* number of iterations so far computed */its66,2501
  PetscReal      errest;         /* error estimate */errest67,2577
  PetscInt       setupcalled;setupcalled68,2631
  LMEConvergedReason reason;reason69,2661
#define LMECheckCoeff(LMECheckCoeff79,2861
#define LMECheckCoeff(LMECheckCoeff83,2919
#define SLEPC_SLICOT(SLEPC_SLICOT94,3257
#define SLEPC_SLICOT(SLEPC_SLICOT96,3376
#define SLEPC_SLICOT(SLEPC_SLICOT98,3422
#define SLICOTsb03od_(SLICOTsb03od_102,3509
#define SLICOTsb03od_(SLICOTsb03od_105,3984

include/slepc/private/makefile,328
makefile:^?makefile^A,1
CFLAGS   =CFLAGS11,399
FFLAGS   =FFLAGS12,410
SOURCEC  =SOURCEC13,421
SOURCEF  =SOURCEF14,432
SOURCEH  = epsimpl.h stimpl.h svdimpl.h pepimpl.h nepimpl.h vecimplslepc.h \SOURCEH15,443
LIBBASE  = libslepcsysLIBBASE17,599
DIRS     =DIRS18,622
LOCDIR   = include/slepc/private/LOCDIR19,633
MANSEC   =MANSEC20,667

include/slepc/private/mfnimpl.h,2511
mfnimpl.h:^?mfnimpl.h^A,1
#define SLEPCMFNIMPL_HSLEPCMFNIMPL_H12,429
SLEPC_EXTERN PetscBool MFNRegisterAllCalled;MFNRegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent MFN_SetUp, MFN_Solve;MFN_SetUp19,608
SLEPC_EXTERN PetscLogEvent MFN_SetUp, MFN_Solve;MFN_Solve19,608
typedef struct _MFNOps *MFNOps;MFNOps21,658
struct _MFNOps {_MFNOps23,691
  PetscErrorCode (*solve)(MFN,Vec,Vec);solve24,708
  PetscErrorCode (*setup)(MFN);setup25,748
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,MFN);setfromoptions26,780
  PetscErrorCode (*publishoptions)(MFN);publishoptions27,839
  PetscErrorCode (*destroy)(MFN);destroy28,880
  PetscErrorCode (*reset)(MFN);reset29,914
  PetscErrorCode (*view)(MFN,PetscViewer);view30,946
#define MAXMFNMONITORS MAXMFNMONITORS36,1061
struct _p_MFN {_p_MFN41,1128
  Mat            A;              /* the problem matrix */A44,1251
  FN             fn;             /* which function to compute */fn45,1309
  PetscInt       max_it;         /* maximum number of iterations */max_it46,1374
  PetscInt       ncv;            /* number of basis vectors */ncv47,1442
  PetscReal      tol;            /* tolerance */tol48,1505
  PetscBool      errorifnotconverged;    /* error out if MFNSolve() does not converge */errorifnotconverged49,1554
  PetscErrorCode (*monitor[MAXMFNMONITORS])(MFN,PetscInt,PetscReal,void*);monitor52,1720
  PetscErrorCode (*monitordestroy[MAXMFNMONITORS])(void**);monitordestroy53,1795
  void           *monitorcontext[MAXMFNMONITORS];monitorcontext54,1855
  PetscInt       numbermonitors;numbermonitors55,1905
  BV             V;              /* set of basis vectors */V58,2014
  PetscInt       nwork;          /* number of work vectors */nwork59,2074
  Vec            *work;          /* work vectors */work60,2136
  void           *data;          /* placeholder for solver-specific stuff */data61,2188
  PetscInt       its;            /* number of iterations so far computed */its64,2342
  PetscInt       nv;             /* size of current Schur decomposition */nv65,2418
  PetscReal      errest;         /* error estimate */errest66,2493
  PetscReal      bnorm;          /* computed norm of right-hand side in current solve */bnorm67,2547
  PetscInt       setupcalled;setupcalled68,2636
  MFNConvergedReason reason;reason69,2666
PETSC_STATIC_INLINE PetscErrorCode MFN_CreateDenseMat(PetscInt k,Mat *A)MFN_CreateDenseMat75,2791
PETSC_STATIC_INLINE PetscErrorCode MFN_CreateVec(PetscInt k,Vec *v)MFN_CreateVec99,3360

include/slepc/private/nepimpl.h,8324
nepimpl.h:^?nepimpl.h^A,1
#define SLEPCNEPIMPL_HSLEPCNEPIMPL_H12,429
SLEPC_EXTERN PetscBool NEPRegisterAllCalled;NEPRegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_SetUp19,608
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_Solve19,608
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_Refine19,608
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_FunctionEval19,608
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_JacobianEval19,608
SLEPC_EXTERN PetscLogEvent NEP_SetUp,NEP_Solve,NEP_Refine,NEP_FunctionEval,NEP_JacobianEval,NEP_Resolvent;NEP_Resolvent19,608
typedef struct _NEPOps *NEPOps;NEPOps21,716
struct _NEPOps {_NEPOps23,749
  PetscErrorCode (*solve)(NEP);solve24,766
  PetscErrorCode (*setup)(NEP);setup25,798
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,NEP);setfromoptions26,830
  PetscErrorCode (*publishoptions)(NEP);publishoptions27,889
  PetscErrorCode (*destroy)(NEP);destroy28,930
  PetscErrorCode (*reset)(NEP);reset29,964
  PetscErrorCode (*view)(NEP,PetscViewer);view30,996
  PetscErrorCode (*computevectors)(NEP);computevectors31,1039
#define MAXNEPMONITORS MAXNEPMONITORS37,1152
typedef enum { NEP_STATE_INITIAL,NEP_STATE_INITIAL39,1178
               NEP_STATE_SETUP,NEP_STATE_SETUP40,1212
               NEP_STATE_SOLVED,NEP_STATE_SOLVED41,1244
               NEP_STATE_EIGENVECTORS } NEPStateType;NEP_STATE_EIGENVECTORS42,1277
               NEP_STATE_EIGENVECTORS } NEPStateType;NEPStateType42,1277
typedef enum { NEP_USER_INTERFACE_CALLBACK=1,NEP_USER_INTERFACE_CALLBACK49,1547
               NEP_USER_INTERFACE_SPLIT } NEPUserInterface;NEP_USER_INTERFACE_SPLIT50,1593
               NEP_USER_INTERFACE_SPLIT } NEPUserInterface;NEPUserInterface50,1593
struct _p_NEP {_p_NEP55,1695
  PetscInt       max_it;           /* maximum number of iterations */max_it58,1818
  PetscInt       nev;              /* number of eigenvalues to compute */nev59,1888
  PetscInt       ncv;              /* number of basis vectors */ncv60,1962
  PetscInt       mpd;              /* maximum dimension of projected problem */mpd61,2027
  PetscInt       nini;             /* number of initial vectors (negative means not copied yet) */nini62,2107
  PetscScalar    target;           /* target value */target63,2206
  PetscReal      tol;              /* tolerance */tol64,2260
  NEPConv        conv;             /* convergence test */conv65,2311
  NEPStop        stop;             /* stopping test */stop66,2369
  NEPWhich       which;            /* which part of the spectrum to be sought */which67,2424
  NEPProblemType problem_type;     /* which kind of problem to be solved */problem_type68,2505
  NEPRefine      refine;           /* type of refinement to be applied after solve */refine69,2581
  PetscInt       npart;            /* number of partitions of the communicator */npart70,2667
  PetscReal      rtol;             /* tolerance for refinement */rtol71,2749
  PetscInt       rits;             /* number of iterations of the refinement method */rits72,2815
  NEPRefineScheme scheme;          /* scheme for solving linear systems within refinement */scheme73,2902
  PetscBool      trackall;         /* whether all the residuals must be computed */trackall74,2995
  PetscBool      twosided;         /* whether to compute left eigenvectors (two-sided solver) */twosided75,3079
  PetscErrorCode (*computefunction)(NEP,PetscScalar,Mat,Mat,void*);computefunction78,3253
  PetscErrorCode (*computejacobian)(NEP,PetscScalar,Mat,void*);computejacobian79,3321
  void           *functionctx;functionctx80,3385
  void           *jacobianctx;jacobianctx81,3416
  PetscErrorCode (*converged)(NEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);converged82,3447
  PetscErrorCode (*convergeduser)(NEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);convergeduser83,3534
  PetscErrorCode (*convergeddestroy)(void*);convergeddestroy84,3625
  PetscErrorCode (*stopping)(NEP,PetscInt,PetscInt,PetscInt,PetscInt,NEPConvergedReason*,void*);stopping85,3670
  PetscErrorCode (*stoppinguser)(NEP,PetscInt,PetscInt,PetscInt,PetscInt,NEPConvergedReason*,void*);stoppinguser86,3767
  PetscErrorCode (*stoppingdestroy)(void*);stoppingdestroy87,3868
  void           *convergedctx;convergedctx88,3912
  void           *stoppingctx;stoppingctx89,3944
  PetscErrorCode (*monitor[MAXNEPMONITORS])(NEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*);monitor90,3975
  PetscErrorCode (*monitordestroy[MAXNEPMONITORS])(void**);monitordestroy91,4095
  void           *monitorcontext[MAXNEPMONITORS];monitorcontext92,4155
  PetscInt       numbermonitors;numbermonitors93,4205
  DS             ds;               /* direct solver object */ds96,4314
  BV             V;                /* set of basis vectors and computed eigenvectors */V97,4376
  BV             W;                /* left basis vectors (if left eigenvectors requested) */W98,4464
  RG             rg;               /* optional region for filtering */rg99,4557
  SlepcSC        sc;               /* sorting criterion data */sc100,4628
  Mat            function;         /* function matrix */function101,4692
  Mat            function_pre;     /* function matrix (preconditioner) */function_pre102,4749
  Mat            jacobian;         /* Jacobian matrix */jacobian103,4823
  Mat            *A;               /* matrix coefficients of split form */A104,4880
  FN             *f;               /* matrix functions of split form */f105,4955
  PetscInt       nt;               /* number of terms in split form */nt106,5027
  MatStructure   mstr;             /* pattern of split matrices */mstr107,5098
  Vec            *IS;              /* references to user-provided initial space */IS108,5165
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigr109,5248
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigi109,5248
  PetscReal      *errest;          /* error estimates */errest110,5329
  PetscInt       *perm;            /* permutation for eigenvalue ordering */perm111,5386
  PetscInt       nwork;            /* number of work vectors */nwork112,5463
  Vec            *work;            /* work vectors */work113,5527
  KSP            refineksp;        /* ksp used in refinement */refineksp114,5581
  PetscSubcomm   refinesubc;       /* context for sub-communicators */refinesubc115,5645
  void           *data;            /* placeholder for solver-specific stuff */data116,5716
  NEPStateType   state;            /* initial -> setup -> solved -> eigenvectors */state119,5871
  PetscInt       nconv;            /* number of converged eigenvalues */nconv120,5955
  PetscInt       its;              /* number of iterations so far computed */its121,6028
  PetscInt       n,nloc;           /* problem dimensions (global, local) */n122,6106
  PetscInt       n,nloc;           /* problem dimensions (global, local) */nloc122,6106
  PetscReal      *nrma;            /* computed matrix norms */nrma123,6182
  NEPUserInterface fui;            /* how the user has defined the nonlinear operator */fui124,6245
  PetscBool      useds;            /* whether the solver uses the DS object or not */useds125,6334
  PetscBool      hasts;            /* whether the solver has two-sided variant */hasts126,6420
  Mat            resolvent;        /* shell matrix to be used in NEPApplyResolvent */resolvent127,6502
  NEPConvergedReason reason;reason128,6588
#define NEPCheckProblem(NEPCheckProblem136,6697
#define NEPCheckCallback(NEPCheckCallback137,6744
#define NEPCheckSplit(NEPCheckSplit138,6792
#define NEPCheckDerivatives(NEPCheckDerivatives139,6837
#define NEPCheckSolved(NEPCheckSolved140,6888
#define NEPCheckProblem(NEPCheckProblem144,6942
#define NEPCheckCallback(NEPCheckCallback149,7163
#define NEPCheckSplit(NEPCheckSplit154,7433
#define NEPCheckSolved(NEPCheckSolved159,7686

include/slepc/private/pepimpl.h,7595
pepimpl.h:^?pepimpl.h^A,1
#define SLEPCPEPIMPL_HSLEPCPEPIMPL_H12,429
SLEPC_EXTERN PetscBool PEPRegisterAllCalled;PEPRegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent PEP_SetUp,PEP_Solve,PEP_Refine;PEP_SetUp19,608
SLEPC_EXTERN PetscLogEvent PEP_SetUp,PEP_Solve,PEP_Refine;PEP_Solve19,608
SLEPC_EXTERN PetscLogEvent PEP_SetUp,PEP_Solve,PEP_Refine;PEP_Refine19,608
typedef struct _PEPOps *PEPOps;PEPOps21,668
struct _PEPOps {_PEPOps23,701
  PetscErrorCode (*solve)(PEP);solve24,718
  PetscErrorCode (*setup)(PEP);setup25,750
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,PEP);setfromoptions26,782
  PetscErrorCode (*publishoptions)(PEP);publishoptions27,841
  PetscErrorCode (*destroy)(PEP);destroy28,882
  PetscErrorCode (*reset)(PEP);reset29,916
  PetscErrorCode (*view)(PEP,PetscViewer);view30,948
  PetscErrorCode (*backtransform)(PEP);backtransform31,991
  PetscErrorCode (*computevectors)(PEP);computevectors32,1031
  PetscErrorCode (*extractvectors)(PEP);extractvectors33,1072
  PetscErrorCode (*setdefaultst)(PEP);setdefaultst34,1113
#define MAXPEPMONITORS MAXPEPMONITORS40,1224
typedef enum { PEP_STATE_INITIAL,PEP_STATE_INITIAL42,1250
               PEP_STATE_SETUP,PEP_STATE_SETUP43,1284
               PEP_STATE_SOLVED,PEP_STATE_SOLVED44,1316
               PEP_STATE_EIGENVECTORS } PEPStateType;PEP_STATE_EIGENVECTORS45,1349
               PEP_STATE_EIGENVECTORS } PEPStateType;PEPStateType45,1349
struct _p_PEP {_p_PEP50,1445
  PetscInt       max_it;           /* maximum number of iterations */max_it53,1568
  PetscInt       nev;              /* number of eigenvalues to compute */nev54,1638
  PetscInt       ncv;              /* number of basis vectors */ncv55,1712
  PetscInt       mpd;              /* maximum dimension of projected problem */mpd56,1777
  PetscInt       nini;             /* number of initial vectors (negative means not copied yet) */nini57,1857
  PetscScalar    target;           /* target value */target58,1956
  PetscReal      tol;              /* tolerance */tol59,2010
  PEPConv        conv;             /* convergence test */conv60,2061
  PEPStop        stop;             /* stopping test */stop61,2119
  PEPWhich       which;            /* which part of the spectrum to be sought */which62,2174
  PetscReal      inta,intb;        /* interval [a,b] for spectrum slicing */inta63,2255
  PetscReal      inta,intb;        /* interval [a,b] for spectrum slicing */intb63,2255
  PEPBasis       basis;            /* polynomial basis used to represent the problem */basis64,2332
  PEPProblemType problem_type;     /* which kind of problem to be solved */problem_type65,2420
  PEPScale       scale;            /* scaling strategy to be used */scale66,2496
  PetscReal      sfactor,dsfactor; /* scaling factors */sfactor67,2565
  PetscReal      sfactor,dsfactor; /* scaling factors */dsfactor67,2565
  PetscInt       sits;             /* number of iterations of the scaling method */sits68,2622
  PetscReal      slambda;          /* norm eigenvalue approximation for scaling */slambda69,2706
  PEPRefine      refine;           /* type of refinement to be applied after solve */refine70,2789
  PetscInt       npart;            /* number of partitions of the communicator */npart71,2875
  PetscReal      rtol;             /* tolerance for refinement */rtol72,2957
  PetscInt       rits;             /* number of iterations of the refinement method */rits73,3023
  PEPRefineScheme scheme;          /* scheme for solving linear systems within refinement */scheme74,3110
  PEPExtract     extract;          /* type of extraction used */extract75,3203
  PetscBool      trackall;         /* whether all the residuals must be computed */trackall76,3268
  PetscErrorCode (*converged)(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);converged79,3429
  PetscErrorCode (*convergeduser)(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);convergeduser80,3516
  PetscErrorCode (*convergeddestroy)(void*);convergeddestroy81,3607
  PetscErrorCode (*stopping)(PEP,PetscInt,PetscInt,PetscInt,PetscInt,PEPConvergedReason*,void*);stopping82,3652
  PetscErrorCode (*stoppinguser)(PEP,PetscInt,PetscInt,PetscInt,PetscInt,PEPConvergedReason*,void*);stoppinguser83,3749
  PetscErrorCode (*stoppingdestroy)(void*);stoppingdestroy84,3850
  void           *convergedctx;convergedctx85,3894
  void           *stoppingctx;stoppingctx86,3926
  PetscErrorCode (*monitor[MAXPEPMONITORS])(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*);monitor87,3957
  PetscErrorCode (*monitordestroy[MAXPEPMONITORS])(void**);monitordestroy88,4077
  void           *monitorcontext[MAXPEPMONITORS];monitorcontext89,4137
  PetscInt        numbermonitors;numbermonitors90,4187
  ST             st;               /* spectral transformation object */st93,4297
  DS             ds;               /* direct solver object */ds94,4369
  BV             V;                /* set of basis vectors and computed eigenvectors */V95,4431
  RG             rg;               /* optional region for filtering */rg96,4519
  SlepcSC        sc;               /* sorting criterion data */sc97,4590
  Mat            *A;               /* coefficient matrices of the polynomial */A98,4654
  PetscInt       nmat;             /* number of matrices */nmat99,4734
  Vec            Dl,Dr;            /* diagonal matrices for balancing */Dl100,4794
  Vec            Dl,Dr;            /* diagonal matrices for balancing */Dr100,4794
  Vec            *IS;              /* references to user-provided initial space */IS101,4867
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigr102,4950
  PetscScalar    *eigr,*eigi;      /* real and imaginary parts of eigenvalues */eigi102,4950
  PetscReal      *errest;          /* error estimates */errest103,5031
  PetscInt       *perm;            /* permutation for eigenvalue ordering */perm104,5088
  PetscReal      *pbc;             /* coefficients defining the polynomial basis */pbc105,5165
  PetscScalar    *solvematcoeffs;  /* coefficients to compute the matrix to be inverted */solvematcoeffs106,5249
  PetscInt       nwork;            /* number of work vectors */nwork107,5340
  Vec            *work;            /* work vectors */work108,5404
  KSP            refineksp;        /* ksp used in refinement */refineksp109,5458
  PetscSubcomm   refinesubc;       /* context for sub-communicators */refinesubc110,5522
  void           *data;            /* placeholder for solver-specific stuff */data111,5593
  PEPStateType   state;            /* initial -> setup -> solved -> eigenvectors */state114,5748
  PetscInt       nconv;            /* number of converged eigenvalues */nconv115,5832
  PetscInt       its;              /* number of iterations so far computed */its116,5905
  PetscInt       n,nloc;           /* problem dimensions (global, local) */n117,5983
  PetscInt       n,nloc;           /* problem dimensions (global, local) */nloc117,5983
  PetscReal      *nrma;            /* computed matrix norms */nrma118,6059
  PetscReal      nrml[2];          /* computed matrix norms for the linearization */nrml119,6122
  PetscBool      sfactor_set;      /* flag to indicate the user gave sfactor */sfactor_set120,6207
  PetscBool      lineariz;         /* current solver is based on linearization */lineariz121,6287
  PEPConvergedReason reason;reason122,6369
#define PEPCheckSolved(PEPCheckSolved130,6478
#define PEPCheckSolved(PEPCheckSolved134,6532

include/slepc/private/rgimpl.h,1075
rgimpl.h:^?rgimpl.h^A,1
#define SLEPCRGIMPL_HSLEPCRGIMPL_H12,428
SLEPC_EXTERN PetscBool RGRegisterAllCalled;RGRegisterAllCalled17,510
typedef struct _RGOps *RGOps;RGOps20,604
struct _RGOps {_RGOps22,635
  PetscErrorCode (*istrivial)(RG,PetscBool*);istrivial23,651
  PetscErrorCode (*computecontour)(RG,PetscInt,PetscScalar*,PetscScalar*);computecontour24,697
  PetscErrorCode (*computebbox)(RG,PetscReal*,PetscReal*,PetscReal*,PetscReal*);computebbox25,772
  PetscErrorCode (*checkinside)(RG,PetscReal,PetscReal,PetscInt*);checkinside26,853
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,RG);setfromoptions27,920
  PetscErrorCode (*view)(RG,PetscViewer);view28,978
  PetscErrorCode (*destroy)(RG);destroy29,1020
struct _p_RG {_p_RG32,1057
  PetscBool   complement;    /* region is the complement of the specified one */complement34,1102
  PetscReal   sfactor;       /* scaling factor */sfactor35,1183
  PetscReal   osfactor;      /* old scaling factor, before RGPushScale */osfactor36,1233
  void        *data;data37,1307
#define RGShowReal(RGShowReal41,1376

include/slepc/private/slepcimpl.h,494
slepcimpl.h:^?slepcimpl.h^A,1
#define SLEPCIMPL_HSLEPCIMPL_H12,426
SLEPC_INTERN PetscBool SlepcBeganPetsc;SlepcBeganPetsc17,507
#define SlepcHeaderCreate(SlepcHeaderCreate40,1192
struct _n_SlepcConvMonitor {_n_SlepcConvMonitor47,1610
  PetscViewer       viewer;viewer48,1639
  PetscViewerFormat format;format49,1667
  PetscInt          oldnconv;oldnconv50,1695
PETSC_STATIC_INLINE PetscErrorCode SlepcPrintEigenvalueASCII(PetscViewer viewer,PetscScalar eigr,PetscScalar eigi)SlepcPrintEigenvalueASCII56,1805

include/slepc/private/stimpl.h,4339
stimpl.h:^?stimpl.h^A,1
#define SLEPCSTIMPL_HSLEPCSTIMPL_H12,428
SLEPC_EXTERN PetscBool STRegisterAllCalled;STRegisterAllCalled17,510
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_SetUp19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_Apply19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_ApplyTranspose19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_MatSetUp19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_MatMult19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_MatMultTranspose19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_MatSolve19,603
SLEPC_EXTERN PetscLogEvent ST_SetUp,ST_Apply,ST_ApplyTranspose,ST_MatSetUp,ST_MatMult,ST_MatMultTranspose,ST_MatSolve,ST_MatSolveTranspose;ST_MatSolveTranspose19,603
typedef struct _STOps *STOps;STOps21,744
struct _STOps {_STOps23,775
  PetscErrorCode (*setup)(ST);setup24,791
  PetscErrorCode (*apply)(ST,Vec,Vec);apply25,822
  PetscErrorCode (*getbilinearform)(ST,Mat*);getbilinearform26,861
  PetscErrorCode (*applytrans)(ST,Vec,Vec);applytrans27,907
  PetscErrorCode (*setshift)(ST,PetscScalar);setshift28,951
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,ST);setfromoptions29,997
  PetscErrorCode (*postsolve)(ST);postsolve30,1055
  PetscErrorCode (*backtransform)(ST,PetscInt,PetscScalar*,PetscScalar*);backtransform31,1090
  PetscErrorCode (*destroy)(ST);destroy32,1164
  PetscErrorCode (*reset)(ST);reset33,1197
  PetscErrorCode (*view)(ST,PetscViewer);view34,1228
  PetscErrorCode (*checknullspace)(ST,BV);checknullspace35,1270
  PetscErrorCode (*setdefaultksp)(ST);setdefaultksp36,1313
typedef enum { ST_STATE_INITIAL,ST_STATE_INITIAL43,1519
               ST_STATE_SETUP,ST_STATE_SETUP44,1552
               ST_STATE_UPDATED } STStateType;ST_STATE_UPDATED45,1583
               ST_STATE_UPDATED } STStateType;STStateType45,1583
struct _p_ST {_p_ST47,1631
  Mat              *A;               /* matrices that define the eigensystem */A50,1751
  PetscInt         nmat;             /* number of user-provided matrices */nmat51,1831
  PetscScalar      sigma;            /* value of the shift */sigma52,1907
  PetscScalar      defsigma;         /* default value of the shift */defsigma53,1969
  STMatMode        matmode;          /* how the transformation matrix is handled */matmode54,2039
  MatStructure     str;              /* whether matrices have the same pattern or not */str55,2123
  PetscBool        transform;        /* whether transformed matrices are computed */transform56,2212
  Vec              D;                /* diagonal matrix for balancing */D57,2297
  KSP              ksp;              /* linear solver used in some ST's */ksp60,2440
  PetscBool        usesksp;          /* whether the KSP object is used or not */usesksp61,2515
  PetscInt         nwork;            /* number of work vectors */nwork62,2596
  Vec              *work;            /* work vectors */work63,2662
  Vec              wb;               /* balancing requires an extra work vector */wb64,2718
  STStateType      state;            /* initial -> setup -> with updated matrices */state65,2801
  PetscObjectState *Astate;          /* matrix state (to identify the original matrices) */Astate66,2886
  Mat              *T;               /* matrices resulting from transformation */T67,2978
  Mat              P;                /* matrix from which preconditioner is built */P68,3060
  PetscBool        sigma_set;        /* whether the user provided the shift or not */sigma_set69,3145
  void             *data;data70,3231
#define STCheckMatrices(STCheckMatrices78,3336
#define STCheckMatrices(STCheckMatrices82,3391

include/slepc/private/svdimpl.h,5173
svdimpl.h:^?svdimpl.h^A,1
#define SLEPCSVDIMPL_HSLEPCSVDIMPL_H12,429
SLEPC_EXTERN PetscBool SVDRegisterAllCalled;SVDRegisterAllCalled17,513
SLEPC_EXTERN PetscLogEvent SVD_SetUp,SVD_Solve;SVD_SetUp19,608
SLEPC_EXTERN PetscLogEvent SVD_SetUp,SVD_Solve;SVD_Solve19,608
typedef struct _SVDOps *SVDOps;SVDOps21,657
struct _SVDOps {_SVDOps23,690
  PetscErrorCode (*solve)(SVD);solve24,707
  PetscErrorCode (*setup)(SVD);setup25,739
  PetscErrorCode (*setfromoptions)(PetscOptionItems*,SVD);setfromoptions26,771
  PetscErrorCode (*publishoptions)(SVD);publishoptions27,830
  PetscErrorCode (*destroy)(SVD);destroy28,871
  PetscErrorCode (*reset)(SVD);reset29,905
  PetscErrorCode (*view)(SVD,PetscViewer);view30,937
#define MAXSVDMONITORS MAXSVDMONITORS36,1052
typedef enum { SVD_STATE_INITIAL,SVD_STATE_INITIAL38,1078
               SVD_STATE_SETUP,SVD_STATE_SETUP39,1112
               SVD_STATE_SOLVED,SVD_STATE_SOLVED40,1144
               SVD_STATE_VECTORS } SVDStateType;SVD_STATE_VECTORS41,1177
               SVD_STATE_VECTORS } SVDStateType;SVDStateType41,1177
struct _p_SVD {_p_SVD46,1268
  Mat            OP;               /* problem matrix */OP49,1391
  PetscInt       max_it;           /* max iterations */max_it50,1447
  PetscInt       nsv;              /* number of requested values */nsv51,1503
  PetscInt       ncv;              /* basis size */ncv52,1571
  PetscInt       mpd;              /* maximum dimension of projected problem */mpd53,1623
  PetscInt       nini,ninil;       /* number of initial vecs (negative means not copied yet) */nini54,1703
  PetscInt       nini,ninil;       /* number of initial vecs (negative means not copied yet) */ninil54,1703
  PetscReal      tol;              /* tolerance */tol55,1799
  SVDConv        conv;             /* convergence test */conv56,1850
  SVDStop        stop;             /* stopping test */stop57,1908
  SVDWhich       which;            /* which singular values are computed */which58,1963
  PetscBool      impltrans;        /* implicit transpose mode */impltrans59,2039
  PetscBool      trackall;         /* whether all the residuals must be computed */trackall60,2104
  PetscErrorCode (*converged)(SVD,PetscReal,PetscReal,PetscReal*,void*);converged63,2265
  PetscErrorCode (*convergeduser)(SVD,PetscReal,PetscReal,PetscReal*,void*);convergeduser64,2338
  PetscErrorCode (*convergeddestroy)(void*);convergeddestroy65,2415
  PetscErrorCode (*stopping)(SVD,PetscInt,PetscInt,PetscInt,PetscInt,SVDConvergedReason*,void*);stopping66,2460
  PetscErrorCode (*stoppinguser)(SVD,PetscInt,PetscInt,PetscInt,PetscInt,SVDConvergedReason*,void*);stoppinguser67,2557
  PetscErrorCode (*stoppingdestroy)(void*);stoppingdestroy68,2658
  void           *convergedctx;convergedctx69,2702
  void           *stoppingctx;stoppingctx70,2734
  PetscErrorCode (*monitor[MAXSVDMONITORS])(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*);monitor71,2765
  PetscErrorCode (*monitordestroy[MAXSVDMONITORS])(void**);monitordestroy72,2870
  void           *monitorcontext[MAXSVDMONITORS];monitorcontext73,2930
  PetscInt       numbermonitors;numbermonitors74,2980
  DS             ds;               /* direct solver object */ds77,3089
  BV             U,V;              /* left and right singular vectors */U78,3151
  BV             U,V;              /* left and right singular vectors */V78,3151
  SlepcSC        sc;               /* sorting criterion data */sc79,3224
  Mat            A;                /* problem matrix (m>n) */A80,3288
  Mat            AT;               /* transposed matrix */AT81,3350
  Vec            *IS,*ISL;         /* placeholder for references to user initial space */IS82,3409
  Vec            *IS,*ISL;         /* placeholder for references to user initial space */ISL82,3409
  PetscReal      *sigma;           /* singular values */sigma83,3499
  PetscInt       *perm;            /* permutation for singular value ordering */perm84,3556
  PetscReal      *errest;          /* error estimates */errest85,3637
  void           *data;            /* placeholder for solver-specific stuff */data86,3694
  SVDStateType   state;            /* initial -> setup -> solved -> vectors */state89,3850
  PetscInt       nconv;            /* number of converged values */nconv90,3929
  PetscInt       its;              /* iteration counter */its91,3997
  PetscBool      leftbasis;        /* if U is filled by the solver */leftbasis92,4056
  SVDConvergedReason reason;reason93,4126
#define SVDCheckSolved(SVDCheckSolved101,4235
#define SVDCheckSolved(SVDCheckSolved105,4289
PETSC_STATIC_INLINE PetscErrorCode SVDMatMult(SVD svd,PetscBool trans,Vec x,Vec y)SVDMatMult112,4506
PETSC_STATIC_INLINE PetscErrorCode SVDMatCreateVecs(SVD svd,Vec *x,Vec *y)SVDMatCreateVecs141,5204
PETSC_STATIC_INLINE PetscErrorCode SVDMatCreateVecsEmpty(SVD svd,Vec *x,Vec *y)SVDMatCreateVecsEmpty154,5492
PETSC_STATIC_INLINE PetscErrorCode SVDMatGetSize(SVD svd,PetscInt *m,PetscInt *n)SVDMatGetSize167,5795
PETSC_STATIC_INLINE PetscErrorCode SVDMatGetLocalSize(SVD svd,PetscInt *m,PetscInt *n)SVDMatGetLocalSize180,6084

include/slepc/private/vecimplslepc.h,2122
vecimplslepc.h:^?vecimplslepc.h^A,1
#define SLEPCVECIMPL_HSLEPCVECIMPL_H12,429
#define SlepcValidVecComp(SlepcValidVecComp19,544
#define SlepcValidVecComp(SlepcValidVecComp23,601
  PetscInt      n;        /* number of active subvectors */n32,892
  PetscInt      N;        /* virtual global size */N33,952
  PetscInt      lN;       /* virtual local size */lN34,1004
  PetscInt      friends;  /* number of vectors sharing this structure */friends35,1055
} Vec_Comp_N;Vec_Comp_N36,1128
  Vec           *x;       /* the vectors */x39,1160
  PetscInt      nx;       /* number of available subvectors */nx40,1204
  Vec_Comp_N    *n;       /* structure shared by friend vectors */n41,1267
} Vec_Comp;Vec_Comp42,1334
typedef PetscInt MatType_t;MatType_t84,3729
#define DVD_MAT_HERMITIAN DVD_MAT_HERMITIAN85,3757
#define DVD_MAT_NEG_DEF DVD_MAT_NEG_DEF86,3790
#define DVD_MAT_POS_DEF DVD_MAT_POS_DEF87,3821
#define DVD_MAT_SINGULAR DVD_MAT_SINGULAR88,3852
#define DVD_MAT_COMPLEX DVD_MAT_COMPLEX89,3884
#define DVD_MAT_IMPLICIT DVD_MAT_IMPLICIT90,3915
#define DVD_MAT_IDENTITY DVD_MAT_IDENTITY91,3947
#define DVD_MAT_DIAG DVD_MAT_DIAG92,3979
#define DVD_MAT_TRIANG DVD_MAT_TRIANG93,4007
#define DVD_MAT_UTRIANG DVD_MAT_UTRIANG94,4037
#define DVD_MAT_LTRIANG DVD_MAT_LTRIANG95,4068
#define DVD_MAT_UNITARY DVD_MAT_UNITARY96,4100
typedef PetscInt EPType_t;EPType_t98,4133
#define DVD_EP_STD DVD_EP_STD99,4160
#define DVD_EP_HERMITIAN DVD_EP_HERMITIAN100,4186
#define DVD_EP_INDEFINITE DVD_EP_INDEFINITE101,4218
#define DVD_IS(DVD_IS103,4252
#define DVD_ISNOT(DVD_ISNOT104,4284
typedef struct VecPool_ {VecPool_107,4342
  Vec      v;              /* template vector */v108,4368
  Vec      *vecs;          /* pool of vectors */vecs109,4417
  PetscInt n;              /* size of vecs */n110,4466
  PetscInt used;           /* number of already used vectors */used111,4512
  PetscInt guess;          /* expected maximum number of vectors */guess112,4576
  struct VecPool_ *next;   /* list of pool of vectors */next113,4644
} VecPool_;VecPool_114,4701
typedef VecPool_* VecPool;VecPool115,4713

include/slepcblaslapack.h,994
slepcblaslapack.h:^?slepcblaslapack.h^A,1
#define SLEPCBLASLAPACK_HSLEPCBLASLAPACK_H15,513
#define SlepcCheckLapackInfo(SlepcCheckLapackInfo19,621
#define SlepcLRT SlepcLRT26,972
#define SlepcLRT SlepcLRT28,1002
# define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_33,1134
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_37,1277
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_39,1360
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_41,1447
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_43,1499
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_47,1596
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_49,1679
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_51,1766
#   define PETSC_BLASLAPACK_MIXEDPREFIX_ PETSC_BLASLAPACK_MIXEDPREFIX_53,1818
#  define PETSCBLASMIXED(PETSCBLASMIXED58,1921
#  define PETSCBLASMIXED(PETSCBLASMIXED60,2030

include/slepcblaslapack_mangle.h,2564
slepcblaslapack_mangle.h:^?slepcblaslapack_mangle.h^A,1
#define SLEPCBLASLAPACK_MANGLE_HSLEPCBLASLAPACK_MANGLE_H12,439
#define BLASrot_ BLASrot_15,522
#define BLASMIXEDrot_ BLASMIXEDrot_16,562
#define LAPACKlaev2_ LAPACKlaev2_17,608
#define LAPACKgehrd_ LAPACKgehrd_18,652
#define LAPACKgelqf_ LAPACKgelqf_19,696
#define LAPACKlarfg_ LAPACKlarfg_20,740
#define LAPACKlag2_ LAPACKlag2_21,784
#define LAPACKlasv2_ LAPACKlasv2_22,830
#define LAPACKlartg_ LAPACKlartg_23,878
#define LAPACKREALlartg_ LAPACKREALlartg_24,922
#define LAPACKlaln2_ LAPACKlaln2_25,974
#define LAPACKlaed4_ LAPACKlaed4_26,1022
#define LAPACKlamrg_ LAPACKlamrg_27,1070
#define LAPACKlapy2_ LAPACKlapy2_28,1118
#define LAPACKorghr_ LAPACKorghr_30,1198
#define LAPACKorghr_ LAPACKorghr_32,1248
#define LAPACKtgexc_ LAPACKtgexc_34,1299
#define LAPACKgeqp3_ LAPACKgeqp3_35,1343
#define BLAStrmm_ BLAStrmm_40,1472
#define LAPACKlanhs_ LAPACKlanhs_41,1514
#define LAPACKlange_ LAPACKlange_42,1558
#define LAPACKpbtrf_ LAPACKpbtrf_43,1602
#define LAPACKlarf_ LAPACKlarf_44,1646
#define LAPACKlacpy_ LAPACKlacpy_45,1688
#define LAPACKlansy_ LAPACKlansy_46,1732
#define LAPACKlaset_ LAPACKlaset_47,1776
#define LAPACKtrsyl_ LAPACKtrsyl_48,1820
#define LAPACKtrtri_ LAPACKtrtri_49,1864
#define LAPACKstevr_ LAPACKstevr_52,2011
#define LAPACKbdsdc_ LAPACKbdsdc_53,2059
#define LAPACKlamch_ LAPACKlamch_54,2107
#define LAPACKlamc3_ LAPACKlamc3_55,2155
#define LAPACKormlq_ LAPACKormlq_59,2290
#define LAPACKorgtr_ LAPACKorgtr_60,2334
#define LAPACKsytrd_ LAPACKsytrd_61,2378
#define LAPACKsyevr_ LAPACKsyevr_62,2422
#define LAPACKsyevd_ LAPACKsyevd_63,2466
#define LAPACKsygvd_ LAPACKsygvd_64,2510
#define LAPACKormlq_ LAPACKormlq_66,2560
#define LAPACKorgtr_ LAPACKorgtr_67,2604
#define LAPACKsytrd_ LAPACKsytrd_68,2648
#define LAPACKsyevr_ LAPACKsyevr_69,2692
#define LAPACKsyevd_ LAPACKsyevd_70,2736
#define LAPACKsygvd_ LAPACKsygvd_71,2780
#define LAPACKggevx_ LAPACKggevx_75,2891
#define LAPACKggev_ LAPACKggev_76,2935
#define LAPACKtrevc_ LAPACKtrevc_77,2977
#define LAPACKgeevx_ LAPACKgeevx_78,3021
#define LAPACKgees_ LAPACKgees_79,3065
#define LAPACKtrexc_ LAPACKtrexc_80,3107
#define LAPACKgesdd_ LAPACKgesdd_81,3151
#define LAPACKtgevc_ LAPACKtgevc_82,3195
#define LAPACKhsein_ LAPACKhsein_83,3239
#define LAPACKstedc_ LAPACKstedc_84,3283
#define LAPACKlascl_ LAPACKlascl_85,3327
#define BLASCOMPLEXgemm_ BLASCOMPLEXgemm_89,3465
#define BLASCOMPLEXscal_ BLASCOMPLEXscal_90,3520
#define LAPACKCOMPLEXgesv_ LAPACKCOMPLEXgesv_91,3575

include/slepcblaslapack_stdcall.h,3097
slepcblaslapack_stdcall.h:^?slepcblaslapack_stdcall.h^A,1
#define SLEPCBLASLAPACK_STDCALL_HSLEPCBLASLAPACK_STDCALL_H12,440
#define BLASrot_ BLASrot_15,524
#define BLASMIXEDrot_ BLASMIXEDrot_16,564
#define LAPACKlaev2_ LAPACKlaev2_17,610
#define LAPACKgehrd_ LAPACKgehrd_18,654
#define LAPACKgelqf_ LAPACKgelqf_19,698
#define LAPACKlarfg_ LAPACKlarfg_20,742
#define LAPACKlag2_ LAPACKlag2_21,786
#define LAPACKlasv2_ LAPACKlasv2_22,832
#define LAPACKlartg_ LAPACKlartg_23,880
#define LAPACKREALlartg_ LAPACKREALlartg_24,924
#define LAPACKlaln2_ LAPACKlaln2_25,976
#define LAPACKlaed4_ LAPACKlaed4_26,1024
#define LAPACKlamrg_ LAPACKlamrg_27,1072
#define LAPACKlapy2_ LAPACKlapy2_28,1120
#define LAPACKorghr_ LAPACKorghr_30,1200
#define LAPACKorghr_ LAPACKorghr_32,1250
#define LAPACKtgexc_ LAPACKtgexc_34,1301
#define LAPACKgeqp3_ LAPACKgeqp3_35,1345
#define BLAStrmm_(BLAStrmm_62,4736
#define LAPACKlanhs_(LAPACKlanhs_63,4852
#define LAPACKlange_(LAPACKlange_64,4931
#define LAPACKpbtrf_(LAPACKpbtrf_65,5016
#define LAPACKlarf_(LAPACKlarf_66,5101
#define LAPACKlacpy_(LAPACKlacpy_67,5201
#define LAPACKlansy_(LAPACKlansy_68,5292
#define LAPACKlaset_(LAPACKlaset_69,5379
#define LAPACKtrsyl_(LAPACKtrsyl_70,5470
#define LAPACKtrtri_(LAPACKtrtri_71,5599
#define LAPACKstevr_(LAPACKstevr_85,7624
#define LAPACKbdsdc_(LAPACKbdsdc_86,7799
#define LAPACKlamch_(LAPACKlamch_87,7938
#define LAPACKlamc3_(LAPACKlamc3_88,7997
#define LAPACKormlq_(LAPACKormlq_97,8937
#define LAPACKorgtr_(LAPACKorgtr_98,9066
#define LAPACKsytrd_(LAPACKsytrd_99,9163
#define LAPACKsyevr_(LAPACKsyevr_100,9272
#define LAPACKsyevd_(LAPACKsyevd_101,9451
#define LAPACKsygvd_(LAPACKsygvd_102,9568
#define LAPACKormlq_(LAPACKormlq_104,9710
#define LAPACKorgtr_(LAPACKorgtr_105,9839
#define LAPACKsytrd_(LAPACKsytrd_106,9936
#define LAPACKsyevr_(LAPACKsyevr_107,10045
#define LAPACKsyevd_(LAPACKsyevd_108,10236
#define LAPACKsygvd_(LAPACKsygvd_109,10365
#define LAPACKggevx_(LAPACKggevx_130,13755
#define LAPACKggev_(LAPACKggev_131,13990
#define LAPACKtrevc_(LAPACKtrevc_132,14140
#define LAPACKgeevx_(LAPACKgeevx_133,14275
#define LAPACKgees_(LAPACKgees_134,14468
#define LAPACKtrexc_(LAPACKtrexc_135,14606
#define LAPACKgesdd_(LAPACKgesdd_136,14715
#define LAPACKtgevc_(LAPACKtgevc_137,14848
#define LAPACKhsein_(LAPACKhsein_138,14995
#define LAPACKstedc_(LAPACKstedc_139,15162
#define LAPACKlascl_(LAPACKlascl_140,15277
#define LAPACKggevx_(LAPACKggevx_142,15392
#define LAPACKggev_(LAPACKggev_143,15627
#define LAPACKtrevc_(LAPACKtrevc_144,15777
#define LAPACKgeevx_(LAPACKgeevx_145,15918
#define LAPACKgees_(LAPACKgees_146,16105
#define LAPACKtrexc_(LAPACKtrexc_147,16243
#define LAPACKgesdd_(LAPACKgesdd_148,16346
#define LAPACKtgevc_(LAPACKtgevc_149,16485
#define LAPACKhsein_(LAPACKhsein_150,16638
#define LAPACKstedc_(LAPACKstedc_151,16805
#define LAPACKlascl_(LAPACKlascl_152,16932
#define BLASCOMPLEXgemm_(BLASCOMPLEXgemm_183,23833
#define BLASCOMPLEXscal_ BLASCOMPLEXscal_185,24210
#define LAPACKCOMPLEXgesv_ LAPACKCOMPLEXgesv_187,24401

include/slepcbv.h,2083
slepcbv.h:^?slepcbv.h^A,1
#define SLEPCBV_HSLEPCBV_H15,486
typedef struct _p_BV* BV;BV28,762
typedef const char* BVType;BVType38,958
#define BVMAT BVMAT39,986
#define BVSVEC BVSVEC40,1013
#define BVVECS BVVECS41,1041
#define BVCONTIGUOUS BVCONTIGUOUS42,1069
#define BVTENSOR BVTENSOR43,1103
SLEPC_EXTERN PetscClassId BV_CLASSID;BV_CLASSID46,1156
typedef enum { BV_ORTHOG_CGS,BV_ORTHOG_CGS56,1417
               BV_ORTHOG_MGS } BVOrthogType;BV_ORTHOG_MGS57,1447
               BV_ORTHOG_MGS } BVOrthogType;BVOrthogType57,1447
SLEPC_EXTERN const char *BVOrthogTypes[];BVOrthogTypes58,1492
typedef enum { BV_ORTHOG_REFINE_IFNEEDED,BV_ORTHOG_REFINE_IFNEEDED68,1758
               BV_ORTHOG_REFINE_NEVER,BV_ORTHOG_REFINE_NEVER69,1800
               BV_ORTHOG_REFINE_ALWAYS } BVOrthogRefineType;BV_ORTHOG_REFINE_ALWAYS70,1839
               BV_ORTHOG_REFINE_ALWAYS } BVOrthogRefineType;BVOrthogRefineType70,1839
SLEPC_EXTERN const char *BVOrthogRefineTypes[];BVOrthogRefineTypes71,1900
typedef enum { BV_ORTHOG_BLOCK_GS,BV_ORTHOG_BLOCK_GS81,2194
               BV_ORTHOG_BLOCK_CHOL,BV_ORTHOG_BLOCK_CHOL82,2229
               BV_ORTHOG_BLOCK_TSQR,BV_ORTHOG_BLOCK_TSQR83,2266
               BV_ORTHOG_BLOCK_TSQRCHOL,BV_ORTHOG_BLOCK_TSQRCHOL84,2303
               BV_ORTHOG_BLOCK_SVQB     } BVOrthogBlockType;BV_ORTHOG_BLOCK_SVQB85,2344
               BV_ORTHOG_BLOCK_SVQB     } BVOrthogBlockType;BVOrthogBlockType85,2344
SLEPC_EXTERN const char *BVOrthogBlockTypes[];BVOrthogBlockTypes86,2405
typedef enum { BV_MATMULT_VECS,BV_MATMULT_VECS103,2889
               BV_MATMULT_MAT,BV_MATMULT_MAT104,2921
               BV_MATMULT_MAT_SAVE } BVMatMultType;BV_MATMULT_MAT_SAVE105,2952
               BV_MATMULT_MAT_SAVE } BVMatMultType;BVMatMultType105,2952
SLEPC_EXTERN const char *BVMatMultTypes[];BVMatMultTypes106,3004
PETSC_STATIC_INLINE PetscErrorCode BVViewFromOptions(BV bv,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)bv,obj,name);}BVViewFromOptions118,3617
SLEPC_EXTERN PetscFunctionList BVList;BVList210,9290

include/slepcds.h,2578
slepcds.h:^?slepcds.h^A,1
#define SLEPCDS_HSLEPCDS_H15,486
#define DS_MAX_SOLVE DS_MAX_SOLVE19,547
typedef struct _p_DS* DS;DS31,900
typedef const char* DSType;DSType41,1129
#define DSHEP DSHEP42,1157
#define DSNHEP DSNHEP43,1180
#define DSGHEP DSGHEP44,1204
#define DSGHIEP DSGHIEP45,1228
#define DSGNHEP DSGNHEP46,1253
#define DSSVD DSSVD47,1278
#define DSPEP DSPEP48,1301
#define DSNEP DSNEP49,1324
SLEPC_EXTERN PetscClassId DS_CLASSID;DS_CLASSID52,1370
typedef enum { DS_STATE_RAW,DS_STATE_RAW61,1526
               DS_STATE_INTERMEDIATE,DS_STATE_INTERMEDIATE62,1555
               DS_STATE_CONDENSED,DS_STATE_CONDENSED63,1593
               DS_STATE_TRUNCATED } DSStateType;DS_STATE_TRUNCATED64,1628
               DS_STATE_TRUNCATED } DSStateType;DSStateType64,1628
SLEPC_EXTERN const char *DSStateTypes[];DSStateTypes65,1677
typedef enum { DS_MAT_A,DS_MAT_A97,2866
               DS_MAT_B,DS_MAT_B98,2891
               DS_MAT_C,DS_MAT_C99,2916
               DS_MAT_T,DS_MAT_T100,2941
               DS_MAT_D,DS_MAT_D101,2966
               DS_MAT_Q,DS_MAT_Q102,2991
               DS_MAT_Z,DS_MAT_Z103,3016
               DS_MAT_X,DS_MAT_X104,3041
               DS_MAT_Y,DS_MAT_Y105,3066
               DS_MAT_U,DS_MAT_U106,3091
               DS_MAT_VT,DS_MAT_VT107,3116
               DS_MAT_W,DS_MAT_W108,3142
               DS_MAT_E0,DS_MAT_E0109,3167
               DS_MAT_E1,DS_MAT_E1110,3193
               DS_MAT_E2,DS_MAT_E2111,3219
               DS_MAT_E3,DS_MAT_E3112,3245
               DS_MAT_E4,DS_MAT_E4113,3271
               DS_MAT_E5,DS_MAT_E5114,3297
               DS_MAT_E6,DS_MAT_E6115,3323
               DS_MAT_E7,DS_MAT_E7116,3349
               DS_MAT_E8,DS_MAT_E8117,3375
               DS_MAT_E9,DS_MAT_E9118,3401
               DS_NUM_MAT } DSMatType;DS_NUM_MAT119,3427
               DS_NUM_MAT } DSMatType;DSMatType119,3427
SLEPC_EXTERN DSMatType DSMatExtra[];DSMatExtra122,3513
#define DS_NUM_EXTRA DS_NUM_EXTRA123,3550
typedef enum { DS_PARALLEL_REDUNDANT,DS_PARALLEL_REDUNDANT132,3713
               DS_PARALLEL_SYNCHRONIZED } DSParallelType;DS_PARALLEL_SYNCHRONIZED133,3751
               DS_PARALLEL_SYNCHRONIZED } DSParallelType;DSParallelType133,3751
SLEPC_EXTERN const char *DSParallelTypes[];DSParallelTypes134,3809
PETSC_STATIC_INLINE PetscErrorCode DSViewFromOptions(DS ds,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)ds,obj,name);}DSViewFromOptions144,4309
SLEPC_EXTERN PetscFunctionList DSList;DSList205,8147

include/slepceps.h,8250
slepceps.h:^?slepceps.h^A,1
#define SLEPCEPS_HSLEPCEPS_H15,489
typedef struct _p_EPS* EPS;EPS32,815
typedef const char* EPSType;EPSType41,960
#define EPSPOWER EPSPOWER42,989
#define EPSSUBSPACE EPSSUBSPACE43,1020
#define EPSARNOLDI EPSARNOLDI44,1054
#define EPSLANCZOS EPSLANCZOS45,1087
#define EPSKRYLOVSCHUR EPSKRYLOVSCHUR46,1120
#define EPSGD EPSGD47,1157
#define EPSJD EPSJD48,1185
#define EPSRQCG EPSRQCG49,1213
#define EPSLOBPCG EPSLOBPCG50,1243
#define EPSCISS EPSCISS51,1275
#define EPSLAPACK EPSLAPACK52,1305
#define EPSARPACK EPSARPACK53,1337
#define EPSBLZPACK EPSBLZPACK54,1369
#define EPSTRLAN EPSTRLAN55,1402
#define EPSBLOPEX EPSBLOPEX56,1433
#define EPSPRIMME EPSPRIMME57,1465
SLEPC_EXTERN PetscClassId EPS_CLASSID;EPS_CLASSID60,1520
typedef enum { EPS_HEP=1,EPS_HEP69,1704
               EPS_GHEP,EPS_GHEP70,1730
               EPS_NHEP,EPS_NHEP71,1755
               EPS_GNHEP,EPS_GNHEP72,1780
               EPS_PGNHEP,EPS_PGNHEP73,1806
               EPS_GHIEP } EPSProblemType;EPS_GHIEP74,1833
               EPS_GHIEP } EPSProblemType;EPSProblemType74,1833
typedef enum { EPS_RITZ,EPS_RITZ84,2052
               EPS_HARMONIC,EPS_HARMONIC85,2077
               EPS_HARMONIC_RELATIVE,EPS_HARMONIC_RELATIVE86,2106
               EPS_HARMONIC_RIGHT,EPS_HARMONIC_RIGHT87,2144
               EPS_HARMONIC_LARGEST,EPS_HARMONIC_LARGEST88,2179
               EPS_REFINED,EPS_REFINED89,2216
               EPS_REFINED_HARMONIC } EPSExtraction;EPS_REFINED_HARMONIC90,2244
               EPS_REFINED_HARMONIC } EPSExtraction;EPSExtraction90,2244
typedef enum { EPS_LARGEST_MAGNITUDE=1,EPS_LARGEST_MAGNITUDE99,2457
               EPS_SMALLEST_MAGNITUDE,EPS_SMALLEST_MAGNITUDE100,2497
               EPS_LARGEST_REAL,EPS_LARGEST_REAL101,2536
               EPS_SMALLEST_REAL,EPS_SMALLEST_REAL102,2569
               EPS_LARGEST_IMAGINARY,EPS_LARGEST_IMAGINARY103,2603
               EPS_SMALLEST_IMAGINARY,EPS_SMALLEST_IMAGINARY104,2641
               EPS_TARGET_MAGNITUDE,EPS_TARGET_MAGNITUDE105,2680
               EPS_TARGET_REAL,EPS_TARGET_REAL106,2717
               EPS_TARGET_IMAGINARY,EPS_TARGET_IMAGINARY107,2749
               EPS_ALL,EPS_ALL108,2786
               EPS_WHICH_USER } EPSWhich;EPS_WHICH_USER109,2810
               EPS_WHICH_USER } EPSWhich;EPSWhich109,2810
typedef enum { EPS_BALANCE_NONE,EPS_BALANCE_NONE118,2984
               EPS_BALANCE_ONESIDE,EPS_BALANCE_ONESIDE119,3017
               EPS_BALANCE_TWOSIDE,EPS_BALANCE_TWOSIDE120,3053
               EPS_BALANCE_USER } EPSBalance;EPS_BALANCE_USER121,3089
               EPS_BALANCE_USER } EPSBalance;EPSBalance121,3089
SLEPC_EXTERN const char *EPSBalanceTypes[];EPSBalanceTypes122,3135
typedef enum { EPS_ERROR_ABSOLUTE,EPS_ERROR_ABSOLUTE131,3322
               EPS_ERROR_RELATIVE,EPS_ERROR_RELATIVE132,3357
               EPS_ERROR_BACKWARD } EPSErrorType;EPS_ERROR_BACKWARD133,3392
               EPS_ERROR_BACKWARD } EPSErrorType;EPSErrorType133,3392
SLEPC_EXTERN const char *EPSErrorTypes[];EPSErrorTypes134,3442
typedef enum { EPS_CONV_ABS,EPS_CONV_ABS143,3632
               EPS_CONV_REL,EPS_CONV_REL144,3661
               EPS_CONV_NORM,EPS_CONV_NORM145,3690
               EPS_CONV_USER } EPSConv;EPS_CONV_USER146,3720
               EPS_CONV_USER } EPSConv;EPSConv146,3720
typedef enum { EPS_STOP_BASIC,EPS_STOP_BASIC155,3895
               EPS_STOP_USER } EPSStop;EPS_STOP_USER156,3926
               EPS_STOP_USER } EPSStop;EPSStop156,3926
              EPS_CONVERGED_TOL                =  1,EPS_CONVERGED_TOL167,4192
              EPS_CONVERGED_USER               =  2,EPS_CONVERGED_USER168,4245
              EPS_DIVERGED_ITS                 = -1,EPS_DIVERGED_ITS170,4327
              EPS_DIVERGED_BREAKDOWN           = -2,EPS_DIVERGED_BREAKDOWN171,4380
              EPS_DIVERGED_SYMMETRY_LOST       = -3,EPS_DIVERGED_SYMMETRY_LOST172,4433
              EPS_CONVERGED_ITERATING          =  0} EPSConvergedReason;EPS_CONVERGED_ITERATING173,4486
              EPS_CONVERGED_ITERATING          =  0} EPSConvergedReason;EPSConvergedReason173,4486
SLEPC_EXTERN const char *const*EPSConvergedReasons;EPSConvergedReasons174,4559
PETSC_STATIC_INLINE PetscErrorCode EPSViewFromOptions(EPS eps,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)eps,obj,name);}EPSViewFromOptions193,5597
PETSC_DEPRECATED_FUNCTION("Use EPSErrorView()") PETSC_STATIC_INLINE PetscErrorCode EPSPrintSolution(EPS eps,PetscViewer v) {return EPSErrorView(eps,EPS_ERROR_RELATIVE,v);}EPSPrintSolution195,5830
PETSC_DEPRECATED_FUNCTION("Use EPSComputeError()") PETSC_STATIC_INLINE PetscErrorCode EPSComputeRelativeError(EPS eps,PetscInt i,PetscReal *r) {return EPSComputeError(eps,i,EPS_ERROR_RELATIVE,r);}EPSComputeRelativeError240,8924
PETSC_DEPRECATED_FUNCTION("Use EPSComputeError() with EPS_ERROR_ABSOLUTE") PETSC_STATIC_INLINE PetscErrorCode EPSComputeResidualNorm(EPS eps,PetscInt i,PetscReal *r) {return EPSComputeError(eps,i,EPS_ERROR_ABSOLUTE,r);}EPSComputeResidualNorm241,9121
SLEPC_EXTERN PetscFunctionList EPSList;EPSList284,12564
typedef enum { EPS_POWER_SHIFT_CONSTANT,EPS_POWER_SHIFT_CONSTANT299,13043
               EPS_POWER_SHIFT_RAYLEIGH,EPS_POWER_SHIFT_RAYLEIGH300,13084
               EPS_POWER_SHIFT_WILKINSON } EPSPowerShiftType;EPS_POWER_SHIFT_WILKINSON301,13125
               EPS_POWER_SHIFT_WILKINSON } EPSPowerShiftType;EPSPowerShiftType301,13125
SLEPC_EXTERN const char *EPSPowerShiftTypes[];EPSPowerShiftTypes302,13187
typedef enum { EPS_LANCZOS_REORTHOG_LOCAL,EPS_LANCZOS_REORTHOG_LOCAL342,15465
               EPS_LANCZOS_REORTHOG_FULL,EPS_LANCZOS_REORTHOG_FULL343,15508
               EPS_LANCZOS_REORTHOG_SELECTIVE,EPS_LANCZOS_REORTHOG_SELECTIVE344,15550
               EPS_LANCZOS_REORTHOG_PERIODIC,EPS_LANCZOS_REORTHOG_PERIODIC345,15597
               EPS_LANCZOS_REORTHOG_PARTIAL,EPS_LANCZOS_REORTHOG_PARTIAL346,15643
               EPS_LANCZOS_REORTHOG_DELAYED } EPSLanczosReorthogType;EPS_LANCZOS_REORTHOG_DELAYED347,15688
               EPS_LANCZOS_REORTHOG_DELAYED } EPSLanczosReorthogType;EPSLanczosReorthogType347,15688
SLEPC_EXTERN const char *EPSLanczosReorthogTypes[];EPSLanczosReorthogTypes348,15758
typedef enum { EPS_PRIMME_DYNAMIC=1,EPS_PRIMME_DYNAMIC365,16390
               EPS_PRIMME_DEFAULT_MIN_TIME,EPS_PRIMME_DEFAULT_MIN_TIME366,16427
               EPS_PRIMME_DEFAULT_MIN_MATVECS,EPS_PRIMME_DEFAULT_MIN_MATVECS367,16471
               EPS_PRIMME_ARNOLDI,EPS_PRIMME_ARNOLDI368,16518
               EPS_PRIMME_GD,EPS_PRIMME_GD369,16553
               EPS_PRIMME_GD_PLUSK,EPS_PRIMME_GD_PLUSK370,16583
               EPS_PRIMME_GD_OLSEN_PLUSK,EPS_PRIMME_GD_OLSEN_PLUSK371,16619
               EPS_PRIMME_JD_OLSEN_PLUSK,EPS_PRIMME_JD_OLSEN_PLUSK372,16661
               EPS_PRIMME_RQI,EPS_PRIMME_RQI373,16703
               EPS_PRIMME_JDQR,EPS_PRIMME_JDQR374,16734
               EPS_PRIMME_JDQMR,EPS_PRIMME_JDQMR375,16766
               EPS_PRIMME_JDQMR_ETOL,EPS_PRIMME_JDQMR_ETOL376,16799
               EPS_PRIMME_SUBSPACE_ITERATION,EPS_PRIMME_SUBSPACE_ITERATION377,16837
               EPS_PRIMME_LOBPCG_ORTHOBASIS,EPS_PRIMME_LOBPCG_ORTHOBASIS378,16883
               EPS_PRIMME_LOBPCG_ORTHOBASISW } EPSPRIMMEMethod;EPS_PRIMME_LOBPCG_ORTHOBASISW379,16928
               EPS_PRIMME_LOBPCG_ORTHOBASISW } EPSPRIMMEMethod;EPSPRIMMEMethod379,16928
SLEPC_EXTERN const char *EPSPRIMMEMethods[];EPSPRIMMEMethods380,16992
typedef enum { EPS_CISS_QUADRULE_TRAPEZOIDAL=1,EPS_CISS_QUADRULE_TRAPEZOIDAL432,19637
               EPS_CISS_QUADRULE_CHEBYSHEV } EPSCISSQuadRule;EPS_CISS_QUADRULE_CHEBYSHEV433,19685
               EPS_CISS_QUADRULE_CHEBYSHEV } EPSCISSQuadRule;EPSCISSQuadRule433,19685
SLEPC_EXTERN const char *EPSCISSQuadRules[];EPSCISSQuadRules434,19747
typedef enum { EPS_CISS_EXTRACTION_RITZ,EPS_CISS_EXTRACTION_RITZ443,19959
               EPS_CISS_EXTRACTION_HANKEL } EPSCISSExtraction;EPS_CISS_EXTRACTION_HANKEL444,20000
               EPS_CISS_EXTRACTION_HANKEL } EPSCISSExtraction;EPSCISSExtraction444,20000
SLEPC_EXTERN const char *EPSCISSExtractions[];EPSCISSExtractions445,20063

include/slepcfn.h,1129
slepcfn.h:^?slepcfn.h^A,1
#define SLEPCFN_HSLEPCFN_H15,494
#define FN_MAX_SOLVE FN_MAX_SOLVE18,535
typedef struct _p_FN* FN;FN28,712
typedef const char* FNType;FNType37,857
#define FNCOMBINE FNCOMBINE38,885
#define FNRATIONAL FNRATIONAL39,914
#define FNEXP FNEXP40,944
#define FNLOG FNLOG41,969
#define FNPHI FNPHI42,994
#define FNSQRT FNSQRT43,1019
#define FNINVSQRT FNINVSQRT44,1045
SLEPC_EXTERN PetscClassId FN_CLASSID;FN_CLASSID47,1097
typedef enum { FN_COMBINE_ADD,FN_COMBINE_ADD56,1261
               FN_COMBINE_MULTIPLY,FN_COMBINE_MULTIPLY57,1292
               FN_COMBINE_DIVIDE,FN_COMBINE_DIVIDE58,1328
               FN_COMBINE_COMPOSE } FNCombineType;FN_COMBINE_COMPOSE59,1362
               FN_COMBINE_COMPOSE } FNCombineType;FNCombineType59,1362
typedef enum { FN_PARALLEL_REDUNDANT,FN_PARALLEL_REDUNDANT68,1559
               FN_PARALLEL_SYNCHRONIZED } FNParallelType;FN_PARALLEL_SYNCHRONIZED69,1597
               FN_PARALLEL_SYNCHRONIZED } FNParallelType;FNParallelType69,1597
SLEPC_EXTERN const char *FNParallelTypes[];FNParallelTypes70,1655
SLEPC_EXTERN PetscFunctionList FNList;FNList95,2917

include/slepclme.h,1461
slepclme.h:^?slepclme.h^A,1
#define SLEPCLME_HSLEPCLME_H15,506
typedef struct _p_LME* LME;LME27,740
typedef const char* LMEType;LMEType36,910
#define LMEKRYLOV LMEKRYLOV37,939
SLEPC_EXTERN PetscClassId LME_CLASSID;LME_CLASSID40,991
typedef enum { LME_LYAPUNOV,LME_LYAPUNOV49,1179
               LME_SYLVESTER,LME_SYLVESTER50,1208
               LME_GEN_LYAPUNOV,LME_GEN_LYAPUNOV51,1238
               LME_GEN_SYLVESTER,LME_GEN_SYLVESTER52,1271
               LME_DT_LYAPUNOV ,LME_DT_LYAPUNOV53,1305
               LME_STEIN} LMEProblemType;LME_STEIN54,1338
               LME_STEIN} LMEProblemType;LMEProblemType54,1338
SLEPC_EXTERN const char *LMEProblemTypes[];LMEProblemTypes55,1380
PETSC_STATIC_INLINE PetscErrorCode LMEViewFromOptions(LME lme,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)lme,obj,name);}LMEViewFromOptions74,2349
              LME_CONVERGED_TOL                =  1,LME_CONVERGED_TOL116,4644
              LME_DIVERGED_ITS                 = -1,LME_DIVERGED_ITS118,4726
              LME_DIVERGED_BREAKDOWN           = -2,LME_DIVERGED_BREAKDOWN119,4779
              LME_CONVERGED_ITERATING          =  0} LMEConvergedReason;LME_CONVERGED_ITERATING120,4832
              LME_CONVERGED_ITERATING          =  0} LMEConvergedReason;LMEConvergedReason120,4832
SLEPC_EXTERN const char *const*LMEConvergedReasons;LMEConvergedReasons121,4905
SLEPC_EXTERN PetscFunctionList LMEList;LMEList125,5036

include/slepcmat.h,484
slepcmat.h:^?slepcmat.h^A,1
#define SLEPCMAT_HSLEPCMAT_H15,494
PETSC_DEPRECATED_FUNCTION("Use MatCreateRedundantMatrix() followed by MatConvert()") PETSC_STATIC_INLINE PetscErrorCode SlepcMatConvertSeqDense(Mat mat,Mat *newmat) {SlepcMatConvertSeqDense22,740
PETSC_DEPRECATED_FUNCTION("Use MatCreateTile()") PETSC_STATIC_INLINE PetscErrorCode SlepcMatTile(PetscScalar a,Mat A,PetscScalar b,Mat B,PetscScalar c,Mat C,PetscScalar d,Mat D,Mat *G) {return MatCreateTile(a,A,b,B,c,C,d,D,G);}SlepcMatTile29,1178

include/slepcmath.h,659
slepcmath.h:^?slepcmath.h^A,1
#define SLEPCMATH_HSLEPCMATH_H16,579
#  define SLEPC_DEFAULT_TOL SLEPC_DEFAULT_TOL22,717
#  define SLEPC_DEFAULT_TOL SLEPC_DEFAULT_TOL24,789
#  define SLEPC_DEFAULT_TOL SLEPC_DEFAULT_TOL26,865
#  define SLEPC_DEFAULT_TOL SLEPC_DEFAULT_TOL28,907
PETSC_STATIC_INLINE PetscReal SlepcAbs(PetscReal x,PetscReal y)SlepcAbs48,1271
#define SlepcAbsEigenvalue(SlepcAbsEigenvalue81,2086
#define SlepcAbsEigenvalue(SlepcAbsEigenvalue83,2138
PETSC_STATIC_INLINE PetscErrorCode SlepcSetFlushToZero(unsigned int *state)SlepcSetFlushToZero92,2283
PETSC_STATIC_INLINE PetscErrorCode SlepcResetFlushToZero(unsigned int *state)SlepcResetFlushToZero109,2699

include/slepcmfn.h,1106
slepcmfn.h:^?slepcmfn.h^A,1
#define SLEPCMFN_HSLEPCMFN_H15,493
typedef struct _p_MFN* MFN;MFN28,742
typedef const char* MFNType;MFNType37,908
#define MFNKRYLOV MFNKRYLOV38,937
#define MFNEXPOKIT MFNEXPOKIT39,966
SLEPC_EXTERN PetscClassId MFN_CLASSID;MFN_CLASSID42,1019
PETSC_STATIC_INLINE PetscErrorCode MFNViewFromOptions(MFN mfn,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)mfn,obj,name);}MFNViewFromOptions55,1617
              MFN_CONVERGED_TOL                =  1,MFN_CONVERGED_TOL95,3746
              MFN_CONVERGED_ITS                =  2,MFN_CONVERGED_ITS96,3799
              MFN_DIVERGED_ITS                 = -1,MFN_DIVERGED_ITS98,3881
              MFN_DIVERGED_BREAKDOWN           = -2,MFN_DIVERGED_BREAKDOWN99,3934
              MFN_CONVERGED_ITERATING          =  0} MFNConvergedReason;MFN_CONVERGED_ITERATING100,3987
              MFN_CONVERGED_ITERATING          =  0} MFNConvergedReason;MFNConvergedReason100,3987
SLEPC_EXTERN const char *const*MFNConvergedReasons;MFNConvergedReasons101,4060
SLEPC_EXTERN PetscFunctionList MFNList;MFNList105,4191

include/slepcnep.h,6650
slepcnep.h:^?slepcnep.h^A,1
#define SLEPCNEP_HSLEPCNEP_H15,490
typedef struct _p_NEP* NEP;NEP30,782
typedef const char* NEPType;NEPType39,930
#define NEPRII NEPRII40,959
#define NEPSLP NEPSLP41,986
#define NEPNARNOLDI NEPNARNOLDI42,1013
#define NEPCISS NEPCISS43,1045
#define NEPINTERPOL NEPINTERPOL44,1073
#define NEPNLEIGS NEPNLEIGS45,1105
SLEPC_EXTERN PetscClassId NEP_CLASSID;NEP_CLASSID48,1158
typedef enum { NEP_GENERAL=1,NEP_GENERAL57,1354
               NEP_RATIONAL     /* NEP defined in split form with all f_i rational */NEP_RATIONAL58,1384
             } NEPProblemType;NEPProblemType59,1470
typedef enum { NEP_LARGEST_MAGNITUDE=1,NEP_LARGEST_MAGNITUDE68,1661
               NEP_SMALLEST_MAGNITUDE,NEP_SMALLEST_MAGNITUDE69,1701
               NEP_LARGEST_REAL,NEP_LARGEST_REAL70,1740
               NEP_SMALLEST_REAL,NEP_SMALLEST_REAL71,1773
               NEP_LARGEST_IMAGINARY,NEP_LARGEST_IMAGINARY72,1807
               NEP_SMALLEST_IMAGINARY,NEP_SMALLEST_IMAGINARY73,1845
               NEP_TARGET_MAGNITUDE,NEP_TARGET_MAGNITUDE74,1884
               NEP_TARGET_REAL,NEP_TARGET_REAL75,1921
               NEP_TARGET_IMAGINARY,NEP_TARGET_IMAGINARY76,1953
               NEP_ALL,NEP_ALL77,1990
               NEP_WHICH_USER } NEPWhich;NEP_WHICH_USER78,2014
               NEP_WHICH_USER } NEPWhich;NEPWhich78,2014
typedef enum { NEP_ERROR_ABSOLUTE,NEP_ERROR_ABSOLUTE87,2199
               NEP_ERROR_RELATIVE,NEP_ERROR_RELATIVE88,2234
               NEP_ERROR_BACKWARD } NEPErrorType;NEP_ERROR_BACKWARD89,2269
               NEP_ERROR_BACKWARD } NEPErrorType;NEPErrorType89,2269
SLEPC_EXTERN const char *NEPErrorTypes[];NEPErrorTypes90,2319
typedef enum { NEP_REFINE_NONE,NEP_REFINE_NONE99,2457
               NEP_REFINE_SIMPLE,NEP_REFINE_SIMPLE100,2489
               NEP_REFINE_MULTIPLE } NEPRefine;NEP_REFINE_MULTIPLE101,2523
               NEP_REFINE_MULTIPLE } NEPRefine;NEPRefine101,2523
SLEPC_EXTERN const char *NEPRefineTypes[];NEPRefineTypes102,2571
typedef enum { NEP_REFINE_SCHEME_SCHUR=1,NEP_REFINE_SCHEME_SCHUR111,2767
               NEP_REFINE_SCHEME_MBE,NEP_REFINE_SCHEME_MBE112,2809
               NEP_REFINE_SCHEME_EXPLICIT } NEPRefineScheme;NEP_REFINE_SCHEME_EXPLICIT113,2847
               NEP_REFINE_SCHEME_EXPLICIT } NEPRefineScheme;NEPRefineScheme113,2847
SLEPC_EXTERN const char *NEPRefineSchemes[];NEPRefineSchemes114,2908
typedef enum { NEP_CONV_ABS,NEP_CONV_ABS123,3101
               NEP_CONV_REL,NEP_CONV_REL124,3130
               NEP_CONV_NORM,NEP_CONV_NORM125,3159
               NEP_CONV_USER } NEPConv;NEP_CONV_USER126,3189
               NEP_CONV_USER } NEPConv;NEPConv126,3189
typedef enum { NEP_STOP_BASIC,NEP_STOP_BASIC135,3364
               NEP_STOP_USER } NEPStop;NEP_STOP_USER136,3395
               NEP_STOP_USER } NEPStop;NEPStop136,3395
              NEP_CONVERGED_TOL                =  1,NEP_CONVERGED_TOL147,3670
              NEP_CONVERGED_USER               =  2,NEP_CONVERGED_USER148,3723
              NEP_DIVERGED_ITS                 = -1,NEP_DIVERGED_ITS150,3805
              NEP_DIVERGED_BREAKDOWN           = -2,NEP_DIVERGED_BREAKDOWN151,3858
              NEP_DIVERGED_LINEAR_SOLVE        = -4,NEP_DIVERGED_LINEAR_SOLVE153,3966
              NEP_DIVERGED_SUBSPACE_EXHAUSTED  = -5,NEP_DIVERGED_SUBSPACE_EXHAUSTED154,4019
              NEP_CONVERGED_ITERATING          =  0} NEPConvergedReason;NEP_CONVERGED_ITERATING155,4072
              NEP_CONVERGED_ITERATING          =  0} NEPConvergedReason;NEPConvergedReason155,4072
SLEPC_EXTERN const char *const*NEPConvergedReasons;NEPConvergedReasons156,4145
PETSC_STATIC_INLINE PetscErrorCode NEPViewFromOptions(NEP nep,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)nep,obj,name);}NEPViewFromOptions171,4894
PETSC_DEPRECATED_FUNCTION("Use NEPSetFunction() and NEPSetJacobian") PETSC_STATIC_INLINE PetscErrorCode NEPSetDerivatives(NEP nep,Mat A,PetscErrorCode (*fun)(NEP,PetscScalar,PetscInt,Mat,void*),void *ctx) {SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_SUP,"Not implemented in this version");}NEPSetDerivatives185,5988
PETSC_DEPRECATED_FUNCTION("Use NEPGetFunction() and NEPGetJacobian") PETSC_STATIC_INLINE PetscErrorCode NEPGetDerivatives(NEP nep,Mat *A,PetscErrorCode (**fun)(NEP,PetscScalar,PetscInt,Mat,void*),void **ctx) {SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_SUP,"Not implemented in this version");}NEPGetDerivatives186,6287
PETSC_DEPRECATED_FUNCTION("Use NEPComputeError()") PETSC_STATIC_INLINE PetscErrorCode NEPComputeRelativeError(NEP nep,PetscInt i,PetscReal *r) {return NEPComputeError(nep,i,NEP_ERROR_RELATIVE,r);}NEPComputeRelativeError220,9017
PETSC_DEPRECATED_FUNCTION("Use NEPComputeError() with NEP_ERROR_ABSOLUTE") PETSC_STATIC_INLINE PetscErrorCode NEPComputeResidualNorm(NEP nep,PetscInt i,PetscReal *r) {return NEPComputeError(nep,i,NEP_ERROR_ABSOLUTE,r);}NEPComputeResidualNorm221,9214
SLEPC_EXTERN PetscFunctionList NEPList;NEPList265,12559
#define SlepcNEPCISSUnavailable(SlepcNEPCISSUnavailable301,14489
PETSC_STATIC_INLINE PetscErrorCode NEPCISSSetSizes(NEP nep,PETSC_UNUSED PetscInt ip,PETSC_UNUSED PetscInt bs,PETSC_UNUSED PetscInt ms,PETSC_UNUSED PetscInt npart,PETSC_UNUSED PetscInt bsmax,PETSC_UNUSED PetscBool realmats) {SlepcNEPCISSUnavailable(nep);}NEPCISSSetSizes305,14699
PETSC_STATIC_INLINE PetscErrorCode NEPCISSGetSizes(NEP nep,PETSC_UNUSED PetscInt *ip,PETSC_UNUSED PetscInt *bs,PETSC_UNUSED PetscInt *ms,PETSC_UNUSED PetscInt *npart,PETSC_UNUSED PetscInt *bsmak,PETSC_UNUSED PetscBool *realmats) {SlepcNEPCISSUnavailable(nep);}NEPCISSGetSizes306,14954
PETSC_STATIC_INLINE PetscErrorCode NEPCISSSetThreshold(NEP nep,PETSC_UNUSED PetscReal delta,PETSC_UNUSED PetscReal spur) {SlepcNEPCISSUnavailable(nep);}NEPCISSSetThreshold307,15215
PETSC_STATIC_INLINE PetscErrorCode NEPCISSGetThreshold(NEP nep,PETSC_UNUSED PetscReal *delta,PETSC_UNUSED PetscReal *spur) {SlepcNEPCISSUnavailable(nep);}NEPCISSGetThreshold308,15368
PETSC_STATIC_INLINE PetscErrorCode NEPCISSSetRefinement(NEP nep,PETSC_UNUSED PetscInt inner,PETSC_UNUSED PetscInt blsize) {SlepcNEPCISSUnavailable(nep);}NEPCISSSetRefinement309,15523
PETSC_STATIC_INLINE PetscErrorCode NEPCISSGetRefinement(NEP nep,PETSC_UNUSED PetscInt *inner,PETSC_UNUSED PetscInt *blsize) {SlepcNEPCISSUnavailable(nep);}NEPCISSGetRefinement310,15677
PETSC_STATIC_INLINE PetscErrorCode NEPCISSGetKSPs(NEP nep,PETSC_UNUSED PetscInt *nsolve,PETSC_UNUSED KSP **ksp) {SlepcNEPCISSUnavailable(nep);}NEPCISSGetKSPs311,15833
#undef SlepcNEPCISSUnavailableSlepcNEPCISSUnavailable312,15977

include/slepcpep.h,6801
slepcpep.h:^?slepcpep.h^A,1
#define SLEPCPEP_HSLEPCPEP_H15,491
typedef struct _p_PEP* PEP;PEP28,740
typedef const char* PEPType;PEPType37,889
#define PEPLINEAR PEPLINEAR38,918
#define PEPQARNOLDI PEPQARNOLDI39,948
#define PEPTOAR PEPTOAR40,980
#define PEPSTOAR PEPSTOAR41,1008
#define PEPJD PEPJD42,1037
SLEPC_EXTERN PetscClassId PEP_CLASSID;PEP_CLASSID45,1086
typedef enum { PEP_GENERAL=1,PEP_GENERAL54,1283
               PEP_HERMITIAN,   /* All A_i  Hermitian */PEP_HERMITIAN55,1313
               PEP_HYPERBOLIC,  /* QEP with Hermitian matrices, M>0, (x'Cx)^2 > 4(x'Mx)(x'Kx) */PEP_HYPERBOLIC56,1370
               PEP_GYROSCOPIC   /* QEP with M, K  Hermitian, M>0, C skew-Hermitian */PEP_GYROSCOPIC57,1467
             } PEPProblemType;PEPProblemType58,1553
typedef enum { PEP_LARGEST_MAGNITUDE=1,PEP_LARGEST_MAGNITUDE67,1744
               PEP_SMALLEST_MAGNITUDE,PEP_SMALLEST_MAGNITUDE68,1784
               PEP_LARGEST_REAL,PEP_LARGEST_REAL69,1823
               PEP_SMALLEST_REAL,PEP_SMALLEST_REAL70,1856
               PEP_LARGEST_IMAGINARY,PEP_LARGEST_IMAGINARY71,1890
               PEP_SMALLEST_IMAGINARY,PEP_SMALLEST_IMAGINARY72,1928
               PEP_TARGET_MAGNITUDE,PEP_TARGET_MAGNITUDE73,1967
               PEP_TARGET_REAL,PEP_TARGET_REAL74,2004
               PEP_TARGET_IMAGINARY,PEP_TARGET_IMAGINARY75,2036
               PEP_ALL,PEP_ALL76,2073
               PEP_WHICH_USER } PEPWhich;PEP_WHICH_USER77,2097
               PEP_WHICH_USER } PEPWhich;PEPWhich77,2097
typedef enum { PEP_BASIS_MONOMIAL,PEP_BASIS_MONOMIAL87,2292
               PEP_BASIS_CHEBYSHEV1,PEP_BASIS_CHEBYSHEV188,2327
               PEP_BASIS_CHEBYSHEV2,PEP_BASIS_CHEBYSHEV289,2364
               PEP_BASIS_LEGENDRE,PEP_BASIS_LEGENDRE90,2401
               PEP_BASIS_LAGUERRE,PEP_BASIS_LAGUERRE91,2436
               PEP_BASIS_HERMITE } PEPBasis;PEP_BASIS_HERMITE92,2471
               PEP_BASIS_HERMITE } PEPBasis;PEPBasis92,2471
SLEPC_EXTERN const char *PEPBasisTypes[];PEPBasisTypes93,2516
typedef enum { PEP_SCALE_NONE,PEP_SCALE_NONE102,2653
               PEP_SCALE_SCALAR,PEP_SCALE_SCALAR103,2684
               PEP_SCALE_DIAGONAL,PEP_SCALE_DIAGONAL104,2717
               PEP_SCALE_BOTH } PEPScale;PEP_SCALE_BOTH105,2752
               PEP_SCALE_BOTH } PEPScale;PEPScale105,2752
SLEPC_EXTERN const char *PEPScaleTypes[];PEPScaleTypes106,2794
typedef enum { PEP_REFINE_NONE,PEP_REFINE_NONE115,2932
               PEP_REFINE_SIMPLE,PEP_REFINE_SIMPLE116,2964
               PEP_REFINE_MULTIPLE } PEPRefine;PEP_REFINE_MULTIPLE117,2998
               PEP_REFINE_MULTIPLE } PEPRefine;PEPRefine117,2998
SLEPC_EXTERN const char *PEPRefineTypes[];PEPRefineTypes118,3046
typedef enum { PEP_REFINE_SCHEME_SCHUR=1,PEP_REFINE_SCHEME_SCHUR127,3242
               PEP_REFINE_SCHEME_MBE,PEP_REFINE_SCHEME_MBE128,3284
               PEP_REFINE_SCHEME_EXPLICIT } PEPRefineScheme;PEP_REFINE_SCHEME_EXPLICIT129,3322
               PEP_REFINE_SCHEME_EXPLICIT } PEPRefineScheme;PEPRefineScheme129,3322
SLEPC_EXTERN const char *PEPRefineSchemes[];PEPRefineSchemes130,3383
typedef enum { PEP_EXTRACT_NONE=1,PEP_EXTRACT_NONE139,3526
               PEP_EXTRACT_NORM,PEP_EXTRACT_NORM140,3561
               PEP_EXTRACT_RESIDUAL,PEP_EXTRACT_RESIDUAL141,3594
               PEP_EXTRACT_STRUCTURED } PEPExtract;PEP_EXTRACT_STRUCTURED142,3631
               PEP_EXTRACT_STRUCTURED } PEPExtract;PEPExtract142,3631
SLEPC_EXTERN const char *PEPExtractTypes[];PEPExtractTypes143,3683
typedef enum { PEP_ERROR_ABSOLUTE,PEP_ERROR_ABSOLUTE152,3870
               PEP_ERROR_RELATIVE,PEP_ERROR_RELATIVE153,3905
               PEP_ERROR_BACKWARD } PEPErrorType;PEP_ERROR_BACKWARD154,3940
               PEP_ERROR_BACKWARD } PEPErrorType;PEPErrorType154,3940
SLEPC_EXTERN const char *PEPErrorTypes[];PEPErrorTypes155,3990
typedef enum { PEP_CONV_ABS,PEP_CONV_ABS164,4180
               PEP_CONV_REL,PEP_CONV_REL165,4209
               PEP_CONV_NORM,PEP_CONV_NORM166,4238
               PEP_CONV_USER } PEPConv;PEP_CONV_USER167,4268
               PEP_CONV_USER } PEPConv;PEPConv167,4268
typedef enum { PEP_STOP_BASIC,PEP_STOP_BASIC176,4443
               PEP_STOP_USER } PEPStop;PEP_STOP_USER177,4474
               PEP_STOP_USER } PEPStop;PEPStop177,4474
              PEP_CONVERGED_TOL                =  1,PEP_CONVERGED_TOL188,4740
              PEP_CONVERGED_USER               =  2,PEP_CONVERGED_USER189,4793
              PEP_DIVERGED_ITS                 = -1,PEP_DIVERGED_ITS191,4875
              PEP_DIVERGED_BREAKDOWN           = -2,PEP_DIVERGED_BREAKDOWN192,4928
              PEP_DIVERGED_SYMMETRY_LOST       = -3,PEP_DIVERGED_SYMMETRY_LOST193,4981
              PEP_CONVERGED_ITERATING          =  0} PEPConvergedReason;PEP_CONVERGED_ITERATING194,5034
              PEP_CONVERGED_ITERATING          =  0} PEPConvergedReason;PEPConvergedReason194,5034
SLEPC_EXTERN const char *const*PEPConvergedReasons;PEPConvergedReasons195,5107
PETSC_STATIC_INLINE PetscErrorCode PEPViewFromOptions(PEP pep,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)pep,obj,name);}PEPViewFromOptions215,6187
PETSC_DEPRECATED_FUNCTION("Use PEPErrorView()") PETSC_STATIC_INLINE PetscErrorCode PEPPrintSolution(PEP pep,PetscViewer v) {return PEPErrorView(pep,PEP_ERROR_BACKWARD,v);}PEPPrintSolution217,6420
PETSC_DEPRECATED_FUNCTION("Use PEPComputeError()") PETSC_STATIC_INLINE PetscErrorCode PEPComputeRelativeError(PEP pep,PetscInt i,PetscReal *r) {return PEPComputeError(pep,i,PEP_ERROR_BACKWARD,r);}PEPComputeRelativeError263,9708
PETSC_DEPRECATED_FUNCTION("Use PEPComputeError() with PEP_ERROR_ABSOLUTE") PETSC_STATIC_INLINE PetscErrorCode PEPComputeResidualNorm(PEP pep,PetscInt i,PetscReal *r) {return PEPComputeError(pep,i,PEP_ERROR_ABSOLUTE,r);}PEPComputeResidualNorm264,9905
SLEPC_EXTERN PetscFunctionList PEPList;PEPList294,12519
PETSC_DEPRECATED_FUNCTION("Use PEPLinearSetLinearization()") PETSC_STATIC_INLINE PetscErrorCode PEPLinearSetCompanionForm(PEP pep,PetscInt cform) {return (cform==1)?PEPLinearSetLinearization(pep,1.0,0.0):PEPLinearSetLinearization(pep,0.0,1.0);}PEPLinearSetCompanionForm308,13244
PETSC_DEPRECATED_FUNCTION("Use PEPLinearGetLinearization()") PETSC_STATIC_INLINE PetscErrorCode PEPLinearGetCompanionForm(PEP pep,PetscInt *cform) {if (cform) *cform=1; return 0;}PEPLinearGetCompanionForm309,13489
typedef enum { PEP_JD_PROJECTION_HARMONIC,PEP_JD_PROJECTION_HARMONIC341,15272
               PEP_JD_PROJECTION_ORTHOGONAL } PEPJDProjection;PEP_JD_PROJECTION_ORTHOGONAL342,15315
               PEP_JD_PROJECTION_ORTHOGONAL } PEPJDProjection;PEPJDProjection342,15315
SLEPC_EXTERN const char *PEPJDProjectionTypes[];PEPJDProjectionTypes343,15378

include/slepcrg.h,510
slepcrg.h:^?slepcrg.h^A,1
#define SLEPCRG_HSLEPCRG_H15,479
typedef const char* RGType;RGType28,705
#define RGINTERVAL RGINTERVAL29,733
#define RGPOLYGON RGPOLYGON30,764
#define RGELLIPSE RGELLIPSE31,794
#define RGRING RGRING32,824
SLEPC_EXTERN PetscClassId RG_CLASSID;RG_CLASSID35,874
PETSC_STATIC_INLINE PetscErrorCode RGViewFromOptions(RG rg,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)rg,obj,name);}RGViewFromOptions45,1368
SLEPC_EXTERN PetscFunctionList RGList;RGList59,2229

include/slepcrgtypes.h,81
slepcrgtypes.h:^?slepcrgtypes.h^A,1
#define SLEPCRGTYPES_HSLEPCRGTYPES_H12,429
typedef struct _p_RG* RG;RG21,540

include/slepcsc.h,454
slepcsc.h:^?slepcsc.h^A,1
#define SLEPCSC_HSLEPCSC_H15,471
struct _n_SlepcSC {_n_SlepcSC50,1584
  PetscErrorCode (*map)(PetscObject,PetscInt,PetscScalar*,PetscScalar*);map52,1687
  PetscObject    mapobj;mapobj53,1760
  PetscErrorCode (*comparison)(PetscScalar,PetscScalar,PetscScalar,PetscScalar,PetscInt*,void*);comparison55,1850
  void           *comparisonctx;comparisonctx56,1947
  RG             rg;rg58,2018
typedef struct _n_SlepcSC* SlepcSC;SlepcSC60,2042

include/slepcst.h,1494
slepcst.h:^?slepcst.h^A,1
#define SLEPCST_HSLEPCST_H15,488
typedef struct _p_ST* ST;ST30,814
typedef const char* STType;STType39,966
#define STSHELL STSHELL40,994
#define STSHIFT STSHIFT41,1022
#define STSINVERT STSINVERT42,1050
#define STCAYLEY STCAYLEY43,1080
#define STPRECOND STPRECOND44,1109
#define STFILTER STFILTER45,1139
SLEPC_EXTERN PetscClassId ST_CLASSID;ST_CLASSID48,1191
PETSC_DEPRECATED_FUNCTION("Use STSetMatrices()") PETSC_STATIC_INLINE PetscErrorCode STSetOperators(ST st,PetscInt n,Mat *A) {return STSetMatrices(st,n,A);}STSetOperators64,1914
PETSC_DEPRECATED_FUNCTION("Use STGetMatrix()") PETSC_STATIC_INLINE PetscErrorCode STGetOperators(ST st,PetscInt k,Mat *A) {return STGetMatrix(st,k,A);}STGetOperators65,2070
PETSC_DEPRECATED_FUNCTION("Use STGetMatrixTransformed()") PETSC_STATIC_INLINE PetscErrorCode STGetTOperators(ST st,PetscInt k,Mat *A) {return STGetMatrixTransformed(st,k,A);}STGetTOperators66,2222
PETSC_DEPRECATED_FUNCTION("Use STGetOperator() followed by MatComputeOperator()") PETSC_STATIC_INLINE PetscErrorCode STComputeExplicitOperator(ST st,Mat *A) {STComputeExplicitOperator67,2397
typedef enum { ST_MATMODE_COPY,ST_MATMODE_COPY120,4785
               ST_MATMODE_INPLACE,ST_MATMODE_INPLACE121,4817
               ST_MATMODE_SHELL } STMatMode;ST_MATMODE_SHELL122,4852
               ST_MATMODE_SHELL } STMatMode;STMatMode122,4852
SLEPC_EXTERN const char *STMatModes[];STMatModes123,4897
SLEPC_EXTERN PetscFunctionList STList;STList130,5180

include/slepcsvd.h,3630
slepcsvd.h:^?slepcsvd.h^A,1
#define SLEPCSVD_HSLEPCSVD_H15,484
typedef struct _p_SVD* SVD;SVD30,768
typedef const char* SVDType;SVDType39,922
#define SVDCROSS SVDCROSS40,951
#define SVDCYCLIC SVDCYCLIC41,982
#define SVDLAPACK SVDLAPACK42,1014
#define SVDLANCZOS SVDLANCZOS43,1046
#define SVDTRLANCZOS SVDTRLANCZOS44,1079
#define SVDPRIMME SVDPRIMME45,1114
SLEPC_EXTERN PetscClassId SVD_CLASSID;SVD_CLASSID48,1169
typedef enum { SVD_LARGEST,SVD_LARGEST58,1409
               SVD_SMALLEST } SVDWhich;SVD_SMALLEST59,1437
               SVD_SMALLEST } SVDWhich;SVDWhich59,1437
typedef enum { SVD_ERROR_ABSOLUTE,SVD_ERROR_ABSOLUTE68,1620
               SVD_ERROR_RELATIVE } SVDErrorType;SVD_ERROR_RELATIVE69,1655
               SVD_ERROR_RELATIVE } SVDErrorType;SVDErrorType69,1655
SLEPC_EXTERN const char *SVDErrorTypes[];SVDErrorTypes70,1705
typedef enum { SVD_CONV_ABS,SVD_CONV_ABS79,1895
               SVD_CONV_REL,SVD_CONV_REL80,1924
               SVD_CONV_USER } SVDConv;SVD_CONV_USER81,1953
               SVD_CONV_USER } SVDConv;SVDConv81,1953
typedef enum { SVD_STOP_BASIC,SVD_STOP_BASIC90,2128
               SVD_STOP_USER } SVDStop;SVD_STOP_USER91,2159
               SVD_STOP_USER } SVDStop;SVDStop91,2159
              SVD_CONVERGED_TOL                =  1,SVD_CONVERGED_TOL102,2433
              SVD_CONVERGED_USER               =  2,SVD_CONVERGED_USER103,2486
              SVD_DIVERGED_ITS                 = -1,SVD_DIVERGED_ITS105,2568
              SVD_DIVERGED_BREAKDOWN           = -2,SVD_DIVERGED_BREAKDOWN106,2621
              SVD_CONVERGED_ITERATING          =  0 } SVDConvergedReason;SVD_CONVERGED_ITERATING107,2674
              SVD_CONVERGED_ITERATING          =  0 } SVDConvergedReason;SVDConvergedReason107,2674
SLEPC_EXTERN const char *const*SVDConvergedReasons;SVDConvergedReasons108,2748
PETSC_DEPRECATED_FUNCTION("Use SVDSetInitialSpaces()") PETSC_STATIC_INLINE PetscErrorCode SVDSetInitialSpace(SVD svd,PetscInt nr,Vec *isr) {return SVDSetInitialSpaces(svd,nr,isr,0,NULL);}SVDSetInitialSpace120,3346
PETSC_DEPRECATED_FUNCTION("Use SVDSetInitialSpaces()") PETSC_STATIC_INLINE PetscErrorCode SVDSetInitialSpaceLeft(SVD svd,PetscInt nl,Vec *isl) {return SVDSetInitialSpaces(svd,0,NULL,nl,isl);}SVDSetInitialSpaceLeft121,3534
PETSC_DEPRECATED_FUNCTION("Use SVDComputeError()") PETSC_STATIC_INLINE PetscErrorCode SVDComputeRelativeError(SVD svd,PetscInt i,PetscReal *r) {return SVDComputeError(svd,i,SVD_ERROR_RELATIVE,r);}SVDComputeRelativeError150,5902
PETSC_DEPRECATED_FUNCTION("Use SVDComputeError() with SVD_ERROR_ABSOLUTE") PETSC_STATIC_INLINE PetscErrorCode SVDComputeResidualNorms(SVD svd,PetscInt i,PetscReal *r1,PETSC_UNUSED PetscReal *r2) {return SVDComputeError(svd,i,SVD_ERROR_ABSOLUTE,r1);}SVDComputeResidualNorms151,6099
PETSC_STATIC_INLINE PetscErrorCode SVDViewFromOptions(SVD svd,PetscObject obj,const char name[]) {return PetscObjectViewFromOptions((PetscObject)svd,obj,name);}SVDViewFromOptions153,6403
PETSC_DEPRECATED_FUNCTION("Use SVDErrorView()") PETSC_STATIC_INLINE PetscErrorCode SVDPrintSolution(SVD svd,PetscViewer v) {return SVDErrorView(svd,SVD_ERROR_RELATIVE,v);}SVDPrintSolution155,6636
SLEPC_EXTERN PetscFunctionList SVDList;SVDList182,8873
typedef enum { SVD_PRIMME_HYBRID=1,SVD_PRIMME_HYBRID212,10053
               SVD_PRIMME_NORMALEQUATIONS,SVD_PRIMME_NORMALEQUATIONS213,10089
               SVD_PRIMME_AUGMENTED } SVDPRIMMEMethod;SVD_PRIMME_AUGMENTED214,10132
               SVD_PRIMME_AUGMENTED } SVDPRIMMEMethod;SVDPRIMMEMethod214,10132
SLEPC_EXTERN const char *SVDPRIMMEMethods[];SVDPRIMMEMethods215,10187

include/slepcsys.h,731
slepcsys.h:^?slepcsys.h^A,1
#define SLEPCSYS_HSLEPCSYS_H16,546
#define SLEPC_VISIBILITY_PUBLIC SLEPC_VISIBILITY_PUBLIC21,616
#define SLEPC_VISIBILITY_PUBLIC SLEPC_VISIBILITY_PUBLIC23,670
#define SLEPC_VISIBILITY_INTERNAL SLEPC_VISIBILITY_INTERNAL25,725
#define SLEPC_EXTERN SLEPC_EXTERN33,1010
#define SLEPC_INTERN SLEPC_INTERN34,1066
#define SLEPC_EXTERN SLEPC_EXTERN36,1130
#define SLEPC_INTERN SLEPC_INTERN37,1182
#define SLEPC_AUTHOR_INFO SLEPC_AUTHOR_INFO50,1570
typedef struct _n_SlepcConvMonitor* SlepcConvMonitor;SlepcConvMonitor74,2214
SLEPC_EXTERN PetscBool SlepcInitializeCalled;SlepcInitializeCalled92,3146
#define SlepcLogFlopsComplex(SlepcLogFlopsComplex95,3224
#define SlepcLogFlopsComplex(SlepcLogFlopsComplex97,3281

include/slepcvec.h,571
slepcvec.h:^?slepcvec.h^A,1
#define SLEPCVEC_HSLEPCVEC_H15,494
#define VECCOMP VECCOMP19,588
PETSC_DEPRECATED_FUNCTION("Use VecNormalizeComplex()") PETSC_STATIC_INLINE PetscErrorCode SlepcVecNormalize(Vec xr,Vec xi,PetscBool c,PetscReal *nrm) {return VecNormalizeComplex(xr,xi,c,nrm);}SlepcVecNormalize32,1222
PETSC_DEPRECATED_FUNCTION("Use VecCheckOrthogonality()") PETSC_STATIC_INLINE PetscErrorCode SlepcCheckOrthogonality(Vec *V,PetscInt nv,Vec *W,PetscInt nw,Mat B,PetscViewer viewer,PetscReal *lev) {return VecCheckOrthogonality(V,nv,W,nw,B,viewer,lev);}SlepcCheckOrthogonality33,1415

include/slepcversion.h,846
slepcversion.h:^?slepcversion.h^A,1
#define SLEPCVERSION_HSLEPCVERSION_H2,29
#define SLEPC_VERSION_RELEASE SLEPC_VERSION_RELEASE4,53
#define SLEPC_VERSION_MAJOR SLEPC_VERSION_MAJOR5,88
#define SLEPC_VERSION_MINOR SLEPC_VERSION_MINOR6,123
#define SLEPC_VERSION_SUBMINOR SLEPC_VERSION_SUBMINOR7,159
#define SLEPC_VERSION_PATCH SLEPC_VERSION_PATCH8,194
#define SLEPC_RELEASE_DATE SLEPC_RELEASE_DATE9,229
#define SLEPC_VERSION_DATE SLEPC_VERSION_DATE10,283
#define SLEPC_VERSION_GIT SLEPC_VERSION_GIT13,360
#define SLEPC_VERSION_DATE_GIT SLEPC_VERSION_DATE_GIT17,448
#define SLEPC_VERSION_EQ(SLEPC_VERSION_EQ20,499
#define SLEPC_VERSION_ SLEPC_VERSION_26,720
#define SLEPC_VERSION_LT(SLEPC_VERSION_LT28,761
#define SLEPC_VERSION_LE(SLEPC_VERSION_LE36,1160
#define SLEPC_VERSION_GT(SLEPC_VERSION_GT40,1300
#define SLEPC_VERSION_GE(SLEPC_VERSION_GE43,1398

lib/slepc/bin/maint/generateetags.py,626
generateetags.py:^?generateetags.py^A,1
  def check_output(*popenargs, **kwargs):check_output20,457
DEVNULL = open(os.devnull, 'w')DEVNULL36,1078
def addFileNameTags(filename):addFileNameTags40,1161
def createTags(flist,etagfile,ctagfile):createTags61,1769
def createTagsBlock(flist,etagfile,ctagfile):createTagsBlock72,2141
def endsWithSuffix(file,suffixes):endsWithSuffix89,3100
def startsWithPrefix(file,prefixes):startsWithPrefix96,3277
def badWebIndex(dirname,file):badWebIndex103,3456
def processDir(flist, dirpath, dirnames, filenames):processDir112,3698
def processFiles(dirname,flist):processFiles142,4937
def main(ctags):main156,5376

lib/slepc/bin/maint/generatefortranstubs.py,453
generatefortranstubs.py:^?generatefortranstubs.py^A,1
  def check_output(*popenargs, **kwargs):check_output13,241
def FixFile(filename):FixFile30,864
def FindSource(filename):FindSource58,2363
def FixDir(petscdir,dir,verbose):FixDir72,2812
def PrepFtnDir(dir):PrepFtnDir159,5839
def processDir(petscdir, bfort, verbose, dirpath, dirnames, filenames):processDir173,6299
def processf90interfaces(petscdir,verbose):processf90interfaces199,8022
def main(petscdir,bfort,dir,verbose):main228,9457

lib/slepc/bin/maint/listexamples.sh,0
listexamples.sh:^?listexamples.sh^A,1

makefile,177
makefile:^?makefile^A,1
LOCDIR = ./LOCDIR15,516
DIRS   = src include docsDIRS16,528
	-@grep "define SLEPC_VERSION" ${SLEPC_DIR}/include/slepcversion.h | ${SED} "s/........//"SLEPC_VERSION63,3214

setup.py,1786
setup.py:^?setup.py^A,1
metadata = {metadata56,1671
CONFIGURE_OPTIONS = []CONFIGURE_OPTIONS61,1739
def bootstrap():bootstrap63,1763
def get_petsc_dir():get_petsc_dir100,3103
def get_petsc_arch():get_petsc_arch111,3436
def config(prefix, dry_run=False):config115,3531
def build(dry_run=False):build133,4100
def install(dest_dir, dry_run=False):install145,4503
class context(object):context157,4926
    def __init__(self):__init__158,4949
    def enter(self):enter161,5041
    def exit(self):exit166,5169
class cmd_install(_install):cmd_install170,5254
    def initialize_options(self):initialize_options172,5284
    def finalize_options(self):finalize_options176,5387
    def run(self):run181,5556
    def get_outputs(self):get_outputs201,6136
def version():version206,6280
def tarball():tarball226,7130
description = __doc__.split('\n')[1:-1]; del description[1:3]description232,7325
      version=version(),version253,7933
      description=description.pop(0),description254,7958
      long_description='\n'.join(description),long_description255,7996
      classifiers= classifiers.split('\n')[1:-1],classifiers256,8043
      keywords = ['SLEPc','PETSc', 'MPI'],keywords257,8093
      platforms=['POSIX'],platforms258,8136
      license='BSD',license259,8163
      url='http://slepc.upv.es/',url261,8185
      download_url=tarball(),download_url262,8219
      author='SLEPc Team',author264,8250
      author_email='slepc-maint@upv.es',author_email265,8277
      maintainer='Lisandro Dalcin',maintainer266,8318
      maintainer_email='dalcinl@gmail.com',maintainer_email267,8354
      packages = ['slepc'],packages269,8399
      package_dir = {'slepc': 'pypi'},package_dir270,8427
      cmdclass={'install': cmd_install},cmdclass271,8466

src/eps/examples/makefile,82
makefile:^?makefile^A,1
LOCDIR   = src/eps/examples/LOCDIR13,405
DIRS     = tests tutorialsDIRS14,434

src/eps/examples/tests/makefile,435
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/eps/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c \EXAMPLESC16,488
EXAMPLESF  = test7f.F test14f.F test15f.F test17f.F90EXAMPLESF22,865
MANSEC     = EPSMANSEC23,919
TESTS      = test1 test2 test3 test4 test5 test6 test7f test8 test9 test10 \TESTS24,936

src/eps/examples/tests/test1.c,141
test1.c:^?test1.c^A,1
static char help[] = "Tests B-orthonormality of eigenvectors in a GHEP problem.\n\n";help11,400
int main(int argc,char **argv)main15,510

src/eps/examples/tests/test10.c,153
test10.c:^?test10.c^A,1
static char help[] = "Computes the smallest nonzero eigenvalue of the Laplacian of a graph.\n\n"help11,400
int main (int argc,char **argv)main19,811

src/eps/examples/tests/test11.c,360
test11.c:^?test11.c^A,1
static char help[] = "Solves the same problem as in ex5, but with a user-defined sorting criterion."help11,400
int main(int argc,char **argv)main26,1033
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel118,4564
PetscErrorCode MyEigenSort(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)MyEigenSort171,6258

src/eps/examples/tests/test12.c,213
test12.c:^?test12.c^A,1
static char help[] = "Diagonal eigenproblem. Illustrates use of shell preconditioner.\n\n"help11,400
PetscErrorCode PCApply_User(PC pc,Vec x,Vec y)PCApply_User18,696
int main(int argc,char **argv)main27,861

src/eps/examples/tests/test13.c,269
test13.c:^?test13.c^A,1
static char help[] = "Test EPSSetArbitrarySelection.\n\n";help11,400
PetscErrorCode MyArbitrarySelection(PetscScalar eigr,PetscScalar eigi,Vec xr,Vec xi,PetscScalar *rr,PetscScalar *ri,void *ctx)MyArbitrarySelection15,483
int main(int argc,char **argv)main27,822

src/eps/examples/tests/test14.c,113
test14.c:^?test14.c^A,1
static char help[] = "Test EPS interface functions.\n\n";help11,400
int main(int argc,char **argv)main15,482

src/eps/examples/tests/test14f.F,804
test14f.F:^?test14f.F^A,1
      program mainmain14,541
 100  format (/'Diagonal Eigenproblem, n =',I3,' (Fortran)')10055,1840
 110  format (' Type set to ',A)11083,2906
 120  format (' Problem type before changing = ',I2)12089,3052
 130  format (' ... changed to ',I2)13095,3264
 140  format (' Extraction before changing = ',I2)140113,3776
 150  format (' ... changed to ',I2)150119,3987
 160  format (' Balance: ',I2,', its=',I2,', cutoff=',F9.6)160129,4257
 170  format (' Which = ',I2,', target = ',F4.1)170139,4613
 180  format (' Dimensions: nev=',I2,', ncv=',I2,', mpd=',I2)180148,4930
 190  format (' Tolerance =',F8.5,', max_its =',I4)190157,5189
 200  format (' Convergence test =',I2,', stopping test =',I2)200166,5515
 210  format (' Finished - converged reason =',I2,', its=',I4)210195,6737

src/eps/examples/tests/test15f.F,367
test15f.F:^?test15f.F^A,1
      program mainmain20,757
 100  format (/'1-D Laplacian Eigenproblem, n =',I3,' (Fortran)')10063,2005
 120  format (' Solution method: ',A)120141,4556
 130  format (' Number of requested eigenvalues:',I2)130147,4786
      subroutine MyEPSMonitor(MyEPSMonitor175,5745
 140  format(i3,' EPS nconv=',i2,' first unconverged value (error) ',   &140194,6326

src/eps/examples/tests/test16.c,269
test16.c:^?test16.c^A,1
static char help[] = "Tests a user-defined convergence test.\n\n";help11,400
PetscErrorCode MyConvergedAbsolute(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)MyConvergedAbsolute19,627
int main(int argc,char **argv)main26,851

src/eps/examples/tests/test17.c,141
test17.c:^?test17.c^A,1
static char help[] = "Test interface functions of spectrum-slicing Krylov-Schur.\n\n"help11,400
int main(int argc,char **argv)main18,718

src/eps/examples/tests/test17f.F90,1036
test17f.F90:^?test17f.F90^A,1
      program mainmain14,548
 100  format (/'Spectrum-slicing test, n =',I3,' (Fortran)'/)10061,2073
 110  format (' Restart parameter before changing = ',f7.4)110150,5490
 120  format (' ... changed to ',f7.4)120157,5763
 130  format (' Locking flag before changing = ',L)130163,5934
 140  format (' ... changed to ',L)140169,6189
 150  format (' Sub-solve dimensions before changing: nev=',I2,', ncv=',I2,', mpd=',I2)150175,6374
 160  format (' ... changed to: nev=',I2,', ncv=',I2,', mpd=',I2)160184,6730
 170    format (' Using ',I2,' partitions')170193,7056
 180    format (f7.4)180209,7655
 185  format (' .. ',f4.1,' (',I3,')')185228,8409
 190  format (' Found ',I2,' eigenvalues in interval [',f7.4,',',f7.4,']')190236,8692
 200    format (' Process ',I2,' has worked in sub-interval ',I2,', containing ',I2,' eigenvalues')200247,9110
 210    format (f7.4)210248,9210
 220    format (' Process ',I2,' owns ',I5,', rows of the global',' matrices, and ',I5,' rows in the subcommunicator')220257,9573

src/eps/examples/tests/test18.c,117
test18.c:^?test18.c^A,1
static char help[] = "Symmetric-indefinite eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main17,597

src/eps/examples/tests/test19.c,116
test19.c:^?test19.c^A,1
static char help[] = "Tests the usage of object prefix.\n\n"help11,400
int main(int argc,char **argv)main17,570

src/eps/examples/tests/test2.c,138
test2.c:^?test2.c^A,1
static char help[] = "Tests multiple calls to EPSSolve with the same matrix.\n\n";help11,400
int main(int argc,char **argv)main15,507

src/eps/examples/tests/test20.c,130
test20.c:^?test20.c^A,1
static char help[] = "Tests multiple calls to EPSSolve changing ncv.\n\n";help11,400
int main(int argc,char **argv)main15,499

src/eps/examples/tests/test21.c,181
test21.c:^?test21.c^A,1
static char help[] = "Illustrates region filtering. "help11,400
int main(int argc,char **argv)main23,693
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel104,4224

src/eps/examples/tests/test22.c,779
test22.c:^?test22.c^A,1
static char help[] = "Illustrates how to obtain invariant subspaces. "help11,400
  Mat         T;T41,1274
  Vec         x1,x2,y1,y2;x142,1291
  Vec         x1,x2,y1,y2;x242,1291
  Vec         x1,x2,y1,y2;y142,1291
  Vec         x1,x2,y1,y2;y242,1291
  PetscScalar alpha,beta,tau1,tau2,sigma;alpha43,1318
  PetscScalar alpha,beta,tau1,tau2,sigma;beta43,1318
  PetscScalar alpha,beta,tau1,tau2,sigma;tau143,1318
  PetscScalar alpha,beta,tau1,tau2,sigma;tau243,1318
  PetscScalar alpha,beta,tau1,tau2,sigma;sigma43,1318
} CTX_BRUSSEL;CTX_BRUSSEL44,1360
int main(int argc,char **argv)main46,1376
PetscErrorCode MatMult_Brussel(Mat A,Vec x,Vec y)MatMult_Brussel200,8378
PetscErrorCode MatGetDiagonal_Brussel(Mat A,Vec diag)MatGetDiagonal_Brussel237,9823

src/eps/examples/tests/test23.c,124
test23.c:^?test23.c^A,1
static char help[] = "Test EPS view and monitor functionality.\n\n";help11,400
int main(int argc,char **argv)main15,493

src/eps/examples/tests/test24.c,132
test24.c:^?test24.c^A,1
static char help[] = "Eigenproblem for the 1-D Laplacian with constraints. "help11,400
int main(int argc,char **argv)main18,636

src/eps/examples/tests/test25.c,125
test25.c:^?test25.c^A,1
static char help[] = "Solves a GNHEP problem with contour integral. "help11,400
int main(int argc,char **argv)main18,631

src/eps/examples/tests/test26.c,116
test26.c:^?test26.c^A,1
static char help[] = "Illustrates the PGNHEP problem type. "help11,400
int main(int argc,char **argv)main18,622

src/eps/examples/tests/test27.c,159
test27.c:^?test27.c^A,1
static char help[] = "Illustrates feeding exact eigenvectors as initial vectors of a second solve.\n\n"help11,400
int main(int argc,char **argv)main19,731

src/eps/examples/tests/test28.c,156
test28.c:^?test28.c^A,1
static char help[] = "Tests multiple calls to EPSSolve with different matrix of different size.\n\n"help11,400
int main(int argc,char **argv)main18,708

src/eps/examples/tests/test29.c,322
test29.c:^?test29.c^A,1
static char help[] = "Illustrates the computation of left eigenvectors for generalized eigenproblems.\n\n"help11,400
int main(int argc,char **argv)main22,782
PetscErrorCode ComputeResidualNorm(Mat A,Mat B,PetscBool trans,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec *z,PetscReal *norm)ComputeResidualNorm192,7430

src/eps/examples/tests/test3.c,139
test3.c:^?test3.c^A,1
static char help[] = "Tests multiple calls to EPSSolve with different matrix.\n\n";help11,400
int main(int argc,char **argv)main15,508

src/eps/examples/tests/test30.c,107
test30.c:^?test30.c^A,1
static char help[] = "Test changing EPS type.\n\n";help11,400
int main(int argc,char **argv)main15,476

src/eps/examples/tests/test31.c,117
test31.c:^?test31.c^A,1
static char help[] = "Test STFILTER interface functions.\n\n"help11,400
int main(int argc,char **argv)main19,689

src/eps/examples/tests/test32.c,129
test32.c:^?test32.c^A,1
static char help[] = "Tests a GHEP problem with symmetric matrices.\n\n";help11,400
int main(int argc,char **argv)main15,498

src/eps/examples/tests/test33.c,126
test33.c:^?test33.c^A,1
static char help[] = "Test interface to external package BLZPACK.\n\n"help11,400
int main(int argc,char **argv)main18,703

src/eps/examples/tests/test34.c,125
test34.c:^?test34.c^A,1
static char help[] = "Test interface to external package PRIMME.\n\n"help11,400
int main(int argc,char **argv)main18,702

src/eps/examples/tests/test35.c,125
test35.c:^?test35.c^A,1
static char help[] = "Test interface to external package PRIMME.\n\n"help11,400
int main(int argc,char **argv)main18,702

src/eps/examples/tests/test4.c,161
test4.c:^?test4.c^A,1
static char help[] = "Test the solution of a HEP without calling EPSSetFromOptions (based on ex1.c).\n\n"help11,400
int main(int argc,char **argv)main18,690

src/eps/examples/tests/test5.c,145
test5.c:^?test5.c^A,1
static char help[] = "Test EPS with different builds with a matrix loaded from a file.\n"help11,400
int main(int argc,char **argv)main18,696

src/eps/examples/tests/test6.c,105
test6.c:^?test6.c^A,1
static char help[] = "Diagonal eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main18,625

src/eps/examples/tests/test7f.F,227
test7f.F:^?test7f.F^A,1
      program mainmain20,784
 100  format (/'1-D Laplacian Eigenproblem, n =',I3,' (Fortran)')10059,1940
 120  format (' Solution method: ',A)120138,4415
 130  format (' Number of requested eigenvalues:',I2)130144,4645

src/eps/examples/tests/test8.c,400
test8.c:^?test8.c^A,1
static char help[] = "Solves the same eigenproblem as in example ex2, but using a shell matrix. "help11,400
int main(int argc,char **argv)main25,922
static void tv(int nx,const PetscScalar *x,PetscScalar *y)tv96,3870
PetscErrorCode MatMult_Laplacian2D(Mat A,Vec x,Vec y)MatMult_Laplacian2D127,4631
PetscErrorCode MatGetDiagonal_Laplacian2D(Mat A,Vec diag)MatGetDiagonal_Laplacian2D159,5428

src/eps/examples/tests/test9.c,372
test9.c:^?test9.c^A,1
static char help[] = "Eigenvalue problem associated with a Markov model of a random walk on a triangular grid. "help11,400
int main(int argc,char **argv)main25,1035
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel118,4546
PetscErrorCode MyEigenSort(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)MyEigenSort170,6214

src/eps/examples/tutorials/ex1.c,170
ex1.c:^?ex1.c^A,1
static char help[] = "Standard symmetric eigenproblem corresponding to the Laplacian operator in 1 dimension.\n\n"help11,400
int main(int argc,char **argv)main17,654

src/eps/examples/tutorials/ex10.c,709
ex10.c:^?ex10.c^A,1
static char help[] = "Illustrates the use of shell spectral transformations. "help11,400
  KSP        ksp;ksp21,814
} SampleShellST;SampleShellST22,832
int main (int argc,char **argv)main32,1225
PetscErrorCode STCreate_User(SampleShellST **shell)STCreate_User165,6717
PetscErrorCode STSetUp_User(SampleShellST *shell,ST st)STSetUp_User195,7741
PetscErrorCode STApply_User(ST st,Vec x,Vec y)STApply_User223,8519
PetscErrorCode STApplyTranspose_User(ST st,Vec x,Vec y)STApplyTranspose_User245,9075
PetscErrorCode STBackTransform_User(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_User273,9956
PetscErrorCode STDestroy_User(SampleShellST *shell)STDestroy_User291,10422

src/eps/examples/tutorials/ex11.c,153
ex11.c:^?ex11.c^A,1
static char help[] = "Computes the smallest nonzero eigenvalue of the Laplacian of a graph.\n\n"help11,400
int main (int argc,char **argv)main19,811

src/eps/examples/tutorials/ex12.c,154
ex12.c:^?ex12.c^A,1
static char help[] = "Compute all eigenvalues in an interval of a symmetric-definite problem.\n\n"help11,400
int main(int argc,char **argv)main18,706

src/eps/examples/tutorials/ex13.c,118
ex13.c:^?ex13.c^A,1
static char help[] = "Generalized Symmetric eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main22,898

src/eps/examples/tutorials/ex18.c,360
ex18.c:^?ex18.c^A,1
static char help[] = "Solves the same problem as in ex5, but with a user-defined sorting criterion."help11,400
int main(int argc,char **argv)main26,1033
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel137,5782
PetscErrorCode MyEigenSort(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)MyEigenSort190,7476

src/eps/examples/tutorials/ex19.c,352
ex19.c:^?ex19.c^A,1
static char help[] = "Standard symmetric eigenproblem for the 3-D Laplacian built with the DM interface.\n\n"help11,400
PetscErrorCode GetExactEigenvalues(PetscInt M,PetscInt N,PetscInt P,PetscInt nconv,PetscReal *exact)GetExactEigenvalues19,695
PetscErrorCode FillMatrix(DM da,Mat A)FillMatrix48,1515
int main(int argc,char **argv)main81,2838

src/eps/examples/tutorials/ex1f.F,507
ex1f.F:^?ex1f.F^A,1
      program mainmain21,845
 100  format (/'1-D Laplacian Eigenproblem, n =',I3,' (Fortran)')10062,2071
 110  format (/' Number of iterations of the method:',I4)110133,4326
 120  format (' Solution method: ',A)120140,4561
 130  format (' Number of requested eigenvalues:',I2)130146,4791
 140  format (' Stopping condition: tol=',1P,E11.4,', maxit=',I4)140151,4965
 150  format (' Number of converged eigenpairs:',I2/)150162,5371
 160      format (1P,'   ',E12.4,'       ',E12.4)160180,6101

src/eps/examples/tutorials/ex1f90.F90,227
ex1f90.F90:^?ex1f90.F90^A,1
      program mainmain21,847
 100  format (/'1-D Laplacian Eigenproblem, n =',I4,' (Fortran)')10064,2101
 120  format (' Solution method: ',A)120133,4609
 130  format (' Number of requested eigenvalues:',I4)130138,4806

src/eps/examples/tutorials/ex2.c,171
ex2.c:^?ex2.c^A,1
static char help[] = "Standard symmetric eigenproblem corresponding to the Laplacian operator in 2 dimensions.\n\n"help11,400
int main(int argc,char **argv)main18,723

src/eps/examples/tutorials/ex24.c,513
ex24.c:^?ex24.c^A,1
static char help[] = "Spectrum folding for a standard symmetric eigenproblem.\n\n"help11,400
  Mat       A;A23,797
  Vec       w;w24,812
  PetscReal target;target25,827
} CTX_FOLD;CTX_FOLD26,847
int main(int argc,char **argv)main35,1054
PetscErrorCode MatMult_Fold(Mat M,Vec x,Vec y)MatMult_Fold197,8018
PetscErrorCode RayleighQuotient(Mat A,Vec x,PetscScalar *r)RayleighQuotient217,8571
PetscErrorCode ComputeResidualNorm(Mat A,PetscScalar lambda,Vec x,PetscReal *r)ComputeResidualNorm233,8982

src/eps/examples/tutorials/ex25.c,138
ex25.c:^?ex25.c^A,1
static char help[] = "Spectrum slicing on generalized symmetric eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main19,730

src/eps/examples/tutorials/ex29.c,378
ex29.c:^?ex29.c^A,1
static char help[] = "Solves the same problem as in ex5, with a user-defined stopping test."help11,400
int main(int argc,char **argv)main28,1118
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel122,5681
PetscErrorCode MyStoppingTest(EPS eps,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,EPSConvergedReason *reason,void *ctx)MyStoppingTest172,7184

src/eps/examples/tutorials/ex3.c,401
ex3.c:^?ex3.c^A,1
static char help[] = "Solves the same eigenproblem as in example ex2, but using a shell matrix. "help11,400
int main(int argc,char **argv)main24,893
static void tv(int nx,const PetscScalar *x,PetscScalar *y)tv110,4494
PetscErrorCode MatMult_Laplacian2D(Mat A,Vec x,Vec y)MatMult_Laplacian2D141,5255
PetscErrorCode MatGetDiagonal_Laplacian2D(Mat A,Vec diag)MatGetDiagonal_Laplacian2D173,6052

src/eps/examples/tutorials/ex30.c,1197
ex30.c:^?ex30.c^A,1
static char help[] = "Illustrates the use of a region for filtering; the number of wanted eigenvalues in not known a priori.\n\n"help11,400
  Mat         T;T35,1551
  Vec         x1,x2,y1,y2;x136,1568
  Vec         x1,x2,y1,y2;x236,1568
  Vec         x1,x2,y1,y2;y136,1568
  Vec         x1,x2,y1,y2;y236,1568
  PetscScalar alpha,beta,tau1,tau2,sigma;alpha37,1595
  PetscScalar alpha,beta,tau1,tau2,sigma;beta37,1595
  PetscScalar alpha,beta,tau1,tau2,sigma;tau137,1595
  PetscScalar alpha,beta,tau1,tau2,sigma;tau237,1595
  PetscScalar alpha,beta,tau1,tau2,sigma;sigma37,1595
  PetscInt    lastnconv;      /* last value of nconv; used in stopping test */lastnconv38,1637
  PetscInt    nreps;          /* number of repetitions of nconv; used in stopping test */nreps39,1716
} CTX_BRUSSEL;CTX_BRUSSEL40,1806
int main(int argc,char **argv)main42,1822
PetscErrorCode MatMult_Brussel(Mat A,Vec x,Vec y)MatMult_Brussel180,7543
PetscErrorCode MatGetDiagonal_Brussel(Mat A,Vec diag)MatGetDiagonal_Brussel217,8988
PetscErrorCode MyStoppingTest(EPS eps,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,EPSConvergedReason *reason,void *ptr)MyStoppingTest252,10274

src/eps/examples/tutorials/ex31.c,4254
ex31.c:^?ex31.c^A,1
static char help[] = "Power grid small signal stability analysis of WECC 9 bus system.\n\help11,400
#define freq freq66,2370
#define w_s w_s67,2386
const PetscInt nbus    = 9; /* Number of network buses */nbus70,2441
const PetscInt ngen    = 3; /* Number of generators */ngen71,2499
const PetscInt nload   = 3; /* Number of loads */nload72,2554
const PetscInt gbus[3] = {0,1,2}; /* Buses at which generators are incident */gbus73,2604
const PetscInt lbus[3] = {4,5,7}; /* Buses at which loads are incident */lbus74,2683
const PetscScalar PG[3] = {0.716786142395021,1.630000000000000,0.850000000000000};PG77,2820
const PetscScalar QG[3] = {0.270702180178785,0.066120127797275,-0.108402221791588};QG78,2903
const PetscScalar H[3]    = {23.64,6.4,3.01};   /* Inertia constant */H80,3013
const PetscScalar Rs[3]   = {0.0,0.0,0.0}; /* Stator Resistance */Rs81,3084
const PetscScalar Xd[3]   = {0.146,0.8958,1.3125};  /* d-axis reactance */Xd82,3151
const PetscScalar Xdp[3]  = {0.0608,0.1198,0.1813}; /* d-axis transient reactance */Xdp83,3226
const PetscScalar Xq[3]   = {0.0969,0.8645,1.2578}; /* q-axis reactance Xq(1) set to 0.4360, value given in text 0.0969 */Xq84,3311
const PetscScalar Xqp[3]  = {0.0969,0.1969,0.25}; /* q-axis transient reactance */Xqp85,3434
const PetscScalar Td0p[3] = {8.96,6.0,5.89}; /* d-axis open circuit time constant */Td0p86,3517
const PetscScalar Tq0p[3] = {0.31,0.535,0.6}; /* q-axis open circuit time constant */Tq0p87,3602
PetscScalar M[3]; /* M = 2*H/w_s */M88,3688
PetscScalar D[3]; /* D = 0.1*M */D89,3724
PetscScalar TM[3]; /* Mechanical Torque */TM91,3759
const PetscScalar KA[3] = {20.0,20.0,20.0};  /* Voltage regulartor gain constant */KA93,3833
const PetscScalar TA[3] = {0.2,0.2,0.2};     /* Voltage regulator time constant */TA94,3917
const PetscScalar KE[3] = {1.0,1.0,1.0};     /* Exciter gain constant */KE95,4000
const PetscScalar TE[3] = {0.314,0.314,0.314}; /* Exciter time constant */TE96,4073
const PetscScalar KF[3] = {0.063,0.063,0.063};  /* Feedback stabilizer gain constant */KF97,4148
const PetscScalar TF[3] = {0.35,0.35,0.35};    /* Feedback stabilizer time constant */TF98,4236
const PetscScalar k1[3] = {0.0039,0.0039,0.0039};k199,4323
const PetscScalar k2[3] = {1.555,1.555,1.555};  /* k1 and k2 for calculating the saturation function SE = k1*exp(k2*Efd) */k2100,4373
PetscScalar Vref[3];Vref102,4498
const PetscScalar PD0[3] = {1.25,0.9,1.0};PD0118,5339
const PetscScalar QD0[3] = {0.5,0.3,0.35};QD0119,5382
const PetscInt    ld_nsegsp[3] = {3,3,3};ld_nsegsp120,5425
const PetscScalar ld_alphap[3] = {0.0,0.0,1.0};ld_alphap121,5467
const PetscScalar ld_betap[3]  = {2.0,1.0,0.0};ld_betap122,5515
const PetscInt    ld_nsegsq[3] = {3,3,3};ld_nsegsq123,5563
const PetscScalar ld_alphaq[3] = {0.0,0.0,1.0};ld_alphaq124,5605
const PetscScalar ld_betaq[3]  = {2.0,1.0,0.0};ld_betaq125,5653
  DM       dmgen, dmnet; /* DMs to manage generator and network subsystem */dmgen128,5719
  DM       dmgen, dmnet; /* DMs to manage generator and network subsystem */dmnet128,5719
  DM       dmpgrid;      /* Composite DM to manage the entire power grid */dmpgrid129,5796
  Mat      Ybus;         /* Network admittance matrix */Ybus130,5872
  Vec      V0;           /* Initial voltage vector (Power flow solution) */V0131,5929
  PetscInt neqs_gen,neqs_net,neqs_pgrid;neqs_gen132,6005
  PetscInt neqs_gen,neqs_net,neqs_pgrid;neqs_net132,6005
  PetscInt neqs_gen,neqs_net,neqs_pgrid;neqs_pgrid132,6005
  IS       is_diff;      /* indices for differential equations */is_diff133,6046
  IS       is_alg;       /* indices for algebraic equations */is_alg134,6112
} Userctx;Userctx135,6175
PetscErrorCode dq2ri(PetscScalar Fd,PetscScalar Fq,PetscScalar delta,PetscScalar *Fr,PetscScalar *Fi)dq2ri138,6273
PetscErrorCode ri2dq(PetscScalar Fr,PetscScalar Fi,PetscScalar delta,PetscScalar *Fd,PetscScalar *Fq)ri2dq147,6639
PetscErrorCode SetInitialGuess(Vec X,Userctx *user)SetInitialGuess155,6918
PetscErrorCode PreallocateJacobian(Mat J,Userctx *user)PreallocateJacobian240,9539
PetscErrorCode ResidualJacobian(Vec X,Mat J,void *ctx)ResidualJacobian289,10671
int main(int argc,char **argv)main519,20949

src/eps/examples/tutorials/ex34.c,1423
ex34.c:^?ex34.c^A,1
static char help[] = "Nonlinear inverse iteration for A(x)*x=lambda*B(x)*x.\n\n";help23,790
  IS    bdis; /* global indices for boundary DoFs */bdis40,1367
} AppCtx;AppCtx41,1420
int main(int argc,char **argv)main43,1431
static void f0_u(PetscInt dim, PetscInt Nf, PetscInt NfAux,f0_u160,6298
static void f1_u(PetscInt dim, PetscInt Nf, PetscInt NfAux,f1_u171,6863
static void g0_uu(PetscInt dim, PetscInt Nf, PetscInt NfAux,g0_uu186,7542
static void g3_uu(PetscInt dim, PetscInt Nf, PetscInt NfAux,g3_uu195,8132
PetscErrorCode SetupDiscretization(DM dm)SetupDiscretization204,8681
PetscErrorCode CreateSquareMesh(MPI_Comm comm,DM *dm)CreateSquareMesh221,9232
PetscErrorCode BoundaryGlobalIndex(DM dm,const char labelname[],IS *bdis)BoundaryGlobalIndex242,9839
static PetscErrorCode FormJacobian(SNES snes,Vec X,Mat A,Mat B,void *ctx)FormJacobian277,11247
PetscErrorCode FormJacobianA(SNES snes,Vec X,Mat A,Mat B,void *ctx)FormJacobianA300,12015
PetscErrorCode FormJacobianB(SNES snes,Vec X,Mat A,Mat B,void *ctx)FormJacobianB317,12605
PetscErrorCode FormFunctionAB(SNES snes,Vec x,Vec Ax,Vec Bx,void *ctx)FormFunctionAB334,13195
static PetscErrorCode FormFunction(SNES snes,Vec X,Vec F,void *ctx)FormFunction351,13711
PetscErrorCode FormFunctionA(SNES snes,Vec X,Vec F,void *ctx)FormFunctionA376,14656
PetscErrorCode FormFunctionB(SNES snes,Vec X,Vec F,void *ctx)FormFunctionB416,16024

src/eps/examples/tutorials/ex35.c,503
ex35.c:^?ex35.c^A,1
static char help[] = "Shell spectral transformations with a non-injective mapping. "help11,400
  Mat         A;A21,839
  Vec         w;w22,856
  PetscScalar target;target23,873
} FoldShellST;FoldShellST24,895
int main (int argc,char **argv)main31,1108
PetscErrorCode STCreate_Fold(Mat A,PetscScalar target,FoldShellST **fold)STCreate_Fold147,6199
PetscErrorCode STApply_Fold(ST st,Vec x,Vec y)STApply_Fold172,6807
PetscErrorCode STDestroy_Fold(FoldShellST *fold)STDestroy_Fold194,7414

src/eps/examples/tutorials/ex36.c,329
ex36.c:^?ex36.c^A,1
static char help[] = "Use the matrix exponential to compute rightmost eigenvalues.\n\n"help11,400
int main(int argc,char **argv)main43,1434
PetscErrorCode STBackTransform_Exp(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_Exp182,7525
PetscErrorCode STApply_Exp(ST st,Vec x,Vec y)STApply_Exp224,8581

src/eps/examples/tutorials/ex4.c,152
ex4.c:^?ex4.c^A,1
static char help[] = "Solves a standard eigensystem Ax=kx with the matrix loaded from a file.\n"help11,400
int main(int argc,char **argv)main18,701

src/eps/examples/tutorials/ex41.c,357
ex41.c:^?ex41.c^A,1
static char help[] = "Illustrates the computation of left eigenvectors.\n\n"help11,400
int main(int argc,char **argv)main24,841
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel182,7275
PetscErrorCode ComputeResidualNorm(Mat A,PetscBool trans,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec u,PetscReal *norm)ComputeResidualNorm237,8911

src/eps/examples/tutorials/ex5.c,240
ex5.c:^?ex5.c^A,1
static char help[] = "Eigenvalue problem associated with a Markov model of a random walk on a triangular grid. "help11,400
int main(int argc,char **argv)main24,924
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel140,5818

src/eps/examples/tutorials/ex6f90.F90,319
ex6f90.F90:^?ex6f90.F90^A,1
      program mainmain22,932
      subroutine MatIsing_Mult(MatIsing_Mult149,5807
      SUBROUTINE MVMISG(MVMISG182,6815
   10       CONTINUE10258,8779
   20       CONTINUE20265,9050
   30    CONTINUE30267,9073
   40       CONTINUE40278,9354
   50       CONTINUE50284,9617
   60    CONTINUE60288,9726

src/eps/examples/tutorials/ex7.c,154
ex7.c:^?ex7.c^A,1
static char help[] = "Solves a generalized eigensystem Ax=kBx with matrices loaded from a file.\n"help11,400
int main(int argc,char **argv)main22,976

src/eps/examples/tutorials/ex9.c,950
ex9.c:^?ex9.c^A,1
static char help[] = "Solves a problem associated to the Brusselator wave model in chemical reactions, illustrating the use of shell matrices.\n\n"help11,400
  Mat         T;T44,1389
  Vec         x1,x2,y1,y2;x145,1406
  Vec         x1,x2,y1,y2;x245,1406
  Vec         x1,x2,y1,y2;y145,1406
  Vec         x1,x2,y1,y2;y245,1406
  PetscScalar alpha,beta,tau1,tau2,sigma;alpha46,1433
  PetscScalar alpha,beta,tau1,tau2,sigma;beta46,1433
  PetscScalar alpha,beta,tau1,tau2,sigma;tau146,1433
  PetscScalar alpha,beta,tau1,tau2,sigma;tau246,1433
  PetscScalar alpha,beta,tau1,tau2,sigma;sigma46,1433
} CTX_BRUSSEL;CTX_BRUSSEL47,1475
int main(int argc,char **argv)main49,1491
PetscErrorCode MatMult_Brussel(Mat A,Vec x,Vec y)MatMult_Brussel194,7268
PetscErrorCode MatMultTranspose_Brussel(Mat A,Vec x,Vec y)MatMultTranspose_Brussel231,8703
PetscErrorCode MatGetDiagonal_Brussel(Mat A,Vec diag)MatGetDiagonal_Brussel268,10165

src/eps/examples/tutorials/makefile,359
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/eps/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex1.c ex2.c ex3.c ex4.c ex5.c ex7.c ex9.c ex10.c ex11.c ex12.c ex13.c \EXAMPLESC16,492
EXAMPLESF  = ex1f.F ex1f90.F90 ex6f90.F90EXAMPLESF18,667
MANSEC     = EPSMANSEC19,709

src/eps/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcepsmod.FSOURCEF17,514
SOURCEH    = slepceps.h slepceps.h90SOURCEH18,541
LIBBASE    = libslepcepsLIBBASE19,578
MANSEC     = EPSMANSEC20,603
LOCDIR     = src/eps/f90-mod/LOCDIR21,620
CLEANFILES = *.modCLEANFILES22,650

src/eps/f90-mod/slepceps.h,146
slepceps.h:^?slepceps.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      EPS, parameter :: SLEPC_NULL_EPS = tEPS(0)EPS18,593

src/eps/f90-mod/slepcepsmod.F,86
slepcepsmod.F:^?slepcepsmod.F^A,1
        module slepcepsdefslepcepsdef10,398
        module slepcepsslepceps20,624

src/eps/impls/cg/lobpcg/lobpcg.c,2105
lobpcg.c:^?lobpcg.c^A,1
  PetscInt  bs;        /* block size */bs34,1108
  PetscBool lock;      /* soft locking active/inactive */lock35,1148
  PetscReal restart;   /* restart parameter */restart36,1206
  PetscInt  guard;     /* number of guard vectors */guard37,1253
} EPS_LOBPCG;EPS_LOBPCG38,1306
PetscErrorCode EPSSetDimensions_LOBPCG(EPS eps,PetscInt nev,PetscInt *ncv,PetscInt *mpd)EPSSetDimensions_LOBPCG40,1321
PetscErrorCode EPSSetUp_LOBPCG(EPS eps)EPSSetUp_LOBPCG55,1914
PetscErrorCode EPSSolve_LOBPCG(EPS eps)EPSSolve_LOBPCG88,3689
static PetscErrorCode EPSLOBPCGSetBlockSize_LOBPCG(EPS eps,PetscInt bs)EPSLOBPCGSetBlockSize_LOBPCG414,16740
PetscErrorCode EPSLOBPCGSetBlockSize(EPS eps,PetscInt bs)EPSLOBPCGSetBlockSize444,17484
static PetscErrorCode EPSLOBPCGGetBlockSize_LOBPCG(EPS eps,PetscInt *bs)EPSLOBPCGGetBlockSize_LOBPCG455,17804
PetscErrorCode EPSLOBPCGGetBlockSize(EPS eps,PetscInt *bs)EPSLOBPCGGetBlockSize479,18255
static PetscErrorCode EPSLOBPCGSetRestart_LOBPCG(EPS eps,PetscReal restart)EPSLOBPCGSetRestart_LOBPCG490,18563
PetscErrorCode EPSLOBPCGSetRestart(EPS eps,PetscReal restart)EPSLOBPCGSetRestart526,19690
static PetscErrorCode EPSLOBPCGGetRestart_LOBPCG(EPS eps,PetscReal *restart)EPSLOBPCGGetRestart_LOBPCG537,20024
PetscErrorCode EPSLOBPCGGetRestart(EPS eps,PetscReal *restart)EPSLOBPCGGetRestart561,20504
static PetscErrorCode EPSLOBPCGSetLocking_LOBPCG(EPS eps,PetscBool lock)EPSLOBPCGSetLocking_LOBPCG572,20826
PetscErrorCode EPSLOBPCGSetLocking(EPS eps,PetscBool lock)EPSLOBPCGSetLocking603,21583
static PetscErrorCode EPSLOBPCGGetLocking_LOBPCG(EPS eps,PetscBool *lock)EPSLOBPCGGetLocking_LOBPCG614,21908
PetscErrorCode EPSLOBPCGGetLocking(EPS eps,PetscBool *lock)EPSLOBPCGGetLocking638,22366
PetscErrorCode EPSView_LOBPCG(EPS eps,PetscViewer viewer)EPSView_LOBPCG649,22679
PetscErrorCode EPSSetFromOptions_LOBPCG(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_LOBPCG665,23335
PetscErrorCode EPSDestroy_LOBPCG(EPS eps)EPSDestroy_LOBPCG688,24349
SLEPC_EXTERN PetscErrorCode EPSCreate_LOBPCG(EPS eps)EPSCreate_LOBPCG703,25105

src/eps/impls/cg/lobpcg/makefile,277
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = lobpcg.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcepsLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = EPSMANSEC20,507
LOCDIR   = src/eps/impls/cg/lobpcg/LOCDIR21,522

src/eps/impls/cg/makefile,145
makefile:^?makefile^A,1
LIBBASE  = libslepcepsLIBBASE13,409
DIRS     = rqcg lobpcgDIRS14,432
LOCDIR   = src/eps/impls/cg/LOCDIR15,455
MANSEC   = EPSMANSEC16,484

src/eps/impls/cg/rqcg/makefile,273
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rqcg.cSOURCEC15,431
SOURCEF  =SOURCEF16,449
SOURCEH  =SOURCEH17,460
LIBBASE  = libslepcepsLIBBASE18,471
DIRS     =DIRS19,494
MANSEC   = EPSMANSEC20,505
LOCDIR   = src/eps/impls/cg/rqcg/LOCDIR21,520

src/eps/impls/cg/rqcg/rqcg.c,1300
rqcg.c:^?rqcg.c^A,1
  PetscInt nrest;         /* user-provided reset parameter */nrest32,980
  PetscInt allocsize;     /* number of columns of work BV's allocated at setup */allocsize33,1042
  BV       AV,W,P,G;AV34,1124
  BV       AV,W,P,G;W34,1124
  BV       AV,W,P,G;P34,1124
  BV       AV,W,P,G;G34,1124
} EPS_RQCG;EPS_RQCG35,1145
PetscErrorCode EPSSetUp_RQCG(EPS eps)EPSSetUp_RQCG37,1158
static PetscErrorCode ExtractSubmatrix(Mat A,PetscInt k,Mat *B)ExtractSubmatrix90,3600
PetscErrorCode EPSSolve_RQCG(EPS eps)EPSSolve_RQCG109,4206
static PetscErrorCode EPSRQCGSetReset_RQCG(EPS eps,PetscInt nrest)EPSRQCGSetReset_RQCG281,11794
PetscErrorCode EPSRQCGSetReset(EPS eps,PetscInt nrest)EPSRQCGSetReset313,12602
static PetscErrorCode EPSRQCGGetReset_RQCG(EPS eps,PetscInt *nrest)EPSRQCGGetReset_RQCG324,12919
PetscErrorCode EPSRQCGGetReset(EPS eps,PetscInt *nrest)EPSRQCGGetReset348,13366
PetscErrorCode EPSReset_RQCG(EPS eps)EPSReset_RQCG359,13671
PetscErrorCode EPSSetFromOptions_RQCG(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_RQCG373,14027
PetscErrorCode EPSDestroy_RQCG(EPS eps)EPSDestroy_RQCG389,14537
PetscErrorCode EPSView_RQCG(EPS eps,PetscViewer viewer)EPSView_RQCG400,14887
SLEPC_EXTERN PetscErrorCode EPSCreate_RQCG(EPS eps)EPSCreate_RQCG414,15307

src/eps/impls/ciss/ciss.c,7215
ciss.c:^?ciss.c^A,1
  PetscInt          N;          /* number of integration points (32) */N38,1211
  PetscInt          L;          /* block size (16) */L39,1283
  PetscInt          M;          /* moment degree (N/4 = 4) */M40,1337
  PetscReal         delta;      /* threshold of singular value (1e-12) */delta41,1399
  PetscInt          L_max;      /* maximum number of columns of the source matrix V */L_max42,1473
  PetscReal         spurious_threshold; /* discard spurious eigenpairs */spurious_threshold43,1560
  PetscBool         isreal;     /* A and B are real */isreal44,1634
  PetscInt          npart;      /* number of partitions */npart45,1689
  PetscInt          refine_inner;refine_inner46,1748
  PetscInt          refine_blocksize;refine_blocksize47,1782
  PetscReal         *sigma;     /* threshold for numerical rank */sigma49,1841
  PetscInt          subcomm_id;subcomm_id50,1908
  PetscInt          num_solve_point;num_solve_point51,1940
  PetscScalar       *weight;weight52,1977
  PetscScalar       *omega;omega53,2006
  PetscScalar       *pp;pp54,2034
  BV                V;V55,2059
  BV                S;S56,2082
  BV                pV;pV57,2105
  BV                Y;Y58,2129
  Vec               xsub;xsub59,2152
  Vec               xdup;xdup60,2178
  KSP               *ksp;       /* ksp array for storing factorizations at integration points */ksp61,2204
  PetscBool         useconj;useconj62,2301
  PetscReal         est_eig;est_eig63,2330
  VecScatter        scatterin;scatterin64,2359
  Mat               pA,pB;pA65,2390
  Mat               pA,pB;pB65,2390
  PetscSubcomm      subcomm;subcomm66,2417
  PetscBool         usest;usest67,2446
  PetscBool         usest_set;  /* whether the user set the usest flag or not */usest_set68,2473
  EPSCISSQuadRule   quad;quad69,2554
  EPSCISSExtraction extraction;extraction70,2580
} EPS_CISS;EPS_CISS71,2612
PETSC_STATIC_INLINE PetscErrorCode EPSCISSResetSolvers(EPS eps)EPSCISSResetSolvers74,2691
PETSC_STATIC_INLINE PetscErrorCode EPSCISSResetSubcomm(EPS eps)EPSCISSResetSubcomm91,3138
PETSC_STATIC_INLINE PetscErrorCode EPSCISSSetUseConj(EPS eps,PetscBool *useconj)EPSCISSSetUseConj104,3571
PETSC_STATIC_INLINE PetscErrorCode EPSCISSSetUpSubComm(EPS eps,PetscInt *num_solve_point)EPSCISSSetUpSubComm135,4650
static PetscErrorCode CISSRedundantMat(EPS eps)CISSRedundantMat154,5464
static PetscErrorCode CISSScatterVec(EPS eps)CISSScatterVec179,6330
static PetscErrorCode SetPathParameter(EPS eps)SetPathParameter218,7910
static PetscErrorCode CISSVecSetRandom(BV V,PetscInt i0,PetscInt i1)CISSVecSetRandom306,11667
static PetscErrorCode VecScatterVecs(EPS eps,BV Vin,PetscInt n)VecScatterVecs330,12378
static PetscErrorCode SolveLinearSystem(EPS eps,Mat A,Mat B,BV V,PetscInt L_start,PetscInt L_end,PetscBool initksp)SolveLinearSystem355,13371
static PetscErrorCode EstimateNumberEigs(EPS eps,PetscInt *L_add)EstimateNumberEigs413,15525
static PetscErrorCode CalcMu(EPS eps,PetscScalar *Mu)CalcMu462,17475
static PetscErrorCode BlockHankel(EPS eps,PetscScalar *Mu,PetscInt s,PetscScalar *H)BlockHankel515,19695
static PetscErrorCode SVD_H0(EPS eps,PetscScalar *S,PetscInt *K)SVD_H0528,20024
static PetscErrorCode ConstructS(EPS eps)ConstructS570,21432
static PetscErrorCode SVD_S(BV S,PetscInt ml,PetscReal delta,PetscReal *sigma,PetscInt *K)SVD_S618,23298
static PetscErrorCode isGhost(EPS eps,PetscInt ld,PetscInt nv,PetscBool *fl)isGhost728,27689
static PetscErrorCode rescale_eig(EPS eps,PetscInt nv)rescale_eig763,28684
PetscErrorCode EPSSetUp_CISS(EPS eps)EPSSetUp_CISS831,31360
PetscErrorCode EPSSolve_CISS(EPS eps)EPSSolve_CISS965,38005
static PetscErrorCode EPSCISSSetSizes_CISS(EPS eps,PetscInt ip,PetscInt bs,PetscInt ms,PetscInt npart,PetscInt bsmax,PetscBool realmats)EPSCISSSetSizes_CISS1185,47262
PetscErrorCode EPSCISSSetSizes(EPS eps,PetscInt ip,PetscInt bs,PetscInt ms,PetscInt npart,PetscInt bsmax,PetscBool realmats)EPSCISSSetSizes1263,50318
static PetscErrorCode EPSCISSGetSizes_CISS(EPS eps,PetscInt *ip,PetscInt *bs,PetscInt *ms,PetscInt *npart,PetscInt *bsmax,PetscBool *realmats)EPSCISSGetSizes_CISS1279,51005
PetscErrorCode EPSCISSGetSizes(EPS eps,PetscInt *ip,PetscInt *bs,PetscInt *ms,PetscInt *npart,PetscInt *bsmax,PetscBool *realmats)EPSCISSGetSizes1313,51874
static PetscErrorCode EPSCISSSetThreshold_CISS(EPS eps,PetscReal delta,PetscReal spur)EPSCISSSetThreshold_CISS1323,52296
PetscErrorCode EPSCISSSetThreshold(EPS eps,PetscReal delta,PetscReal spur)EPSCISSSetThreshold1362,53432
static PetscErrorCode EPSCISSGetThreshold_CISS(EPS eps,PetscReal *delta,PetscReal *spur)EPSCISSGetThreshold_CISS1374,53837
PetscErrorCode EPSCISSGetThreshold(EPS eps,PetscReal *delta,PetscReal *spur)EPSCISSGetThreshold1401,54464
static PetscErrorCode EPSCISSSetRefinement_CISS(EPS eps,PetscInt inner,PetscInt blsize)EPSCISSSetRefinement_CISS1411,54778
PetscErrorCode EPSCISSSetRefinement(EPS eps,PetscInt inner,PetscInt blsize)EPSCISSSetRefinement1450,55990
static PetscErrorCode EPSCISSGetRefinement_CISS(EPS eps,PetscInt *inner,PetscInt *blsize)EPSCISSGetRefinement_CISS1462,56397
PetscErrorCode EPSCISSGetRefinement(EPS eps, PetscInt *inner, PetscInt *blsize)EPSCISSGetRefinement1489,57072
static PetscErrorCode EPSCISSSetUseST_CISS(EPS eps,PetscBool usest)EPSCISSSetUseST_CISS1499,57390
PetscErrorCode EPSCISSSetUseST(EPS eps,PetscBool usest)EPSCISSSetUseST1527,58066
static PetscErrorCode EPSCISSGetUseST_CISS(EPS eps,PetscBool *usest)EPSCISSGetUseST_CISS1538,58386
PetscErrorCode EPSCISSGetUseST(EPS eps,PetscBool *usest)EPSCISSGetUseST1563,58881
static PetscErrorCode EPSCISSSetQuadRule_CISS(EPS eps,EPSCISSQuadRule quad)EPSCISSSetQuadRule_CISS1574,59189
PetscErrorCode EPSCISSSetQuadRule(EPS eps,EPSCISSQuadRule quad)EPSCISSSetQuadRule1606,60014
static PetscErrorCode EPSCISSGetQuadRule_CISS(EPS eps,EPSCISSQuadRule *quad)EPSCISSGetQuadRule_CISS1617,60349
PetscErrorCode EPSCISSGetQuadRule(EPS eps,EPSCISSQuadRule *quad)EPSCISSGetQuadRule1641,60821
static PetscErrorCode EPSCISSSetExtraction_CISS(EPS eps,EPSCISSExtraction extraction)EPSCISSSetExtraction_CISS1652,61140
PetscErrorCode EPSCISSSetExtraction(EPS eps,EPSCISSExtraction extraction)EPSCISSSetExtraction1684,62022
static PetscErrorCode EPSCISSGetExtraction_CISS(EPS eps,EPSCISSExtraction *extraction)EPSCISSGetExtraction_CISS1695,62383
PetscErrorCode EPSCISSGetExtraction(EPS eps,EPSCISSExtraction *extraction)EPSCISSGetExtraction1719,62899
static PetscErrorCode EPSCISSGetKSPs_CISS(EPS eps,PetscInt *nsolve,KSP **ksp)EPSCISSGetKSPs_CISS1730,63244
PetscErrorCode EPSCISSGetKSPs(EPS eps,PetscInt *nsolve,KSP **ksp)EPSCISSGetKSPs1785,65374
PetscErrorCode EPSReset_CISS(EPS eps)EPSReset_CISS1795,65666
PetscErrorCode EPSSetFromOptions_CISS(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_CISS1821,66414
PetscErrorCode EPSDestroy_CISS(EPS eps)EPSDestroy_CISS1875,69739
PetscErrorCode EPSView_CISS(EPS eps,PetscViewer viewer)EPSView_CISS1900,71329
PetscErrorCode EPSSetDefaultST_CISS(EPS eps)EPSSetDefaultST_CISS1929,72945
SLEPC_EXTERN PetscErrorCode EPSCreate_CISS(EPS eps)EPSCreate_CISS1948,73492

src/eps/impls/ciss/makefile,270
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = ciss.cSOURCEC15,431
SOURCEF  =SOURCEF16,449
SOURCEH  =SOURCEH17,460
LIBBASE  = libslepcepsLIBBASE18,471
DIRS     =DIRS19,494
MANSEC   = EPSMANSEC20,505
LOCDIR   = src/eps/impls/ciss/LOCDIR21,520

src/eps/impls/davidson/davidson.c,1315
davidson.c:^?davidson.c^A,1
static PetscBool  cited = PETSC_FALSE;cited16,491
static const char citation[] =citation17,530
PetscErrorCode EPSSetUp_XD(EPS eps)EPSSetUp_XD29,982
PetscErrorCode EPSSolve_XD(EPS eps)EPSSolve_XD185,8176
PetscErrorCode EPSReset_XD(EPS eps)EPSReset_XD225,9494
PetscErrorCode EPSXDSetKrylovStart_XD(EPS eps,PetscBool krylovstart)EPSXDSetKrylovStart_XD240,9996
PetscErrorCode EPSXDGetKrylovStart_XD(EPS eps,PetscBool *krylovstart)EPSXDGetKrylovStart_XD249,10203
PetscErrorCode EPSXDSetBlockSize_XD(EPS eps,PetscInt blocksize)EPSXDSetBlockSize_XD258,10412
PetscErrorCode EPSXDGetBlockSize_XD(EPS eps,PetscInt *blocksize)EPSXDGetBlockSize_XD269,10805
PetscErrorCode EPSXDSetRestart_XD(EPS eps,PetscInt minv,PetscInt plusk)EPSXDSetRestart_XD278,11005
PetscErrorCode EPSXDGetRestart_XD(EPS eps,PetscInt *minv,PetscInt *plusk)EPSXDGetRestart_XD292,11601
PetscErrorCode EPSXDGetInitialSize_XD(EPS eps,PetscInt *initialsize)EPSXDGetInitialSize_XD302,11845
PetscErrorCode EPSXDSetInitialSize_XD(EPS eps,PetscInt initialsize)EPSXDSetInitialSize_XD311,12053
PetscErrorCode EPSXDSetBOrth_XD(EPS eps,PetscBool borth)EPSXDSetBOrth_XD322,12465
PetscErrorCode EPSXDGetBOrth_XD(EPS eps,PetscBool *borth)EPSXDGetBOrth_XD331,12646
PetscErrorCode EPSComputeVectors_XD(EPS eps)EPSComputeVectors_XD348,13201

src/eps/impls/davidson/davidson.h,8768
davidson.h:^?davidson.h^A,1
typedef PetscErrorCode (*dvdCallback)(struct _dvdDashboard*);dvdCallback22,683
typedef struct _dvdFunctionList {_dvdFunctionList23,745
  dvdCallback f;f24,779
  struct _dvdFunctionList *next;next25,796
} dvdFunctionList;dvdFunctionList26,829
  DVD_HARM_NONE,DVD_HARM_NONE29,864
  DVD_HARM_RR,DVD_HARM_RR30,881
  DVD_HARM_RRR,DVD_HARM_RRR31,896
  DVD_HARM_REIGS,DVD_HARM_REIGS32,912
  DVD_HARM_LEIGSDVD_HARM_LEIGS33,930
} HarmType_t;HarmType_t34,947
  DVD_INITV_CLASSIC,DVD_INITV_CLASSIC37,977
  DVD_INITV_KRYLOVDVD_INITV_KRYLOV38,998
} InitType_t;InitType_t39,1017
typedef struct _dvdDashboard {_dvdDashboard46,1130
  PetscErrorCode (*initV)(struct _dvdDashboard*);initV49,1211
  void *initV_data;initV_data50,1261
  PetscErrorCode (*calcPairs)(struct _dvdDashboard*);calcPairs53,1329
  void *calcPairs_data;calcPairs_data54,1383
  PetscBool (*testConv)(struct _dvdDashboard*,PetscScalar,PetscScalar,PetscReal,PetscReal*);testConv57,1447
  void *testConv_data;testConv_data58,1540
  PetscErrorCode (*improveX)(struct _dvdDashboard*,PetscInt,PetscInt,PetscInt*);improveX61,1604
  void *improveX_data;improveX_data62,1685
  PetscErrorCode (*isRestarting)(struct _dvdDashboard*,PetscBool*);isRestarting65,1738
  void *isRestarting_data;isRestarting_data66,1806
  PetscErrorCode (*restartV)(struct _dvdDashboard*);restartV69,1861
  void *restartV_data;restartV_data70,1914
  PetscErrorCode (*updateV)(struct _dvdDashboard*);updateV73,1955
  void *updateV_data;updateV_data74,2007
  Mat         A,B;            /* problem matrices */A77,2066
  Mat         A,B;            /* problem matrices */B77,2066
  MatType_t   sA,sB;          /* matrix specifications */sA78,2119
  MatType_t   sA,sB;          /* matrix specifications */sB78,2119
  EPType_t    sEP;            /* problem specifications */sEP79,2177
  PetscInt    nev;            /* number of eigenpairs */nev80,2236
  EPSWhich    which;          /* spectrum selection */which81,2293
  PetscBool   withTarget;     /* if there is a target */withTarget82,2348
  PetscScalar target[2];      /* target value */target83,2405
  PetscReal   tol;            /* tolerance */tol84,2454
  PetscBool   correctXnorm;   /* if true, norm of X are computed */correctXnorm85,2500
  PetscInt nconv;             /* number of converged eigenpairs */nconv88,2607
  PetscInt npreconv;          /* number of pairs ready to converge */npreconv89,2674
  BV       W;                 /* left basis for harmonic case */W91,2745
  BV       AX;                /* A*V */AX92,2810
  BV       BX;                /* B*V */BX93,2850
  PetscInt size_D;            /* active vectors */size_D94,2890
  PetscInt max_size_proj;     /* max size projected problem */max_size_proj95,2941
  PetscInt max_size_P;        /* max unconverged vectors in the projector */max_size_P96,3004
  PetscInt bs;                /* max vectors that expands the subspace every iteration */bs97,3081
  EPS      eps;               /* connection to SLEPc */eps98,3171
  VecPool auxV;               /* auxiliary vectors */auxV101,3258
  BV      auxBV;              /* auxiliary vectors */auxBV102,3312
  PetscScalar *ceigr,*ceigi;  /* converged eigenvalues */ceigr105,3404
  PetscScalar *ceigr,*ceigi;  /* converged eigenvalues */ceigi105,3404
  PetscScalar *eigr,*eigi;    /* current eigenvalues */eigr106,3462
  PetscScalar *eigr,*eigi;    /* current eigenvalues */eigi106,3462
  PetscReal   *nR;            /* residual norm */nR107,3518
  PetscReal   *real_nR;       /* original nR */real_nR108,3568
  PetscReal   *nX;            /* X norm */nX109,3616
  PetscReal   *real_nX;       /* original nX */real_nX110,3659
  PetscReal   *errest;        /* relative error eigenpairs */errest111,3707
  PetscReal   *nBds;          /* B-norms of projected problem  */nBds112,3769
  PetscErrorCode (*e_Vchanged)(struct _dvdDashboard*,PetscInt,PetscInt,PetscInt,PetscInt);e_Vchanged115,3880
  void *e_Vchanged_data;e_Vchanged_data116,3971
  PetscErrorCode (*calcpairs_residual)(struct _dvdDashboard*,PetscInt,PetscInt);calcpairs_residual117,3996
  PetscErrorCode (*calcpairs_selectPairs)(struct _dvdDashboard*,PetscInt);calcpairs_selectPairs118,4077
  void *calcpairs_residual_data;calcpairs_residual_data119,4152
  PetscErrorCode (*improvex_precond)(struct _dvdDashboard*,PetscInt,Vec,Vec);improvex_precond120,4185
  void *improvex_precond_data;improvex_precond_data121,4263
  PetscErrorCode (*improvex_jd_proj_uv)(struct _dvdDashboard*,PetscInt,PetscInt,Vec*,Vec*,Vec*,PetscScalar*,PetscScalar*,PetscScalar*,PetscScalar*,PetscInt);improvex_jd_proj_uv122,4294
  PetscErrorCode (*improvex_jd_lit)(struct _dvdDashboard*,PetscInt,PetscScalar*,PetscScalar*,PetscInt*,PetscReal*);improvex_jd_lit123,4452
  PetscErrorCode (*calcpairs_W)(struct _dvdDashboard*);calcpairs_W124,4568
  void *calcpairs_W_data;calcpairs_W_data125,4624
  PetscErrorCode (*calcpairs_proj_trans)(struct _dvdDashboard*);calcpairs_proj_trans126,4650
  PetscErrorCode (*calcpairs_eigs_trans)(struct _dvdDashboard*);calcpairs_eigs_trans127,4715
  PetscErrorCode (*calcpairs_eig_backtrans)(struct _dvdDashboard*,PetscScalar,PetscScalar,PetscScalar*,PetscScalar*);calcpairs_eig_backtrans128,4780
  PetscErrorCode (*calcpairs_proj_res)(struct _dvdDashboard*,PetscInt,PetscInt,Vec*);calcpairs_proj_res129,4898
  PetscErrorCode (*preTestConv)(struct _dvdDashboard*,PetscInt,PetscInt,PetscInt,PetscInt*);preTestConv130,4984
  PetscErrorCode (*e_newIteration)(struct _dvdDashboard*);e_newIteration131,5077
  void *e_newIteration_data;e_newIteration_data132,5136
  dvdFunctionList *startList;  /* starting list */startList134,5166
  dvdFunctionList *endList;    /* ending list */endList135,5217
  dvdFunctionList *destroyList;/* destructor list */destroyList136,5266
  Mat       H,G;               /* projected problem matrices */H138,5320
  Mat       H,G;               /* projected problem matrices */G138,5320
  Mat       auxM;              /* auxiliary dense matrix */auxM139,5384
  PetscInt  size_MT;           /* rows in MT */size_MT140,5444
  PetscInt  V_tra_s;V_tra_s142,5493
  PetscInt  V_tra_e;       /* cX <- [cX V*MT(0:V_tra_s-1)], V <- V*MT(V_tra_s:V_tra_e) */V_tra_e143,5514
  PetscInt  V_new_s;V_new_s144,5604
  PetscInt  V_new_e;           /* added to V the columns V_new_s:V_new_e */V_new_e145,5625
  PetscBool W_shift;           /* if true W is shifted when vectors converge */W_shift146,5701
} dvdDashboard;dvdDashboard147,5781
  PetscInt  blocksize;     /* block size */blocksize151,5891
  PetscInt  initialsize;   /* initial size of V */initialsize152,5935
  PetscInt  minv;          /* size of V after restarting */minv153,5986
  PetscInt  plusk;         /* keep plusk eigenvectors from the last iteration */plusk154,6046
  PetscBool ipB;           /* true if B-ortho is used */ipB155,6127
  PetscReal fix;           /* the fix parameter */fix156,6184
  PetscBool krylovstart;   /* true if the starting subspace is a Krylov basis */krylovstart157,6235
  PetscBool dynamic;       /* true if dynamic stopping criterion is used */dynamic158,6316
  PetscBool doubleexp;     /* double expansion in GD (GD2) */doubleexp159,6392
  dvdDashboard ddb;ddb162,6530
} EPS_DAVIDSON;EPS_DAVIDSON163,6550
PETSC_STATIC_INLINE PetscErrorCode EPSDavidsonFLAdd(dvdFunctionList **fl,dvdCallback f)EPSDavidsonFLAdd165,6567
PETSC_STATIC_INLINE PetscErrorCode EPSDavidsonFLCall(dvdFunctionList *fl,dvdDashboard *d)EPSDavidsonFLCall178,6831
PETSC_STATIC_INLINE PetscErrorCode EPSDavidsonFLDestroy(dvdFunctionList **fl)EPSDavidsonFLDestroy188,7081
  PetscInt max_size_V;         /* max size of the searching subspace (mpd) */max_size_V221,8055
  PetscInt max_size_X;         /* max size of X (bs) */max_size_X222,8133
  PetscInt size_V;             /* real size of V (nev+size_P+mpd) */size_V223,8189
  PetscInt max_size_oldX;      /* max size of oldX */max_size_oldX224,8258
  PetscInt max_nev;            /* max number of converged pairs */max_nev225,8312
  PetscInt max_size_P;         /* number of computed vectors for the projector */max_size_P226,8379
  PetscInt max_size_cP;        /* number of converged vectors in the projectors */max_size_cP227,8461
  PetscInt max_size_proj;      /* max size projected problem */max_size_proj228,8544
  PetscInt max_size_cX_proj;   /* max converged vectors in the projected problem */max_size_cX_proj229,8608
  PetscInt state;              /* method states:state230,8692
} dvdBlackboard;dvdBlackboard234,8893
#define DVD_STATE_PRECONF DVD_STATE_PRECONF236,8911
#define DVD_STATE_CONF DVD_STATE_CONF237,8939
#define DVD_STATE_RUN DVD_STATE_RUN238,8964

src/eps/impls/davidson/dvdcalcpairs.c,1458
dvdcalcpairs.c:^?dvdcalcpairs.c^A,1
static PetscErrorCode dvd_calcpairs_qz_start(dvdDashboard *d)dvd_calcpairs_qz_start26,752
static PetscErrorCode dvd_calcpairs_qz_d(dvdDashboard *d)dvd_calcpairs_qz_d38,1139
static PetscErrorCode dvd_calcpairs_projeig_solve(dvdDashboard *d)dvd_calcpairs_projeig_solve56,1732
static PetscErrorCode EPSXDUpdateProj(Mat Q,Mat Z,PetscInt l,Mat A,PetscInt lA,PetscInt kA,Mat aux)EPSXDUpdateProj95,3198
static PetscErrorCode dvd_calcpairs_updateproj(dvdDashboard *d)dvd_calcpairs_updateproj149,5752
PETSC_STATIC_INLINE PetscErrorCode dvd_calcpairs_updateBV0_gen(dvdDashboard *d,BV bv,DSMatType mat)dvd_calcpairs_updateBV0_gen198,7906
static PetscErrorCode dvd_calcpairs_proj(dvdDashboard *d)dvd_calcpairs_proj216,8638
static PetscErrorCode dvd_calcpairs_apply_arbitrary(dvdDashboard *d,PetscInt r_s,PetscInt r_e,PetscScalar *rr,PetscScalar *ri)dvd_calcpairs_apply_arbitrary308,12695
static PetscErrorCode dvd_calcpairs_selectPairs(dvdDashboard *d,PetscInt n)dvd_calcpairs_selectPairs371,14652
static PetscErrorCode EPSXDComputeDSConv(dvdDashboard *d)EPSXDComputeDSConv416,16052
static PetscErrorCode dvd_calcpairs_res_0(dvdDashboard *d,PetscInt r_s,PetscInt r_e)dvd_calcpairs_res_0462,18024
static PetscErrorCode dvd_calcpairs_proj_res(dvdDashboard *d,PetscInt r_s,PetscInt r_e,Vec *R)dvd_calcpairs_proj_res488,19035
PetscErrorCode dvd_calcpairs_qz(dvdDashboard *d,dvdBlackboard *b,PetscBool borth,PetscBool harm)dvd_calcpairs_qz521,20303

src/eps/impls/davidson/dvdgd2.c,406
dvdgd2.c:^?dvdgd2.c^A,1
  PetscInt size_X;size_X19,525
} dvdImprovex_gd2;dvdImprovex_gd220,544
static PetscErrorCode dvd_improvex_gd2_d(dvdDashboard *d)dvd_improvex_gd2_d22,564
static PetscErrorCode dvd_improvex_gd2_gen(dvdDashboard *d,PetscInt r_s,PetscInt r_e,PetscInt *size_D)dvd_improvex_gd2_gen33,838
PetscErrorCode dvd_improvex_gd2(dvdDashboard *d,dvdBlackboard *b,KSP ksp,PetscInt max_bs)dvd_improvex_gd2190,6433

src/eps/impls/davidson/dvdimprovex.c,5084
dvdimprovex.c:^?dvdimprovex.c^A,1
  PetscInt     size_X;size_X22,643
  KSP          ksp;                /* correction equation solver */ksp23,666
  Vec          friends;            /* reference vector for composite vectors */friends24,734
  PetscScalar  theta[4],thetai[2]; /* the shifts used in the correction eq. */theta25,814
  PetscScalar  theta[4],thetai[2]; /* the shifts used in the correction eq. */thetai25,814
  PetscInt     maxits;             /* maximum number of iterations */maxits26,893
  PetscInt     r_s,r_e;            /* the selected eigenpairs to improve */r_s27,963
  PetscInt     r_s,r_e;            /* the selected eigenpairs to improve */r_e27,963
  PetscInt     ksp_max_size;       /* the ksp maximum subvectors size */ksp_max_size28,1039
  PetscReal    tol;                /* the maximum solution tolerance */tol29,1112
  PetscReal    lastTol;            /* last tol for dynamic stopping criterion */lastTol30,1184
  PetscReal    fix;                /* tolerance for using the approx. eigenvalue */fix31,1265
  PetscBool    dynamic;            /* if the dynamic stopping criterion is applied */dynamic32,1349
  dvdDashboard *d;                 /* the currect dvdDashboard reference */d33,1435
  PC           old_pc;             /* old pc in ksp */old_pc34,1511
  BV           KZ;                 /* KZ vecs for the projector KZ*inv(X'*KZ)*X' */KZ35,1566
  BV           U;                  /* new X vectors */U36,1650
  PetscScalar  *XKZ;               /* X'*KZ */XKZ37,1705
  PetscScalar  *iXKZ;              /* inverse of XKZ */iXKZ38,1752
  PetscInt     ldXKZ;              /* leading dimension of XKZ */ldXKZ39,1808
  PetscInt     size_iXKZ;          /* size of iXKZ */size_iXKZ40,1874
  PetscInt     ldiXKZ;             /* leading dimension of iXKZ */ldiXKZ41,1928
  PetscInt     size_cX;            /* last value of d->size_cX */size_cX42,1995
  PetscInt     old_size_X;         /* last number of improved vectors */old_size_X43,2061
  PetscBLASInt *iXKZPivots;        /* array of pivots */iXKZPivots44,2134
} dvdImprovex_jd;dvdImprovex_jd45,2191
static PetscErrorCode dvd_improvex_apply_proj(dvdDashboard *d,Vec *V,PetscInt cV)dvd_improvex_apply_proj52,2330
static PetscErrorCode dvd_improvex_applytrans_proj(dvdDashboard *d,Vec *V,PetscInt cV)dvd_improvex_applytrans_proj110,4296
static PetscErrorCode dvd_improvex_jd_end(dvdDashboard *d)dvd_improvex_jd_end164,6174
static PetscErrorCode dvd_improvex_jd_d(dvdDashboard *d)dvd_improvex_jd_d180,6589
PETSC_STATIC_INLINE PetscErrorCode dvd_aux_matmult(dvdImprovex_jd *data,const Vec *x,const Vec *y)dvd_aux_matmult200,7164
PETSC_STATIC_INLINE PetscErrorCode dvd_aux_matmulttrans(dvdImprovex_jd *data,const Vec *x,const Vec *y)dvd_aux_matmulttrans245,8617
static PetscErrorCode PCApplyBA_dvd(PC pc,PCSide side,Vec in,Vec out,Vec w)PCApplyBA_dvd287,10086
static PetscErrorCode PCApply_dvd(PC pc,Vec in,Vec out)PCApply_dvd346,11971
static PetscErrorCode PCApplyTranspose_dvd(PC pc,Vec in,Vec out)PCApplyTranspose_dvd369,12692
static PetscErrorCode MatMult_dvd_jd(Mat A,Vec in,Vec out)MatMult_dvd_jd399,13668
static PetscErrorCode MatMultTranspose_dvd_jd(Mat A,Vec in,Vec out)MatMultTranspose_dvd_jd422,14393
static PetscErrorCode MatCreateVecs_dvd_jd(Mat A,Vec *right,Vec *left)MatCreateVecs_dvd_jd455,15461
static PetscErrorCode dvd_improvex_jd_start(dvdDashboard *d)dvd_improvex_jd_start496,16453
static PetscErrorCode dvd_improvex_jd_proj_cuv(dvdDashboard *d,PetscInt i_s,PetscInt i_e,Vec *kr,PetscScalar *theta,PetscScalar *thetai,PetscScalar *pX,PetscScalar *pY,PetscInt ld)dvd_improvex_jd_proj_cuv574,19784
static PetscErrorCode dvd_improvex_jd_gen(dvdDashboard *d,PetscInt r_s,PetscInt r_e,PetscInt *size_D)dvd_improvex_jd_gen656,23115
PetscErrorCode dvd_improvex_jd(dvdDashboard *d,dvdBlackboard *b,KSP ksp,PetscInt max_bs,PetscBool dynamic)dvd_improvex_jd786,28259
PETSC_STATIC_INLINE PetscErrorCode dvd_complex_rayleigh_quotient(Vec ur,Vec ui,Vec Axr,Vec Axi,Vec Bxr,Vec Bxi,PetscScalar *eigr,PetscScalar *eigi)dvd_complex_rayleigh_quotient851,30439
PETSC_STATIC_INLINE PetscErrorCode dvd_compute_n_rr(PetscInt i_s,PetscInt n,PetscScalar *eigr,PetscScalar *eigi,Vec *u,Vec *Ax,Vec *Bx)dvd_compute_n_rr887,32111
PetscErrorCode dvd_improvex_jd_proj_uv_KZX(dvdDashboard *d,PetscInt i_s,PetscInt i_e,Vec *u,Vec *v,Vec *kr,PetscScalar *theta,PetscScalar *thetai,PetscScalar *pX,PetscScalar *pY,PetscInt ld)dvd_improvex_jd_proj_uv_KZX926,33831
static PetscErrorCode dvd_improvex_jd_lit_const_0(dvdDashboard *d,PetscInt i,PetscScalar* theta,PetscScalar* thetai,PetscInt *maxits,PetscReal *tol)dvd_improvex_jd_lit_const_01036,37710
PetscErrorCode dvd_improvex_jd_lit_const(dvdDashboard *d,dvdBlackboard *b,PetscInt maxits,PetscReal tol,PetscReal fix)dvd_improvex_jd_lit_const1066,38430
PetscErrorCode dvd_improvex_jd_proj_uv(dvdDashboard *d,dvdBlackboard *b)dvd_improvex_jd_proj_uv1081,38850
PetscErrorCode dvd_improvex_compute_X(dvdDashboard *d,PetscInt i_s,PetscInt i_e,Vec *u_,PetscScalar *pX,PetscInt ld)dvd_improvex_compute_X1091,39097

src/eps/impls/davidson/dvdinitv.c,704
dvdinitv.c:^?dvdinitv.c^A,1
  PetscInt k;                 /* desired initial subspace size */k19,511
  PetscInt user;              /* number of user initial vectors */user20,577
  void     *old_initV_data;   /* old initV data */old_initV_data21,644
} dvdInitV;dvdInitV22,695
static PetscErrorCode dvd_initV_classic_0(dvdDashboard *d)dvd_initV_classic_024,708
static PetscErrorCode dvd_initV_krylov_0(dvdDashboard *d)dvd_initV_krylov_046,1526
static PetscErrorCode dvd_initV_d(dvdDashboard *d)dvd_initV_d94,3369
PetscErrorCode dvd_initV(dvdDashboard *d, dvdBlackboard *b, PetscInt k,PetscInt user, PetscBool krylov)dvd_initV108,3693
PetscErrorCode dvd_orthV(BV V,PetscInt V_new_s,PetscInt V_new_e)dvd_orthV131,4369

src/eps/impls/davidson/dvdschm.c,713
dvdschm.c:^?dvdschm.c^A,1
#define DVD_CHECKSUM(DVD_CHECKSUM13,423
PetscErrorCode dvd_schm_basic_preconf(dvdDashboard *d,dvdBlackboard *b,PetscInt mpd,PetscInt min_size_V,PetscInt bs,PetscInt ini_size_V,PetscInt size_initV,PetscInt plusk,HarmType_t harmMode,KSP ksp,InitType_t init,PetscBool allResiduals,PetscBool orth,PetscBool doubleexp)dvd_schm_basic_preconf15,487
PetscErrorCode dvd_schm_basic_conf(dvdDashboard *d,dvdBlackboard *b,PetscInt mpd,PetscInt min_size_V,PetscInt bs,PetscInt ini_size_V,PetscInt size_initV,PetscInt plusk,HarmType_t harmMode,PetscBool fixedTarget,PetscScalar t,KSP ksp,PetscReal fix,InitType_t init,PetscBool allResiduals,PetscBool orth,PetscBool dynamic,PetscBool doubleexp)dvd_schm_basic_conf53,2175

src/eps/impls/davidson/dvdtestconv.c,241
dvdtestconv.c:^?dvdtestconv.c^A,1
static PetscBool dvd_testconv_slepc_0(dvdDashboard *d,PetscScalar eigvr,PetscScalar eigvi,PetscReal r,PetscReal *err)dvd_testconv_slepc_018,493
PetscErrorCode dvd_testconv_slepc(dvdDashboard *d, dvdBlackboard *b)dvd_testconv_slepc27,847

src/eps/impls/davidson/dvdupdatev.c,1906
dvdupdatev.c:^?dvdupdatev.c^A,1
  PetscInt          min_size_V;        /* restart with this number of eigenvectors */min_size_V19,528
  PetscInt          plusk;             /* at restart, save plusk vectors from last iteration */plusk20,614
  PetscInt          mpd;               /* max size of the searching subspace */mpd21,710
  void              *old_updateV_data; /* old updateV data */old_updateV_data22,790
  PetscErrorCode    (*old_isRestarting)(dvdDashboard*,PetscBool*);  /* old isRestarting */old_isRestarting23,852
  Mat               oldU;              /* previous projected right igenvectors */oldU24,943
  Mat               oldV;              /* previous projected left eigenvectors */oldV25,1025
  PetscInt          size_oldU;         /* size of oldU */size_oldU26,1107
  PetscBool         allResiduals;      /* if computing all the residuals */allResiduals27,1165
} dvdManagV_basic;dvdManagV_basic28,1241
static PetscErrorCode dvd_updateV_start(dvdDashboard *d)dvd_updateV_start30,1261
static PetscErrorCode dvd_isrestarting_fullV(dvdDashboard *d,PetscBool *r)dvd_isrestarting_fullV49,1774
static PetscErrorCode dvd_managementV_basic_d(dvdDashboard *d)dvd_managementV_basic_d68,2322
static PetscErrorCode dvd_updateV_conv_gen(dvdDashboard *d)dvd_updateV_conv_gen86,2861
static PetscErrorCode dvd_updateV_restart_gen(dvdDashboard *d)dvd_updateV_restart_gen153,5251
static PetscErrorCode dvd_updateV_testConv(dvdDashboard *d,PetscInt s,PetscInt pre,PetscInt e,PetscInt *nConv)dvd_updateV_testConv214,8056
static PetscErrorCode dvd_updateV_update_gen(dvdDashboard *d)dvd_updateV_update_gen254,9203
static PetscErrorCode dvd_updateV_extrapol(dvdDashboard *d)dvd_updateV_extrapol301,10702
PetscErrorCode dvd_managementV_basic(dvdDashboard *d,dvdBlackboard *b,PetscInt bs,PetscInt mpd,PetscInt min_size_V,PetscInt plusk,PetscBool harm,PetscBool allResiduals)dvd_managementV_basic338,11937

src/eps/impls/davidson/dvdutils.c,1929
dvdutils.c:^?dvdutils.c^A,1
  PC pc;pc19,494
} dvdPCWrapper;dvdPCWrapper20,503
  PetscScalar Wa,Wb;       /* span{W} = span{Wa*AV - Wb*BV} */Wa34,846
  PetscScalar Wa,Wb;       /* span{W} = span{Wa*AV - Wb*BV} */Wb34,846
  PetscScalar Pa,Pb;       /* H=W'*(Pa*AV - Pb*BV), G=W'*(Wa*AV - Wb*BV) */Pa35,909
  PetscScalar Pa,Pb;       /* H=W'*(Pa*AV - Pb*BV), G=W'*(Wa*AV - Wb*BV) */Pb35,909
  PetscBool   withTarget;withTarget36,985
  HarmType_t  mode;mode37,1011
} dvdHarmonic;dvdHarmonic38,1031
  Vec diagA, diagB;diagA41,1064
  Vec diagA, diagB;diagB41,1064
} dvdJacobiPrecond;dvdJacobiPrecond42,1084
static PetscErrorCode dvd_improvex_precond_d(dvdDashboard *d)dvd_improvex_precond_d44,1105
static PetscErrorCode dvd_static_precond_PC_0(dvdDashboard *d,PetscInt i,Vec x,Vec Px)dvd_static_precond_PC_056,1441
static PetscErrorCode dvd_precond_none(dvdDashboard *d,PetscInt i,Vec x,Vec Px)dvd_precond_none69,1760
PetscErrorCode dvd_static_precond_PC(dvdDashboard *d,dvdBlackboard *b,PC pc)dvd_static_precond_PC81,2004
static PetscErrorCode dvd_harm_d(dvdDashboard *d)dvd_harm_d125,3639
static PetscErrorCode dvd_harm_transf(dvdHarmonic *dvdh,PetscScalar t)dvd_harm_transf135,3845
static PetscErrorCode dvd_harm_updateW(dvdDashboard *d)dvd_harm_updateW166,4831
static PetscErrorCode dvd_harm_proj(dvdDashboard *d)dvd_harm_proj194,5928
PetscErrorCode dvd_harm_updateproj(dvdDashboard *d)dvd_harm_updateproj232,6994
static PetscErrorCode dvd_harm_backtrans(dvdHarmonic *data,PetscScalar *ar,PetscScalar *ai)dvd_harm_backtrans269,8041
static PetscErrorCode dvd_harm_eig_backtrans(dvdDashboard *d,PetscScalar ar,PetscScalar ai,PetscScalar *br,PetscScalar *bi)dvd_harm_eig_backtrans290,8674
static PetscErrorCode dvd_harm_eigs_trans(dvdDashboard *d)dvd_harm_eigs_trans302,9016
PetscErrorCode dvd_harm_conf(dvdDashboard *d,dvdBlackboard *b,HarmType_t mode,PetscBool fixedTarget,PetscScalar t)dvd_harm_conf316,9399

src/eps/impls/davidson/gd/gd.c,1718
gd.c:^?gd.c^A,1
PetscErrorCode EPSSetFromOptions_GD(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_GD33,1018
PetscErrorCode EPSSetUp_GD(EPS eps)EPSSetUp_GD70,3111
PetscErrorCode EPSView_GD(EPS eps,PetscViewer viewer)EPSView_GD87,3614
PetscErrorCode EPSDestroy_GD(EPS eps)EPSDestroy_GD122,5163
PetscErrorCode EPSGDSetKrylovStart(EPS eps,PetscBool krylovstart)EPSGDSetKrylovStart161,6894
PetscErrorCode EPSGDGetKrylovStart(EPS eps,PetscBool *krylovstart)EPSGDGetKrylovStart189,7612
PetscErrorCode EPSGDSetBlockSize(EPS eps,PetscInt blocksize)EPSGDSetBlockSize217,8400
PetscErrorCode EPSGDGetBlockSize(EPS eps,PetscInt *blocksize)EPSGDGetBlockSize244,9084
PetscErrorCode EPSGDSetRestart(EPS eps,PetscInt minv,PetscInt plusk)EPSGDSetRestart274,10020
PetscErrorCode EPSGDGetRestart(EPS eps,PetscInt *minv,PetscInt *plusk)EPSGDGetRestart303,10857
PetscErrorCode EPSGDSetInitialSize(EPS eps,PetscInt initialsize)EPSGDSetInitialSize337,12051
PetscErrorCode EPSGDGetInitialSize(EPS eps,PetscInt *initialsize)EPSGDGetInitialSize371,13193
PetscErrorCode EPSGDSetBOrth(EPS eps,PetscBool borth)EPSGDSetBOrth399,13969
PetscErrorCode EPSGDGetBOrth(EPS eps,PetscBool *borth)EPSGDGetBOrth426,14625
static PetscErrorCode EPSGDSetDoubleExpansion_GD(EPS eps,PetscBool doubleexp)EPSGDSetDoubleExpansion_GD437,14929
PetscErrorCode EPSGDSetDoubleExpansion(EPS eps,PetscBool doubleexp)EPSGDSetDoubleExpansion463,15664
static PetscErrorCode EPSGDGetDoubleExpansion_GD(EPS eps,PetscBool *doubleexp)EPSGDGetDoubleExpansion_GD474,16012
PetscErrorCode EPSGDGetDoubleExpansion(EPS eps,PetscBool *doubleexp)EPSGDGetDoubleExpansion499,16537
SLEPC_EXTERN PetscErrorCode EPSCreate_GD(EPS eps)EPSCreate_GD510,16873

src/eps/impls/davidson/gd/makefile,275
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = gd.cSOURCEC15,431
SOURCEF  =SOURCEF16,447
SOURCEH  =SOURCEH17,458
LIBBASE  = libslepcepsLIBBASE18,469
DIRS     =DIRS19,492
MANSEC   = EPSMANSEC20,503
LOCDIR   = src/eps/impls/davidson/gd/LOCDIR21,518

src/eps/impls/davidson/jd/jd.c,2098
jd.c:^?jd.c^A,1
PetscErrorCode EPSSetFromOptions_JD(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_JD34,1096
PetscErrorCode EPSSetDefaultST_JD(EPS eps)EPSSetDefaultST_JD77,3565
PetscErrorCode EPSSetUp_JD(EPS eps)EPSSetUp_JD95,4104
PetscErrorCode EPSView_JD(EPS eps,PetscViewer viewer)EPSView_JD112,4609
PetscErrorCode EPSDestroy_JD(EPS eps)EPSDestroy_JD149,6360
PetscErrorCode EPSJDSetKrylovStart(EPS eps,PetscBool krylovstart)EPSJDSetKrylovStart190,8277
PetscErrorCode EPSJDGetKrylovStart(EPS eps,PetscBool *krylovstart)EPSJDGetKrylovStart218,9001
PetscErrorCode EPSJDSetBlockSize(EPS eps,PetscInt blocksize)EPSJDSetBlockSize246,9789
PetscErrorCode EPSJDGetBlockSize(EPS eps,PetscInt *blocksize)EPSJDGetBlockSize273,10473
PetscErrorCode EPSJDSetRestart(EPS eps,PetscInt minv,PetscInt plusk)EPSJDSetRestart303,11409
PetscErrorCode EPSJDGetRestart(EPS eps,PetscInt *minv,PetscInt *plusk)EPSJDGetRestart332,12246
PetscErrorCode EPSJDSetInitialSize(EPS eps,PetscInt initialsize)EPSJDSetInitialSize366,13440
PetscErrorCode EPSJDGetInitialSize(EPS eps,PetscInt *initialsize)EPSJDGetInitialSize400,14582
PetscErrorCode EPSJDSetFix_JD(EPS eps,PetscReal fix)EPSJDSetFix_JD411,14913
PetscErrorCode EPSJDSetFix(EPS eps,PetscReal fix)EPSJDSetFix444,15804
PetscErrorCode EPSJDGetFix_JD(EPS eps,PetscReal *fix)EPSJDGetFix_JD455,16110
PetscErrorCode EPSJDGetFix(EPS eps,PetscReal *fix)EPSJDGetFix485,16788
PetscErrorCode EPSJDSetConstCorrectionTol_JD(EPS eps,PetscBool constant)EPSJDSetConstCorrectionTol_JD496,17082
PetscErrorCode EPSJDSetConstCorrectionTol(EPS eps,PetscBool constant)EPSJDSetConstCorrectionTol523,17862
PetscErrorCode EPSJDGetConstCorrectionTol_JD(EPS eps,PetscBool *constant)EPSJDGetConstCorrectionTol_JD534,18213
PetscErrorCode EPSJDGetConstCorrectionTol(EPS eps,PetscBool *constant)EPSJDGetConstCorrectionTol560,18968
PetscErrorCode EPSJDSetBOrth(EPS eps,PetscBool borth)EPSJDSetBOrth588,19752
PetscErrorCode EPSJDGetBOrth(EPS eps,PetscBool *borth)EPSJDGetBOrth615,20408
SLEPC_EXTERN PetscErrorCode EPSCreate_JD(EPS eps)EPSCreate_JD626,20712

src/eps/impls/davidson/jd/makefile,275
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = jd.cSOURCEC15,431
SOURCEF  =SOURCEF16,447
SOURCEH  =SOURCEH17,458
LIBBASE  = libslepcepsLIBBASE18,469
DIRS     =DIRS19,492
MANSEC   = EPSMANSEC20,503
LOCDIR   = src/eps/impls/davidson/jd/LOCDIR21,518

src/eps/impls/davidson/makefile,337
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = davidson.c dvdcalcpairs.c dvdimprovex.c dvdinitv.c \SOURCEC15,431
SOURCEF  =SOURCEF17,563
SOURCEH  = davidson.hSOURCEH18,574
LIBBASE  = libslepcepsLIBBASE19,596
DIRS     = gd jdDIRS20,619
LOCDIR   = src/eps/impls/davidson/LOCDIR21,636
MANSEC   = EPSMANSEC22,671

src/eps/impls/external/arpack/arpack.c,426
arpack.c:^?arpack.c^A,1
PetscErrorCode EPSSetUp_ARPACK(EPS eps)EPSSetUp_ARPACK17,518
PetscErrorCode EPSSolve_ARPACK(EPS eps)EPSSolve_ARPACK76,3562
PetscErrorCode EPSBackTransform_ARPACK(EPS eps)EPSBackTransform_ARPACK260,11472
PetscErrorCode EPSReset_ARPACK(EPS eps)EPSReset_ARPACK273,11786
PetscErrorCode EPSDestroy_ARPACK(EPS eps)EPSDestroy_ARPACK289,12215
SLEPC_EXTERN PetscErrorCode EPSCreate_ARPACK(EPS eps)EPSCreate_ARPACK298,12379

src/eps/impls/external/arpack/arpack.h,1935
arpack.h:^?arpack.h^A,1
#define SLEPC_ARPACK_HSLEPC_ARPACK_H15,490
  PetscBool    *select;select18,531
  PetscScalar  *workev;workev19,555
  PetscScalar  *workd;workd20,579
  PetscScalar  *workl;workl21,602
  PetscBLASInt lworkl;lworkl22,625
  PetscReal    *rwork;rwork23,648
} EPS_ARPACK;EPS_ARPACK24,671
#define SLEPC_ARPACK(SLEPC_ARPACK37,885
#define SLEPC_ARPACK(SLEPC_ARPACK39,969
#define SLEPC_ARPACK(SLEPC_ARPACK41,1018
#define SLEPC_ARPACK(SLEPC_ARPACK47,1118
#define SLEPC_ARPACK(SLEPC_ARPACK49,1202
#define SLEPC_ARPACK(SLEPC_ARPACK51,1251
#define SLEPC_ARPACK(SLEPC_ARPACK61,1395
#define SLEPC_ARPACK(SLEPC_ARPACK63,1479
#define SLEPC_ARPACK(SLEPC_ARPACK65,1528
#define SLEPC_ARPACK(SLEPC_ARPACK71,1628
#define SLEPC_ARPACK(SLEPC_ARPACK73,1712
#define SLEPC_ARPACK(SLEPC_ARPACK75,1761
#define SLEPC_ARPACK(SLEPC_ARPACK89,1963
#define SLEPC_ARPACK(SLEPC_ARPACK91,2048
#define SLEPC_ARPACK(SLEPC_ARPACK93,2098
#define SLEPC_ARPACK(SLEPC_ARPACK99,2199
#define SLEPC_ARPACK(SLEPC_ARPACK101,2284
#define SLEPC_ARPACK(SLEPC_ARPACK103,2334
#define SLEPC_ARPACK(SLEPC_ARPACK113,2479
#define SLEPC_ARPACK(SLEPC_ARPACK115,2564
#define SLEPC_ARPACK(SLEPC_ARPACK117,2614
#define SLEPC_ARPACK(SLEPC_ARPACK123,2715
#define SLEPC_ARPACK(SLEPC_ARPACK125,2800
#define SLEPC_ARPACK(SLEPC_ARPACK127,2850
#define COMM_ARGCOMM_ARG138,2958
#define ARPACKnaupd_(ARPACKnaupd_142,3009
#define ARPACKneupd_(ARPACKneupd_143,3164
#define ARPACKsaupd_(ARPACKsaupd_144,3375
#define ARPACKseupd_(ARPACKseupd_145,3530
#define ARPACKnaupd_(ARPACKnaupd_149,3731
#define ARPACKneupd_(ARPACKneupd_150,3892
#define COMM_ARG COMM_ARG156,4130
#define ARPACKnaupd_(ARPACKnaupd_160,4192
#define ARPACKneupd_(ARPACKneupd_161,4354
#define ARPACKsaupd_(ARPACKsaupd_162,4572
#define ARPACKseupd_(ARPACKseupd_163,4734
#define ARPACKnaupd_(ARPACKnaupd_167,4942
#define ARPACKneupd_(ARPACKneupd_168,5110

src/eps/impls/external/arpack/makefile,292
makefile:^?makefile^A,1
CFLAGS   =CFLAGS15,447
FFLAGS   =FFLAGS16,458
SOURCEC  = arpack.cSOURCEC17,469
SOURCEF  =SOURCEF18,489
SOURCEH  = arpack.hSOURCEH19,500
LIBBASE  = libslepcepsLIBBASE20,520
DIRS     =DIRS21,543
MANSEC   = EPSMANSEC22,554
LOCDIR   = src/eps/impls/external/arpack/LOCDIR23,569

src/eps/impls/external/blopex/blopex.c,2016
blopex.c:^?blopex.c^A,1
PetscInt slepc_blopex_useconstr = -1;slepc_blopex_useconstr21,682
  lobpcg_Tolerance           tol;tol24,738
  lobpcg_BLASLAPACKFunctions blap_fn;blap_fn25,772
  mv_InterfaceInterpreter    ii;ii26,810
  ST                         st;st27,843
  Vec                        w;w28,876
  PetscInt                   bs;     /* block size */bs29,908
} EPS_BLOPEX;EPS_BLOPEX30,962
static void Precond_FnSingleVector(void *data,void *x,void *y)Precond_FnSingleVector32,977
static void Precond_FnMultiVector(void *data,void *x,void *y)Precond_FnMultiVector45,1374
static void OperatorASingleVector(void *data,void *x,void *y)OperatorASingleVector54,1587
static void OperatorAMultiVector(void *data,void *x,void *y)OperatorAMultiVector80,2498
static void OperatorBSingleVector(void *data,void *x,void *y)OperatorBSingleVector89,2709
static void OperatorBMultiVector(void *data,void *x,void *y)OperatorBMultiVector102,3103
PetscErrorCode EPSSetDimensions_BLOPEX(EPS eps,PetscInt nev,PetscInt *ncv,PetscInt *mpd)EPSSetDimensions_BLOPEX111,3314
PetscErrorCode EPSSetUp_BLOPEX(EPS eps)EPSSetUp_BLOPEX127,3856
PetscErrorCode EPSSolve_BLOPEX(EPS eps)EPSSolve_BLOPEX185,6664
static PetscErrorCode EPSBLOPEXSetBlockSize_BLOPEX(EPS eps,PetscInt bs)EPSBLOPEXSetBlockSize_BLOPEX288,10733
PetscErrorCode EPSBLOPEXSetBlockSize(EPS eps,PetscInt bs)EPSBLOPEXSetBlockSize319,11433
static PetscErrorCode EPSBLOPEXGetBlockSize_BLOPEX(EPS eps,PetscInt *bs)EPSBLOPEXGetBlockSize_BLOPEX330,11753
PetscErrorCode EPSBLOPEXGetBlockSize(EPS eps,PetscInt *bs)EPSBLOPEXGetBlockSize354,12204
PetscErrorCode EPSReset_BLOPEX(EPS eps)EPSReset_BLOPEX365,12512
PetscErrorCode EPSDestroy_BLOPEX(EPS eps)EPSDestroy_BLOPEX375,12727
PetscErrorCode EPSView_BLOPEX(EPS eps,PetscViewer viewer)EPSView_BLOPEX387,13124
PetscErrorCode EPSSetFromOptions_BLOPEX(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_BLOPEX401,13533
SLEPC_EXTERN PetscErrorCode EPSCreate_BLOPEX(EPS eps)EPSCreate_BLOPEX419,14092

src/eps/impls/external/blopex/blopex.h,121
blopex.h:^?blopex.h^A,1
#define SLEPC_BLOPEX_HSLEPC_BLOPEX_H12,429
SLEPC_INTERN PetscInt slepc_blopex_useconstr;slepc_blopex_useconstr17,510

src/eps/impls/external/blopex/makefile,385
makefile:^?makefile^A,1
CFLAGS   = ${BLOPEX_INCLUDE} -DBlopexInt=PetscIntCFLAGS15,447
FFLAGS   =FFLAGS16,497
SOURCEC  = blopex.c slepc-interface.c petsc-interface.cSOURCEC17,508
SOURCEF  =SOURCEF18,564
SOURCEH  = blopex.h petsc-interface.hSOURCEH19,575
LIBBASE  = libslepcepsLIBBASE20,613
DIRS     =DIRS21,636
MANSEC   = EPSMANSEC22,647
LOCDIR   = src/eps/impls/external/blopex/LOCDIR23,662

src/eps/impls/external/blopex/petsc-interface.c,1791
petsc-interface.c:^?petsc-interface.c^A,1
static PetscRandom LOBPCG_RandomContext = NULL;LOBPCG_RandomContext13,557
BlopexInt PETSC_dpotrf_interface (char *uplo,BlopexInt *n,double *a,BlopexInt * lda,BlopexInt *info)PETSC_dpotrf_interface16,638
BlopexInt PETSC_dsygv_interface (BlopexInt *itype,char *jobz,char *uplo,BlopexInt *n,double *a,BlopexInt *lda,double *b,BlopexInt *ldb,double *w,double *work,BlopexInt *lwork,BlopexInt *info)PETSC_dsygv_interface31,928
BlopexInt PETSC_zpotrf_interface (char *uplo,BlopexInt *n,komplex *a,BlopexInt* lda,BlopexInt *info)PETSC_zpotrf_interface48,1439
BlopexInt PETSC_zsygv_interface (BlopexInt *itype,char *jobz,char *uplo,BlopexInt *n,komplex *a,BlopexInt *lda,komplex *b,BlopexInt *ldb,double *w,komplex *work,BlopexInt *lwork,double *rwork,BlopexInt *info)PETSC_zsygv_interface62,1726
void *PETSC_MimicVector(void *vvector)PETSC_MimicVector80,2272
BlopexInt PETSC_DestroyVector(void *vvector)PETSC_DestroyVector89,2452
BlopexInt PETSC_InnerProd(void *x,void *y,void *result)PETSC_InnerProd98,2601
BlopexInt PETSC_CopyVector(void *x,void *y)PETSC_CopyVector106,2765
BlopexInt PETSC_ClearVector(void *x)PETSC_ClearVector114,2898
BlopexInt PETSC_SetRandomValues(void* v,BlopexInt seed)PETSC_SetRandomValues122,3020
BlopexInt PETSC_ScaleVector(double alpha,void *x)PETSC_ScaleVector133,3343
BlopexInt PETSC_Axpy(void *alpha,void *x,void *y)PETSC_Axpy141,3481
BlopexInt PETSC_VectorSize(void *x)PETSC_VectorSize149,3640
int LOBPCG_InitRandomContext(MPI_Comm comm,PetscRandom rand)LOBPCG_InitRandomContext156,3732
int LOBPCG_SetFromOptionsRandomContext(void)LOBPCG_SetFromOptionsRandomContext171,4139
int LOBPCG_DestroyRandomContext(void)LOBPCG_DestroyRandomContext184,4582
int PETSCSetupInterpreter(mv_InterfaceInterpreter *i)PETSCSetupInterpreter192,4727

src/eps/impls/external/blopex/petsc-interface.h,60
petsc-interface.h:^?petsc-interface.h^A,1
#define PETSC_INTERFACE_HEADERPETSC_INTERFACE_HEADER7,334

src/eps/impls/external/blopex/slepc-interface.c,202
slepc-interface.c:^?slepc-interface.c^A,1
static void* mv_TempMultiVectorCreateFromBV(void* ii_,BlopexInt n,void* sample)mv_TempMultiVectorCreateFromBV21,680
int SLEPCSetupInterpreter(mv_InterfaceInterpreter *i)SLEPCSetupInterpreter64,2302

src/eps/impls/external/blzpack/blzpack.c,1527
blzpack.c:^?blzpack.c^A,1
const char* blzpack_error[33] = {blzpack_error17,544
PetscErrorCode EPSSetUp_BLZPACK(EPS eps)EPSSetUp_BLZPACK53,1931
PetscErrorCode EPSSolve_BLZPACK(EPS eps)EPSSolve_BLZPACK135,6295
PetscErrorCode EPSBackTransform_BLZPACK(EPS eps)EPSBackTransform_BLZPACK257,11530
PetscErrorCode EPSReset_BLZPACK(EPS eps)EPSReset_BLZPACK269,11809
PetscErrorCode EPSDestroy_BLZPACK(EPS eps)EPSDestroy_BLZPACK283,12196
PetscErrorCode EPSView_BLZPACK(EPS eps,PetscViewer viewer)EPSView_BLZPACK296,12759
PetscErrorCode EPSSetFromOptions_BLZPACK(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_BLZPACK314,13432
static PetscErrorCode EPSBlzpackSetBlockSize_BLZPACK(EPS eps,PetscInt bs)EPSBlzpackSetBlockSize_BLZPACK336,14235
PetscErrorCode EPSBlzpackSetBlockSize(EPS eps,PetscInt bs)EPSBlzpackSetBlockSize364,14971
static PetscErrorCode EPSBlzpackGetBlockSize_BLZPACK(EPS eps,PetscInt *bs)EPSBlzpackGetBlockSize_BLZPACK375,15293
PetscErrorCode EPSBlzpackGetBlockSize(EPS eps,PetscInt *bs)EPSBlzpackGetBlockSize399,15759
static PetscErrorCode EPSBlzpackSetNSteps_BLZPACK(EPS eps,PetscInt nsteps)EPSBlzpackSetNSteps_BLZPACK410,16069
PetscErrorCode EPSBlzpackSetNSteps(EPS eps,PetscInt nsteps)EPSBlzpackSetNSteps439,16736
static PetscErrorCode EPSBlzpackGetNSteps_BLZPACK(EPS eps,PetscInt *nsteps)EPSBlzpackGetNSteps_BLZPACK450,17064
PetscErrorCode EPSBlzpackGetNSteps(EPS eps,PetscInt *nsteps)EPSBlzpackGetNSteps474,17558
SLEPC_EXTERN PetscErrorCode EPSCreate_BLZPACK(EPS eps)EPSCreate_BLZPACK485,17874

src/eps/impls/external/blzpack/blzpack.h,810
blzpack.h:^?blzpack.h^A,1
#define SLEPC_BLZPACK_HSLEPC_BLZPACK_H15,492
  PetscBLASInt         block_size;      /* block size */block_size18,534
  PetscBLASInt         slice;           /* use spectrum slicing */slice19,591
  PetscBLASInt         nsteps;          /* maximum number of steps per run */nsteps20,658
  PetscBLASInt         *istor;istor21,736
  PetscReal            *rstor;rstor22,767
  PetscScalar          *u;u23,798
  PetscScalar          *v;v24,825
  PetscScalar          *eig;eig25,852
} EPS_BLZPACK;EPS_BLZPACK26,881
#define SLEPC_BLZPACK(SLEPC_BLZPACK33,998
#define SLEPC_BLZPACK(SLEPC_BLZPACK35,1081
#define SLEPC_BLZPACK(SLEPC_BLZPACK37,1128
#define BLZpack_ BLZpack_49,1376
#define BLZpack_ BLZpack_51,1428
#define BLZistorr_ BLZistorr_54,1482
#define BLZrstorr_ BLZrstorr_55,1530

src/eps/impls/external/blzpack/makefile,295
makefile:^?makefile^A,1
CFLAGS   =CFLAGS15,448
FFLAGS   =FFLAGS16,459
SOURCEC  = blzpack.cSOURCEC17,470
SOURCEF  =SOURCEF18,491
SOURCEH  = blzpack.hSOURCEH19,502
LIBBASE  = libslepcepsLIBBASE20,523
DIRS     =DIRS21,546
MANSEC   = EPSMANSEC22,557
LOCDIR   = src/eps/impls/external/blzpack/LOCDIR23,572

src/eps/impls/external/makefile,174
makefile:^?makefile^A,1
LIBBASE  = libslepcepsLIBBASE13,409
DIRS     = arpack blopex blzpack primme trlanDIRS14,432
LOCDIR   = src/eps/impls/external/LOCDIR15,478
MANSEC   = EPSMANSEC16,513

src/eps/impls/external/primme/makefile,299
makefile:^?makefile^A,1
CFLAGS   = ${PRIMME_FLAGS}CFLAGS15,447
FFLAGS   =FFLAGS16,474
SOURCEC  = primme.cSOURCEC17,485
SOURCEF  =SOURCEF18,505
SOURCEH  =SOURCEH19,516
LIBBASE  = libslepcepsLIBBASE20,527
DIRS     =DIRS21,550
MANSEC   = EPSMANSEC22,561
LOCDIR   = src/eps/impls/external/primme/LOCDIR23,576

src/eps/impls/external/primme/primme.c,2550
primme.c:^?primme.c^A,1
#define PRIMME_DRIVER PRIMME_DRIVER20,609
#define PRIMME_DRIVER PRIMME_DRIVER22,645
#define PRIMME_DRIVER PRIMME_DRIVER26,723
#define PRIMME_DRIVER PRIMME_DRIVER28,759
  primme_params primme;           /* param struc */primme33,821
  primme_preset_method method;    /* primme method */method34,873
  Mat       A;                    /* problem matrix */A35,927
  KSP       ksp;                  /* linear solver and preconditioner */ksp36,982
  Vec       x,y;                  /* auxiliary vectors */x37,1055
  Vec       x,y;                  /* auxiliary vectors */y37,1055
  double    target;               /* a copy of eps's target */target38,1113
} EPS_PRIMME;EPS_PRIMME39,1176
static void par_GlobalSumReal(void *sendBuf,void *recvBuf,int *count,primme_params *primme,int *ierr)par_GlobalSumReal44,1401
PetscErrorCode EPSSetUp_PRIMME(EPS eps)EPSSetUp_PRIMME49,1689
PetscErrorCode EPSSolve_PRIMME(EPS eps)EPSSolve_PRIMME138,5891
static void multMatvec_PRIMME(void *xa,PRIMME_INT *ldx,void *ya,PRIMME_INT *ldy,int *blockSize,struct primme_params *primme,int *ierr)multMatvec_PRIMME178,7378
static void applyPreconditioner_PRIMME(void *xa,PRIMME_INT *ldx,void *ya,PRIMME_INT *ldy,int *blockSize,struct primme_params *primme,int *ierr)applyPreconditioner_PRIMME196,8186
PetscErrorCode EPSReset_PRIMME(EPS eps)EPSReset_PRIMME213,9021
PetscErrorCode EPSDestroy_PRIMME(EPS eps)EPSDestroy_PRIMME225,9303
PetscErrorCode EPSView_PRIMME(EPS eps,PetscViewer viewer)EPSView_PRIMME238,9861
PetscErrorCode EPSSetFromOptions_PRIMME(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_PRIMME260,10678
static PetscErrorCode EPSPRIMMESetBlockSize_PRIMME(EPS eps,PetscInt bs)EPSPRIMMESetBlockSize_PRIMME281,11558
PetscErrorCode EPSPRIMMESetBlockSize(EPS eps,PetscInt bs)EPSPRIMMESetBlockSize317,12690
static PetscErrorCode EPSPRIMMEGetBlockSize_PRIMME(EPS eps,PetscInt *bs)EPSPRIMMEGetBlockSize_PRIMME328,13010
PetscErrorCode EPSPRIMMEGetBlockSize(EPS eps,PetscInt *bs)EPSPRIMMEGetBlockSize352,13489
static PetscErrorCode EPSPRIMMESetMethod_PRIMME(EPS eps,EPSPRIMMEMethod method)EPSPRIMMESetMethod_PRIMME363,13797
PetscErrorCode EPSPRIMMESetMethod(EPS eps,EPSPRIMMEMethod method)EPSPRIMMESetMethod391,14470
static PetscErrorCode EPSPRIMMEGetMethod_PRIMME(EPS eps,EPSPRIMMEMethod *method)EPSPRIMMEGetMethod_PRIMME402,14811
PetscErrorCode EPSPRIMMEGetMethod(EPS eps,EPSPRIMMEMethod *method)EPSPRIMMEGetMethod426,15323
SLEPC_EXTERN PetscErrorCode EPSCreate_PRIMME(EPS eps)EPSCreate_PRIMME437,15648

src/eps/impls/external/trlan/makefile,289
makefile:^?makefile^A,1
CFLAGS   =CFLAGS15,446
FFLAGS   =FFLAGS16,457
SOURCEC  = trlan.cSOURCEC17,468
SOURCEF  =SOURCEF18,487
SOURCEH  = trlan.hSOURCEH19,498
LIBBASE  = libslepcepsLIBBASE20,517
DIRS     =DIRS21,540
MANSEC   = EPSMANSEC22,551
LOCDIR   = src/eps/impls/external/trlan/LOCDIR23,566

src/eps/impls/external/trlan/trlan.c,581
trlan.c:^?trlan.c^A,1
  EPS eps;eps19,591
  Vec x,y;x20,602
  Vec x,y;y20,602
} globaldata;globaldata21,613
PetscErrorCode EPSSetUp_TRLAN(EPS eps)EPSSetUp_TRLAN23,628
static PetscBLASInt MatMult_TRLAN(PetscBLASInt *n,PetscBLASInt *m,PetscReal *xin,PetscBLASInt *ldx,PetscReal *yout,PetscBLASInt *ldy)MatMult_TRLAN64,2859
PetscErrorCode EPSSolve_TRLAN(EPS eps)EPSSolve_TRLAN83,3546
PetscErrorCode EPSReset_TRLAN(EPS eps)EPSReset_TRLAN145,6230
PetscErrorCode EPSDestroy_TRLAN(EPS eps)EPSDestroy_TRLAN155,6436
SLEPC_EXTERN PetscErrorCode EPSCreate_TRLAN(EPS eps)EPSCreate_TRLAN164,6599

src/eps/impls/external/trlan/trlan.h,332
trlan.h:^?trlan.h^A,1
#define SLEPC_TRLAN_HSLEPC_TRLAN_H15,488
  PetscBLASInt       maxlan;maxlan18,528
  PetscBLASInt       restart;restart19,557
  PetscReal          *work;work20,587
  PetscBLASInt       lwork;lwork21,615
} EPS_TRLAN;EPS_TRLAN22,643
#define TRLan_ TRLan_30,828
#define TRLan_ TRLan_32,889
#define TRLan_ TRLan_34,918

src/eps/impls/krylov/arnoldi/arnoldi.c,980
arnoldi.c:^?arnoldi.c^A,1
  PetscBool delayed;delayed28,774
} EPS_ARNOLDI;EPS_ARNOLDI29,795
PetscErrorCode EPSSetUp_Arnoldi(EPS eps)EPSSetUp_Arnoldi31,811
PetscErrorCode EPSSolve_Arnoldi(EPS eps)EPSSolve_Arnoldi60,2330
PetscErrorCode EPSSetFromOptions_Arnoldi(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_Arnoldi142,6000
static PetscErrorCode EPSArnoldiSetDelayed_Arnoldi(EPS eps,PetscBool delayed)EPSArnoldiSetDelayed_Arnoldi158,6591
PetscErrorCode EPSArnoldiSetDelayed(EPS eps,PetscBool delayed)EPSArnoldiSetDelayed189,7410
static PetscErrorCode EPSArnoldiGetDelayed_Arnoldi(EPS eps,PetscBool *delayed)EPSArnoldiGetDelayed_Arnoldi200,7746
PetscErrorCode EPSArnoldiGetDelayed(EPS eps,PetscBool *delayed)EPSArnoldiGetDelayed225,8310
PetscErrorCode EPSDestroy_Arnoldi(EPS eps)EPSDestroy_Arnoldi236,8634
PetscErrorCode EPSView_Arnoldi(EPS eps,PetscViewer viewer)EPSView_Arnoldi247,8997
SLEPC_EXTERN PetscErrorCode EPSCreate_Arnoldi(EPS eps)EPSCreate_Arnoldi261,9444

src/eps/impls/krylov/arnoldi/makefile,283
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = arnoldi.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcepsLIBBASE18,474
DIRS     =DIRS19,497
MANSEC   = EPSMANSEC20,508
LOCDIR   = src/eps/impls/krylov/arnoldi/LOCDIR21,523

src/eps/impls/krylov/epskrylov.c,1189
epskrylov.c:^?epskrylov.c^A,1
PetscErrorCode EPSBasicArnoldi(EPS eps,PetscBool trans,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscReal *beta,PetscBool *breakdown)EPSBasicArnoldi29,1044
PetscErrorCode EPSDelayedArnoldi(EPS eps,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscReal *beta,PetscBool *breakdown)EPSDelayedArnoldi77,2778
PetscErrorCode EPSDelayedArnoldi1(EPS eps,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscReal *beta,PetscBool *breakdown)EPSDelayedArnoldi1187,6460
PetscErrorCode EPSKrylovConvergence_Filter(EPS eps,PetscBool getall,PetscInt kini,PetscInt nits,PetscReal beta,PetscReal gamma,PetscInt *kout)EPSKrylovConvergence_Filter233,7901
PetscErrorCode EPSKrylovConvergence(EPS eps,PetscBool getall,PetscInt kini,PetscInt nits,PetscReal beta,PetscReal betat,PetscReal corrf,PetscInt *kout)EPSKrylovConvergence281,9825
PetscErrorCode EPSFullLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscInt k,PetscInt *M,PetscBool *breakdown)EPSFullLanczos392,14235
PetscErrorCode EPSPseudoLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscReal *omega,PetscInt k,PetscInt *M,PetscBool *breakdown,PetscBool *symmlost,PetscReal *cos,Vec w)EPSPseudoLanczos423,15432

src/eps/impls/krylov/krylovschur/ftn-custom/makefile,275
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zkrylovschurf.cSOURCEC15,469
SOURCEF  =SOURCEF16,496
SOURCEH  =SOURCEH17,507
DIRS     =DIRS18,518
LIBBASE  = libslepcepsLIBBASE19,529
LOCDIR   = src/eps/impls/krylov/krylovschur/ftn-custom/LOCDIR20,552

src/eps/impls/krylov/krylovschur/ftn-custom/zkrylovschurf.c,1547
zkrylovschurf.c:^?zkrylovschurf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL epskrylovschursetsubintervals_(EPS *eps,PetscReal *subint,PetscErrorCode *ierr)epskrylovschursetsubintervals_28,1274
SLEPC_EXTERN void PETSC_STDCALL epskrylovschurgetsubintervals_(EPS *eps,PetscReal *subint,PetscErrorCode *ierr)epskrylovschurgetsubintervals_34,1475
SLEPC_EXTERN void PETSC_STDCALL epskrylovschurgetinertias_(EPS *eps,PetscInt *nshift,PetscReal *shifts,PetscInt *inertias,PetscErrorCode *ierr)epskrylovschurgetinertias_46,1908
SLEPC_EXTERN void PETSC_STDCALL epskrylovschurgetsubcomminfo_(EPS *eps,PetscInt *k,PetscInt *n,Vec *v,PetscErrorCode *ierr)epskrylovschurgetsubcomminfo_62,2526
SLEPC_EXTERN void PETSC_STDCALL epskrylovschurgetsubcommmats_(EPS *eps,Mat *A,Mat *B,PetscErrorCode *ierr)epskrylovschurgetsubcommmats_68,2734

src/eps/impls/krylov/krylovschur/krylovschur.c,5598
krylovschur.c:^?krylovschur.c^A,1
PetscErrorCode EPSGetArbitraryValues(EPS eps,PetscScalar *rr,PetscScalar *ri)EPSGetArbitraryValues35,1100
static PetscErrorCode EstimateRange(Mat A,PetscReal *left,PetscReal *right)EstimateRange62,2061
static PetscErrorCode EPSSetUp_KrylovSchur_Filter(EPS eps)EPSSetUp_KrylovSchur_Filter94,3245
PetscErrorCode EPSSetUp_KrylovSchur(EPS eps)EPSSetUp_KrylovSchur129,5257
PetscErrorCode EPSSolve_KrylovSchur_Default(EPS eps)EPSSolve_KrylovSchur_Default241,10752
static PetscErrorCode EPSKrylovSchurSetRestart_KrylovSchur(EPS eps,PetscReal keep)EPSKrylovSchurSetRestart_KrylovSchur363,15732
PetscErrorCode EPSKrylovSchurSetRestart(EPS eps,PetscReal keep)EPSKrylovSchurSetRestart397,16707
static PetscErrorCode EPSKrylovSchurGetRestart_KrylovSchur(EPS eps,PetscReal *keep)EPSKrylovSchurGetRestart_KrylovSchur408,17042
PetscErrorCode EPSKrylovSchurGetRestart(EPS eps,PetscReal *keep)EPSKrylovSchurGetRestart433,17549
static PetscErrorCode EPSKrylovSchurSetLocking_KrylovSchur(EPS eps,PetscBool lock)EPSKrylovSchurSetLocking_KrylovSchur444,17872
PetscErrorCode EPSKrylovSchurSetLocking(EPS eps,PetscBool lock)EPSKrylovSchurSetLocking476,18739
static PetscErrorCode EPSKrylovSchurGetLocking_KrylovSchur(EPS eps,PetscBool *lock)EPSKrylovSchurGetLocking_KrylovSchur487,19074
PetscErrorCode EPSKrylovSchurGetLocking(EPS eps,PetscBool *lock)EPSKrylovSchurGetLocking512,19571
static PetscErrorCode EPSKrylovSchurSetPartitions_KrylovSchur(EPS eps,PetscInt npart)EPSKrylovSchurSetPartitions_KrylovSchur523,19894
PetscErrorCode EPSKrylovSchurSetPartitions(EPS eps,PetscInt npart)EPSKrylovSchurSetPartitions572,21539
static PetscErrorCode EPSKrylovSchurGetPartitions_KrylovSchur(EPS eps,PetscInt *npart)EPSKrylovSchurGetPartitions_KrylovSchur583,21880
PetscErrorCode EPSKrylovSchurGetPartitions(EPS eps,PetscInt *npart)EPSKrylovSchurGetPartitions608,22418
static PetscErrorCode EPSKrylovSchurSetDetectZeros_KrylovSchur(EPS eps,PetscBool detect)EPSKrylovSchurSetDetectZeros_KrylovSchur619,22747
PetscErrorCode EPSKrylovSchurSetDetectZeros(EPS eps,PetscBool detect)EPSKrylovSchurSetDetectZeros655,23852
static PetscErrorCode EPSKrylovSchurGetDetectZeros_KrylovSchur(EPS eps,PetscBool *detect)EPSKrylovSchurGetDetectZeros_KrylovSchur666,24201
PetscErrorCode EPSKrylovSchurGetDetectZeros(EPS eps,PetscBool *detect)EPSKrylovSchurGetDetectZeros691,24768
static PetscErrorCode EPSKrylovSchurSetDimensions_KrylovSchur(EPS eps,PetscInt nev,PetscInt ncv,PetscInt mpd)EPSKrylovSchurSetDimensions_KrylovSchur702,25105
PetscErrorCode EPSKrylovSchurSetDimensions(EPS eps,PetscInt nev,PetscInt ncv,PetscInt mpd)EPSKrylovSchurSetDimensions747,26772
static PetscErrorCode EPSKrylovSchurGetDimensions_KrylovSchur(EPS eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)EPSKrylovSchurGetDimensions_KrylovSchur760,27249
PetscErrorCode EPSKrylovSchurGetDimensions(EPS eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)EPSKrylovSchurGetDimensions789,28056
static PetscErrorCode EPSKrylovSchurSetSubintervals_KrylovSchur(EPS eps,PetscReal* subint)EPSKrylovSchurSetSubintervals_KrylovSchur799,28404
PetscErrorCode EPSKrylovSchurSetSubintervals(EPS eps,PetscReal *subint)EPSKrylovSchurSetSubintervals840,30160
static PetscErrorCode EPSKrylovSchurGetSubintervals_KrylovSchur(EPS eps,PetscReal **subint)EPSKrylovSchurGetSubintervals_KrylovSchur850,30464
PetscErrorCode EPSKrylovSchurGetSubintervals(EPS eps,PetscReal **subint)EPSKrylovSchurGetSubintervals899,32079
static PetscErrorCode EPSKrylovSchurGetInertias_KrylovSchur(EPS eps,PetscInt *n,PetscReal **shifts,PetscInt **inertias)EPSKrylovSchurGetInertias_KrylovSchur910,32416
PetscErrorCode EPSKrylovSchurGetInertias(EPS eps,PetscInt *n,PetscReal **shifts,PetscInt **inertias)EPSKrylovSchurGetInertias1000,35474
static PetscErrorCode EPSKrylovSchurGetSubcommInfo_KrylovSchur(EPS eps,PetscInt *k,PetscInt *n,Vec *v)EPSKrylovSchurGetSubcommInfo_KrylovSchur1011,35865
PetscErrorCode EPSKrylovSchurGetSubcommInfo(EPS eps,PetscInt *k,PetscInt *n,Vec *v)EPSKrylovSchurGetSubcommInfo1053,37369
static PetscErrorCode EPSKrylovSchurGetSubcommPairs_KrylovSchur(EPS eps,PetscInt i,PetscScalar *eig,Vec v)EPSKrylovSchurGetSubcommPairs_KrylovSchur1063,37697
PetscErrorCode EPSKrylovSchurGetSubcommPairs(EPS eps,PetscInt i,PetscScalar *eig,Vec v)EPSKrylovSchurGetSubcommPairs1104,39296
static PetscErrorCode EPSKrylovSchurGetSubcommMats_KrylovSchur(EPS eps,Mat *A,Mat *B)EPSKrylovSchurGetSubcommMats_KrylovSchur1115,39680
PetscErrorCode EPSKrylovSchurGetSubcommMats(EPS eps,Mat *A,Mat *B)EPSKrylovSchurGetSubcommMats1150,40953
static PetscErrorCode EPSKrylovSchurUpdateSubcommMats_KrylovSchur(EPS eps,PetscScalar a,PetscScalar ap,Mat Au,PetscScalar b,PetscScalar bp, Mat Bu,MatStructure str,PetscBool globalup)EPSKrylovSchurUpdateSubcommMats_KrylovSchur1160,41247
PetscErrorCode EPSKrylovSchurUpdateSubcommMats(EPS eps,PetscScalar s,PetscScalar a,Mat Au,PetscScalar t,PetscScalar b,Mat Bu,MatStructure str,PetscBool globalup)EPSKrylovSchurUpdateSubcommMats1254,45429
PetscErrorCode EPSSetFromOptions_KrylovSchur(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_KrylovSchur1272,46302
PetscErrorCode EPSView_KrylovSchur(EPS eps,PetscViewer viewer)EPSView_KrylovSchur1308,48470
PetscErrorCode EPSDestroy_KrylovSchur(EPS eps)EPSDestroy_KrylovSchur1335,49812
PetscErrorCode EPSReset_KrylovSchur(EPS eps)EPSReset_KrylovSchur1361,51783
PetscErrorCode EPSSetDefaultST_KrylovSchur(EPS eps)EPSSetDefaultST_KrylovSchur1374,52118
SLEPC_EXTERN PetscErrorCode EPSCreate_KrylovSchur(EPS eps)EPSCreate_KrylovSchur1387,52389

src/eps/impls/krylov/krylovschur/krylovschur.h,5414
krylovschur.h:^?krylovschur.h^A,1
#define SLEPC_KRYLOVSCHUR_HSLEPC_KRYLOVSCHUR_H15,475
typedef struct _n_shift *EPS_shift;EPS_shift27,1082
struct _n_shift {_n_shift28,1118
  PetscReal     value;value29,1136
  PetscInt      inertia;inertia30,1159
  PetscBool     comp[2];      /* Shows completion of subintervals (left and right) */comp31,1184
  EPS_shift     neighb[2];    /* Adjacent shifts */neighb32,1270
  PetscInt      index;        /* Index in eig where found values are stored */index33,1322
  PetscInt      neigs;        /* Number of values found */neigs34,1401
  PetscReal     ext[2];       /* Limits for accepted values */ext35,1460
  PetscInt      nsch[2];      /* Number of missing values for each subinterval */nsch36,1523
  PetscInt      nconv[2];     /* Converged on each side (accepted or not) */nconv37,1605
struct _n_SR {_n_SR41,1744
  PetscReal     int0,int1;    /* Extremes of the interval */int042,1759
  PetscReal     int0,int1;    /* Extremes of the interval */int142,1759
  PetscInt      dir;          /* Determines the order of values in eig (+1 incr, -1 decr) */dir43,1820
  PetscBool     hasEnd;       /* Tells whether the interval has an end */hasEnd44,1913
  PetscInt      inertia0,inertia1;inertia045,1987
  PetscInt      inertia0,inertia1;inertia145,1987
  PetscScalar   *back;back46,2022
  PetscInt      numEigs;      /* Number of eigenvalues in the interval */numEigs47,2045
  PetscInt      indexEig;indexEig48,2119
  EPS_shift     sPres;        /* Present shift */sPres49,2145
  EPS_shift     *pending;     /* Pending shifts array */pending50,2195
  PetscInt      nPend;        /* Number of pending shifts */nPend51,2252
  PetscInt      maxPend;      /* Size of "pending" array */maxPend52,2313
  PetscInt      *idxDef;      /* For deflation */idxDef53,2373
  PetscInt      nMAXCompl;nMAXCompl54,2423
  PetscInt      iterCompl;iterCompl55,2450
  PetscInt      itsKs;        /* Krylovschur restarts */itsKs56,2477
  PetscInt      nleap;nleap57,2534
  EPS_shift     s0;           /* Initial shift */s058,2557
  PetscScalar   *S;           /* Matrix for projected problem */S59,2607
  PetscInt      nS;nS60,2672
  EPS_shift     sPrev;sPrev61,2692
  PetscInt      nv;           /* position of restart vector */nv62,2715
  BV            V;            /* working basis (for subsolve) */V63,2778
  BV            Vnext;        /* temporary working basis during change of shift */Vnext64,2843
  PetscScalar   *eigr,*eigi;  /* eigenvalues (for subsolve) */eigr65,2926
  PetscScalar   *eigr,*eigi;  /* eigenvalues (for subsolve) */eigi65,2926
  PetscReal     *errest;      /* error estimates (for subsolve) */errest66,2989
  PetscInt      *perm;        /* permutation (for subsolve) */perm67,3056
typedef struct _n_SR *EPS_SR;EPS_SR69,3122
  PetscReal        keep;               /* restart parameter */keep72,3170
  PetscBool        lock;               /* locking/non-locking variant */lock73,3233
  EPS_SR           sr;                 /* spectrum slicing context */sr75,3362
  PetscInt         nev;                /* number of eigenvalues to compute */nev76,3432
  PetscInt         ncv;                /* number of basis vectors */ncv77,3510
  PetscInt         mpd;                /* maximum dimension of projected problem */mpd78,3579
  PetscInt         npart;              /* number of partitions of subcommunicator */npart79,3663
  PetscBool        detect;             /* check for zeros during factorizations */detect80,3748
  PetscReal        *subintervals;      /* partition of global interval */subintervals81,3831
  PetscBool        subintset;          /* subintervals set by user */subintset82,3905
  PetscMPIInt      *nconv_loc;         /* converged eigenpairs for each subinterval */nconv_loc83,3975
  EPS              eps;                /* additional eps for slice runs */eps84,4062
  PetscBool        global;             /* flag distinguishing global from local eps */global85,4137
  PetscReal        *shifts;            /* array containing global shifts */shifts86,4224
  PetscInt         *inertias;          /* array containing global inertias */inertias87,4300
  PetscInt         nshifts;            /* elements in the arrays of shifts and inertias */nshifts88,4378
  PetscSubcomm     subc;               /* context for subcommunicators */subc89,4469
  MPI_Comm         commrank;           /* group processes with same rank in subcommunicators */commrank90,4543
  PetscBool        commset;            /* flag indicating that commrank was created */commset91,4639
  PetscObjectState Astate,Bstate;      /* state of subcommunicator matrices */Astate92,4726
  PetscObjectState Astate,Bstate;      /* state of subcommunicator matrices */Bstate92,4726
  PetscObjectId    Aid,Bid;            /* Id of subcommunicator matrices */Aid93,4805
  PetscObjectId    Aid,Bid;            /* Id of subcommunicator matrices */Bid93,4805
  IS               isrow,iscol;        /* index sets used in update of subcomm mats */isrow94,4881
  IS               isrow,iscol;        /* index sets used in update of subcomm mats */iscol94,4881
  Mat              *submata,*submatb;  /* seq matrices used in update of subcomm mats */submata95,4968
  Mat              *submata,*submatb;  /* seq matrices used in update of subcomm mats */submatb95,4968
} EPS_KRYLOVSCHUR;EPS_KRYLOVSCHUR96,5057

src/eps/impls/krylov/krylovschur/ks-indef.c,95
ks-indef.c:^?ks-indef.c^A,1
PetscErrorCode EPSSolve_KrylovSchur_Indefinite(EPS eps)EPSSolve_KrylovSchur_Indefinite18,566

src/eps/impls/krylov/krylovschur/ks-slice.c,2109
ks-slice.c:^?ks-slice.c^A,1
static PetscBool  cited = PETSC_FALSE;cited29,949
static const char citation[] =citation30,988
#define SLICE_PTOL SLICE_PTOL42,1408
#define InertiaMismatch(InertiaMismatch44,1455
static PetscErrorCode EPSSliceResetSR(EPS eps)EPSSliceResetSR49,1689
PetscErrorCode EPSReset_KrylovSchur_Slice(EPS eps)EPSReset_KrylovSchur_Slice77,2388
static PetscErrorCode EPSSliceAllocateSolution(EPS eps,PetscInt extra)EPSSliceAllocateSolution113,3653
static PetscErrorCode EPSSliceGetEPS(EPS eps)EPSSliceGetEPS158,5569
static PetscErrorCode EPSSliceGetInertia(EPS eps,PetscReal shift,PetscInt *inertia,PetscInt *zeros)EPSSliceGetInertia317,12306
static PetscErrorCode EPSBackTransform_Skip(EPS eps)EPSBackTransform_Skip349,13368
PetscErrorCode EPSSetUp_KrylovSchur_Slice(EPS eps)EPSSetUp_KrylovSchur_Slice355,13474
static PetscErrorCode EPSSliceGatherEigenVectors(EPS eps)EPSSliceGatherEigenVectors559,24163
PetscErrorCode EPSComputeVectors_Slice(EPS eps)EPSComputeVectors_Slice624,26748
#define SWAP(SWAP637,27079
static PetscErrorCode EPSSliceGetInertias(EPS eps,PetscInt *n,PetscReal **shifts,PetscInt **inertias)EPSSliceGetInertias639,27115
static PetscErrorCode EPSSliceGatherSolution(EPS eps)EPSSliceGatherSolution693,28761
static PetscErrorCode EPSCreateShift(EPS eps,PetscReal val,EPS_shift neighb0,EPS_shift neighb1)EPSCreateShift787,33717
static PetscErrorCode EPSPrepareRational(EPS eps)EPSPrepareRational824,34876
static PetscErrorCode EPSExtractShift(EPS eps)EPSExtractShift868,36310
static PetscErrorCode EPSKrylovSchur_Slice(EPS eps)EPSKrylovSchur_Slice905,37728
static PetscErrorCode EPSGetNewShiftValue(EPS eps,PetscInt side,PetscReal *newS)EPSGetNewShiftValue1086,45143
static PetscErrorCode sortRealEigenvalues(PetscScalar *r,PetscInt *perm,PetscInt nr,PetscBool prev,PetscInt dir)sortRealEigenvalues1164,49198
static PetscErrorCode EPSStoreEigenpairs(EPS eps)EPSStoreEigenpairs1183,49754
static PetscErrorCode EPSLookForDeflation(EPS eps)EPSLookForDeflation1234,51727
PetscErrorCode EPSSolve_KrylovSchur_Slice(EPS eps)EPSSolve_KrylovSchur_Slice1304,54213

src/eps/impls/krylov/krylovschur/ks-symm.c,83
ks-symm.c:^?ks-symm.c^A,1
PetscErrorCode EPSSolve_KrylovSchur_Symm(EPS eps)EPSSolve_KrylovSchur_Symm19,556

src/eps/impls/krylov/krylovschur/ks-twosided.c,289
ks-twosided.c:^?ks-twosided.c^A,1
static PetscErrorCode EPSTwoSidedRQUpdate1(EPS eps,Mat M,PetscInt nv)EPSTwoSidedRQUpdate127,808
static PetscErrorCode EPSTwoSidedRQUpdate2(EPS eps,Mat M,PetscInt k)EPSTwoSidedRQUpdate276,3009
PetscErrorCode EPSSolve_KrylovSchur_TwoSided(EPS eps)EPSSolve_KrylovSchur_TwoSided123,4932

src/eps/impls/krylov/krylovschur/makefile,351
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = krylovschur.c ks-symm.c ks-slice.c ks-indef.c ks-twosided.cSOURCEC15,431
SOURCEF  =SOURCEF16,502
SOURCEH  = krylovschur.hSOURCEH17,513
LIBBASE  = libslepcepsLIBBASE18,538
DIRS     =DIRS19,561
MANSEC   = EPSMANSEC20,572
LOCDIR   = src/eps/impls/krylov/krylovschur/LOCDIR21,587

src/eps/impls/krylov/lanczos/lanczos.c,2482
lanczos.c:^?lanczos.c^A,1
  EPSLanczosReorthogType reorthog;      /* user-provided reorthogonalization parameter */reorthog31,929
  PetscInt               allocsize;     /* number of columns of work BV's allocated at setup */allocsize32,1019
  BV                     AV;            /* work BV used in selective reorthogonalization */AV33,1115
} EPS_LANCZOS;EPS_LANCZOS34,1207
PetscErrorCode EPSSetUp_Lanczos(EPS eps)EPSSetUp_Lanczos36,1223
static PetscErrorCode EPSLocalLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscInt k,PetscInt *M,PetscBool *breakdown)EPSLocalLanczos100,4402
static PetscErrorCode DenseTridiagonal(PetscInt n_,PetscReal *D,PetscReal *E,PetscReal *w,PetscScalar *V)DenseTridiagonal158,6193
static PetscErrorCode EPSSelectiveLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscInt k,PetscInt *M,PetscBool *breakdown,PetscReal anorm)EPSSelectiveLanczos208,7865
static void update_omega(PetscReal *omega,PetscReal *omega_old,PetscInt j,PetscReal *alpha,PetscReal *beta,PetscReal eps1,PetscReal anorm)update_omega287,10561
static void compute_int(PetscBool *which,PetscReal *mu,PetscInt j,PetscReal delta,PetscReal eta)compute_int322,11733
static PetscErrorCode EPSPartialLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscInt k,PetscInt *M,PetscBool *breakdown,PetscReal anorm)EPSPartialLanczos365,12743
static PetscErrorCode EPSBasicLanczos(EPS eps,PetscReal *alpha,PetscReal *beta,PetscInt k,PetscInt *m,PetscBool *breakdown,PetscReal anorm)EPSBasicLanczos489,17469
PetscErrorCode EPSSolve_Lanczos(EPS eps)EPSSolve_Lanczos533,19113
PetscErrorCode EPSSetFromOptions_Lanczos(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_Lanczos719,26141
static PetscErrorCode EPSLanczosSetReorthog_Lanczos(EPS eps,EPSLanczosReorthogType reorthog)EPSLanczosSetReorthog_Lanczos736,26844
PetscErrorCode EPSLanczosSetReorthog(EPS eps,EPSLanczosReorthogType reorthog)EPSLanczosSetReorthog777,28080
static PetscErrorCode EPSLanczosGetReorthog_Lanczos(EPS eps,EPSLanczosReorthogType *reorthog)EPSLanczosGetReorthog_Lanczos788,28447
PetscErrorCode EPSLanczosGetReorthog(EPS eps,EPSLanczosReorthogType *reorthog)EPSLanczosGetReorthog813,29016
PetscErrorCode EPSReset_Lanczos(EPS eps)EPSReset_Lanczos824,29367
PetscErrorCode EPSDestroy_Lanczos(EPS eps)EPSDestroy_Lanczos835,29612
PetscErrorCode EPSView_Lanczos(EPS eps,PetscViewer viewer)EPSView_Lanczos846,29977
SLEPC_EXTERN PetscErrorCode EPSCreate_Lanczos(EPS eps)EPSCreate_Lanczos860,30436

src/eps/impls/krylov/lanczos/makefile,283
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = lanczos.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcepsLIBBASE18,474
DIRS     =DIRS19,497
MANSEC   = EPSMANSEC20,508
LOCDIR   = src/eps/impls/krylov/lanczos/LOCDIR21,523

src/eps/impls/krylov/makefile,305
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = epskrylov.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcepsLIBBASE18,476
DIRS     = arnoldi lanczos krylovschurDIRS19,499
LOCDIR   = src/eps/impls/krylov/LOCDIR20,538
MANSEC   = EPSMANSEC21,571

src/eps/impls/lapack/lapack.c,208
lapack.c:^?lapack.c^A,1
PetscErrorCode EPSSetUp_LAPACK(EPS eps)EPSSetUp_LAPACK17,590
PetscErrorCode EPSSolve_LAPACK(EPS eps)EPSSolve_LAPACK136,5550
SLEPC_EXTERN PetscErrorCode EPSCreate_LAPACK(EPS eps)EPSCreate_LAPACK182,7242

src/eps/impls/lapack/makefile,274
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = lapack.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcepsLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = EPSMANSEC20,507
LOCDIR   = src/eps/impls/lapack/LOCDIR21,522

src/eps/impls/makefile,185
makefile:^?makefile^A,1
LIBBASE  = libslepcepsLIBBASE13,409
DIRS     = power subspace krylov davidson cg ciss lapack externalDIRS14,432
LOCDIR   = src/eps/impls/LOCDIR15,498
MANSEC   = EPSMANSEC16,524

src/eps/impls/power/makefile,272
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = power.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcepsLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = EPSMANSEC20,506
LOCDIR   = src/eps/impls/power/LOCDIR21,521

src/eps/impls/power/power.c,4305
power.c:^?power.c^A,1
  EPSPowerShiftType shift_type;shift_type45,1612
  PetscBool         nonlinear;nonlinear46,1644
  PetscBool         update;update47,1675
  SNES              snes;snes48,1703
  PetscErrorCode    (*formFunctionB)(SNES,Vec,Vec,void*);formFunctionB49,1729
  void              *formFunctionBctx;formFunctionBctx50,1787
  PetscErrorCode    (*formFunctionA)(SNES,Vec,Vec,void*);formFunctionA51,1826
  void              *formFunctionActx;formFunctionActx52,1884
  PetscErrorCode    (*formFunctionAB)(SNES,Vec,Vec,Vec,void*);formFunctionAB53,1923
  PetscInt          idx;  /* index of the first nonzero entry in the iteration vector */idx54,1986
  PetscInt          p;    /* process id of the owner of idx */p55,2075
} EPS_POWER;EPS_POWER56,2138
PetscErrorCode EPSSetUp_Power(EPS eps)EPSSetUp_Power58,2152
static PetscErrorCode FirstNonzeroIdx(Vec x,PetscInt *idx,PetscInt *p)FirstNonzeroIdx160,7912
static PetscErrorCode Normalize(Vec x,PetscReal norm,PetscInt idx,PetscInt p,PetscScalar *sign)Normalize187,8906
static PetscErrorCode EPSPowerUpdateFunctionB(EPS eps,Vec x,Vec Bx)EPSPowerUpdateFunctionB212,9756
static PetscErrorCode EPSPowerUpdateFunctionA(EPS eps,Vec x,Vec Ax)EPSPowerUpdateFunctionA233,10330
static PetscErrorCode SNESLineSearchPostheckFunction(SNESLineSearch linesearch,Vec x,Vec y,Vec w,PetscBool *changed_y,PetscBool *changed_w,void *ctx)SNESLineSearchPostheckFunction252,10970
static PetscErrorCode EPSPowerFormFunction_Update(SNES snes,Vec x,Vec y,void *ctx)EPSPowerFormFunction_Update268,11572
static PetscErrorCode EPSPowerApply_SNES(EPS eps,Vec x,Vec y)EPSPowerApply_SNES296,12514
static PetscErrorCode EPSPowerComputeInitialGuess_Update(EPS eps)EPSPowerComputeInitialGuess_Update316,12996
PetscErrorCode EPSSolve_Power(EPS eps)EPSSolve_Power361,15005
PetscErrorCode EPSSolve_TS_Power(EPS eps)EPSSolve_TS_Power549,22432
PetscErrorCode EPSStopping_Power(EPS eps,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,EPSConvergedReason *reason,void *ctx)EPSStopping_Power680,27861
PetscErrorCode EPSBackTransform_Power(EPS eps)EPSBackTransform_Power698,28438
PetscErrorCode EPSSetFromOptions_Power(PetscOptionItems *PetscOptionsObject,EPS eps)EPSSetFromOptions_Power711,28788
static PetscErrorCode EPSPowerSetShiftType_Power(EPS eps,EPSPowerShiftType shift)EPSPowerSetShiftType_Power734,29863
PetscErrorCode EPSPowerSetShiftType(EPS eps,EPSPowerShiftType shift)EPSPowerSetShiftType782,31335
static PetscErrorCode EPSPowerGetShiftType_Power(EPS eps,EPSPowerShiftType *shift)EPSPowerGetShiftType_Power793,31681
PetscErrorCode EPSPowerGetShiftType(EPS eps,EPSPowerShiftType *shift)EPSPowerGetShiftType818,32190
static PetscErrorCode EPSPowerSetNonlinear_Power(EPS eps,PetscBool nonlinear)EPSPowerSetNonlinear_Power829,32520
PetscErrorCode EPSPowerSetNonlinear(EPS eps,PetscBool nonlinear)EPSPowerSetNonlinear872,34007
static PetscErrorCode EPSPowerGetNonlinear_Power(EPS eps,PetscBool *nonlinear)EPSPowerGetNonlinear_Power883,34349
PetscErrorCode EPSPowerGetNonlinear(EPS eps,PetscBool *nonlinear)EPSPowerGetNonlinear907,34859
static PetscErrorCode EPSPowerSetUpdate_Power(EPS eps,PetscBool update)EPSPowerSetUpdate_Power918,35189
PetscErrorCode EPSPowerSetUpdate(EPS eps,PetscBool update)EPSPowerSetUpdate946,36057
static PetscErrorCode EPSPowerGetUpdate_Power(EPS eps,PetscBool *update)EPSPowerGetUpdate_Power957,36384
PetscErrorCode EPSPowerGetUpdate(EPS eps,PetscBool *update)EPSPowerGetUpdate982,36913
static PetscErrorCode EPSPowerSetSNES_Power(EPS eps,SNES snes)EPSPowerSetSNES_Power993,37228
PetscErrorCode EPSPowerSetSNES(EPS eps,SNES snes)EPSPowerSetSNES1021,37983
static PetscErrorCode EPSPowerGetSNES_Power(EPS eps,SNES *snes)EPSPowerGetSNES_Power1033,38328
PetscErrorCode EPSPowerGetSNES(EPS eps,SNES *snes)EPSPowerGetSNES1067,39402
PetscErrorCode EPSReset_Power(EPS eps)EPSReset_Power1078,39693
PetscErrorCode EPSDestroy_Power(EPS eps)EPSDestroy_Power1088,39926
PetscErrorCode EPSView_Power(EPS eps,PetscViewer viewer)EPSView_Power1109,40996
PetscErrorCode EPSComputeVectors_Power(EPS eps)EPSComputeVectors_Power1134,41978
PetscErrorCode EPSSetDefaultST_Power(EPS eps)EPSSetDefaultST_Power1157,42714
SLEPC_EXTERN PetscErrorCode EPSCreate_Power(EPS eps)EPSCreate_Power1173,43099

src/eps/impls/subspace/makefile,278
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = subspace.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  =SOURCEH17,464
LIBBASE  = libslepcepsLIBBASE18,475
DIRS     =DIRS19,498
MANSEC   = EPSMANSEC20,509
LOCDIR   = src/eps/impls/subspace/LOCDIR21,524

src/eps/impls/subspace/subspace.c,678
subspace.c:^?subspace.c^A,1
PetscErrorCode EPSSetUp_Subspace(EPS eps)EPSSetUp_Subspace28,767
static PetscErrorCode EPSSubspaceFindGroup(PetscInt l,PetscInt m,PetscScalar *wr,PetscScalar *wi,PetscReal *rsd,PetscReal grptol,PetscInt *ngrp,PetscReal *ctr,PetscReal *ae,PetscReal *arsd)EPSSubspaceFindGroup67,2603
static PetscErrorCode EPSSubspaceResidualNorms(BV V,BV AV,PetscScalar *T,PetscInt l,PetscInt m,PetscInt ldt,Vec w,PetscReal *rsd)EPSSubspaceResidualNorms109,3699
PetscErrorCode EPSSolve_Subspace(EPS eps)EPSSolve_Subspace139,4528
PetscErrorCode EPSDestroy_Subspace(EPS eps)EPSDestroy_Subspace285,10580
SLEPC_EXTERN PetscErrorCode EPSCreate_Subspace(EPS eps)EPSCreate_Subspace294,10746

src/eps/interface/dlregiseps.c,1793
dlregiseps.c:^?dlregiseps.c^A,1
static PetscBool EPSPackageInitialized = PETSC_FALSE;EPSPackageInitialized13,436
const char *EPSBalanceTypes[] = {"NONE","ONESIDE","TWOSIDE","USER","EPSBalance","EPS_BALANCE_",0};EPSBalanceTypes15,491
const char *EPSErrorTypes[] = {"ABSOLUTE","RELATIVE","BACKWARD","EPSErrorType","EPS_ERROR_",0};EPSErrorTypes16,590
const char *EPSPowerShiftTypes[] = {"CONSTANT","RAYLEIGH","WILKINSON","EPSPowerShiftType","EPS_POWER_SHIFT_",0};EPSPowerShiftTypes17,686
const char *EPSLanczosReorthogTypes[] = {"LOCAL","FULL","SELECTIVE","PERIODIC","PARTIAL","DELAYED","EPSLanczosReorthogType","EPS_LANCZOS_REORTHOG_",0};EPSLanczosReorthogTypes18,799
const char *EPSPRIMMEMethods[] = {"","DYNAMIC","DEFAULT_MIN_TIME","DEFAULT_MIN_MATVECS","ARNOLDI","GD","GD_PLUSK","GD_OLSEN_PLUSK","JD_OLSEN_PLUSK","RQI","JDQR","JDQMR","JDQMR_ETOL","SUBSPACE_ITERATION","LOBPCG_ORTHOBASIS","LOBPCG_ORTHOBASISW","EPSPRIMMEMethod","EPS_PRIMME_",0};EPSPRIMMEMethods19,951
const char *EPSCISSQuadRules[] = {"(not set yet)","TRAPEZOIDAL","CHEBYSHEV","EPSCISSQuadRule","EPS_CISS_QUADRULE_",0};EPSCISSQuadRules20,1231
const char *EPSCISSExtractions[] = {"RITZ","HANKEL","EPSCISSExtraction","EPS_CISS_EXTRACTION_",0};EPSCISSExtractions21,1350
const char *const EPSConvergedReasons_Shifted[] = {"","DIVERGED_SYMMETRY_LOST","DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","CONVERGED_USER","EPSConvergedReason","EPS_",0};EPSConvergedReasons_Shifted22,1449
const char *const*EPSConvergedReasons = EPSConvergedReasons_Shifted + 4;EPSConvergedReasons23,1651
PetscErrorCode EPSFinalizePackage(void)EPSFinalizePackage33,1918
PetscErrorCode EPSInitializePackage()EPSInitializePackage53,2455
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepceps()PetscDLLibraryRegister_slepceps94,4005

src/eps/interface/epsbasic.c,1771
epsbasic.c:^?epsbasic.c^A,1
PetscFunctionList EPSList = 0;EPSList16,490
PetscBool         EPSRegisterAllCalled = PETSC_FALSE;EPSRegisterAllCalled17,521
PetscClassId      EPS_CLASSID = 0;EPS_CLASSID18,575
PetscLogEvent     EPS_SetUp = 0,EPS_Solve = 0;EPS_SetUp19,610
PetscLogEvent     EPS_SetUp = 0,EPS_Solve = 0;EPS_Solve19,610
PetscErrorCode EPSCreate(MPI_Comm comm,EPS *outeps)EPSCreate39,965
PetscErrorCode EPSSetType(EPS eps,EPSType type)EPSSetType152,4466
PetscErrorCode EPSGetType(EPS eps,EPSType *type)EPSGetType191,5538
PetscErrorCode EPSRegister(const char *name,PetscErrorCode (*function)(EPS))EPSRegister226,6344
PetscErrorCode EPSReset(EPS eps)EPSReset255,7147
PetscErrorCode EPSDestroy(EPS *eps)EPSDestroy285,7938
PetscErrorCode EPSSetTarget(EPS eps,PetscScalar target)EPSSetTarget341,9866
PetscErrorCode EPSGetTarget(EPS eps,PetscScalar* target)EPSGetTarget372,10552
PetscErrorCode EPSSetInterval(EPS eps,PetscReal inta,PetscReal intb)EPSSetInterval409,11725
PetscErrorCode EPSGetInterval(EPS eps,PetscReal* inta,PetscReal* intb)EPSGetInterval443,12621
PetscErrorCode EPSSetST(EPS eps,ST st)EPSSetST469,13263
PetscErrorCode EPSGetST(EPS eps,ST *st)EPSGetST500,14025
PetscErrorCode EPSSetBV(EPS eps,BV V)EPSSetBV530,14865
PetscErrorCode EPSGetBV(EPS eps,BV *V)EPSGetBV560,15586
PetscErrorCode EPSSetRG(EPS eps,RG rg)EPSSetRG594,16523
PetscErrorCode EPSGetRG(EPS eps,RG *rg)EPSGetRG624,17232
PetscErrorCode EPSSetDS(EPS eps,DS ds)EPSSetDS658,18199
PetscErrorCode EPSGetDS(EPS eps,DS *ds)EPSGetDS688,18929
PetscErrorCode EPSIsGeneralized(EPS eps,PetscBool* is)EPSIsGeneralized721,19813
PetscErrorCode EPSIsHermitian(EPS eps,PetscBool* is)EPSIsHermitian746,20320
PetscErrorCode EPSIsPositive(EPS eps,PetscBool* is)EPSIsPositive771,20870

src/eps/interface/epsdefault.c,1408
epsdefault.c:^?epsdefault.c^A,1
PetscErrorCode EPSBackTransform_Default(EPS eps)EPSBackTransform_Default17,560
PetscErrorCode EPSComputeVectors_Hermitian(EPS eps)EPSComputeVectors_Hermitian30,900
PetscErrorCode EPSComputeVectors_Indefinite(EPS eps)EPSComputeVectors_Indefinite70,2199
PetscErrorCode EPSComputeVectors_Twosided(EPS eps)EPSComputeVectors_Twosided115,3587
PetscErrorCode EPSComputeVectors_Schur(EPS eps)EPSComputeVectors_Schur144,4567
PetscErrorCode EPSSetWorkVecs(EPS eps,PetscInt nw)EPSSetWorkVecs269,8618
PetscErrorCode EPSSetWhichEigenpairs_Default(EPS eps)EPSSetWhichEigenpairs_Default293,9415
PetscErrorCode EPSConvergedRelative(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)EPSConvergedRelative308,9843
PetscErrorCode EPSConvergedAbsolute(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)EPSConvergedAbsolute321,10151
PetscErrorCode EPSConvergedNorm(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)EPSConvergedNorm332,10439
PetscErrorCode EPSStoppingBasic(EPS eps,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,EPSConvergedReason *reason,void *ctx)EPSStoppingBasic374,11794
PetscErrorCode EPSComputeRitzVector(EPS eps,PetscScalar *Zr,PetscScalar *Zi,BV V,Vec x,Vec y)EPSComputeRitzVector399,12678
PetscErrorCode EPSBuildBalance_Krylov(EPS eps)EPSBuildBalance_Krylov467,14803

src/eps/interface/epsmon.c,1569
epsmon.c:^?epsmon.c^A,1
PetscErrorCode EPSMonitor(EPS eps,PetscInt it,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest)EPSMonitor20,582
PetscErrorCode EPSMonitorSet(EPS eps,PetscErrorCode (*monitor)(EPS,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))EPSMonitorSet79,2943
PetscErrorCode EPSMonitorCancel(EPS eps)EPSMonitorCancel107,3995
PetscErrorCode EPSGetMonitorContext(EPS eps,void **ctx)EPSGetMonitorContext139,4683
PetscErrorCode EPSMonitorAll(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)EPSMonitorAll167,5455
PetscErrorCode EPSMonitorFirst(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)EPSMonitorFirst224,7823
PetscErrorCode EPSMonitorConverged(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,SlepcConvMonitor ctx)EPSMonitorConverged279,10111
PetscErrorCode EPSMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)EPSMonitorLGCreate347,12713
PetscErrorCode EPSMonitorLG(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitorLG363,13259
PetscErrorCode EPSMonitorLGAll(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitorLGAll387,14105

src/eps/interface/epsopts.c,3908
epsopts.c:^?epsopts.c^A,1
PetscErrorCode EPSMonitorSetFromOptions(EPS eps,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(EPS,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscBool trackall)EPSMonitorSetFromOptions36,1163
PetscErrorCode EPSConvMonitorSetFromOptions(EPS eps,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(EPS,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,SlepcConvMonitor))EPSConvMonitorSetFromOptions74,2777
PetscErrorCode EPSSetFromOptions(EPS eps)EPSSetFromOptions107,4057
PetscErrorCode EPSGetTolerances(EPS eps,PetscReal *tol,PetscInt *maxits)EPSGetTolerances314,18424
PetscErrorCode EPSSetTolerances(EPS eps,PetscReal tol,PetscInt maxits)EPSSetTolerances345,19244
PetscErrorCode EPSGetDimensions(EPS eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)EPSGetDimensions386,20494
PetscErrorCode EPSSetDimensions(EPS eps,PetscInt nev,PetscInt ncv,PetscInt mpd)EPSSetDimensions434,22205
PetscErrorCode EPSSetWhichEigenpairs(EPS eps,EPSWhich which)EPSSetWhichEigenpairs519,25867
PetscErrorCode EPSGetWhichEigenpairs(EPS eps,EPSWhich *which)EPSGetWhichEigenpairs568,27092
PetscErrorCode EPSSetEigenvalueComparison(EPS eps,PetscErrorCode (*func)(PetscScalar,PetscScalar,PetscScalar,PetscScalar,PetscInt*,void*),void* ctx)EPSSetEigenvalueComparison608,28402
PetscErrorCode EPSSetArbitrarySelection(EPS eps,PetscErrorCode (*func)(PetscScalar,PetscScalar,Vec,Vec,PetscScalar*,PetscScalar*,void*),void* ctx)EPSSetArbitrarySelection665,30899
PetscErrorCode EPSSetConvergenceTestFunction(EPS eps,PetscErrorCode (*func)(EPS,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*),void* ctx,PetscErrorCode (*destroy)(void*))EPSSetConvergenceTestFunction705,32352
PetscErrorCode EPSSetConvergenceTest(EPS eps,EPSConv conv)EPSSetConvergenceTest754,34140
PetscErrorCode EPSGetConvergenceTest(EPS eps,EPSConv *conv)EPSGetConvergenceTest790,35274
PetscErrorCode EPSSetStoppingTestFunction(EPS eps,PetscErrorCode (*func)(EPS,PetscInt,PetscInt,PetscInt,PetscInt,EPSConvergedReason*,void*),void* ctx,PetscErrorCode (*destroy)(void*))EPSSetStoppingTestFunction832,36763
PetscErrorCode EPSSetStoppingTest(EPS eps,EPSStop stop)EPSSetStoppingTest875,38105
PetscErrorCode EPSGetStoppingTest(EPS eps,EPSStop *stop)EPSGetStoppingTest909,39081
PetscErrorCode EPSSetProblemType(EPS eps,EPSProblemType type)EPSSetProblemType952,40721
PetscErrorCode EPSGetProblemType(EPS eps,EPSProblemType *type)EPSGetProblemType1012,42331
PetscErrorCode EPSSetExtraction(EPS eps,EPSExtraction extr)EPSSetExtraction1054,43647
PetscErrorCode EPSGetExtraction(EPS eps,EPSExtraction *extr)EPSGetExtraction1078,44153
PetscErrorCode EPSSetBalance(EPS eps,EPSBalance bal,PetscInt its,PetscReal cutoff)EPSSetBalance1129,46052
PetscErrorCode EPSGetBalance(EPS eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff)EPSGetBalance1183,47710
PetscErrorCode EPSSetTwoSided(EPS eps,PetscBool twosided)EPSSetTwoSided1218,48809
PetscErrorCode EPSGetTwoSided(EPS eps,PetscBool *twosided)EPSGetTwoSided1246,49425
PetscErrorCode EPSSetTrueResidual(EPS eps,PetscBool trueres)EPSSetTrueResidual1282,50671
PetscErrorCode EPSGetTrueResidual(EPS eps,PetscBool *trueres)EPSGetTrueResidual1307,51208
PetscErrorCode EPSSetTrackAll(EPS eps,PetscBool trackall)EPSSetTrackAll1339,52155
PetscErrorCode EPSGetTrackAll(EPS eps,PetscBool *trackall)EPSGetTrackAll1364,52679
PetscErrorCode EPSSetPurify(EPS eps,PetscBool purify)EPSSetPurify1395,53644
PetscErrorCode EPSGetPurify(EPS eps,PetscBool *purify)EPSGetPurify1423,54217
PetscErrorCode EPSSetOptionsPrefix(EPS eps,const char *prefix)EPSSetOptionsPrefix1458,55133
PetscErrorCode EPSAppendOptionsPrefix(EPS eps,const char *prefix)EPSAppendOptionsPrefix1494,56396
PetscErrorCode EPSGetOptionsPrefix(EPS eps,const char *prefix[])EPSGetOptionsPrefix1532,57634

src/eps/interface/epsregis.c,59
epsregis.c:^?epsregis.c^A,1
PetscErrorCode EPSRegisterAll(void)EPSRegisterAll49,1609

src/eps/interface/epssetup.c,828
epssetup.c:^?epssetup.c^A,1
PetscErrorCode EPSSetDefaultST(EPS eps)EPSSetDefaultST22,748
PetscErrorCode EPSSetDefaultST_Precond(EPS eps)EPSSetDefaultST_Precond38,1166
PetscErrorCode EPSSetDefaultST_GMRES(EPS eps)EPSSetDefaultST_GMRES59,1771
PetscErrorCode EPSSetUp(EPS eps)EPSSetUp96,2896
PetscErrorCode EPSSetOperators(EPS eps,Mat A,Mat B)EPSSetOperators325,12348
PetscErrorCode EPSGetOperators(EPS eps,Mat *A,Mat *B)EPSGetOperators376,13933
PetscErrorCode EPSSetDeflationSpace(EPS eps,PetscInt n,Vec v[])EPSSetDeflationSpace423,15264
PetscErrorCode EPSSetInitialSpace(EPS eps,PetscInt n,Vec is[])EPSSetInitialSpace468,16707
PetscErrorCode EPSSetDimensions_Default(EPS eps,PetscInt nev,PetscInt *ncv,PetscInt *mpd)EPSSetDimensions_Default489,17387
PetscErrorCode EPSAllocateSolution(EPS eps,PetscInt extra)EPSAllocateSolution532,18782

src/eps/interface/epssolve.c,1518
epssolve.c:^?epssolve.c^A,1
PetscErrorCode EPSComputeVectors(EPS eps)EPSComputeVectors18,593
#define SWAP(SWAP31,905
static PetscErrorCode EPSComputeValues(EPS eps)EPSComputeValues33,941
PetscErrorCode EPSSolve(EPS eps)EPSSolve123,4899
PetscErrorCode EPSGetIterationNumber(EPS eps,PetscInt *its)EPSGetIterationNumber229,8369
PetscErrorCode EPSGetConverged(EPS eps,PetscInt *nconv)EPSGetConverged256,8923
PetscErrorCode EPSGetConvergedReason(EPS eps,EPSConvergedReason *reason)EPSGetConvergedReason292,9947
PetscErrorCode EPSGetInvariantSubspace(EPS eps,Vec v[])EPSGetInvariantSubspace331,11157
PetscErrorCode EPSGetEigenpair(EPS eps,PetscInt i,PetscScalar *eigr,PetscScalar *eigi,Vec Vr,Vec Vi)EPSGetEigenpair403,13914
PetscErrorCode EPSGetEigenvalue(EPS eps,PetscInt i,PetscScalar *eigr,PetscScalar *eigi)EPSGetEigenvalue443,15216
PetscErrorCode EPSGetEigenvector(EPS eps,PetscInt i,Vec Vr,Vec Vi)EPSGetEigenvector496,16962
PetscErrorCode EPSGetLeftEigenvector(EPS eps,PetscInt i,Vec Wr,Vec Wi)EPSGetLeftEigenvector547,18803
PetscErrorCode EPSGetErrorEstimate(EPS eps,PetscInt i,PetscReal *errest)EPSGetErrorEstimate588,20156
PetscErrorCode EPSComputeResidualNorm_Private(EPS eps,PetscBool trans,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec *z,PetscReal *norm)EPSComputeResidualNorm_Private609,20871
PetscErrorCode EPSComputeError(EPS eps,PetscInt i,EPSErrorType type,PetscReal *error)EPSComputeError686,23857
PetscErrorCode EPSGetStartVector(EPS eps,PetscInt i,PetscBool *breakdown)EPSGetStartVector788,27456

src/eps/interface/epsview.c,1490
epsview.c:^?epsview.c^A,1
PetscErrorCode EPSView(EPS eps,PetscViewer viewer)EPSView44,1303
#define HERM HERM60,1817
PetscErrorCode EPSReasonView(EPS eps,PetscViewer viewer)EPSReasonView241,10771
PetscErrorCode EPSReasonViewFromOptions(EPS eps)EPSReasonViewFromOptions271,11994
static PetscErrorCode EPSErrorView_ASCII(EPS eps,EPSErrorType etype,PetscViewer viewer)EPSErrorView_ASCII293,12753
static PetscErrorCode EPSErrorView_DETAIL(EPS eps,EPSErrorType etype,PetscViewer viewer)EPSErrorView_DETAIL333,14425
#define EXLEN EXLEN339,14613
static PetscErrorCode EPSErrorView_MATLAB(EPS eps,EPSErrorType etype,PetscViewer viewer)EPSErrorView_MATLAB376,15947
PetscErrorCode EPSErrorView(EPS eps,EPSErrorType etype,PetscViewer viewer)EPSErrorView420,17417
PetscErrorCode EPSErrorViewFromOptions(EPS eps)EPSErrorViewFromOptions466,18872
static PetscErrorCode EPSValuesView_DRAW(EPS eps,PetscViewer viewer)EPSValuesView_DRAW502,20522
static PetscErrorCode EPSValuesView_ASCII(EPS eps,PetscViewer viewer)EPSValuesView_ASCII532,21446
static PetscErrorCode EPSValuesView_MATLAB(EPS eps,PetscViewer viewer)EPSValuesView_MATLAB549,22017
PetscErrorCode EPSValuesView(EPS eps,PetscViewer viewer)EPSValuesView594,23225
PetscErrorCode EPSValuesViewFromOptions(EPS eps)EPSValuesViewFromOptions641,24748
PetscErrorCode EPSVectorsView(EPS eps,PetscViewer viewer)EPSVectorsView688,26243
#define NMLEN NMLEN693,26368
PetscErrorCode EPSVectorsViewFromOptions(EPS eps)EPSVectorsViewFromOptions738,27868

src/eps/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zepsf.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepcepsLIBBASE19,521
LOCDIR   = src/eps/interface/ftn-custom/LOCDIR20,544

src/eps/interface/ftn-custom/zepsf.c,16581
zepsf.c:^?zepsf.c^A,1
SLEPC_EXTERN void epsmonitorall_(EPS *eps,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)epsmonitorall_125,6910
SLEPC_EXTERN void epsmonitorconverged_(EPS *eps,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,SlepcConvMonitor *ctx,PetscErrorCode *ierr)epsmonitorconverged_130,7174
SLEPC_EXTERN void epsmonitorfirst_(EPS *eps,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)epsmonitorfirst_135,7445
SLEPC_EXTERN void epsmonitorlg_(EPS *eps,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)epsmonitorlg_140,7713
SLEPC_EXTERN void epsmonitorlgall_(EPS *eps,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)epsmonitorlgall_145,7957
  PetscFortranCallbackId monitor;monitor151,8223
  PetscFortranCallbackId monitordestroy;monitordestroy152,8257
  PetscFortranCallbackId convergence;convergence153,8298
  PetscFortranCallbackId convdestroy;convdestroy154,8336
  PetscFortranCallbackId stopping;stopping155,8374
  PetscFortranCallbackId stopdestroy;stopdestroy156,8409
  PetscFortranCallbackId comparison;comparison157,8447
  PetscFortranCallbackId arbitrary;arbitrary158,8484
} _cb;_cb159,8520
static PetscErrorCode ourmonitor(EPS eps,PetscInt i,PetscInt nc,PetscScalar *er,PetscScalar *ei,PetscReal *d,PetscInt l,void* ctx)ourmonitor162,8620
static PetscErrorCode ourdestroy(void** ctx)ourdestroy167,8938
static PetscErrorCode ourconvergence(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)ourconvergence173,9105
static PetscErrorCode ourconvdestroy(void *ctx)ourconvdestroy178,9405
static PetscErrorCode ourstopping(EPS eps,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,EPSConvergedReason *reason,void *ctx)ourstopping184,9571
static PetscErrorCode ourstopdestroy(void *ctx)ourstopdestroy189,9903
static PetscErrorCode oureigenvaluecomparison(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)oureigenvaluecomparison195,10069
static PetscErrorCode ourarbitraryfunc(PetscScalar er,PetscScalar ei,Vec xr,Vec xi,PetscScalar *rr,PetscScalar *ri,void *ctx)ourarbitraryfunc201,10395
SLEPC_EXTERN void PETSC_STDCALL epsview_(EPS *eps,PetscViewer *viewer,PetscErrorCode *ierr)epsview_207,10721
SLEPC_EXTERN void PETSC_STDCALL epsreasonview_(EPS *eps,PetscViewer *viewer,PetscErrorCode *ierr)epsreasonview_214,10908
SLEPC_EXTERN void PETSC_STDCALL epserrorview_(EPS *eps,EPSErrorType *etype,PetscViewer *viewer,PetscErrorCode *ierr)epserrorview_221,11107
SLEPC_EXTERN void PETSC_STDCALL epsvaluesview_(EPS *eps,PetscViewer *viewer,PetscErrorCode *ierr)epsvaluesview_228,11331
SLEPC_EXTERN void PETSC_STDCALL epsvectorsview_(EPS *eps,PetscViewer *viewer,PetscErrorCode *ierr)epsvectorsview_235,11530
SLEPC_EXTERN void PETSC_STDCALL epssettype_(EPS *eps,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))epssettype_242,11731
SLEPC_EXTERN void PETSC_STDCALL epsgettype_(EPS *eps,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))epsgettype_251,11965
SLEPC_EXTERN void PETSC_STDCALL epssetoptionsprefix_(EPS *eps,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))epssetoptionsprefix_260,12263
SLEPC_EXTERN void PETSC_STDCALL epsappendoptionsprefix_(EPS *eps,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))epsappendoptionsprefix_269,12521
SLEPC_EXTERN void PETSC_STDCALL epsgetoptionsprefix_(EPS *eps,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))epsgetoptionsprefix_278,12785
SLEPC_EXTERN void PETSC_STDCALL epsmonitorset_(EPS *eps,void (PETSC_STDCALL *monitor)(EPS*,PetscInt*,PetscInt*,PetscScalar*,PetscScalar*,PetscReal*,PetscInt*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)epsmonitorset_287,13112
SLEPC_EXTERN void PETSC_STDCALL epsconvergedabsolute_(EPS *eps,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)epsconvergedabsolute_308,15051
SLEPC_EXTERN void PETSC_STDCALL epsconvergedrelative_(EPS *eps,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)epsconvergedrelative_313,15286
SLEPC_EXTERN void PETSC_STDCALL epsconvergednorm_(EPS *eps,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)epsconvergednorm_318,15521
SLEPC_EXTERN void PETSC_STDCALL epssetconvergencetestfunction_(EPS *eps,void (PETSC_STDCALL *func)(EPS*,PetscScalar*,PetscScalar*,PetscReal*,PetscReal*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)epssetconvergencetestfunction_323,15748
SLEPC_EXTERN void PETSC_STDCALL epsstoppingbasic_(EPS *eps,PetscInt *its,PetscInt *max_it,PetscInt *nconv,PetscInt *nev,EPSConvergedReason *reason,void *ctx,PetscErrorCode *ierr)epsstoppingbasic_340,16893
SLEPC_EXTERN void PETSC_STDCALL epssetstoppingtestfunction_(EPS *eps,void (PETSC_STDCALL *func)(EPS*,PetscInt,PetscInt,PetscInt,PetscInt,EPSConvergedReason*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)epssetstoppingtestfunction_345,17147
SLEPC_EXTERN void PETSC_STDCALL epsseteigenvaluecomparison_(EPS *eps,void (PETSC_STDCALL *func)(PetscScalar*,PetscScalar*,PetscScalar*,PetscScalar*,PetscInt*,void*),void* ctx,PetscErrorCode *ierr)epsseteigenvaluecomparison_358,18010
SLEPC_EXTERN void PETSC_STDCALL epssetarbitraryselection_(EPS *eps,void (PETSC_STDCALL *func)(PetscScalar*,PetscScalar*,Vec*,Vec*,PetscScalar*,PetscScalar*,void*,PetscErrorCode*),void *ctx,PetscErrorCode *ierr)epssetarbitraryselection_365,18466
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions_372,18926
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions000_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions000_380,19179
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions100_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions100_385,19342
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions010_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions010_390,19505
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions001_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions001_395,19668
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions110_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions110_400,19831
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions011_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions011_405,19994
SLEPC_EXTERN void PETSC_STDCALL epsgetdimensions101_(EPS *eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)epsgetdimensions101_410,20157
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenpair_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)epsgeteigenpair_415,20320
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenpair00_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)epsgeteigenpair00_422,20572
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenpair10_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)epsgeteigenpair10_427,20760
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenpair01_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)epsgeteigenpair01_432,20948
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenpair11_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)epsgeteigenpair11_437,21136
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenvalue_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,int *ierr)epsgeteigenvalue_442,21324
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenvalue00_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,int *ierr)epsgeteigenvalue00_449,21554
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenvalue10_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,int *ierr)epsgeteigenvalue10_454,21722
SLEPC_EXTERN void PETSC_STDCALL epsgeteigenvalue01_(EPS *eps,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,int *ierr)epsgeteigenvalue01_459,21890
SLEPC_EXTERN void PETSC_STDCALL epsgettolerances_(EPS *eps,PetscReal *tol,PetscInt *maxits,int *ierr)epsgettolerances_464,22058
SLEPC_EXTERN void PETSC_STDCALL epsgettolerances00_(EPS *eps,PetscReal *tol,PetscInt *maxits,int *ierr)epsgettolerances00_471,22270
SLEPC_EXTERN void PETSC_STDCALL epsgettolerances10_(EPS *eps,PetscReal *tol,PetscInt *maxits,int *ierr)epsgettolerances10_476,22421
SLEPC_EXTERN void PETSC_STDCALL epsgettolerances01_(EPS *eps,PetscReal *tol,PetscInt *maxits,int *ierr)epsgettolerances01_481,22572
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance_486,22723
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance000_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance000_494,22979
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance100_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance100_499,23145
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance010_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance010_504,23311
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance001_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance001_509,23477
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance110_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance110_514,23643
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance011_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance011_519,23809
SLEPC_EXTERN void PETSC_STDCALL epsgetbalance101_(EPS *eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff,int *ierr)epsgetbalance101_524,23975
SLEPC_EXTERN void PETSC_STDCALL epssetdeflationspace0_(EPS *eps,PetscInt *n,Vec *ds,int *ierr)epssetdeflationspace0_529,24141
SLEPC_EXTERN void PETSC_STDCALL epssetdeflationspace1_(EPS *eps,PetscInt *n,Vec *ds,int *ierr)epssetdeflationspace1_535,24313
SLEPC_EXTERN void PETSC_STDCALL epssetinitialspace0_(EPS *eps,PetscInt *n,Vec *is,int *ierr)epssetinitialspace0_541,24485
SLEPC_EXTERN void PETSC_STDCALL epssetinitialspace1_(EPS *eps,PetscInt *n,Vec *is,int *ierr)epssetinitialspace1_547,24653

src/eps/interface/makefile,361
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = epsmon.c epsbasic.c epsview.c epsdefault.c epsregis.c epsopts.c epssetup.c epssolve.c dlregiseps.cSOURCEC15,431
SOURCEF  =SOURCEF16,541
SOURCEH  =SOURCEH17,552
LIBBASE  = libslepcepsLIBBASE18,563
DIRS     =DIRS19,586
MANSEC   = EPSMANSEC20,597
LOCDIR   = src/eps/interface/LOCDIR21,612

src/eps/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/epsimpl.h ../../include/slepceps.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/eps/LOCDIR15,527
MANSEC   = EPSMANSEC16,547

src/lme/examples/makefile,82
makefile:^?makefile^A,1
LOCDIR   = src/lme/examples/LOCDIR13,405
DIRS     = tests tutorialsDIRS14,434

src/lme/examples/tests/makefile,295
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/lme/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.cEXAMPLESC16,488
EXAMPLESF  = EXAMPLESF17,509
MANSEC     = LMEMANSEC18,523
TESTS      = test1TESTS19,540

src/lme/examples/tests/test1.c,129
test1.c:^?test1.c^A,1
static char help[] = "Test MFN interface functions, based on ex32.c.\n\n"help11,400
int main(int argc,char **argv)main18,681

src/lme/examples/tutorials/ex32.c,132
ex32.c:^?ex32.c^A,1
static char help[] = "Solves a Lypunov equation with the 2-D Laplacian.\n\n"help11,400
int main(int argc,char **argv)main18,684

src/lme/examples/tutorials/makefile,265
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/lme/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex32.cEXAMPLESC16,492
EXAMPLESF  =EXAMPLESF17,512
MANSEC     = LMEMANSEC18,525

src/lme/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,476
FFLAGS     =FFLAGS15,489
SOURCEC    =SOURCEC16,502
SOURCEF    = slepclmemod.FSOURCEF17,515
SOURCEH    = slepclme.h slepclme.h90SOURCEH18,542
LIBBASE    = libslepclmeLIBBASE19,579
MANSEC     = LMEMANSEC20,604
LOCDIR     = src/lme/f90-mod/LOCDIR21,621
CLEANFILES = *.modCLEANFILES22,651

src/lme/f90-mod/slepclme.h,146
slepclme.h:^?slepclme.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      LME, parameter :: SLEPC_NULL_LME = tLME(0)LME19,630

src/lme/f90-mod/slepclmemod.F,86
slepclmemod.F:^?slepclmemod.F^A,1
        module slepclmedefslepclmedef10,398
        module slepclmeslepclme17,557

src/lme/impls/krylov/lmekrylov.c,568
lmekrylov.c:^?lmekrylov.c^A,1
PetscErrorCode LMESetUp_Krylov(LME lme)LMESetUp_Krylov36,1228
PetscErrorCode LMEBasicArnoldi(LME lme,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscReal *beta,PetscBool *breakdown)LMEBasicArnoldi49,1550
PetscErrorCode LMESolve_Krylov_Lyapunov_Vec(LME lme,Vec b,PetscBool fixed,PetscInt rrank,BV C1,BV *X1,PetscInt *col,PetscBool *fail,PetscInt *totalits)LMESolve_Krylov_Lyapunov_Vec82,2741
PetscErrorCode LMESolve_Krylov_Lyapunov(LME lme)LMESolve_Krylov_Lyapunov193,6836
SLEPC_EXTERN PetscErrorCode LMECreate_Krylov(LME lme)LMECreate_Krylov236,8318

src/lme/impls/krylov/makefile,277
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = lmekrylov.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepclmeLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = LMEMANSEC20,510
LOCDIR   = src/lme/impls/krylov/LOCDIR21,525

src/lme/impls/makefile,137
makefile:^?makefile^A,1
LIBBASE  = libslepclmeLIBBASE13,409
DIRS     = krylovDIRS14,432
LOCDIR   = src/lme/impls/LOCDIR15,450
MANSEC   = LMEMANSEC16,476

src/lme/interface/dlregislme.c,775
dlregislme.c:^?dlregislme.c^A,1
static PetscBool LMEPackageInitialized = PETSC_FALSE;LMEPackageInitialized13,436
const char *LMEProblemTypes[] = {"LYAPUNOV","SYLVESTER","GEN_LYAPUNOV","GEN_SYLVESTER","DT_LYAPUNOV","STEIN","LMEProblemType","LME_",0};LMEProblemTypes15,491
const char *const LMEConvergedReasons_Shifted[] = {"DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","LMEConvergedReason","LME_",0};LMEConvergedReasons_Shifted16,628
const char *const*LMEConvergedReasons = LMEConvergedReasons_Shifted + 2;LMEConvergedReasons17,785
PetscErrorCode LMEFinalizePackage(void)LMEFinalizePackage27,1052
PetscErrorCode LMEInitializePackage(void)LMEInitializePackage47,1589
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepclme()PetscDLLibraryRegister_slepclme89,3248

src/lme/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zlmef.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepclmeLIBBASE19,521
LOCDIR   = src/lme/interface/ftn-custom/LOCDIR20,544

src/lme/interface/ftn-custom/zlmef.c,3701
zlmef.c:^?zlmef.c^A,1
SLEPC_EXTERN void lmemonitordefault_(LME *lme,PetscInt *it,PetscReal *errest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)lmemonitordefault_48,2221
SLEPC_EXTERN void lmemonitorlg_(LME *lme,PetscInt *it,PetscReal *errest,void *ctx,PetscErrorCode *ierr)lmemonitorlg_53,2404
  PetscFortranCallbackId monitor;monitor59,2575
  PetscFortranCallbackId monitordestroy;monitordestroy60,2609
} _cb;_cb61,2650
static PetscErrorCode ourmonitor(LME lme,PetscInt i,PetscReal d,void* ctx)ourmonitor64,2750
static PetscErrorCode ourdestroy(void** ctx)ourdestroy69,2954
SLEPC_EXTERN void PETSC_STDCALL lmeview_(LME *lme,PetscViewer *viewer,PetscErrorCode *ierr)lmeview_75,3121
SLEPC_EXTERN void PETSC_STDCALL lmereasonview_(LME *lme,PetscViewer *viewer,PetscErrorCode *ierr)lmereasonview_82,3308
SLEPC_EXTERN void PETSC_STDCALL lmesettype_(LME *lme,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))lmesettype_89,3507
SLEPC_EXTERN void PETSC_STDCALL lmegettype_(LME *lme,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))lmegettype_98,3741
SLEPC_EXTERN void PETSC_STDCALL lmesetoptionsprefix_(LME *lme,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))lmesetoptionsprefix_107,4039
SLEPC_EXTERN void PETSC_STDCALL lmeappendoptionsprefix_(LME *lme,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))lmeappendoptionsprefix_116,4297
SLEPC_EXTERN void PETSC_STDCALL lmegetoptionsprefix_(LME *lme,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))lmegetoptionsprefix_125,4561
SLEPC_EXTERN void PETSC_STDCALL lmemonitorset_(LME *lme,void (PETSC_STDCALL *monitor)(LME*,PetscInt*,PetscReal*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)lmemonitorset_134,4888
SLEPC_EXTERN void PETSC_STDCALL lmegettolerances_(LME *lme,PetscReal *tol,PetscInt *maxits,int *ierr)lmegettolerances_149,5986
SLEPC_EXTERN void PETSC_STDCALL lmegettolerances00_(LME *lme,PetscReal *tol,PetscInt *maxits,int *ierr)lmegettolerances00_156,6198
SLEPC_EXTERN void PETSC_STDCALL lmegettolerances10_(LME *lme,PetscReal *tol,PetscInt *maxits,int *ierr)lmegettolerances10_161,6349
SLEPC_EXTERN void PETSC_STDCALL lmegettolerances01_(LME *lme,PetscReal *tol,PetscInt *maxits,int *ierr)lmegettolerances01_166,6500

src/lme/interface/lmebasic.c,1206
lmebasic.c:^?lmebasic.c^A,1
PetscFunctionList LMEList = 0;LMEList16,490
PetscBool         LMERegisterAllCalled = PETSC_FALSE;LMERegisterAllCalled17,521
PetscClassId      LME_CLASSID = 0;LME_CLASSID18,575
PetscLogEvent     LME_SetUp = 0,LME_Solve = 0,LME_ComputeError = 0;LME_SetUp19,610
PetscLogEvent     LME_SetUp = 0,LME_Solve = 0,LME_ComputeError = 0;LME_Solve19,610
PetscLogEvent     LME_SetUp = 0,LME_Solve = 0,LME_ComputeError = 0;LME_ComputeError19,610
PetscErrorCode LMEView(LME lme,PetscViewer viewer)LMEView48,1448
PetscErrorCode LMEReasonView(LME lme,PetscViewer viewer)LMEReasonView109,3719
PetscErrorCode LMEReasonViewFromOptions(LME lme)LMEReasonViewFromOptions139,4925
PetscErrorCode LMECreate(MPI_Comm comm,LME *outlme)LMECreate179,5986
PetscErrorCode LMESetType(LME lme,LMEType type)LMESetType247,7929
PetscErrorCode LMEGetType(LME lme,LMEType *type)LMEGetType286,9002
PetscErrorCode LMERegister(const char *name,PetscErrorCode (*function)(LME))LMERegister321,9818
PetscErrorCode LMEReset(LME lme)LMEReset344,10369
PetscErrorCode LMEDestroy(LME *lme)LMEDestroy377,11280
PetscErrorCode LMESetBV(LME lme,BV bv)LMESetBV409,12183
PetscErrorCode LMEGetBV(LME lme,BV *bv)LMEGetBV440,12928

src/lme/interface/lmedense.c,882
lmedense.c:^?lmedense.c^A,1
PetscErrorCode LMERankSVD(LME lme,PetscInt n,PetscScalar *L,PetscScalar *U,PetscInt *rank)LMERankSVD21,734
static PetscErrorCode LyapunovResidual(PetscScalar *H,PetscInt m,PetscInt ldh,PetscScalar *r,PetscScalar *L,PetscInt ldl,PetscReal *res)LyapunovResidual60,1938
static PetscErrorCode LyapunovChol_SLICOT(PetscScalar *H,PetscInt m,PetscInt ldh,PetscScalar *r,PetscScalar *L,PetscInt ldl,PetscReal *res)LyapunovChol_SLICOT94,3009
static PetscErrorCode CholeskyFactor(PetscScalar *A,PetscInt m,PetscInt lda)CholeskyFactor226,7682
static PetscErrorCode LyapunovChol_LAPACK(PetscScalar *H,PetscInt m,PetscInt ldh,PetscScalar *r,PetscScalar *L,PetscInt ldl,PetscReal *res)LyapunovChol_LAPACK273,9128
PetscErrorCode LMEDenseLyapunovChol(LME lme,PetscScalar *H,PetscInt m,PetscInt ldh,PetscScalar *r,PetscScalar *L,PetscInt ldl,PetscReal *res)LMEDenseLyapunovChol376,12660

src/lme/interface/lmemon.c,782
lmemon.c:^?lmemon.c^A,1
PetscErrorCode LMEMonitor(LME lme,PetscInt it,PetscReal errest)LMEMonitor20,582
PetscErrorCode LMEMonitorSet(LME lme,PetscErrorCode (*monitor)(LME,PetscInt,PetscReal,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))LMEMonitorSet69,2247
PetscErrorCode LMEMonitorCancel(LME lme)LMEMonitorCancel97,3272
PetscErrorCode LMEGetMonitorContext(LME lme,void **ctx)LMEGetMonitorContext129,3978
PetscErrorCode LMEMonitorDefault(LME lme,PetscInt its,PetscReal errest,PetscViewerAndFormat *vf)LMEMonitorDefault153,4558
PetscErrorCode LMEMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)LMEMonitorLGCreate201,6144
PetscErrorCode LMEMonitorLG(LME lme,PetscInt its,PetscReal errest,void *ctx)LMEMonitorLG217,6690

src/lme/interface/lmeopts.c,1307
lmeopts.c:^?lmeopts.c^A,1
PetscErrorCode LMEMonitorSetFromOptions(LME lme,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(LME,PetscInt,PetscReal,PetscViewerAndFormat*))LMEMonitorSetFromOptions35,1047
PetscErrorCode LMESetFromOptions(LME lme)LMESetFromOptions68,2277
PetscErrorCode LMESetProblemType(LME lme,LMEProblemType type)LMESetProblemType192,8449
PetscErrorCode LMEGetProblemType(LME lme,LMEProblemType *type)LMEGetProblemType229,9376
PetscErrorCode LMEGetTolerances(LME lme,PetscReal *tol,PetscInt *maxits)LMEGetTolerances258,10035
PetscErrorCode LMESetTolerances(LME lme,PetscReal tol,PetscInt maxits)LMESetTolerances289,10873
PetscErrorCode LMEGetDimensions(LME lme,PetscInt *ncv)LMEGetDimensions327,11984
PetscErrorCode LMESetDimensions(LME lme,PetscInt ncv)LMESetDimensions356,12714
PetscErrorCode LMESetErrorIfNotConverged(LME lme,PetscBool flg)LMESetErrorIfNotConverged392,13787
PetscErrorCode LMEGetErrorIfNotConverged(LME lme,PetscBool *flag)LMEGetErrorIfNotConverged417,14418
PetscErrorCode LMESetOptionsPrefix(LME lme,const char *prefix)LMESetOptionsPrefix452,15372
PetscErrorCode LMEAppendOptionsPrefix(LME lme,const char *prefix)LMEAppendOptionsPrefix482,16281
PetscErrorCode LMEGetOptionsPrefix(LME lme,const char *prefix[])LMEGetOptionsPrefix514,17156

src/lme/interface/lmeregis.c,58
lmeregis.c:^?lmeregis.c^A,1
PetscErrorCode LMERegisterAll(void)LMERegisterAll24,656

src/lme/interface/lmesetup.c,803
lmesetup.c:^?lmesetup.c^A,1
PETSC_STATIC_INLINE PetscErrorCode LMESetUp_Lyapunov(LME lme)LMESetUp_Lyapunov16,510
PetscErrorCode LMESetUp(LME lme)LMESetUp52,1931
PETSC_STATIC_INLINE PetscErrorCode LMESetCoefficients_Private(LME lme,Mat A,Mat *lmeA)LMESetCoefficients_Private111,3859
PetscErrorCode LMESetCoefficients(LME lme,Mat A,Mat B,Mat D,Mat E)LMESetCoefficients153,5199
PetscErrorCode LMEGetCoefficients(LME lme,Mat *A,Mat *B,Mat *D,Mat *E)LMEGetCoefficients206,6758
PetscErrorCode LMESetRHS(LME lme,Mat C)LMESetRHS241,7762
PetscErrorCode LMEGetRHS(LME lme,Mat *C)LMEGetRHS278,8795
PetscErrorCode LMESetSolution(LME lme,Mat X)LMESetSolution315,10013
PetscErrorCode LMEGetSolution(LME lme,Mat *X)LMEGetSolution352,11081
PetscErrorCode LMEAllocateSolution(LME lme,PetscInt extra)LMEAllocateSolution378,11726

src/lme/interface/lmesolve.c,531
lmesolve.c:^?lmesolve.c^A,1
PetscErrorCode LMESolve(LME lme)LMESolve41,1457
PetscErrorCode LMEGetIterationNumber(LME lme,PetscInt *its)LMEGetIterationNumber98,3617
PetscErrorCode LMEGetConvergedReason(LME lme,LMEConvergedReason *reason)LMEGetConvergedReason132,4519
PetscErrorCode LMEGetErrorEstimate(LME lme,PetscReal *errest)LMEGetErrorEstimate161,5229
PetscErrorCode LMEComputeResidualNorm_Lyapunov(LME lme,PetscReal *norm)LMEComputeResidualNorm_Lyapunov174,5587
PetscErrorCode LMEComputeError(LME lme,PetscReal *error)LMEComputeError304,10619

src/lme/interface/makefile,349
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = lmemon.c lmebasic.c lmeregis.c lmeopts.c lmedense.c lmesetup.c lmesolve.c dlregislme.cSOURCEC15,431
SOURCEF  =SOURCEF16,529
SOURCEH  =SOURCEH17,540
LIBBASE  = libslepclmeLIBBASE18,551
DIRS     =DIRS19,574
MANSEC   = LMEMANSEC20,585
LOCDIR   = src/lme/interface/LOCDIR21,600

src/lme/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/lmeimpl.h ../../include/slepclme.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/lme/LOCDIR15,527
MANSEC   = LMEMANSEC16,547

src/makefile,81
makefile:^?makefile^A,1
DIRS     = sys eps svd pep nep mfn lmeDIRS11,399
LOCDIR   = src/LOCDIR13,439

src/mfn/examples/makefile,82
makefile:^?makefile^A,1
LOCDIR   = src/mfn/examples/LOCDIR13,405
DIRS     = tests tutorialsDIRS14,434

src/mfn/examples/tests/makefile,352
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/mfn/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.cEXAMPLESC16,488
EXAMPLESF  = test3f.FEXAMPLESF17,533
MANSEC     = MFNMANSEC18,555
TESTS      = test1 test2 test3 test3f test4TESTS19,572

src/mfn/examples/tests/test1.c,133
test1.c:^?test1.c^A,1
static char help[] = "Computes exp(t*A)*v for a matrix loaded from file.\n\n"help11,400
int main(int argc,char **argv)main18,697

src/mfn/examples/tests/test2.c,149
test2.c:^?test2.c^A,1
static char help[] = "Tests the case when both arguments of MFNSolve() are the same Vec.\n\n"help11,400
int main(int argc,char **argv)main19,778

src/mfn/examples/tests/test3.c,112
test3.c:^?test3.c^A,1
static char help[] = "Test MFN interface functions.\n\n"help11,400
int main(int argc,char **argv)main17,592

src/mfn/examples/tests/test3f.F,334
test3f.F:^?test3f.F^A,1
      program mainmain19,691
 100  format (/'nSquare root of Laplacian, n=',I3,' (Fortran)')10056,1863
 110  format (/' Tolerance: ',F7.4,', maxit: ',I4)110129,4267
 120  format (' Subspace dimension: ',I3)120134,4425
 130  format (' Converged reason:',I2)130149,4947
 150  format (' sqrt(A)*v has norm ',F7.4)150160,5261

src/mfn/examples/tests/test4.c,113
test4.c:^?test4.c^A,1
static char help[] = "Illustrates use of MFNSetBV().\n\n"help11,400
int main(int argc,char **argv)main18,677

src/mfn/examples/tutorials/ex23.c,219
ex23.c:^?ex23.c^A,1
static char help[] = "Computes exp(t*A)*v for a matrix associated with a Markov model.\n\n"help11,400
int main(int argc,char **argv)main24,856
PetscErrorCode MatMarkovModel(PetscInt m,Mat A)MatMarkovModel121,4636

src/mfn/examples/tutorials/ex23f90.F90,385
ex23f90.F90:^?ex23f90.F90^A,1
      program mainmain21,857
 100  format (/'Markov y=exp(t*A)*e_1, N=',I6,' (m=',I4,')')10065,2279
 120  format (' Number of iterations of the method: ',I4)120162,5843
 130  format (' Subspace dimension:',I4)130167,6022
 140  format (' Stopping condition: tol=',f10.7,' maxit=',I4)140172,6196
 150  format (' Computed vector at time t=',f4.1,' has norm ',f8.5)150181,6527

src/mfn/examples/tutorials/ex26.c,143
ex26.c:^?ex26.c^A,1
static char help[] = "Computes the action of the square root of the 2-D Laplacian.\n\n"help11,400
int main(int argc,char **argv)main19,772

src/mfn/examples/tutorials/ex37.c,158
ex37.c:^?ex37.c^A,1
static char help[] = "Computes exp(t*A)*v for an advection diffusion operator with Peclet number.\n\n"help11,400
int main(int argc,char **argv)main20,852

src/mfn/examples/tutorials/ex39.c,200
ex39.c:^?ex39.c^A,1
static char help[] = "Exponential integrator for the heat equation with source term.\n\n"help26,994
PetscErrorCode BuildFNPhi(FN fphi)BuildFNPhi48,1953
int main(int argc,char **argv)main83,3128

src/mfn/examples/tutorials/makefile,298
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/mfn/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex23.c ex26.c ex37.c ex39.cEXAMPLESC16,492
EXAMPLESF  = ex23f90.F90EXAMPLESF17,533
MANSEC     = MFNMANSEC18,558

src/mfn/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcmfnmod.FSOURCEF17,514
SOURCEH    = slepcmfn.h slepcmfn.h90SOURCEH18,541
LIBBASE    = libslepcmfnLIBBASE19,578
MANSEC     = MFNMANSEC20,603
LOCDIR     = src/mfn/f90-mod/LOCDIR21,620
CLEANFILES = *.modCLEANFILES22,650

src/mfn/f90-mod/slepcmfn.h,146
slepcmfn.h:^?slepcmfn.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      MFN, parameter :: SLEPC_NULL_MFN = tMFN(0)MFN19,630

src/mfn/f90-mod/slepcmfnmod.F,86
slepcmfnmod.F:^?slepcmfnmod.F^A,1
        module slepcmfndefslepcmfndef10,398
        module slepcmfnslepcmfn18,580

src/mfn/impls/expokit/makefile,279
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = mfnexpokit.cSOURCEC15,431
SOURCEF  =SOURCEF16,455
SOURCEH  =SOURCEH17,466
LIBBASE  = libslepcmfnLIBBASE18,477
DIRS     =DIRS19,500
MANSEC   = MFNMANSEC20,511
LOCDIR   = src/mfn/impls/expokit/LOCDIR21,526

src/mfn/impls/expokit/mfnexpokit.c,225
mfnexpokit.c:^?mfnexpokit.c^A,1
PetscErrorCode MFNSetUp_Expokit(MFN mfn)MFNSetUp_Expokit28,816
PetscErrorCode MFNSolve_Expokit(MFN mfn,Vec b,Vec x)MFNSolve_Expokit45,1353
SLEPC_EXTERN PetscErrorCode MFNCreate_Expokit(MFN mfn)MFNCreate_Expokit183,6006

src/mfn/impls/krylov/makefile,277
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = mfnkrylov.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcmfnLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = MFNMANSEC20,510
LOCDIR   = src/mfn/impls/krylov/LOCDIR21,525

src/mfn/impls/krylov/mfnkrylov.c,371
mfnkrylov.c:^?mfnkrylov.c^A,1
PetscErrorCode MFNSetUp_Krylov(MFN mfn)MFNSetUp_Krylov30,911
PetscErrorCode MFNBasicArnoldi(MFN mfn,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscReal *beta,PetscBool *breakdown)MFNBasicArnoldi43,1233
PetscErrorCode MFNSolve_Krylov(MFN mfn,Vec b,Vec x)MFNSolve_Krylov76,2424
SLEPC_EXTERN PetscErrorCode MFNCreate_Krylov(MFN mfn)MFNCreate_Krylov169,5578

src/mfn/impls/makefile,145
makefile:^?makefile^A,1
LIBBASE  = libslepcmfnLIBBASE13,409
DIRS     = krylov expokitDIRS14,432
LOCDIR   = src/mfn/impls/LOCDIR15,458
MANSEC   = MFNMANSEC16,484

src/mfn/interface/dlregismfn.c,630
dlregismfn.c:^?dlregismfn.c^A,1
static PetscBool MFNPackageInitialized = PETSC_FALSE;MFNPackageInitialized13,436
const char *const MFNConvergedReasons_Shifted[] = {"DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","CONVERGED_ITS","MFNConvergedReason","MFN_",0};MFNConvergedReasons_Shifted15,491
const char *const*MFNConvergedReasons = MFNConvergedReasons_Shifted + 2;MFNConvergedReasons16,664
PetscErrorCode MFNFinalizePackage(void)MFNFinalizePackage26,931
PetscErrorCode MFNInitializePackage(void)MFNInitializePackage46,1468
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepcmfn()PetscDLLibraryRegister_slepcmfn87,3027

src/mfn/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zmfnf.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepcmfnLIBBASE19,521
LOCDIR   = src/mfn/interface/ftn-custom/LOCDIR20,544

src/mfn/interface/ftn-custom/zmfnf.c,3701
zmfnf.c:^?zmfnf.c^A,1
SLEPC_EXTERN void mfnmonitordefault_(MFN *mfn,PetscInt *it,PetscReal *errest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)mfnmonitordefault_48,2221
SLEPC_EXTERN void mfnmonitorlg_(MFN *mfn,PetscInt *it,PetscReal *errest,void *ctx,PetscErrorCode *ierr)mfnmonitorlg_53,2404
  PetscFortranCallbackId monitor;monitor59,2575
  PetscFortranCallbackId monitordestroy;monitordestroy60,2609
} _cb;_cb61,2650
static PetscErrorCode ourmonitor(MFN mfn,PetscInt i,PetscReal d,void* ctx)ourmonitor64,2750
static PetscErrorCode ourdestroy(void** ctx)ourdestroy69,2954
SLEPC_EXTERN void PETSC_STDCALL mfnview_(MFN *mfn,PetscViewer *viewer,PetscErrorCode *ierr)mfnview_75,3121
SLEPC_EXTERN void PETSC_STDCALL mfnreasonview_(MFN *mfn,PetscViewer *viewer,PetscErrorCode *ierr)mfnreasonview_82,3308
SLEPC_EXTERN void PETSC_STDCALL mfnsettype_(MFN *mfn,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))mfnsettype_89,3507
SLEPC_EXTERN void PETSC_STDCALL mfngettype_(MFN *mfn,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))mfngettype_98,3741
SLEPC_EXTERN void PETSC_STDCALL mfnsetoptionsprefix_(MFN *mfn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))mfnsetoptionsprefix_107,4039
SLEPC_EXTERN void PETSC_STDCALL mfnappendoptionsprefix_(MFN *mfn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))mfnappendoptionsprefix_116,4297
SLEPC_EXTERN void PETSC_STDCALL mfngetoptionsprefix_(MFN *mfn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))mfngetoptionsprefix_125,4561
SLEPC_EXTERN void PETSC_STDCALL mfnmonitorset_(MFN *mfn,void (PETSC_STDCALL *monitor)(MFN*,PetscInt*,PetscReal*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)mfnmonitorset_134,4888
SLEPC_EXTERN void PETSC_STDCALL mfngettolerances_(MFN *mfn,PetscReal *tol,PetscInt *maxits,int *ierr)mfngettolerances_149,5986
SLEPC_EXTERN void PETSC_STDCALL mfngettolerances00_(MFN *mfn,PetscReal *tol,PetscInt *maxits,int *ierr)mfngettolerances00_156,6198
SLEPC_EXTERN void PETSC_STDCALL mfngettolerances10_(MFN *mfn,PetscReal *tol,PetscInt *maxits,int *ierr)mfngettolerances10_161,6349
SLEPC_EXTERN void PETSC_STDCALL mfngettolerances01_(MFN *mfn,PetscReal *tol,PetscInt *maxits,int *ierr)mfngettolerances01_166,6500

src/mfn/interface/makefile,338
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = mfnmon.c mfnbasic.c mfnregis.c mfnopts.c mfnsetup.c mfnsolve.c dlregismfn.cSOURCEC15,431
SOURCEF  =SOURCEF16,518
SOURCEH  =SOURCEH17,529
LIBBASE  = libslepcmfnLIBBASE18,540
DIRS     =DIRS19,563
MANSEC   = MFNMANSEC20,574
LOCDIR   = src/mfn/interface/LOCDIR21,589

src/mfn/interface/mfnbasic.c,1188
mfnbasic.c:^?mfnbasic.c^A,1
PetscFunctionList MFNList = 0;MFNList16,490
PetscBool         MFNRegisterAllCalled = PETSC_FALSE;MFNRegisterAllCalled17,521
PetscClassId      MFN_CLASSID = 0;MFN_CLASSID18,575
PetscLogEvent     MFN_SetUp = 0,MFN_Solve = 0;MFN_SetUp19,610
PetscLogEvent     MFN_SetUp = 0,MFN_Solve = 0;MFN_Solve19,610
PetscErrorCode MFNView(MFN mfn,PetscViewer viewer)MFNView48,1420
PetscErrorCode MFNReasonView(MFN mfn,PetscViewer viewer)MFNReasonView102,3398
PetscErrorCode MFNReasonViewFromOptions(MFN mfn)MFNReasonViewFromOptions132,4583
PetscErrorCode MFNCreate(MPI_Comm comm,MFN *outmfn)MFNCreate172,5644
PetscErrorCode MFNSetType(MFN mfn,MFNType type)MFNSetType236,7438
PetscErrorCode MFNGetType(MFN mfn,MFNType *type)MFNGetType275,8504
PetscErrorCode MFNRegister(const char *name,PetscErrorCode (*function)(MFN))MFNRegister310,9313
PetscErrorCode MFNReset(MFN mfn)MFNReset333,9857
PetscErrorCode MFNDestroy(MFN *mfn)MFNDestroy361,10541
PetscErrorCode MFNSetBV(MFN mfn,BV bv)MFNSetBV394,11477
PetscErrorCode MFNGetBV(MFN mfn,BV *bv)MFNGetBV425,12215
PetscErrorCode MFNSetFN(MFN mfn,FN fn)MFNSetFN459,13165
PetscErrorCode MFNGetFN(MFN mfn,FN *fn)MFNGetFN489,13891

src/mfn/interface/mfnmon.c,782
mfnmon.c:^?mfnmon.c^A,1
PetscErrorCode MFNMonitor(MFN mfn,PetscInt it,PetscReal errest)MFNMonitor20,582
PetscErrorCode MFNMonitorSet(MFN mfn,PetscErrorCode (*monitor)(MFN,PetscInt,PetscReal,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))MFNMonitorSet69,2219
PetscErrorCode MFNMonitorCancel(MFN mfn)MFNMonitorCancel97,3230
PetscErrorCode MFNGetMonitorContext(MFN mfn,void **ctx)MFNGetMonitorContext129,3922
PetscErrorCode MFNMonitorDefault(MFN mfn,PetscInt its,PetscReal errest,PetscViewerAndFormat *vf)MFNMonitorDefault153,4481
PetscErrorCode MFNMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)MFNMonitorLGCreate201,6067
PetscErrorCode MFNMonitorLG(MFN mfn,PetscInt its,PetscReal errest,void *ctx)MFNMonitorLG217,6613

src/mfn/interface/mfnopts.c,1123
mfnopts.c:^?mfnopts.c^A,1
PetscErrorCode MFNMonitorSetFromOptions(MFN mfn,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(MFN,PetscInt,PetscReal,PetscViewerAndFormat*))MFNMonitorSetFromOptions35,1047
PetscErrorCode MFNSetFromOptions(MFN mfn)MFNSetFromOptions68,2263
PetscErrorCode MFNGetTolerances(MFN mfn,PetscReal *tol,PetscInt *maxits)MFNGetTolerances157,5975
PetscErrorCode MFNSetTolerances(MFN mfn,PetscReal tol,PetscInt maxits)MFNSetTolerances188,6799
PetscErrorCode MFNGetDimensions(MFN mfn,PetscInt *ncv)MFNGetDimensions226,7896
PetscErrorCode MFNSetDimensions(MFN mfn,PetscInt ncv)MFNSetDimensions255,8612
PetscErrorCode MFNSetErrorIfNotConverged(MFN mfn,PetscBool flg)MFNSetErrorIfNotConverged291,9671
PetscErrorCode MFNGetErrorIfNotConverged(MFN mfn,PetscBool *flag)MFNGetErrorIfNotConverged316,10288
PetscErrorCode MFNSetOptionsPrefix(MFN mfn,const char *prefix)MFNSetOptionsPrefix351,11228
PetscErrorCode MFNAppendOptionsPrefix(MFN mfn,const char *prefix)MFNAppendOptionsPrefix383,12247
PetscErrorCode MFNGetOptionsPrefix(MFN mfn,const char *prefix[])MFNGetOptionsPrefix417,13235

src/mfn/interface/mfnregis.c,58
mfnregis.c:^?mfnregis.c^A,1
PetscErrorCode MFNRegisterAll(void)MFNRegisterAll25,708

src/mfn/interface/mfnsetup.c,275
mfnsetup.c:^?mfnsetup.c^A,1
PetscErrorCode MFNSetUp(MFN mfn)MFNSetUp34,980
PetscErrorCode MFNSetOperator(MFN mfn,Mat A)MFNSetOperator90,2603
PetscErrorCode MFNGetOperator(MFN mfn,Mat *A)MFNGetOperator125,3534
PetscErrorCode MFNAllocateSolution(MFN mfn,PetscInt extra)MFNAllocateSolution151,4165

src/mfn/interface/mfnsolve.c,257
mfnsolve.c:^?mfnsolve.c^A,1
PetscErrorCode MFNSolve(MFN mfn,Vec b,Vec x)MFNSolve46,1546
PetscErrorCode MFNGetIterationNumber(MFN mfn,PetscInt *its)MFNGetIterationNumber112,4019
PetscErrorCode MFNGetConvergedReason(MFN mfn,MFNConvergedReason *reason)MFNGetConvergedReason153,5313

src/mfn/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/mfnimpl.h ../../include/slepcmfn.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/mfn/LOCDIR15,527
MANSEC   = MFNMANSEC16,547

src/nep/examples/makefile,88
makefile:^?makefile^A,1
LOCDIR   = src/nep/examples/LOCDIR13,405
DIRS     = tests tutorials nlevpDIRS14,434

src/nep/examples/nlevp/gun.c,168
gun.c:^?gun.c^A,1
static char help[] = "Radio-frequency gun cavity.\n\n"help25,1009
#define NMAT NMAT31,1306
#define SIGMA SIGMA32,1321
int main(int argc,char **argv)main34,1345

src/nep/examples/nlevp/loaded_string.c,161
loaded_string.c:^?loaded_string.c^A,1
static char help[] = "Finite element model of a loaded vibrating string.\n\n"help22,881
#define NMAT NMAT30,1164
int main(int argc,char **argv)main32,1180

src/nep/examples/nlevp/makefile,320
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/nep/examples/nlevp/LOCDIR15,451
EXAMPLESC  = loaded_string.c gun.cEXAMPLESC16,488
EXAMPLESF  =EXAMPLESF17,523
MANSEC     = NEPMANSEC18,536
TESTS      = loaded_string gunTESTS19,553

src/nep/examples/tests/makefile,440
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/nep/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c \EXAMPLESC16,488
EXAMPLESF  = test2f.FEXAMPLESF18,642
MANSEC     = NEPMANSEC19,664
TESTS      = test1 test2 test2f test3 test4 test5 test6 test7 test8 test9 test10 test11 \TESTS20,681

src/nep/examples/tests/test1.c,503
test1.c:^?test1.c^A,1
static char help[] = "Simple 1-D nonlinear eigenproblem.\n\n"help11,400
  PetscScalar kappa;   /* ratio between stiffness of spring and attached mass */kappa35,965
  PetscReal   h;       /* mesh spacing */h36,1046
} ApplicationCtx;ApplicationCtx37,1088
int main(int argc,char **argv)main39,1107
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction123,4443
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian195,6512

src/nep/examples/tests/test10.c,136
test10.c:^?test10.c^A,1
static char help[] = "Tests multiple calls to NEPSolve(). Based on ex22.c.\n\n"help11,400
int main(int argc,char **argv)main35,1052

src/nep/examples/tests/test11.c,130
test11.c:^?test11.c^A,1
static char help[] = "Test the CISS solver with the problem of ex22.\n\n"help11,400
int main(int argc,char **argv)main35,1046

src/nep/examples/tests/test12.c,236
test12.c:^?test12.c^A,1
static char help[] = "Test some NLEIGS interface functions.\n\n"help11,400
int main(int argc,char **argv)main29,888
PetscErrorCode ComputeSingularities(NEP nep,PetscInt *maxnp,PetscScalar *xi,void *pt)ComputeSingularities151,6446

src/nep/examples/tests/test13.c,123
test13.c:^?test13.c^A,1
static char help[] = "Test the NEPProjectOperator() operator.\n\n"help11,400
int main(int argc,char **argv)main36,1066

src/nep/examples/tests/test14.c,266
test14.c:^?test14.c^A,1
static char help[] = "Tests a user-defined convergence test in NEP.\n\n"help11,400
PetscErrorCode MyConvergedRel(NEP nep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)MyConvergedRel25,783
int main(int argc,char **argv)main34,1011

src/nep/examples/tests/test15.c,525
test15.c:^?test15.c^A,1
static char help[] = "Illustrates the use of a user-defined stopping test.\n\n"help11,400
  PetscInt    lastnconv;      /* last value of nconv; used in stopping test */lastnconv42,1228
  PetscInt    nreps;          /* number of repetitions of nconv; used in stopping test */nreps43,1307
} CTX_DELAY;CTX_DELAY44,1397
int main(int argc,char **argv)main46,1411
PetscErrorCode MyStoppingTest(NEP nep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,NEPConvergedReason *reason,void *ptr)MyStoppingTest205,7842

src/nep/examples/tests/test2.c,113
test2.c:^?test2.c^A,1
static char help[] = "Test NEP interface functions.\n\n";help11,400
int main(int argc,char **argv)main15,482

src/nep/examples/tests/test2f.F,773
test2f.F:^?test2f.F^A,1
      program mainmain14,541
 100  format (/'Diagonal Nonlinear Eigenproblem, n =',I3,' (Fortran)')10056,1887
 110  format (' Nonlinear function with ',I2,' terms')110124,4395
 120  format (' Type set to ',A)120135,4747
 130  format (' Problem type before changing = ',I2)130141,4893
 140  format (' ... changed to ',I2)140147,5110
 190  format (' Refinement: ',I2,', tol=',F12.9,', its=',I2', scheme=', &190159,5472
 200  format (' Which = ',I2,', target = ',F4.1)200170,5855
 210  format (' Dimensions: nev=',I2,', ncv=',I2,', mpd=',I2)210179,6125
 220  format (' Tolerance =',F9.6,', max_its =',I4)220188,6384
 230  format (' Convergence test =',I2,', stopping test =',I2)230197,6710
 240  format (' Finished - converged reason =',I2)240221,7679

src/nep/examples/tests/test3.c,514
test3.c:^?test3.c^A,1
static char help[] = "Test the SLP solver with a user-provided EPS.\n\n"help11,400
  PetscScalar kappa;   /* ratio between stiffness of spring and attached mass */kappa35,976
  PetscReal   h;       /* mesh spacing */h36,1057
} ApplicationCtx;ApplicationCtx37,1099
int main(int argc,char **argv)main39,1118
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction146,5402
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian218,7471

src/nep/examples/tests/test4.c,514
test4.c:^?test4.c^A,1
static char help[] = "Test the RII solver with a user-provided KSP.\n\n"help11,400
  PetscScalar kappa;   /* ratio between stiffness of spring and attached mass */kappa35,976
  PetscReal   h;       /* mesh spacing */h36,1057
} ApplicationCtx;ApplicationCtx37,1099
int main(int argc,char **argv)main39,1118
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction147,5748
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian219,7817

src/nep/examples/tests/test5.c,134
test5.c:^?test5.c^A,1
static char help[] = "Test the INTERPOL solver with a user-provided PEP.\n\n"help11,400
int main(int argc,char **argv)main36,1079

src/nep/examples/tests/test6.c,134
test6.c:^?test6.c^A,1
static char help[] = "Test the NArnoldi solver with a user-provided KSP.\n\n"help11,400
int main(int argc,char **argv)main37,1121

src/nep/examples/tests/test7.c,1184
test7.c:^?test7.c^A,1
static char help[] = "Test the NLEIGS solver with shell matrices.\n\n"help11,400
  PetscScalar t;  /* square root of lambda */t41,1537
} MatCtx;MatCtx42,1583
int main(int argc,char **argv)main44,1594
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction183,8466
PetscErrorCode ComputeSingularities(NEP nep,PetscInt *maxnp,PetscScalar *xi,void *pt)ComputeSingularities200,8959
PetscErrorCode MatMult_A0(Mat A,Vec x,Vec y)MatMult_A0214,9335
PetscErrorCode MatGetDiagonal_A0(Mat A,Vec diag)MatGetDiagonal_A0233,9886
PetscErrorCode MatDuplicate_A0(Mat A,MatDuplicateOption op,Mat *B)MatDuplicate_A0242,10058
PetscErrorCode MatMult_A1(Mat A,Vec x,Vec y)MatMult_A1261,10874
PetscErrorCode MatGetDiagonal_A1(Mat A,Vec diag)MatGetDiagonal_A1270,11037
PetscErrorCode MatDuplicate_A1(Mat A,MatDuplicateOption op,Mat *B)MatDuplicate_A1279,11208
PetscErrorCode MatMult_F(Mat A,Vec x,Vec y)MatMult_F298,12023
PetscErrorCode MatGetDiagonal_F(Mat A,Vec diag)MatGetDiagonal_F320,12672
PetscErrorCode MatDuplicate_F(Mat A,MatDuplicateOption op,Mat *B)MatDuplicate_F331,12932
PetscErrorCode MatDestroy_F(Mat A)MatDestroy_F353,13913

src/nep/examples/tests/test8.c,124
test8.c:^?test8.c^A,1
static char help[] = "Test NEP view and monitor functionality.\n\n";help11,400
int main(int argc,char **argv)main15,493

src/nep/examples/tests/test9.c,149
test9.c:^?test9.c^A,1
static char help[] = "Test the NLEIGS solver with FNCOMBINE.\n\n"help22,881
#define NMAT NMAT31,1216
int main(int argc,char **argv)main33,1232

src/nep/examples/tutorials/ex20.c,724
ex20.c:^?ex20.c^A,1
static char help[] = "Simple 1-D nonlinear eigenproblem.\n\n"help11,400
  PetscScalar kappa;   /* ratio between stiffness of spring and attached mass */kappa38,1104
  PetscReal   h;       /* mesh spacing */h39,1185
} ApplicationCtx;ApplicationCtx40,1227
int main(int argc,char **argv)main42,1246
PetscErrorCode FormInitialGuess(Vec x)FormInitialGuess207,7771
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction229,8316
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian300,10332
PetscErrorCode CheckSolution(PetscScalar lambda,Vec y,PetscReal *error,void *ctx)CheckSolution366,12160
PetscErrorCode FixSign(Vec x)FixSign402,13308

src/nep/examples/tutorials/ex20f90.F90,210
ex20f90.F90:^?ex20f90.F90^A,1
      module UserModuleUserModule28,1085
      type UserUser31,1165
      program mainmain37,1267
      subroutine FormFunction(FormFunction202,7588
      subroutine FormJacobian(FormJacobian263,9340

src/nep/examples/tutorials/ex21.c,1184
ex21.c:^?ex21.c^A,1
static char help[] = "Simple 1-D nonlinear eigenproblem (matrix-free version, sequential).\n\n"help11,400
  PetscScalar lambda,kappa;lambda42,1258
  PetscScalar lambda,kappa;kappa42,1258
  PetscReal   h;h43,1286
} MatCtx;MatCtx44,1303
  PetscScalar kappa;   /* ratio between stiffness of spring and attached mass */kappa50,1373
  PetscReal   h;       /* mesh spacing */h51,1454
} ApplicationCtx;ApplicationCtx52,1496
int main(int argc,char **argv)main54,1515
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction178,6725
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian201,7345
PetscErrorCode MatMult_Fun(Mat A,Vec x,Vec y)MatMult_Fun213,7685
PetscErrorCode MatGetDiagonal_Fun(Mat A,Vec diag)MatGetDiagonal_Fun244,8706
PetscErrorCode MatDestroy_Fun(Mat A)MatDestroy_Fun266,9375
PetscErrorCode MatDuplicate_Fun(Mat A,MatDuplicateOption op,Mat *B)MatDuplicate_Fun278,9684
PetscErrorCode MatMult_Jac(Mat A,Vec x,Vec y)MatMult_Jac304,10722
PetscErrorCode MatGetDiagonal_Jac(Mat A,Vec diag)MatGetDiagonal_Jac334,11682
PetscErrorCode MatDestroy_Jac(Mat A)MatDestroy_Jac355,12302

src/nep/examples/tutorials/ex22.c,112
ex22.c:^?ex22.c^A,1
static char help[] = "Delay differential equation.\n\n"help11,400
int main(int argc,char **argv)main35,1028

src/nep/examples/tutorials/ex22f90.F90,222
ex22f90.F90:^?ex22f90.F90^A,1
      program mainmain35,1239
 100  format (/'Delay Eigenproblem, n =',I4,', tau =',F6.3)10077,2690
 120  format (' Solution method: ',A)120202,7850
 130  format (' Number of requested eigenvalues:',I4)130207,8047

src/nep/examples/tutorials/ex27.c,452
ex27.c:^?ex27.c^A,1
static char help[] = "Simple nonlinear eigenproblem using the NLEIGS solver.\n\n"help11,400
int main(int argc,char **argv)main32,1098
PetscErrorCode FormFunction(NEP nep,PetscScalar lambda,Mat fun,Mat B,void *ctx)FormFunction177,7320
PetscErrorCode FormJacobian(NEP nep,PetscScalar lambda,Mat jac,void *ctx)FormJacobian223,8873
PetscErrorCode ComputeSingularities(NEP nep,PetscInt *maxnp,PetscScalar *xi,void *pt)ComputeSingularities243,9543

src/nep/examples/tutorials/ex27f90.F90,184
ex27f90.F90:^?ex27f90.F90^A,1
PROGRAM mainmain24,971
SUBROUTINE FormFunction(FormFunction200,8322
SUBROUTINE FormJacobian(FormJacobian266,10158
SUBROUTINE ComputeSingularities(ComputeSingularities299,11252

src/nep/examples/tutorials/ex42.c,170
ex42.c:^?ex42.c^A,1
static char help[] = "Illustrates computation of left eigenvectors and resolvent.\n\n"help22,881
#define NMAT NMAT31,1237
int main(int argc,char **argv)main33,1253

src/nep/examples/tutorials/makefile,329
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/nep/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex20.c ex21.c ex22.c ex27.c ex42.cEXAMPLESC16,492
EXAMPLESF  = ex20f90.F90 ex22f90.F90 ex27f90.F90EXAMPLESF17,540
MANSEC     = NEPMANSEC18,589

src/nep/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcnepmod.FSOURCEF17,514
SOURCEH    = slepcnep.h slepcnep.h90SOURCEH18,541
LIBBASE    = libslepcnepLIBBASE19,578
MANSEC     = NEPMANSEC20,603
LOCDIR     = src/nep/f90-mod/LOCDIR21,620
CLEANFILES = *.modCLEANFILES22,650

src/nep/f90-mod/slepcnep.h,146
slepcnep.h:^?slepcnep.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      NEP, parameter :: SLEPC_NULL_NEP = tNEP(0)NEP18,593

src/nep/f90-mod/slepcnepmod.F,86
slepcnepmod.F:^?slepcnepmod.F^A,1
        module slepcnepdefslepcnepdef10,398
        module slepcnepslepcnep20,626

src/nep/impls/ciss/makefile,271
makefile:^?makefile^A,1
CFLAGS   =CFLAGS15,437
FFLAGS   =FFLAGS16,448
SOURCEC  = nciss.cSOURCEC17,459
SOURCEF  =SOURCEF18,478
SOURCEH  =SOURCEH19,489
LIBBASE  = libslepcnepLIBBASE20,500
DIRS     =DIRS21,523
MANSEC   = NEPMANSEC22,534
LOCDIR   = src/nep/impls/ciss/LOCDIR23,549

src/nep/impls/ciss/nciss.c,4889
nciss.c:^?nciss.c^A,1
  PetscInt     N;          /* number of integration points (32) */N38,1204
  PetscInt     L;          /* block size (16) */L39,1271
  PetscInt     M;          /* moment degree (N/4 = 4) */M40,1320
  PetscReal    delta;      /* threshold of singular value (1e-12) */delta41,1377
  PetscInt     L_max;      /* maximum number of columns of the source matrix V */L_max42,1446
  PetscReal    spurious_threshold; /* discard spurious eigenpairs */spurious_threshold43,1528
  PetscBool    isreal;     /* T(z) is real for real z */isreal44,1597
  PetscInt     npart;      /* number of partitions */npart45,1654
  PetscInt     refine_inner;refine_inner46,1708
  PetscInt     refine_blocksize;refine_blocksize47,1737
  PetscReal    *sigma;     /* threshold for numerical rank */sigma49,1791
  PetscInt     subcomm_id;subcomm_id50,1853
  PetscInt     num_solve_point;num_solve_point51,1880
  PetscScalar  *weight;weight52,1912
  PetscScalar  *omega;omega53,1936
  PetscScalar  *pp;pp54,1959
  BV           V;V55,1979
  BV           S;S56,1997
  BV           Y;Y57,2015
  KSP          *ksp;       /* ksp array for storing factorizations at integration points */ksp58,2033
  PetscBool    useconj;useconj59,2125
  PetscReal    est_eig;est_eig60,2149
  PetscSubcomm subcomm;subcomm61,2173
} NEP_CISS;NEP_CISS62,2197
PETSC_STATIC_INLINE PetscErrorCode NEPCISSResetSolvers(NEP nep)NEPCISSResetSolvers65,2276
PETSC_STATIC_INLINE PetscErrorCode NEPCISSResetSubcomm(NEP nep)NEPCISSResetSubcomm82,2723
PETSC_STATIC_INLINE PetscErrorCode NEPCISSSetUseConj(NEP nep,PetscBool *useconj)NEPCISSSetUseConj95,3156
PETSC_STATIC_INLINE PetscErrorCode NEPCISSSetUpSubComm(NEP nep,PetscInt *num_solve_point)NEPCISSSetUpSubComm113,3826
static PetscErrorCode SetPathParameter(NEP nep)SetPathParameter132,4640
static PetscErrorCode CISSVecSetRandom(BV V,PetscInt i0,PetscInt i1)CISSVecSetRandom156,5593
static PetscErrorCode SolveLinearSystem(NEP nep,Mat T,Mat dT,BV V,PetscInt L_start,PetscInt L_end,PetscBool initksp)SolveLinearSystem180,6304
static PetscErrorCode EstimateNumberEigs(NEP nep,PetscInt *L_add)EstimateNumberEigs213,7636
static PetscErrorCode CalcMu(NEP nep, PetscScalar *Mu)CalcMu254,9255
static PetscErrorCode BlockHankel(NEP nep,PetscScalar *Mu,PetscInt s,PetscScalar *H)BlockHankel302,11327
static PetscErrorCode SVD_H0(NEP nep,PetscScalar *S,PetscInt *K)SVD_H0315,11657
static PetscErrorCode ConstructS(NEP nep)ConstructS357,13065
static PetscErrorCode isGhost(NEP nep,PetscInt ld,PetscInt nv,PetscBool *fl)isGhost399,14654
PetscErrorCode NEPSetUp_CISS(NEP nep)NEPSetUp_CISS434,15643
PetscErrorCode NEPSolve_CISS(NEP nep)NEPSolve_CISS499,18728
static PetscErrorCode NEPCISSSetSizes_CISS(NEP nep,PetscInt ip,PetscInt bs,PetscInt ms,PetscInt npart,PetscInt bsmax,PetscBool realmats)NEPCISSSetSizes_CISS649,25470
PetscErrorCode NEPCISSSetSizes(NEP nep,PetscInt ip,PetscInt bs,PetscInt ms,PetscInt npart,PetscInt bsmax,PetscBool realmats)NEPCISSSetSizes732,28897
static PetscErrorCode NEPCISSGetSizes_CISS(NEP nep,PetscInt *ip,PetscInt *bs,PetscInt *ms,PetscInt *npart,PetscInt *bsmax,PetscBool *realmats)NEPCISSGetSizes_CISS748,29584
PetscErrorCode NEPCISSGetSizes(NEP nep,PetscInt *ip,PetscInt *bs,PetscInt *ms,PetscInt *npart,PetscInt *bsmax,PetscBool *realmats)NEPCISSGetSizes782,30460
static PetscErrorCode NEPCISSSetThreshold_CISS(NEP nep,PetscReal delta,PetscReal spur)NEPCISSSetThreshold_CISS792,30882
PetscErrorCode NEPCISSSetThreshold(NEP nep,PetscReal delta,PetscReal spur)NEPCISSSetThreshold831,32018
static PetscErrorCode NEPCISSGetThreshold_CISS(NEP nep,PetscReal *delta,PetscReal *spur)NEPCISSGetThreshold_CISS843,32423
PetscErrorCode NEPCISSGetThreshold(NEP nep,PetscReal *delta,PetscReal *spur)NEPCISSGetThreshold870,33050
static PetscErrorCode NEPCISSSetRefinement_CISS(NEP nep,PetscInt inner,PetscInt blsize)NEPCISSSetRefinement_CISS880,33364
PetscErrorCode NEPCISSSetRefinement(NEP nep,PetscInt inner,PetscInt blsize)NEPCISSSetRefinement919,34576
static PetscErrorCode NEPCISSGetRefinement_CISS(NEP nep,PetscInt *inner,PetscInt *blsize)NEPCISSGetRefinement_CISS931,34983
PetscErrorCode NEPCISSGetRefinement(NEP nep, PetscInt *inner, PetscInt *blsize)NEPCISSGetRefinement958,35658
static PetscErrorCode NEPCISSGetKSPs_CISS(NEP nep,PetscInt *nsolve,KSP **ksp)NEPCISSGetKSPs_CISS968,35976
PetscErrorCode NEPCISSGetKSPs(NEP nep,PetscInt *nsolve,KSP **ksp)NEPCISSGetKSPs1023,38103
PetscErrorCode NEPReset_CISS(NEP nep)NEPReset_CISS1033,38395
PetscErrorCode NEPSetFromOptions_CISS(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_CISS1049,38798
PetscErrorCode NEPDestroy_CISS(NEP nep)NEPDestroy_CISS1091,41317
PetscErrorCode NEPView_CISS(NEP nep,PetscViewer viewer)NEPView_CISS1110,42327
SLEPC_EXTERN PetscErrorCode NEPCreate_CISS(NEP nep)NEPCreate_CISS1133,43578

src/nep/impls/interpol/interpol.c,2100
interpol.c:^?interpol.c^A,1
  PEP       pep;pep30,928
  PetscReal tol;       /* tolerance for norm of polynomial coefficients */tol31,945
  PetscInt  maxdeg;    /* maximum degree of interpolation polynomial */maxdeg32,1020
  PetscInt  deg;       /* actual degree of interpolation polynomial */deg33,1092
} NEP_INTERPOL;NEP_INTERPOL34,1163
PetscErrorCode NEPSetUp_Interpol(NEP nep)NEPSetUp_Interpol36,1180
static PetscErrorCode ChebyshevNodes(PetscInt d,PetscReal a,PetscReal b,PetscScalar *x,PetscReal *dct2)ChebyshevNodes102,4568
PetscErrorCode NEPSolve_Interpol(NEP nep)NEPSolve_Interpol116,4935
static PetscErrorCode PEPMonitor_Interpol(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)PEPMonitor_Interpol200,7884
PetscErrorCode NEPSetFromOptions_Interpol(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_Interpol228,8754
static PetscErrorCode NEPInterpolSetInterpolation_Interpol(NEP nep,PetscReal tol,PetscInt degree)NEPInterpolSetInterpolation_Interpol252,9804
PetscErrorCode NEPInterpolSetInterpolation(NEP nep,PetscReal tol,PetscInt deg)NEPInterpolSetInterpolation302,11451
static PetscErrorCode NEPInterpolGetInterpolation_Interpol(NEP nep,PetscReal *tol,PetscInt *deg)NEPInterpolGetInterpolation_Interpol314,11860
PetscErrorCode NEPInterpolGetInterpolation(NEP nep,PetscReal *tol,PetscInt *deg)NEPInterpolGetInterpolation341,12506
static PetscErrorCode NEPInterpolSetPEP_Interpol(NEP nep,PEP pep)NEPInterpolSetPEP_Interpol351,12828
PetscErrorCode NEPInterpolSetPEP(NEP nep,PEP pep)NEPInterpolSetPEP379,13560
static PetscErrorCode NEPInterpolGetPEP_Interpol(NEP nep,PEP *pep)NEPInterpolGetPEP_Interpol391,13902
PetscErrorCode NEPInterpolGetPEP(NEP nep,PEP *pep)NEPInterpolGetPEP426,15064
PetscErrorCode NEPView_Interpol(NEP nep,PetscViewer viewer)NEPView_Interpol437,15354
PetscErrorCode NEPReset_Interpol(NEP nep)NEPReset_Interpol456,16160
PetscErrorCode NEPDestroy_Interpol(NEP nep)NEPDestroy_Interpol466,16372
SLEPC_EXTERN PetscErrorCode NEPCreate_Interpol(NEP nep)NEPCreate_Interpol481,17038

src/nep/impls/interpol/makefile,278
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = interpol.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  =SOURCEH17,464
LIBBASE  = libslepcnepLIBBASE18,475
DIRS     =DIRS19,498
MANSEC   = NEPMANSEC20,509
LOCDIR   = src/nep/impls/interpol/LOCDIR21,524

src/nep/impls/makefile,316
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = nepdefl.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  = nepdefl.hSOURCEH17,463
LIBBASE  = libslepcnepLIBBASE18,484
DIRS     = rii slp narnoldi interpol ciss nleigsDIRS19,507
LOCDIR   = src/nep/impls/LOCDIR20,556
MANSEC   = NEPMANSEC21,582

src/nep/impls/narnoldi/makefile,278
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = narnoldi.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  =SOURCEH17,464
LIBBASE  = libslepcnepLIBBASE18,475
DIRS     =DIRS19,498
MANSEC   = NEPMANSEC20,509
LOCDIR   = src/nep/impls/narnoldi/LOCDIR21,524

src/nep/impls/narnoldi/narnoldi.c,1617
narnoldi.c:^?narnoldi.c^A,1
  PetscInt lag;             /* interval to rebuild preconditioner */lag29,784
  KSP      ksp;             /* linear solver object */ksp30,853
} NEP_NARNOLDI;NEP_NARNOLDI31,908
PetscErrorCode NEPSetUp_NArnoldi(NEP nep)NEPSetUp_NArnoldi33,925
PetscErrorCode NEPSolve_NArnoldi(NEP nep)NEPSolve_NArnoldi53,1886
static PetscErrorCode NEPNArnoldiSetLagPreconditioner_NArnoldi(NEP nep,PetscInt lag)NEPNArnoldiSetLagPreconditioner_NArnoldi225,9124
PetscErrorCode NEPNArnoldiSetLagPreconditioner(NEP nep,PetscInt lag)NEPNArnoldiSetLagPreconditioner258,10076
static PetscErrorCode NEPNArnoldiGetLagPreconditioner_NArnoldi(NEP nep,PetscInt *lag)NEPNArnoldiGetLagPreconditioner_NArnoldi269,10419
PetscErrorCode NEPNArnoldiGetLagPreconditioner(NEP nep,PetscInt *lag)NEPNArnoldiGetLagPreconditioner293,10917
PetscErrorCode NEPSetFromOptions_NArnoldi(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_NArnoldi304,11248
static PetscErrorCode NEPNArnoldiSetKSP_NArnoldi(NEP nep,KSP ksp)NEPNArnoldiSetKSP_NArnoldi324,12018
PetscErrorCode NEPNArnoldiSetKSP(NEP nep,KSP ksp)NEPNArnoldiSetKSP352,12722
static PetscErrorCode NEPNArnoldiGetKSP_NArnoldi(NEP nep,KSP *ksp)NEPNArnoldiGetKSP_NArnoldi364,13064
PetscErrorCode NEPNArnoldiGetKSP(NEP nep,KSP *ksp)NEPNArnoldiGetKSP400,14315
PetscErrorCode NEPView_NArnoldi(NEP nep,PetscViewer viewer)NEPView_NArnoldi411,14605
PetscErrorCode NEPReset_NArnoldi(NEP nep)NEPReset_NArnoldi431,15325
PetscErrorCode NEPDestroy_NArnoldi(NEP nep)NEPDestroy_NArnoldi441,15537
SLEPC_EXTERN PetscErrorCode NEPCreate_NArnoldi(NEP nep)NEPCreate_NArnoldi456,16211

src/nep/impls/nepdefl.c,2673
nepdefl.c:^?nepdefl.c^A,1
PetscErrorCode NEPDeflationGetInvariantPair(NEP_EXT_OP extop,BV *X,Mat *H)NEPDeflationGetInvariantPair15,515
PetscErrorCode NEPDeflationCopyToExtendedVec(NEP_EXT_OP extop,Vec v,PetscScalar *a,Vec vex,PetscBool back)NEPDeflationCopyToExtendedVec27,804
PetscErrorCode NEPDeflationCreateVec(NEP_EXT_OP extop,Vec *v)NEPDeflationCreateVec70,2483
PetscErrorCode NEPDeflationCreateBV(NEP_EXT_OP extop,PetscInt sz,BV *V)NEPDeflationCreateBV93,3222
PetscErrorCode NEPDeflationSetRandomVec(NEP_EXT_OP extop,Vec v)NEPDeflationSetRandomVec121,4279
static PetscErrorCode NEPDeflationEvaluateBasisMat(NEP_EXT_OP extop,PetscInt idx,PetscBool hat,PetscScalar *bval,PetscScalar *Hj,PetscScalar *Hjprev)NEPDeflationEvaluateBasisMat146,5207
PetscErrorCode NEPDeflationLocking(NEP_EXT_OP extop,Vec u,PetscScalar lambda)NEPDeflationLocking180,6684
static PetscErrorCode NEPDeflationEvaluateHatFunction(NEP_EXT_OP extop, PetscInt idx,PetscScalar lambda,PetscScalar *y,PetscScalar *hfj,PetscScalar *hfjp,PetscInt ld)NEPDeflationEvaluateHatFunction215,8243
static PetscErrorCode NEPDeflationMatShell_MatMult(Mat M,Vec x,Vec y)NEPDeflationMatShell_MatMult272,10523
static PetscErrorCode NEPDeflationMatShell_CreateVecs(Mat M,Vec *right,Vec *left)NEPDeflationMatShell_CreateVecs317,12403
static PetscErrorCode NEPDeflationMatShell_Destroy(Mat M)NEPDeflationMatShell_Destroy333,12808
static PetscErrorCode NEPDeflationEvaluateBasis(NEP_EXT_OP extop,PetscScalar lambda,PetscInt n,PetscScalar *val,PetscBool jacobian)NEPDeflationEvaluateBasis352,13429
static PetscErrorCode NEPDeflationComputeShellMat(NEP_EXT_OP extop,PetscScalar lambda,PetscBool jacobian,Mat *M)NEPDeflationComputeShellMat372,13928
PetscErrorCode NEPDeflationComputeFunction(NEP_EXT_OP extop,PetscScalar lambda,Mat *F)NEPDeflationComputeFunction501,20251
PetscErrorCode NEPDeflationComputeJacobian(NEP_EXT_OP extop,PetscScalar lambda,Mat *J)NEPDeflationComputeJacobian511,20523
PetscErrorCode NEPDeflationSolveSetUp(NEP_EXT_OP extop,PetscScalar lambda)NEPDeflationSolveSetUp521,20794
PetscErrorCode NEPDeflationFunctionSolve(NEP_EXT_OP extop,Vec b,Vec x)NEPDeflationFunctionSolve578,23369
PetscErrorCode NEPDeflationReset(NEP_EXT_OP extop)NEPDeflationReset637,26041
PetscErrorCode NEPDeflationInitialize(NEP nep,BV X,KSP ksp,PetscBool sincfun,PetscInt sz,NEP_EXT_OP *extop)NEPDeflationInitialize680,27539
PetscErrorCode NEPDeflationDSNEPComputeMatrix(DS ds,PetscScalar lambda,PetscBool deriv,DSMatType mat,void *ctx)NEPDeflationDSNEPComputeMatrix727,29129
PetscErrorCode NEPDeflationProjectOperator(NEP_EXT_OP extop,BV Vext,DS ds,PetscInt j0,PetscInt j1)NEPDeflationProjectOperator838,34641

src/nep/impls/nepdefl.h,2663
nepdefl.h:^?nepdefl.h^A,1
#define SLEPC_NEPDEFL_HSLEPC_NEPDEFL_H14,474
# define MAX_MINIDX MAX_MINIDX16,499
typedef struct _n_nep_ext_op *NEP_EXT_OP;NEP_EXT_OP18,522
typedef struct _n_nep_def_fun_solve *NEP_DEF_FUN_SOLVE;NEP_DEF_FUN_SOLVE19,564
typedef struct _n_nep_def_project *NEP_DEF_PROJECT;NEP_DEF_PROJECT20,620
struct _n_nep_ext_op {_n_nep_ext_op23,724
  NEP               nep;nep24,747
  PetscScalar       *H;     /* invariant pair (X,H) */H25,772
  BV                X;      /* locked eigenvectors */X26,827
  PetscScalar       *bc;    /* polinomial basis roots */bc27,881
  RG                rg;rg28,938
  PetscInt          midx;   /* minimality index */midx29,962
  PetscInt          max_midx;max_midx30,1013
  PetscInt          szd;    /* maximum size for deflation */szd31,1043
  PetscInt          n;      /* invariant pair size */n32,1104
  Mat               MF;     /* function shell matrix */MF33,1158
  Mat               MJ;     /* Jacobian shell matrix */MJ34,1214
  PetscBool         simpU;  /* the way U is computed */simpU35,1270
  NEP_DEF_FUN_SOLVE solve;  /* MatSolve context for the operator */solve36,1326
  NEP_DEF_PROJECT   proj;   /* context for the projected eigenproblem */proj37,1394
  BV                W;W39,1498
  PetscScalar       *Hj;    /* matrix containing the powers of the invariant pair matrix */Hj40,1521
  PetscScalar       *XpX;   /* X^*X */XpX41,1613
struct _n_nep_def_fun_solve {_n_nep_def_fun_solve44,1656
  KSP          ksp;   /* */ksp45,1686
  PetscBool    sincf;sincf46,1714
  Mat          T;T47,1736
  PetscScalar  theta;theta48,1754
  PetscInt     n;n49,1776
  PetscScalar  *M;M50,1794
  PetscScalar  *work;work51,1813
  Vec          w[2];w52,1835
  BV           T_1U;T_1U53,1856
  NEP_EXT_OP   extop;extop54,1877
  NEP          nep;nep58,1920
  Mat          T;T59,1940
  BV           U;U60,1958
  PetscScalar  *A;A61,1976
  PetscScalar  *B;B62,1995
  PetscScalar  theta;theta63,2014
  PetscInt     n;n64,2036
  NEP_EXT_OP   extop;extop65,2054
  PetscBool    jacob;jacob66,2076
  Vec          w[2];w67,2098
  PetscScalar  *work;work68,2119
  PetscScalar  *hfj;hfj69,2141
  PetscScalar  *hfjp;hfjp70,2162
  PetscBool    hfjset;hfjset71,2184
} NEP_DEF_MATSHELL;NEP_DEF_MATSHELL72,2207
struct _n_nep_def_project {_n_nep_def_project74,2228
  Mat          *V1pApX;V1pApX75,2256
  Mat          XpV1;XpV176,2280
  PetscScalar  *V2;V277,2301
  Vec          w;w78,2321
  BV           V1;V179,2339
  PetscInt     dim;dim80,2358
  PetscScalar  *work;work81,2378
  PetscInt     lwork;lwork82,2400
  NEP_EXT_OP   extop;extop83,2422

src/nep/impls/nleigs/ftn-custom/makefile,258
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = znleigsf.cSOURCEC15,469
SOURCEF  =SOURCEF16,491
SOURCEH  =SOURCEH17,502
DIRS     =DIRS18,513
LIBBASE  = libslepcnepLIBBASE19,524
LOCDIR   = src/nep/impls/nleigs/ftn-custom/LOCDIR20,547

src/nep/impls/nleigs/ftn-custom/znleigsf.c,860
znleigsf.c:^?znleigsf.c^A,1
  PetscFortranCallbackId singularities;singularities23,864
} _cb;_cb24,904
static PetscErrorCode oursingularitiesfunc(NEP nep,PetscInt *maxnp,PetscScalar *xi,void *ctx)oursingularitiesfunc26,912
SLEPC_EXTERN void PETSC_STDCALL nepnleigssetsingularitiesfunction_(NEP *nep,void (PETSC_STDCALL *func)(NEP*,PetscInt*,PetscScalar*,void*,PetscErrorCode*),void *ctx,PetscErrorCode *ierr)nepnleigssetsingularitiesfunction_31,1146
SLEPC_EXTERN void PETSC_STDCALL nepnleigsgetrkshifts_(NEP *nep,PetscInt *ns,PetscScalar *pshifts,int *ierr)nepnleigsgetrkshifts_38,1598

src/nep/impls/nleigs/makefile,295
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = nleigs.c nleigs-fullb.cSOURCEC15,431
SOURCEF  =SOURCEF16,466
SOURCEH  = nleigs.hSOURCEH17,477
LIBBASE  = libslepcLIBBASE18,497
DIRS     =DIRS19,517
MANSEC   = NEPMANSEC20,528
LOCDIR   = src/nep/impls/nleigs/LOCDIR21,543

src/nep/impls/nleigs/nleigs-fullb.c,1308
nleigs-fullb.c:^?nleigs-fullb.c^A,1
static PetscErrorCode MatMult_FullBasis_Sinvert(Mat M,Vec x,Vec y)MatMult_FullBasis_Sinvert17,585
static PetscErrorCode MatMultTranspose_FullBasis_Sinvert(Mat M,Vec x,Vec y)MatMultTranspose_FullBasis_Sinvert106,4168
static PetscErrorCode BackTransform_FullBasis(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)BackTransform_FullBasis206,7892
static PetscErrorCode Apply_FullBasis(ST st,Vec x,Vec y)Apply_FullBasis217,8227
static PetscErrorCode ApplyTranspose_FullBasis(ST st,Vec x,Vec y)ApplyTranspose_FullBasis230,8541
PetscErrorCode NEPSetUp_NLEIGS_FullBasis(NEP nep)NEPSetUp_NLEIGS_FullBasis243,8873
static PetscErrorCode NEPNLEIGSExtract_None(NEP nep,EPS eps)NEPNLEIGSExtract_None336,13808
PetscErrorCode NEPSolve_NLEIGS_FullBasis(NEP nep)NEPSolve_NLEIGS_FullBasis400,16199
PetscErrorCode NEPNLEIGSSetEPS_NLEIGS(NEP nep,EPS eps)NEPNLEIGSSetEPS_NLEIGS424,17050
PetscErrorCode NEPNLEIGSSetEPS(NEP nep,EPS eps)NEPNLEIGSSetEPS451,17725
static PetscErrorCode EPSMonitor_NLEIGS(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitor_NLEIGS463,18063
PetscErrorCode NEPNLEIGSGetEPS_NLEIGS(NEP nep,EPS *eps)NEPNLEIGSGetEPS_NLEIGS480,18671
PetscErrorCode NEPNLEIGSGetEPS(NEP nep,EPS *eps)NEPNLEIGSGetEPS515,19786

src/nep/impls/nleigs/nleigs.c,7144
nleigs.c:^?nleigs.c^A,1
PetscErrorCode NEPNLEIGSBackTransform(PetscObject ob,PetscInt n,PetscScalar *valr,PetscScalar *vali)NEPNLEIGSBackTransform30,873
static PetscErrorCode NEPNLEIGSAuxiliarPRootFinder(PetscInt deg,PetscScalar *polcoeffs,PetscScalar *wr,PetscScalar *wi,PetscBool *avail)NEPNLEIGSAuxiliarPRootFinder58,1519
static PetscErrorCode NEPNLEIGSAuxiliarRmDuplicates(PetscInt nin,PetscScalar *pin,PetscInt *nout,PetscScalar *pout,PetscInt max)NEPNLEIGSAuxiliarRmDuplicates121,3555
static PetscErrorCode NEPNLEIGSFNSingularities(FN f,PetscInt *nisol,PetscScalar **isol,PetscBool *rational)NEPNLEIGSFNSingularities138,3986
static PetscErrorCode NEPNLEIGSRationalSingularities(NEP nep,PetscInt *ndptx,PetscScalar *dxi,PetscBool *rational)NEPNLEIGSRationalSingularities192,6111
static PetscErrorCode NEPNLEIGSAAAComputation(NEP nep,PetscInt ndpt,PetscScalar *ds,PetscScalar *F,PetscInt *ndptx,PetscScalar *dxi)NEPNLEIGSAAAComputation217,6916
static PetscErrorCode NEPNLEIGSAAASingularities(NEP nep,PetscInt ndpt,PetscScalar *ds,PetscInt *ndptx,PetscScalar *dxi)NEPNLEIGSAAASingularities321,10775
static PetscErrorCode NEPNLEIGSLejaBagbyPoints(NEP nep)NEPNLEIGSLejaBagbyPoints373,12649
PetscErrorCode NEPNLEIGSEvalNRTFunct(NEP nep,PetscInt k,PetscScalar sigma,PetscScalar *b)NEPNLEIGSEvalNRTFunct444,15968
static PetscErrorCode MatMult_Fun(Mat A,Vec x,Vec y)MatMult_Fun458,16337
static PetscErrorCode MatMultTranspose_Fun(Mat A,Vec x,Vec y)MatMultTranspose_Fun475,16844
static PetscErrorCode MatGetDiagonal_Fun(Mat A,Vec diag)MatGetDiagonal_Fun492,17378
static PetscErrorCode MatDuplicate_Fun(Mat A,MatDuplicateOption op,Mat *B)MatDuplicate_Fun509,17908
static PetscErrorCode MatDestroy_Fun(Mat A)MatDestroy_Fun546,19665
static PetscErrorCode MatAXPY_Fun(Mat Y,PetscScalar a,Mat X,MatStructure str)MatAXPY_Fun565,20141
static PetscErrorCode MatScale_Fun(Mat M,PetscScalar a)MatScale_Fun592,20909
static PetscErrorCode NLEIGSMatToMatShellArray(Mat M,Mat *Ms,PetscInt maxnmat)NLEIGSMatToMatShellArray604,21196
static PetscErrorCode NEPNLEIGSNormEstimation(NEP nep,Mat M,PetscReal *norm,Vec *w)NEPNLEIGSNormEstimation634,22749
static PetscErrorCode NEPNLEIGSDividedDifferences_split(NEP nep)NEPNLEIGSDividedDifferences_split676,24530
static PetscErrorCode NEPNLEIGSDividedDifferences_callback(NEP nep)NEPNLEIGSDividedDifferences_callback794,28939
PetscErrorCode NEPNLEIGSKrylovConvergence(NEP nep,PetscBool getall,PetscInt kini,PetscInt nits,PetscReal betah,PetscScalar betak,PetscInt *kout,Vec *w)NEPNLEIGSKrylovConvergence880,32047
PetscErrorCode NEPSetUp_NLEIGS(NEP nep)NEPSetUp_NLEIGS922,33496
static PetscErrorCode NEPTOARExtendBasis(NEP nep,PetscInt idxrktg,PetscScalar *S,PetscInt ls,PetscInt nv,BV W,BV V,Vec t,PetscScalar *r,PetscInt lr,Vec *t_)NEPTOARExtendBasis1001,37101
static PetscErrorCode NEPTOARCoefficients(NEP nep,PetscScalar sigma,PetscInt nv,PetscScalar *S,PetscInt ls,PetscScalar *r,PetscInt lr,PetscScalar *x,PetscScalar *work)NEPTOARCoefficients1070,40341
static PetscErrorCode NEPNLEIGS_RKcontinuation(NEP nep,PetscInt ini,PetscInt end,PetscScalar *K,PetscScalar *H,PetscInt ld,PetscScalar sigma,PetscScalar *S,PetscInt lds,PetscScalar *cont,PetscScalar *t,PetscScalar *work)NEPNLEIGS_RKcontinuation1090,41038
PetscErrorCode NEPNLEIGSTOARrun(NEP nep,PetscScalar *K,PetscScalar *H,PetscInt ldh,BV W,PetscInt k,PetscInt *M,PetscBool *breakdown,Vec *t_)NEPNLEIGSTOARrun1142,42904
PetscErrorCode NEPSolve_NLEIGS(NEP nep)NEPSolve_NLEIGS1203,45200
static PetscErrorCode NEPNLEIGSSetSingularitiesFunction_NLEIGS(NEP nep,PetscErrorCode (*fun)(NEP,PetscInt*,PetscScalar*,void*),void *ctx)NEPNLEIGSSetSingularitiesFunction_NLEIGS1379,52465
PetscErrorCode NEPNLEIGSSetSingularitiesFunction(NEP nep,PetscErrorCode (*fun)(NEP,PetscInt*,PetscScalar*,void*),void *ctx)NEPNLEIGSSetSingularitiesFunction1422,54034
static PetscErrorCode NEPNLEIGSGetSingularitiesFunction_NLEIGS(NEP nep,PetscErrorCode (**fun)(NEP,PetscInt*,PetscScalar*,void*),void **ctx)NEPNLEIGSGetSingularitiesFunction_NLEIGS1432,54442
PetscErrorCode NEPNLEIGSGetSingularitiesFunction(NEP nep,PetscErrorCode (**fun)(NEP,PetscInt*,PetscScalar*,void*),void **ctx)NEPNLEIGSGetSingularitiesFunction1459,55220
static PetscErrorCode NEPNLEIGSSetRestart_NLEIGS(NEP nep,PetscReal keep)NEPNLEIGSSetRestart_NLEIGS1469,55632
PetscErrorCode NEPNLEIGSSetRestart(NEP nep,PetscReal keep)NEPNLEIGSSetRestart1503,56558
static PetscErrorCode NEPNLEIGSGetRestart_NLEIGS(NEP nep,PetscReal *keep)NEPNLEIGSGetRestart_NLEIGS1514,56883
PetscErrorCode NEPNLEIGSGetRestart(NEP nep,PetscReal *keep)NEPNLEIGSGetRestart1538,57351
static PetscErrorCode NEPNLEIGSSetLocking_NLEIGS(NEP nep,PetscBool lock)NEPNLEIGSSetLocking_NLEIGS1549,57664
PetscErrorCode NEPNLEIGSSetLocking(NEP nep,PetscBool lock)NEPNLEIGSSetLocking1581,58490
static PetscErrorCode NEPNLEIGSGetLocking_NLEIGS(NEP nep,PetscBool *lock)NEPNLEIGSGetLocking_NLEIGS1592,58815
PetscErrorCode NEPNLEIGSGetLocking(NEP nep,PetscBool *lock)NEPNLEIGSGetLocking1616,59273
static PetscErrorCode NEPNLEIGSSetInterpolation_NLEIGS(NEP nep,PetscReal tol,PetscInt degree)NEPNLEIGSSetInterpolation_NLEIGS1627,59586
PetscErrorCode NEPNLEIGSSetInterpolation(NEP nep,PetscReal tol,PetscInt degree)NEPNLEIGSSetInterpolation1677,61252
static PetscErrorCode NEPNLEIGSGetInterpolation_NLEIGS(NEP nep,PetscReal *tol,PetscInt *degree)NEPNLEIGSGetInterpolation_NLEIGS1689,61666
PetscErrorCode NEPNLEIGSGetInterpolation(NEP nep,PetscReal *tol,PetscInt *degree)NEPNLEIGSGetInterpolation1716,62337
static PetscErrorCode NEPNLEIGSSetRKShifts_NLEIGS(NEP nep,PetscInt ns,PetscScalar *shifts)NEPNLEIGSSetRKShifts_NLEIGS1726,62661
PetscErrorCode NEPNLEIGSSetRKShifts(NEP nep,PetscInt ns,PetscScalar shifts[])NEPNLEIGSSetRKShifts1777,64325
static PetscErrorCode NEPNLEIGSGetRKShifts_NLEIGS(NEP nep,PetscInt *ns,PetscScalar **shifts)NEPNLEIGSGetRKShifts_NLEIGS1789,64731
PetscErrorCode NEPNLEIGSGetRKShifts(NEP nep,PetscInt *ns,PetscScalar *shifts[])NEPNLEIGSGetRKShifts1824,65527
static PetscErrorCode NEPNLEIGSGetKSPs_NLEIGS(NEP nep,PetscInt *nsolve,KSP **ksp)NEPNLEIGSGetKSPs_NLEIGS1836,65911
PetscErrorCode NEPNLEIGSGetKSPs(NEP nep,PetscInt *nsolve,KSP **ksp)NEPNLEIGSGetKSPs1887,67838
static PetscErrorCode NEPNLEIGSSetFullBasis_NLEIGS(NEP nep,PetscBool fullbasis)NEPNLEIGSSetFullBasis_NLEIGS1897,68134
PetscErrorCode NEPNLEIGSSetFullBasis(NEP nep,PetscBool fullbasis)NEPNLEIGSSetFullBasis1937,69474
static PetscErrorCode NEPNLEIGSGetFullBasis_NLEIGS(NEP nep,PetscBool *fullbasis)NEPNLEIGSGetFullBasis_NLEIGS1948,69818
PetscErrorCode NEPNLEIGSGetFullBasis(NEP nep,PetscBool *fullbasis)NEPNLEIGSGetFullBasis1973,70320
#define SHIFTMAX SHIFTMAX1984,70652
PetscErrorCode NEPSetFromOptions_NLEIGS(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_NLEIGS1986,70673
PetscErrorCode NEPView_NLEIGS(NEP nep,PetscViewer viewer)NEPView_NLEIGS2032,72935
PetscErrorCode NEPReset_NLEIGS(NEP nep)NEPReset_NLEIGS2075,75022
PetscErrorCode NEPDestroy_NLEIGS(NEP nep)NEPDestroy_NLEIGS2100,75800
SLEPC_EXTERN PetscErrorCode NEPCreate_NLEIGS(NEP nep)NEPCreate_NLEIGS2131,77846

src/nep/impls/nleigs/nleigs.h,2422
nleigs.h:^?nleigs.h^A,1
#define SLEPC_NLEIGS_HSLEPC_NLEIGS_H15,464
#define  LBPOINTS LBPOINTS18,489
#define  NDPOINTS NDPOINTS19,577
  BV             V;         /* tensor vector basis for the linearization */V22,658
  BV             W;         /* tensor vector basis for the linearization */W23,734
  PetscInt       nmat;      /* number of interpolation points */nmat24,810
  PetscScalar    *s,*xi;    /* Leja-Bagby points */s25,875
  PetscScalar    *s,*xi;    /* Leja-Bagby points */xi25,875
  PetscScalar    *beta;     /* scaling factors */beta26,927
  Mat            *D;        /* divided difference matrices */D27,977
  PetscScalar    *coeffD;   /* coefficients for divided differences in split form */coeffD28,1039
  PetscInt       nshifts;   /* provided number of shifts */nshifts29,1124
  PetscScalar    *shifts;   /* user-provided shifts for the Rational Krylov variant */shifts30,1184
  PetscInt       nshiftsw;  /* actual number of shifts (1 if Krylov-Schur) */nshiftsw31,1271
  PetscReal      ddtol;     /* tolerance for divided difference convergence */ddtol32,1349
  PetscInt       ddmaxit;   /* maximum number of divided difference terms */ddmaxit33,1428
  PetscReal      keep;      /* restart parameter */keep34,1505
  PetscBool      lock;      /* locking/non-locking variant */lock35,1557
  PetscInt       idxrk;     /* index of next shift to use */idxrk36,1619
  KSP            *ksp;      /* ksp array for storing shift factorizations */ksp37,1680
  Vec            vrn;       /* random vector with normally distributed value */vrn38,1757
  PetscBool      fullbasis; /* use full Krylov basis instead of TOAR basis */fullbasis39,1837
  EPS            eps;       /* eigensolver used in the full basis variant */eps40,1915
  Mat            A;         /* shell matrix used for the eps in full basis */A41,1992
  Vec            w[6];      /* work vectors */w42,2070
  void           *singularitiesctx;singularitiesctx43,2117
  PetscErrorCode (*computesingularities)(NEP,PetscInt*,PetscScalar*,void*);computesingularities44,2153
} NEP_NLEIGS;NEP_NLEIGS45,2229
  PetscInt    nmat,maxnmat;nmat48,2261
  PetscInt    nmat,maxnmat;maxnmat48,2261
  PetscScalar *coeff;coeff49,2289
  Mat         *A;A50,2311
  Vec         t;t51,2329
} ShellMatCtx;ShellMatCtx52,2346
PETSC_STATIC_INLINE PetscErrorCode NEPNLEIGSSetShifts(NEP nep,PetscInt *nshiftsw)NEPNLEIGSSetShifts54,2362

src/nep/impls/rii/makefile,268
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rii.cSOURCEC15,431
SOURCEF  =SOURCEF16,448
SOURCEH  =SOURCEH17,459
LIBBASE  = libslepcnepLIBBASE18,470
DIRS     =DIRS19,493
MANSEC   = NEPMANSEC20,504
LOCDIR   = src/nep/impls/rii/LOCDIR21,519

src/nep/impls/rii/rii.c,2477
rii.c:^?rii.c^A,1
  PetscInt  max_inner_it;     /* maximum number of Newton iterations */max_inner_it29,841
  PetscInt  lag;              /* interval to rebuild preconditioner */lag30,913
  PetscBool cctol;            /* constant correction tolerance */cctol31,984
  KSP       ksp;              /* linear solver object */ksp32,1050
} NEP_RII;NEP_RII33,1107
PetscErrorCode NEPSetUp_RII(NEP nep)NEPSetUp_RII35,1119
PetscErrorCode NEPSolve_RII(NEP nep)NEPSolve_RII56,1995
PetscErrorCode NEPSetFromOptions_RII(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_RII195,7914
static PetscErrorCode NEPRIISetMaximumIterations_RII(NEP nep,PetscInt its)NEPRIISetMaximumIterations_RII222,9110
PetscErrorCode NEPRIISetMaximumIterations(NEP nep,PetscInt its)NEPRIISetMaximumIterations250,9872
static PetscErrorCode NEPRIIGetMaximumIterations_RII(NEP nep,PetscInt *its)NEPRIIGetMaximumIterations_RII261,10205
PetscErrorCode NEPRIIGetMaximumIterations(NEP nep,PetscInt *its)NEPRIIGetMaximumIterations285,10686
static PetscErrorCode NEPRIISetLagPreconditioner_RII(NEP nep,PetscInt lag)NEPRIISetLagPreconditioner_RII296,11007
PetscErrorCode NEPRIISetLagPreconditioner(NEP nep,PetscInt lag)NEPRIISetLagPreconditioner329,11924
static PetscErrorCode NEPRIIGetLagPreconditioner_RII(NEP nep,PetscInt *lag)NEPRIIGetLagPreconditioner_RII340,12257
PetscErrorCode NEPRIIGetLagPreconditioner(NEP nep,PetscInt *lag)NEPRIIGetLagPreconditioner364,12725
static PetscErrorCode NEPRIISetConstCorrectionTol_RII(NEP nep,PetscBool cct)NEPRIISetConstCorrectionTol_RII375,13046
PetscErrorCode NEPRIISetConstCorrectionTol(NEP nep,PetscBool cct)NEPRIISetConstCorrectionTol407,13887
static PetscErrorCode NEPRIIGetConstCorrectionTol_RII(NEP nep,PetscBool *cct)NEPRIIGetConstCorrectionTol_RII418,14224
PetscErrorCode NEPRIIGetConstCorrectionTol(NEP nep,PetscBool *cct)NEPRIIGetConstCorrectionTol442,14707
static PetscErrorCode NEPRIISetKSP_RII(NEP nep,KSP ksp)NEPRIISetKSP_RII453,15033
PetscErrorCode NEPRIISetKSP(NEP nep,KSP ksp)NEPRIISetKSP481,15712
static PetscErrorCode NEPRIIGetKSP_RII(NEP nep,KSP *ksp)NEPRIIGetKSP_RII493,16044
PetscErrorCode NEPRIIGetKSP(NEP nep,KSP *ksp)NEPRIIGetKSP529,17265
PetscErrorCode NEPView_RII(NEP nep,PetscViewer viewer)NEPView_RII540,17545
PetscErrorCode NEPReset_RII(NEP nep)NEPReset_RII564,18512
PetscErrorCode NEPDestroy_RII(NEP nep)NEPDestroy_RII574,18714
SLEPC_EXTERN PetscErrorCode NEPCreate_RII(NEP nep)NEPCreate_RII593,19780

src/nep/impls/slp/makefile,268
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = slp.cSOURCEC15,431
SOURCEF  =SOURCEF16,448
SOURCEH  =SOURCEH17,459
LIBBASE  = libslepcnepLIBBASE18,470
DIRS     =DIRS19,493
MANSEC   = NEPMANSEC20,504
LOCDIR   = src/nep/impls/slp/LOCDIR21,519

src/nep/impls/slp/slp.c,1774
slp.c:^?slp.c^A,1
  EPS        eps;      /* linear eigensolver for T*z = mu*Tp*z */eps29,831
  KSP        ksp;ksp30,897
} NEP_SLP;NEP_SLP31,915
  NEP_EXT_OP extop;extop34,944
  Vec        w;w35,964
} NEP_SLP_EPS_MSHELL;NEP_SLP_EPS_MSHELL36,980
PetscErrorCode NEPSetUp_SLP(NEP nep)NEPSetUp_SLP38,1003
PetscErrorCode NEPSLPEPSMatShell_MatMult(Mat M,Vec x,Vec y)NEPSLPEPSMatShell_MatMult69,2658
PetscErrorCode NEPSLPEPSMatShell_Destroy(Mat M)NEPSLPEPSMatShell_Destroy81,3013
PetscErrorCode NEPSLPEPSMatShell_CreateVecs(Mat M,Vec *left,Vec *right)NEPSLPEPSMatShell_CreateVecs93,3311
static PetscErrorCode NEPSLPSetUpLinearEP(NEP nep,NEP_EXT_OP extop,PetscScalar lambda,Vec u,PetscBool ini)NEPSLPSetUpLinearEP109,3692
PetscErrorCode NEPSolve_SLP(NEP nep)NEPSolve_SLP138,5100
PetscErrorCode NEPSetFromOptions_SLP(PetscOptionItems *PetscOptionsObject,NEP nep)NEPSetFromOptions_SLP239,9508
static PetscErrorCode NEPSLPSetEPS_SLP(NEP nep,EPS eps)NEPSLPSetEPS_SLP255,10082
PetscErrorCode NEPSLPSetEPS(NEP nep,EPS eps)NEPSLPSetEPS283,10774
static PetscErrorCode NEPSLPGetEPS_SLP(NEP nep,EPS *eps)NEPSLPGetEPS_SLP295,11106
PetscErrorCode NEPSLPGetEPS(NEP nep,EPS *eps)NEPSLPGetEPS329,12142
static PetscErrorCode NEPSLPSetKSP_SLP(NEP nep,KSP ksp)NEPSLPSetKSP_SLP340,12422
PetscErrorCode NEPSLPSetKSP(NEP nep,KSP ksp)NEPSLPSetKSP368,13101
static PetscErrorCode NEPSLPGetKSP_SLP(NEP nep,KSP *ksp)NEPSLPGetKSP_SLP380,13433
PetscErrorCode NEPSLPGetKSP(NEP nep,KSP *ksp)NEPSLPGetKSP415,14555
PetscErrorCode NEPView_SLP(NEP nep,PetscViewer viewer)NEPView_SLP426,14835
PetscErrorCode NEPReset_SLP(NEP nep)NEPReset_SLP445,15516
PetscErrorCode NEPDestroy_SLP(NEP nep)NEPDestroy_SLP456,15761
SLEPC_EXTERN PetscErrorCode NEPCreate_SLP(NEP nep)NEPCreate_SLP472,16423

src/nep/interface/dlregisnep.c,1047
dlregisnep.c:^?dlregisnep.c^A,1
static PetscBool NEPPackageInitialized = PETSC_FALSE;NEPPackageInitialized13,436
const char *NEPErrorTypes[] = {"ABSOLUTE","RELATIVE","BACKWARD","NEPErrorType","NEP_ERROR_",0};NEPErrorTypes15,491
const char *NEPRefineTypes[] = {"NONE","SIMPLE","MULTIPLE","NEPRefine","NEP_REFINE_",0};NEPRefineTypes16,587
const char *NEPRefineSchemes[] = {"","SCHUR","MBE","EXPLICIT","NEPRefineScheme","NEP_REFINE_SCHEME_",0};NEPRefineSchemes17,676
const char *const NEPConvergedReasons_Shifted[] = {"DIVERGED_SUBSPACE_EXHAUSTED","DIVERGED_LINEAR_SOLVE","","DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","CONVERGED_USER","NEPConvergedReason","NEP_",0};NEPConvergedReasons_Shifted18,781
const char *const*NEPConvergedReasons = NEPConvergedReasons_Shifted + 5;NEPConvergedReasons19,1012
PetscErrorCode NEPFinalizePackage(void)NEPFinalizePackage29,1282
PetscErrorCode NEPInitializePackage(void)NEPInitializePackage49,1823
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepcnep()PetscDLLibraryRegister_slepcnep94,3739

src/nep/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = znepf.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepcnepLIBBASE19,521
LOCDIR   = src/nep/interface/ftn-custom/LOCDIR20,544

src/nep/interface/ftn-custom/znepf.c,16230
znepf.c:^?znepf.c^A,1
SLEPC_EXTERN void nepmonitorall_(NEP *nep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)nepmonitorall_122,6629
SLEPC_EXTERN void nepmonitorconverged_(NEP *nep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,SlepcConvMonitor *ctx,PetscErrorCode *ierr)nepmonitorconverged_127,6893
SLEPC_EXTERN void nepmonitorfirst_(NEP *nep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)nepmonitorfirst_132,7164
SLEPC_EXTERN void nepmonitorlg_(NEP *nep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)nepmonitorlg_137,7432
SLEPC_EXTERN void nepmonitorlgall_(NEP *nep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)nepmonitorlgall_142,7676
  PetscFortranCallbackId monitor;monitor148,7942
  PetscFortranCallbackId monitordestroy;monitordestroy149,7976
  PetscFortranCallbackId convergence;convergence150,8017
  PetscFortranCallbackId convdestroy;convdestroy151,8055
  PetscFortranCallbackId stopping;stopping152,8093
  PetscFortranCallbackId stopdestroy;stopdestroy153,8128
  PetscFortranCallbackId comparison;comparison154,8166
  PetscFortranCallbackId function;function155,8203
  PetscFortranCallbackId jacobian;jacobian156,8238
  PetscFortranCallbackId function_pgiptr;function_pgiptr158,8310
  PetscFortranCallbackId jacobian_pgiptr;jacobian_pgiptr159,8352
} _cb;_cb161,8401
static PetscErrorCode ourmonitor(NEP nep,PetscInt i,PetscInt nc,PetscScalar *er,PetscScalar *ei,PetscReal *d,PetscInt l,void* ctx)ourmonitor164,8501
static PetscErrorCode ourdestroy(void** ctx)ourdestroy169,8819
static PetscErrorCode ourconvergence(NEP nep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)ourconvergence175,8986
static PetscErrorCode ourconvdestroy(void *ctx)ourconvdestroy180,9286
static PetscErrorCode ourstopping(NEP nep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,NEPConvergedReason *reason,void *ctx)ourstopping186,9452
static PetscErrorCode ourstopdestroy(void *ctx)ourstopdestroy191,9784
static PetscErrorCode oureigenvaluecomparison(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)oureigenvaluecomparison197,9950
static PetscErrorCode ournepfunction(NEP nep,PetscScalar lambda,Mat T,Mat P,void *ctx)ournepfunction203,10276
static PetscErrorCode ournepjacobian(NEP nep,PetscScalar lambda,Mat J,void *ctx)ournepjacobian212,10723
SLEPC_EXTERN void PETSC_STDCALL nepview_(NEP *nep,PetscViewer *viewer,PetscErrorCode *ierr)nepview_221,11156
SLEPC_EXTERN void PETSC_STDCALL nepreasonview_(NEP *nep,PetscViewer *viewer,PetscErrorCode *ierr)nepreasonview_228,11343
SLEPC_EXTERN void PETSC_STDCALL neperrorview_(NEP *nep,NEPErrorType *etype,PetscViewer *viewer,PetscErrorCode *ierr)neperrorview_235,11542
SLEPC_EXTERN void PETSC_STDCALL nepvaluesview_(NEP *nep,PetscViewer *viewer,PetscErrorCode *ierr)nepvaluesview_242,11766
SLEPC_EXTERN void PETSC_STDCALL nepvectorsview_(NEP *nep,PetscViewer *viewer,PetscErrorCode *ierr)nepvectorsview_249,11965
SLEPC_EXTERN void PETSC_STDCALL nepsettype_(NEP *nep,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))nepsettype_256,12166
SLEPC_EXTERN void PETSC_STDCALL nepgettype_(NEP *nep,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))nepgettype_265,12400
SLEPC_EXTERN void PETSC_STDCALL nepsetoptionsprefix_(NEP *nep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))nepsetoptionsprefix_274,12698
SLEPC_EXTERN void PETSC_STDCALL nepappendoptionsprefix_(NEP *nep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))nepappendoptionsprefix_283,12956
SLEPC_EXTERN void PETSC_STDCALL nepgetoptionsprefix_(NEP *nep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))nepgetoptionsprefix_292,13220
SLEPC_EXTERN void PETSC_STDCALL nepmonitorset_(NEP *nep,void (PETSC_STDCALL *monitor)(NEP*,PetscInt*,PetscInt*,PetscScalar*,PetscScalar*,PetscReal*,PetscInt*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)nepmonitorset_301,13547
SLEPC_EXTERN void PETSC_STDCALL nepconvergedabsolute_(NEP *nep,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)nepconvergedabsolute_322,15486
SLEPC_EXTERN void PETSC_STDCALL nepconvergedrelative_(NEP *nep,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)nepconvergedrelative_327,15721
SLEPC_EXTERN void PETSC_STDCALL nepsetconvergencetestfunction_(NEP *nep,void (PETSC_STDCALL *func)(NEP*,PetscScalar*,PetscScalar*,PetscReal*,PetscReal*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)nepsetconvergencetestfunction_332,15956
SLEPC_EXTERN void PETSC_STDCALL nepstoppingbasic_(NEP *nep,PetscInt *its,PetscInt *max_it,PetscInt *nconv,PetscInt *nev,NEPConvergedReason *reason,void *ctx,PetscErrorCode *ierr)nepstoppingbasic_347,16966
SLEPC_EXTERN void PETSC_STDCALL nepsetstoppingtestfunction_(NEP *nep,void (PETSC_STDCALL *func)(NEP*,PetscInt,PetscInt,PetscInt,PetscInt,NEPConvergedReason*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)nepsetstoppingtestfunction_352,17220
SLEPC_EXTERN void PETSC_STDCALL nepseteigenvaluecomparison_(NEP *nep,void (PETSC_STDCALL *func)(PetscScalar*,PetscScalar*,PetscScalar*,PetscScalar*,PetscInt*,void*),void* ctx,PetscErrorCode *ierr)nepseteigenvaluecomparison_365,18083
SLEPC_EXTERN void PETSC_STDCALL nepsetfunction_(NEP *nep,Mat *A,Mat *B,void (PETSC_STDCALL *func)(NEP*,PetscScalar*,Mat*,Mat*,void*,PetscErrorCode*),void *ctx,PetscErrorCode *ierr PETSC_F90_2PTR_PROTO(ptr))nepsetfunction_372,18539
SLEPC_EXTERN void PETSC_STDCALL nepgetfunction_(NEP *nep,Mat *A,Mat *B,void *func,void **ctx,PetscErrorCode *ierr)nepgetfunction_382,19184
SLEPC_EXTERN void PETSC_STDCALL nepsetjacobian_(NEP *nep,Mat *J,void (PETSC_STDCALL *func)(NEP*,PetscScalar*,Mat*,void*,PetscErrorCode*),void *ctx,PetscErrorCode *ierr PETSC_F90_2PTR_PROTO(ptr))nepsetjacobian_391,19564
SLEPC_EXTERN void PETSC_STDCALL nepgetjacobian_(NEP *nep,Mat *J,void *func,void **ctx,PetscErrorCode *ierr)nepgetjacobian_401,20194
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions_409,20538
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions000_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions000_417,20791
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions100_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions100_422,20954
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions010_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions010_427,21117
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions001_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions001_432,21280
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions110_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions110_437,21443
SLEPC_EXTERN void PETSC_STDCALL nepgetdimensions011_(NEP *nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)nepgetdimensions011_442,21606
SLEPC_EXTERN void PETSC_STDCALL nepgeteigenpair_(NEP *nep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)nepgeteigenpair_447,21769
SLEPC_EXTERN void PETSC_STDCALL nepgeteigenpair00_(NEP *nep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)nepgeteigenpair00_454,22021
SLEPC_EXTERN void PETSC_STDCALL nepgeteigenpair10_(NEP *nep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)nepgeteigenpair10_459,22209
SLEPC_EXTERN void PETSC_STDCALL nepgeteigenpair01_(NEP *nep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)nepgeteigenpair01_464,22397
SLEPC_EXTERN void PETSC_STDCALL nepgeteigenpair11_(NEP *nep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)nepgeteigenpair11_469,22585
SLEPC_EXTERN void PETSC_STDCALL nepgettolerances_(NEP *nep,PetscReal *tol,PetscInt *maxits,int *ierr)nepgettolerances_474,22773
SLEPC_EXTERN void PETSC_STDCALL nepgettolerances00_(NEP *nep,PetscReal *tol,PetscInt *maxits,int *ierr)nepgettolerances00_481,22985
SLEPC_EXTERN void PETSC_STDCALL nepgettolerances10_(NEP *nep,PetscReal *tol,PetscInt *maxits,int *ierr)nepgettolerances10_486,23136
SLEPC_EXTERN void PETSC_STDCALL nepgettolerances01_(NEP *nep,PetscReal *tol,PetscInt *maxits,int *ierr)nepgettolerances01_491,23287
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine_496,23438
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine000_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine000_504,23743
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine100_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine100_509,23959
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine010_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine010_514,24175
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine001_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine001_519,24391
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine110_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine110_524,24607
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine011_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine011_529,24823
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine101_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine101_534,25039
SLEPC_EXTERN void PETSC_STDCALL nepgetrefine111_(NEP *nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme,int *ierr)nepgetrefine111_539,25255
SLEPC_EXTERN void PETSC_STDCALL nepsetinitialspace0_(NEP *nep,PetscInt *n,Vec *is,int *ierr)nepsetinitialspace0_544,25471
SLEPC_EXTERN void PETSC_STDCALL nepsetinitialspace1_(NEP *nep,PetscInt *n,Vec *is,int *ierr)nepsetinitialspace1_550,25639

src/nep/interface/makefile,385
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = nepmon.c nepbasic.c nepview.c nepdefault.c nepregis.c nepopts.c nepsetup.c nepsolve.c neprefine.c nepresolv.c dlregisnep.cSOURCEC15,431
SOURCEF  =SOURCEF16,565
SOURCEH  =SOURCEH17,576
LIBBASE  = libslepcnepLIBBASE18,587
DIRS     =DIRS19,610
MANSEC   = NEPMANSEC20,621
LOCDIR   = src/nep/interface/LOCDIR21,636

src/nep/interface/nepbasic.c,2975
nepbasic.c:^?nepbasic.c^A,1
PetscFunctionList NEPList = 0;NEPList16,490
PetscBool         NEPRegisterAllCalled = PETSC_FALSE;NEPRegisterAllCalled17,521
PetscClassId      NEP_CLASSID = 0;NEP_CLASSID18,575
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_SetUp19,610
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_Solve19,610
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_Refine19,610
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_FunctionEval19,610
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_JacobianEval19,610
PetscLogEvent     NEP_SetUp = 0,NEP_Solve = 0,NEP_Refine = 0,NEP_FunctionEval = 0,NEP_JacobianEval = 0,NEP_Resolvent = 0;NEP_Resolvent19,610
PetscErrorCode NEPCreate(MPI_Comm comm,NEP *outnep)NEPCreate36,988
PetscErrorCode NEPSetType(NEP nep,NEPType type)NEPSetType145,4385
PetscErrorCode NEPGetType(NEP nep,NEPType *type)NEPGetType184,5457
PetscErrorCode NEPRegister(const char *name,PetscErrorCode (*function)(NEP))NEPRegister219,6273
PetscErrorCode NEPReset_Problem(NEP nep)NEPReset_Problem232,6603
PetscErrorCode NEPReset(NEP nep)NEPReset266,7518
PetscErrorCode NEPDestroy(NEP *nep)NEPDestroy297,8378
PetscErrorCode NEPSetBV(NEP nep,BV bv)NEPSetBV342,9891
PetscErrorCode NEPGetBV(NEP nep,BV *bv)NEPGetBV373,10631
PetscErrorCode NEPSetRG(NEP nep,RG rg)NEPSetRG407,11581
PetscErrorCode NEPGetRG(NEP nep,RG *rg)NEPGetRG438,12310
PetscErrorCode NEPSetDS(NEP nep,DS ds)NEPSetDS472,13287
PetscErrorCode NEPGetDS(NEP nep,DS *ds)NEPGetDS503,14030
PetscErrorCode NEPRefineGetKSP(NEP nep,KSP *ksp)NEPRefineGetKSP536,14914
PetscErrorCode NEPSetTarget(NEP nep,PetscScalar target)NEPSetTarget587,16976
PetscErrorCode NEPGetTarget(NEP nep,PetscScalar* target)NEPGetTarget614,17515
PetscErrorCode NEPSetFunction(NEP nep,Mat A,Mat B,PetscErrorCode (*fun)(NEP,PetscScalar,Mat,Mat,void*),void *ctx)NEPSetFunction652,18745
PetscErrorCode NEPGetFunction(NEP nep,Mat *A,Mat *B,PetscErrorCode (**fun)(NEP,PetscScalar,Mat,Mat,void*),void **ctx)NEPGetFunction702,20362
PetscErrorCode NEPSetJacobian(NEP nep,Mat A,PetscErrorCode (*jac)(NEP,PetscScalar,Mat,void*),void *ctx)NEPSetJacobian741,21617
PetscErrorCode NEPGetJacobian(NEP nep,Mat *A,PetscErrorCode (**jac)(NEP,PetscScalar,Mat,void*),void **ctx)NEPGetJacobian783,22923
PetscErrorCode NEPSetSplitOperator(NEP nep,PetscInt n,Mat A[],FN f[],MatStructure str)NEPSetSplitOperator825,24311
PetscErrorCode NEPGetSplitOperatorTerm(NEP nep,PetscInt k,Mat *A,FN *f)NEPGetSplitOperatorTerm883,26355
PetscErrorCode NEPGetSplitOperatorInfo(NEP nep,PetscInt *n,MatStructure *str)NEPGetSplitOperatorInfo911,27210

src/nep/interface/nepdefault.c,847
nepdefault.c:^?nepdefault.c^A,1
PetscErrorCode NEPSetWorkVecs(NEP nep,PetscInt nw)NEPSetWorkVecs31,855
PetscErrorCode NEPGetDefaultShift(NEP nep,PetscScalar *sigma)NEPGetDefaultShift51,1439
PetscErrorCode NEPConvergedRelative(NEP nep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)NEPConvergedRelative84,2231
PetscErrorCode NEPConvergedAbsolute(NEP nep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)NEPConvergedAbsolute97,2539
PetscErrorCode NEPConvergedNorm(NEP nep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)NEPConvergedNorm107,2806
PetscErrorCode NEPStoppingBasic(NEP nep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,NEPConvergedReason *reason,void *ctx)NEPStoppingBasic165,4900
PetscErrorCode NEPComputeVectors_Schur(NEP nep)NEPComputeVectors_Schur181,5535

src/nep/interface/nepmon.c,1569
nepmon.c:^?nepmon.c^A,1
PetscErrorCode NEPMonitor(NEP nep,PetscInt it,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest)NEPMonitor20,585
PetscErrorCode NEPMonitorSet(NEP nep,PetscErrorCode (*monitor)(NEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))NEPMonitorSet80,2960
PetscErrorCode NEPMonitorCancel(NEP nep)NEPMonitorCancel108,4011
PetscErrorCode NEPGetMonitorContext(NEP nep,void **ctx)NEPGetMonitorContext140,4720
PetscErrorCode NEPMonitorAll(NEP nep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)NEPMonitorAll168,5512
PetscErrorCode NEPMonitorFirst(NEP nep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)NEPMonitorFirst222,7820
PetscErrorCode NEPMonitorConverged(NEP nep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,SlepcConvMonitor ctx)NEPMonitorConverged274,10038
PetscErrorCode NEPMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)NEPMonitorLGCreate339,12544
PetscErrorCode NEPMonitorLG(NEP nep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)NEPMonitorLG355,13090
PetscErrorCode NEPMonitorLGAll(NEP nep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)NEPMonitorLGAll379,13936

src/nep/interface/nepopts.c,3276
nepopts.c:^?nepopts.c^A,1
PetscErrorCode NEPMonitorSetFromOptions(NEP nep,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(NEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscBool trackall)NEPMonitorSetFromOptions36,1176
PetscErrorCode NEPConvMonitorSetFromOptions(NEP nep,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(NEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,SlepcConvMonitor))NEPConvMonitorSetFromOptions74,2800
PetscErrorCode NEPSetFromOptions(NEP nep)NEPSetFromOptions107,4090
PetscErrorCode NEPGetTolerances(NEP nep,PetscReal *tol,PetscInt *maxits)NEPGetTolerances286,15762
PetscErrorCode NEPSetTolerances(NEP nep,PetscReal tol,PetscInt maxits)NEPSetTolerances317,16598
PetscErrorCode NEPGetDimensions(NEP nep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)NEPGetDimensions361,17936
PetscErrorCode NEPSetDimensions(NEP nep,PetscInt nev,PetscInt ncv,PetscInt mpd)NEPSetDimensions405,19436
PetscErrorCode NEPSetWhichEigenpairs(NEP nep,NEPWhich which)NEPSetWhichEigenpairs482,22607
PetscErrorCode NEPGetWhichEigenpairs(NEP nep,NEPWhich *which)NEPGetWhichEigenpairs531,23842
PetscErrorCode NEPSetEigenvalueComparison(NEP nep,PetscErrorCode (*func)(PetscScalar,PetscScalar,PetscScalar,PetscScalar,PetscInt*,void*),void* ctx)NEPSetEigenvalueComparison571,25152
PetscErrorCode NEPSetProblemType(NEP nep,NEPProblemType type)NEPSetProblemType606,26359
PetscErrorCode NEPGetProblemType(NEP nep,NEPProblemType *type)NEPGetProblemType634,27095
PetscErrorCode NEPSetTwoSided(NEP nep,PetscBool twosided)NEPSetTwoSided668,28110
PetscErrorCode NEPGetTwoSided(NEP nep,PetscBool *twosided)NEPGetTwoSided696,28726
PetscErrorCode NEPSetConvergenceTestFunction(NEP nep,PetscErrorCode (*func)(NEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*),void* ctx,PetscErrorCode (*destroy)(void*))NEPSetConvergenceTestFunction735,30081
PetscErrorCode NEPSetConvergenceTest(NEP nep,NEPConv conv)NEPSetConvergenceTest783,31803
PetscErrorCode NEPGetConvergenceTest(NEP nep,NEPConv *conv)NEPGetConvergenceTest819,32947
PetscErrorCode NEPSetStoppingTestFunction(NEP nep,PetscErrorCode (*func)(NEP,PetscInt,PetscInt,PetscInt,PetscInt,NEPConvergedReason*,void*),void* ctx,PetscErrorCode (*destroy)(void*))NEPSetStoppingTestFunction861,34456
PetscErrorCode NEPSetStoppingTest(NEP nep,NEPStop stop)NEPSetStoppingTest904,35808
PetscErrorCode NEPGetStoppingTest(NEP nep,NEPStop *stop)NEPGetStoppingTest938,36794
PetscErrorCode NEPSetTrackAll(NEP nep,PetscBool trackall)NEPSetTrackAll969,37700
PetscErrorCode NEPGetTrackAll(NEP nep,PetscBool *trackall)NEPGetTrackAll994,38224
PetscErrorCode NEPSetRefine(NEP nep,NEPRefine refine,PetscInt npart,PetscReal tol,PetscInt its,NEPRefineScheme scheme)NEPSetRefine1051,40495
PetscErrorCode NEPGetRefine(NEP nep,NEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,NEPRefineScheme *scheme)NEPGetRefine1117,42721
PetscErrorCode NEPSetOptionsPrefix(NEP nep,const char *prefix)NEPSetOptionsPrefix1155,43838
PetscErrorCode NEPAppendOptionsPrefix(NEP nep,const char *prefix)NEPAppendOptionsPrefix1189,44987
PetscErrorCode NEPGetOptionsPrefix(NEP nep,const char *prefix[])NEPGetOptionsPrefix1225,46108

src/nep/interface/neprefine.c,1343
neprefine.c:^?neprefine.c^A,1
#define NREF_MAXIT NREF_MAXIT17,516
  VecScatter    *scatter_id,nst;scatter_id20,556
  VecScatter    *scatter_id,nst;nst20,556
  Mat           *A;A21,589
  Vec           nv,vg,v,w;nv22,609
  Vec           nv,vg,v,w;vg22,609
  Vec           nv,vg,v,w;v22,609
  Vec           nv,vg,v,w;w22,609
  FN            *fn;fn23,636
} NEPSimpNRefctx;NEPSimpNRefctx24,657
  Mat          M1;M127,693
  Vec          M2,M3;M228,712
  Vec          M2,M3;M328,712
  PetscScalar  M4,m3;M429,734
  PetscScalar  M4,m3;m329,734
} FSubctx;FSubctx30,756
static PetscErrorCode MatFSMult(Mat M ,Vec x,Vec y)MatFSMult32,768
static PetscErrorCode NEPSimpleNRefSetUp(NEP nep,NEPSimpNRefctx **ctx_)NEPSimpleNRefSetUp47,1151
static PetscErrorCode NEPSimpleNRefGatherEigenpair(NEP nep,NEPSimpNRefctx *ctx,PetscInt sc,PetscInt idx,PetscInt *fail)NEPSimpleNRefGatherEigenpair130,4486
static PetscErrorCode NEPSimpleNRefScatterEigenvector(NEP nep,NEPSimpNRefctx *ctx,PetscInt sc,PetscInt idx)NEPSimpleNRefScatterEigenvector169,6085
static PetscErrorCode NEPSimpleNRefSetUpSystem(NEP nep,NEPSimpNRefctx *ctx,Mat *A,PetscInt idx,Mat *Mt,Mat *T,Mat *P,PetscBool ini,Vec t,Vec v)NEPSimpleNRefSetUpSystem193,6965
PetscErrorCode NEPNewtonRefinementSimple(NEP nep,PetscInt *maxits,PetscReal tol,PetscInt k)NEPNewtonRefinementSimple368,13692

src/nep/interface/nepregis.c,58
nepregis.c:^?nepregis.c^A,1
PetscErrorCode NEPRegisterAll(void)NEPRegisterAll31,943

src/nep/interface/nepresolv.c,772
nepresolv.c:^?nepresolv.c^A,1
  NEP              nep;nep17,568
  RG               rg;rg18,592
  PetscScalar      omega;omega19,615
  PetscScalar      *nfactor;         /* normalization factors y_i'*T'(lambda_i)*x_i */nfactor20,641
  PetscBool        *nfactor_avail;nfactor_avail21,728
  PetscScalar      *dots;            /* inner products y_i'*v */dots22,763
  PetscBool        *dots_avail;dots_avail23,828
  PetscObjectId    vid;vid24,860
  PetscObjectState vstate;vstate25,884
} ResolventCtx;ResolventCtx26,911
static PetscErrorCode MatMult_Resolvent(Mat M,Vec v,Vec r)MatMult_Resolvent28,928
static PetscErrorCode MatDestroy_Resolvent(Mat M)MatDestroy_Resolvent73,2523
PetscErrorCode NEPApplyResolvent(NEP nep,RG rg,PetscScalar omega,Vec v,Vec r)NEPApplyResolvent113,3780

src/nep/interface/nepsetup.c,353
nepsetup.c:^?nepsetup.c^A,1
PetscErrorCode NEPSetUp(NEP nep)NEPSetUp34,959
PetscErrorCode NEPSetInitialSpace(NEP nep,PetscInt n,Vec is[])NEPSetInitialSpace236,8900
PetscErrorCode NEPSetDimensions_Default(NEP nep,PetscInt nev,PetscInt *ncv,PetscInt *mpd)NEPSetDimensions_Default257,9580
PetscErrorCode NEPAllocateSolution(NEP nep,PetscInt extra)NEPAllocateSolution292,10627

src/nep/interface/nepsolve.c,1634
nepsolve.c:^?nepsolve.c^A,1
PetscErrorCode NEPComputeVectors(NEP nep)NEPComputeVectors18,601
PetscErrorCode NEPSolve(NEP nep)NEPSolve51,1589
PetscErrorCode NEPProjectOperator(NEP nep,PetscInt j0,PetscInt j1)NEPProjectOperator128,4147
PetscErrorCode NEPApplyFunction(NEP nep,PetscScalar lambda,Vec x,Vec v,Vec y,Mat A,Mat B)NEPApplyFunction176,5656
PetscErrorCode NEPApplyAdjoint(NEP nep,PetscScalar lambda,Vec x,Vec v,Vec y,Mat A,Mat B)NEPApplyAdjoint225,7155
PetscErrorCode NEPApplyJacobian(NEP nep,PetscScalar lambda,Vec x,Vec v,Vec y,Mat A)NEPApplyJacobian283,9050
PetscErrorCode NEPGetIterationNumber(NEP nep,PetscInt *its)NEPGetIterationNumber335,10677
PetscErrorCode NEPGetConverged(NEP nep,PetscInt *nconv)NEPGetConverged362,11241
PetscErrorCode NEPGetConvergedReason(NEP nep,NEPConvergedReason *reason)NEPGetConvergedReason401,12352
PetscErrorCode NEPGetEigenpair(NEP nep,PetscInt i,PetscScalar *eigr,PetscScalar *eigi,Vec Vr,Vec Vi)NEPGetEigenpair446,13910
PetscErrorCode NEPGetLeftEigenvector(NEP nep,PetscInt i,Vec Wr,Vec Wi)NEPGetLeftEigenvector509,15994
PetscErrorCode NEPGetErrorEstimate(NEP nep,PetscInt i,PetscReal *errest)NEPGetErrorEstimate549,17331
PetscErrorCode NEPComputeResidualNorm_Private(NEP nep,PetscBool adj,PetscScalar lambda,Vec x,Vec *w,PetscReal *norm)NEPComputeResidualNorm_Private570,18065
PetscErrorCode NEPComputeError(NEP nep,PetscInt i,NEPErrorType type,PetscReal *error)NEPComputeError610,19200
PetscErrorCode NEPComputeFunction(NEP nep,PetscScalar lambda,Mat A,Mat B)NEPComputeFunction713,22436
PetscErrorCode NEPComputeJacobian(NEP nep,PetscScalar lambda,Mat A)NEPComputeJacobian764,24011

src/nep/interface/nepview.c,1462
nepview.c:^?nepview.c^A,1
PetscErrorCode NEPView(NEP nep,PetscViewer viewer)NEPView44,1303
PetscErrorCode NEPReasonView(NEP nep,PetscViewer viewer)NEPReasonView215,9044
PetscErrorCode NEPReasonViewFromOptions(NEP nep)NEPReasonViewFromOptions245,10283
static PetscErrorCode NEPErrorView_ASCII(NEP nep,NEPErrorType etype,PetscViewer viewer)NEPErrorView_ASCII267,11042
static PetscErrorCode NEPErrorView_DETAIL(NEP nep,NEPErrorType etype,PetscViewer viewer)NEPErrorView_DETAIL307,12714
#define EXLEN EXLEN313,12902
static PetscErrorCode NEPErrorView_MATLAB(NEP nep,NEPErrorType etype,PetscViewer viewer)NEPErrorView_MATLAB350,14182
PetscErrorCode NEPErrorView(NEP nep,NEPErrorType etype,PetscViewer viewer)NEPErrorView394,15662
PetscErrorCode NEPErrorViewFromOptions(NEP nep)NEPErrorViewFromOptions440,17127
static PetscErrorCode NEPValuesView_DRAW(NEP nep,PetscViewer viewer)NEPValuesView_DRAW476,18777
static PetscErrorCode NEPValuesView_ASCII(NEP nep,PetscViewer viewer)NEPValuesView_ASCII506,19701
static PetscErrorCode NEPValuesView_MATLAB(NEP nep,PetscViewer viewer)NEPValuesView_MATLAB523,20272
PetscErrorCode NEPValuesView(NEP nep,PetscViewer viewer)NEPValuesView568,21490
PetscErrorCode NEPValuesViewFromOptions(NEP nep)NEPValuesViewFromOptions615,23023
PetscErrorCode NEPVectorsView(NEP nep,PetscViewer viewer)NEPVectorsView662,24528
#define NMLEN NMLEN667,24653
PetscErrorCode NEPVectorsViewFromOptions(NEP nep)NEPVectorsViewFromOptions712,26163

src/nep/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/nepimpl.h ../../include/slepcnep.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/nep/LOCDIR15,527
MANSEC   = NEPMANSEC16,547

src/pep/examples/makefile,88
makefile:^?makefile^A,1
LOCDIR   = src/pep/examples/LOCDIR13,405
DIRS     = tests tutorials nlevpDIRS14,434

src/pep/examples/nlevp/acoustic_wave_1d.c,143
acoustic_wave_1d.c:^?acoustic_wave_1d.c^A,1
static char help[] = "Quadratic eigenproblem from an acoustics application (1-D).\n\n"help24,991
int main(int argc,char **argv)main31,1249

src/pep/examples/nlevp/acoustic_wave_2d.c,143
acoustic_wave_2d.c:^?acoustic_wave_2d.c^A,1
static char help[] = "Quadratic eigenproblem from an acoustics application (2-D).\n\n"help22,863
int main(int argc,char **argv)main29,1142

src/pep/examples/nlevp/butterfly.c,165
butterfly.c:^?butterfly.c^A,1
static char help[] = "Quartic polynomial eigenproblem with T-even structure.\n\n"help21,822
#define NMAT NMAT28,1114
int main(int argc,char **argv)main30,1130

src/pep/examples/nlevp/damped_beam.c,145
damped_beam.c:^?damped_beam.c^A,1
static char help[] = "Quadratic eigenproblem from the vibrarion analysis of a beam.\n\n"help22,890
int main(int argc,char **argv)main28,1088

src/pep/examples/nlevp/loaded_string.c,161
loaded_string.c:^?loaded_string.c^A,1
static char help[] = "Finite element model of a loaded vibrating string.\n\n"help24,993
#define NMAT NMAT32,1276
int main(int argc,char **argv)main34,1292

src/pep/examples/nlevp/makefile,404
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/pep/examples/nlevp/LOCDIR15,451
EXAMPLESC  = acoustic_wave_1d.c acoustic_wave_2d.c butterfly.c damped_beam.c \EXAMPLESC16,488
EXAMPLESF  =EXAMPLESF18,661
MANSEC     = PEPMANSEC19,674
TESTS      = acoustic_wave_1d acoustic_wave_2d butterfly damped_beam \TESTS20,691

src/pep/examples/nlevp/pdde_stability.c,313
pdde_stability.c:^?pdde_stability.c^A,1
static char help[] = "Stability analysis of a discretized partial delay-differential equation.\n\n"help23,931
#define NMAT NMAT30,1236
PetscErrorCode MyEigenSort(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)MyEigenSort39,1545
int main(int argc,char **argv)main50,1877

src/pep/examples/nlevp/planar_waveguide.c,208
planar_waveguide.c:^?planar_waveguide.c^A,1
static char help[] = "FEM solution of the propagation constants in a six-layer planar waveguide.\n\n"help23,938
#define NMAT NMAT29,1150
#define NL NL30,1165
int main(int argc,char **argv)main32,1181

src/pep/examples/nlevp/sleeper.c,133
sleeper.c:^?sleeper.c^A,1
static char help[] = "Oscillations of a rail track resting on sleepers.\n\n"help22,879
int main(int argc,char **argv)main28,1074

src/pep/examples/nlevp/spring.c,126
spring.c:^?spring.c^A,1
static char help[] = "FEM model of a damped mass-spring system.\n\n"help25,1127
int main(int argc,char **argv)main34,1490

src/pep/examples/nlevp/wiresaw.c,117
wiresaw.c:^?wiresaw.c^A,1
static char help[] = "Vibration analysis of a wiresaw.\n\n"help28,1199
int main(int argc,char **argv)main36,1497

src/pep/examples/tests/makefile,438
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/pep/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c \EXAMPLESC16,488
EXAMPLESF  = test3f.FEXAMPLESF18,606
MANSEC     = PEPMANSEC19,628
TESTS      = test1 test2 test3 test3f test4 test5 test6 test7 test8 test9 test10 test11TESTS20,645

src/pep/examples/tests/test1.c,162
test1.c:^?test1.c^A,1
static char help[] = "Test the solution of a PEP without calling PEPSetFromOptions (based on ex16.c).\n\n"help11,400
int main(int argc,char **argv)main20,820

src/pep/examples/tests/test10.c,284
test10.c:^?test10.c^A,1
static char help[] = "Tests a user-defined convergence test in PEP (based on ex16.c).\n\n"help11,400
PetscErrorCode MyConvergedRel(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)MyConvergedRel21,782
int main(int argc,char **argv)main30,1010

src/pep/examples/tests/test11.c,527
test11.c:^?test11.c^A,1
static char help[] = "Illustrates the use of a user-defined stopping test.\n\n"help22,868
  PetscInt    lastnconv;      /* last value of nconv; used in stopping test */lastnconv37,1391
  PetscInt    nreps;          /* number of repetitions of nconv; used in stopping test */nreps38,1470
} CTX_SPRING;CTX_SPRING39,1560
int main(int argc,char **argv)main41,1575
PetscErrorCode MyStoppingTest(PEP pep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,PEPConvergedReason *reason,void *ptr)MyStoppingTest184,7454

src/pep/examples/tests/test2.c,138
test2.c:^?test2.c^A,1
static char help[] = "Test the solution of a PEP from a finite element model of "help22,868
int main(int argc,char **argv)main33,1355

src/pep/examples/tests/test3.c,113
test3.c:^?test3.c^A,1
static char help[] = "Test PEP interface functions.\n\n";help11,400
int main(int argc,char **argv)main15,482

src/pep/examples/tests/test3f.F,999
test3f.F:^?test3f.F^A,1
      program mainmain14,541
 100  format (/'Diagonal Quadratic Eigenproblem, n =',I3,' (Fortran)')10057,1926
 110  format (' Polynomial of degree ',I2)110106,3833
 120  format (' Type set to ',A)120116,4120
 130  format (' Problem type before changing = ',I2)130122,4266
 140  format (' ... changed to ',I2)140128,4484
 150  format (' Extraction before changing = ',I2)150134,4628
 160  format (' ... changed to ',I2)160140,4843
 170  format (' Scaling: ',I2,', alpha=',F7.4,', its=',I2)170153,5294
 180  format (' Polynomial basis: ',I2)180161,5534
 190  format (' Refinement: ',I2,', tol=',F7.4,', its=',I2', schem=',I2)190173,5896
 200  format (' Which = ',I2,', target = ',F4.1)200183,6265
 210  format (' Dimensions: nev=',I2,', ncv=',I2,', mpd=',I2)210192,6582
 220  format (' Tolerance =',F8.5,', max_its =',I4)220201,6841
 230  format (' Convergence test =',I2,', stopping test =',I2)230210,7167
 240  format (' Finished - converged reason =',I2)240238,8338

src/pep/examples/tests/test4.c,149
test4.c:^?test4.c^A,1
static char help[] = "Solve a quadratic problem with PEPLINEAR with a user-provided EPS.\n\n"help11,400
int main(int argc,char **argv)main18,701

src/pep/examples/tests/test5.c,124
test5.c:^?test5.c^A,1
static char help[] = "Test PEP view and monitor functionality.\n\n";help11,400
int main(int argc,char **argv)main15,493

src/pep/examples/tests/test6.c,157
test6.c:^?test6.c^A,1
static char help[] = "Tests multiple calls to PEPSolve with different matrix of different size.\n\n"help22,868
int main(int argc,char **argv)main33,1374

src/pep/examples/tests/test7.c,134
test7.c:^?test7.c^A,1
static char help[] = "Test interface functions of spectrum-slicing STOAR.\n\n"help11,400
int main(int argc,char **argv)main17,613

src/pep/examples/tests/test8.c,125
test8.c:^?test8.c^A,1
static char help[] = "Test interface functions of polynomial JD.\n\n"help11,400
int main(int argc,char **argv)main18,702

src/pep/examples/tests/test9.c,288
test9.c:^?test9.c^A,1
static char help[] = "Illustrates use of PEPSetEigenvalueComparison().\n\n"help11,400
#define NMAT NMAT18,708
PetscErrorCode MyEigenSort(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)MyEigenSort28,1041
int main(int argc,char **argv)main42,1446

src/pep/examples/tutorials/ex16.c,119
ex16.c:^?ex16.c^A,1
static char help[] = "Simple quadratic eigenvalue problem.\n\n"help11,400
int main(int argc,char **argv)main18,671

src/pep/examples/tutorials/ex16f90.F90,233
ex16f90.F90:^?ex16f90.F90^A,1
      program mainmain21,865
 100  format (/'Quadratic Eigenproblem, N=',I6,' (',I4,'x',I4,' grid)')10064,2262
 120  format (' Solution method: ',A)120161,6192
 130  format (' Number of requested eigenvalues:',I4)130166,6389

src/pep/examples/tutorials/ex17.c,201
ex17.c:^?ex17.c^A,1
static char help[] = "Solves a polynomial eigenproblem P(l)x = 0 with matrices loaded from a file.\n\n"help11,400
#define MAX_MATRICES MAX_MATRICES17,673
int main(int argc,char **argv)main19,698

src/pep/examples/tutorials/ex28.c,699
ex28.c:^?ex28.c^A,1
static char help[] = "A quadratic eigenproblem defined using shell matrices.\n\n"help11,400
int main(int argc,char **argv)main27,978
static void tv(int nx,const PetscScalar *x,PetscScalar *y)tv131,5550
PetscErrorCode MatMult_Laplacian2D(Mat A,Vec x,Vec y)MatMult_Laplacian2D162,6311
PetscErrorCode MatGetDiagonal_Laplacian2D(Mat A,Vec diag)MatGetDiagonal_Laplacian2D194,7108
PetscErrorCode MatMult_Zero(Mat A,Vec x,Vec y)MatMult_Zero206,7353
PetscErrorCode MatGetDiagonal_Zero(Mat A,Vec diag)MatGetDiagonal_Zero215,7519
PetscErrorCode MatMult_Identity(Mat A,Vec x,Vec y)MatMult_Identity227,7761
PetscErrorCode MatGetDiagonal_Identity(Mat A,Vec diag)MatGetDiagonal_Identity236,7933

src/pep/examples/tutorials/ex38.c,136
ex38.c:^?ex38.c^A,1
static char help[] = "Spectrum slicing on quadratic symmetric eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main17,590

src/pep/examples/tutorials/ex40.c,1135
ex40.c:^?ex40.c^A,1
static char help[] = "Checking the definite property in quadratic symmetric eigenproblem.\n\n"help11,400
int main(int argc,char **argv)main30,1324
static PetscErrorCode QEPDefiniteTransformMap_Initial(PetscBool hyperbolic,PetscReal xi,PetscReal mu,PetscInt n,PetscScalar *val,PetscBool backtransform)QEPDefiniteTransformMap_Initial261,10969
PetscErrorCode QEPDefiniteTransformMap(PetscBool hyperbolic,PetscReal xi,PetscReal mu,PetscInt n,PetscScalar *val,PetscBool backtransform)QEPDefiniteTransformMap283,11807
PetscErrorCode TransformMatricesMoebius(Mat A[3],MatStructure str,PetscReal a,PetscReal b,PetscReal c,PetscReal d,Mat B[3])TransformMatricesMoebius311,12693
PetscErrorCode QEPDefiniteTransformGetMatrices(PEP pep,PetscBool hyperbolic,PetscReal xi,PetscReal mu,Mat T[3])QEPDefiniteTransformGetMatrices348,13935
static PetscErrorCode PEPResidualNorm(Mat *A,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec *z,PetscReal *norm)PEPResidualNorm379,14949
PetscErrorCode QEPDefiniteCheckError(Mat *A,PEP pep,PetscBool hyperbolic,PetscReal xi,PetscReal mu)QEPDefiniteCheckError454,16982
#define EXLEN EXLEN462,17237

src/pep/examples/tutorials/makefile,298
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/pep/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex16.c ex17.c ex28.c ex38.cEXAMPLESC16,492
EXAMPLESF  = ex16f90.F90EXAMPLESF17,533
MANSEC     = PEPMANSEC18,558

src/pep/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcpepmod.FSOURCEF17,514
SOURCEH    = slepcpep.h slepcpep.h90SOURCEH18,541
LIBBASE    = libslepcpepLIBBASE19,578
MANSEC     = PEPMANSEC20,603
LOCDIR     = src/pep/f90-mod/LOCDIR21,620
CLEANFILES = *.modCLEANFILES22,650

src/pep/f90-mod/slepcpep.h,146
slepcpep.h:^?slepcpep.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      PEP, parameter :: SLEPC_NULL_PEP = tPEP(0)PEP18,593

src/pep/f90-mod/slepcpepmod.F,86
slepcpepmod.F:^?slepcpepmod.F^A,1
        module slepcpepdefslepcpepdef10,398
        module slepcpepslepcpep19,599

src/pep/impls/jd/makefile,267
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = pjd.cSOURCEC15,431
SOURCEF  =SOURCEF16,448
SOURCEH  =SOURCEH17,459
LIBBASE  = libslepcpepLIBBASE18,470
DIRS     =DIRS19,493
MANSEC   = PEPMANSEC20,504
LOCDIR   = src/pep/impls/jd/LOCDIR21,519

src/pep/impls/jd/pjd.c,7163
pjd.c:^?pjd.c^A,1
static PetscBool  cited = PETSC_FALSE;cited38,1280
static const char citation[] =citation39,1319
  PetscReal   keep;          /* restart parameter */keep52,1778
  PetscReal   fix;           /* fix parameter */fix53,1831
  PetscBool   reusepc;       /* flag indicating whether pc is rebuilt or not */reusepc54,1880
  BV          V;             /* work basis vectors to store the search space */V55,1960
  BV          W;             /* work basis vectors to store the test space */W56,2040
  BV          *TV;           /* work basis vectors to store T*V (each TV[i] is the coefficient for \lambda^i of T*V for the extended T) */TV57,2118
  BV          *AX;           /* work basis vectors to store A_i*X for locked eigenvectors */AX58,2257
  BV          N[2];          /* auxiliary work BVs */N59,2350
  BV          X;             /* locked eigenvectors */X60,2404
  PetscScalar *T;            /* matrix of the invariant pair */T61,2459
  PetscScalar *Tj;           /* matrix containing the powers of the invariant pair matrix */Tj62,2523
  PetscScalar *XpX;          /* X^H*X */XpX63,2616
  PetscInt    ld;            /* leading dimension for Tj and XpX */ld64,2657
  PC          pcshell;       /* preconditioner including basic precond+projector */pcshell65,2725
  Mat         Pshell;        /* auxiliary shell matrix */Pshell66,2809
  PetscInt    nlock;         /* number of locked vectors in the invariant pair */nlock67,2867
  Vec         vtempl;        /* reference nested vector */vtempl68,2949
  PetscInt    midx;          /* minimality index */midx69,3008
  PetscInt    mmidx;         /* maximum allowed minimality index */mmidx70,3060
  PEPJDProjection proj;      /* projection type (orthogonal, harmonic) */proj71,3128
} PEP_JD;PEP_JD72,3202
  PEP         pep;pep75,3230
  PC          pc;            /* basic preconditioner */pc76,3249
  Vec         Bp[2];         /* preconditioned residual of derivative polynomial, B\p */Bp77,3305
  Vec         u[2];          /* Ritz vector */u78,3394
  PetscScalar gamma[2];      /* precomputed scalar u'*B\p */gamma79,3441
  PetscScalar theta;theta80,3502
  PetscScalar *M;M81,3523
  PetscScalar *ps;ps82,3541
  PetscInt    ld;ld83,3560
  Vec         *work;work84,3578
  Mat         PPr;PPr85,3599
  BV          X;X86,3618
  PetscInt    n;n87,3635
} PEP_JD_PCSHELL;PEP_JD_PCSHELL88,3652
  Mat         Pr,Pi;         /* matrix polynomial evaluated at theta */Pr91,3688
  Mat         Pr,Pi;         /* matrix polynomial evaluated at theta */Pi91,3688
  PEP         pep;pep92,3760
  Vec         *work;work93,3779
  PetscScalar theta[2];theta94,3800
} PEP_JD_MATSHELL;PEP_JD_MATSHELL95,3824
static PetscErrorCode PEPJDDuplicateBasis(PEP pep,BV *basis)PEPJDDuplicateBasis100,3890
PetscErrorCode PEPSetUp_JD(PEP pep)PEPSetUp_JD128,4891
static PetscErrorCode PEPJDUpdateTV(PEP pep,PetscInt low,PetscInt high,Vec *w)PEPJDUpdateTV187,7486
static PetscErrorCode PEPJDOrthogonalize(PetscInt row,PetscInt col,PetscScalar *X,PetscInt ldx,PetscInt *rk,PetscInt *P,PetscScalar *R,PetscInt ldr)PEPJDOrthogonalize291,12305
static PetscErrorCode PEPJDExtendedPCApply(PC pc,Vec x,Vec y)PEPJDExtendedPCApply349,14235
static PetscErrorCode PCShellApply_PEPJD(PC pc,Vec x,Vec y)PCShellApply_PEPJD418,16802
static PetscErrorCode PEPJDCopyToExtendedVec(PEP pep,Vec v,PetscScalar *a,PetscInt na,PetscInt off,Vec vex,PetscBool back)PEPJDCopyToExtendedVec468,18367
static PetscErrorCode PEPJDEvaluateHatBasis(PEP pep,PetscInt n,PetscScalar *H,PetscInt ldh,PetscScalar *beval,PetscScalar *t,PetscInt idx,PetscScalar *qpp,PetscScalar *qp,PetscScalar *q)PEPJDEvaluateHatBasis509,19984
static PetscErrorCode PEPJDComputeResidual(PEP pep,PetscBool derivative,PetscInt sz,Vec *u,PetscScalar *theta,Vec *p,Vec *work)PEPJDComputeResidual550,21358
static PetscErrorCode PEPJDProcessInitialSpace(PEP pep,Vec *w)PEPJDProcessInitialSpace708,27827
static PetscErrorCode PEPJDShellMatMult(Mat P,Vec x,Vec y)PEPJDShellMatMult743,29315
static PetscErrorCode PEPJDSellMatCreateVecs(Mat A,Vec *right,Vec *left)PEPJDSellMatCreateVecs885,35261
static PetscErrorCode PEPJDUpdateExtendedPC(PEP pep,PetscScalar theta)PEPJDUpdateExtendedPC914,36011
static PetscErrorCode PEPJDMatSetUp(PEP pep,PetscInt sz,PetscScalar *theta)PEPJDMatSetUp994,39293
static PetscErrorCode PEPJDCreateShellPC(PEP pep,Vec *ww)PEPJDCreateShellPC1059,41547
static PetscErrorCode PEPJDEigenvectors(PEP pep)PEPJDEigenvectors1131,44501
static PetscErrorCode PEPJDLockConverged(PEP pep,PetscInt *nv,PetscInt sz)PEPJDLockConverged1183,46472
PetscErrorCode PEPJDSystemSetUp(PEP pep,PetscInt sz,PetscScalar *theta,Vec *u,Vec *p,Vec *ww)PEPJDSystemSetUp1270,50350
PetscErrorCode PEPSolve_JD(PEP pep)PEPSolve_JD1303,51512
PetscErrorCode PEPJDSetRestart_JD(PEP pep,PetscReal keep)PEPJDSetRestart_JD1583,64365
PetscErrorCode PEPJDSetRestart(PEP pep,PetscReal keep)PEPJDSetRestart1617,65265
PetscErrorCode PEPJDGetRestart_JD(PEP pep,PetscReal *keep)PEPJDGetRestart_JD1628,65582
PetscErrorCode PEPJDGetRestart(PEP pep,PetscReal *keep)PEPJDGetRestart1652,66028
PetscErrorCode PEPJDSetFix_JD(PEP pep,PetscReal fix)PEPJDSetFix_JD1663,66333
PetscErrorCode PEPJDSetFix(PEP pep,PetscReal fix)PEPJDSetFix1698,67232
PetscErrorCode PEPJDGetFix_JD(PEP pep,PetscReal *fix)PEPJDGetFix_JD1709,67538
PetscErrorCode PEPJDGetFix(PEP pep,PetscReal *fix)PEPJDGetFix1739,68202
PetscErrorCode PEPJDSetReusePreconditioner_JD(PEP pep,PetscBool reusepc)PEPJDSetReusePreconditioner_JD1750,68496
PetscErrorCode PEPJDSetReusePreconditioner(PEP pep,PetscBool reusepc)PEPJDSetReusePreconditioner1781,69319
PetscErrorCode PEPJDGetReusePreconditioner_JD(PEP pep,PetscBool *reusepc)PEPJDGetReusePreconditioner_JD1792,69669
PetscErrorCode PEPJDGetReusePreconditioner(PEP pep,PetscBool *reusepc)PEPJDGetReusePreconditioner1816,70142
PetscErrorCode PEPJDSetMinimalityIndex_JD(PEP pep,PetscInt mmidx)PEPJDSetMinimalityIndex_JD1827,70480
PetscErrorCode PEPJDSetMinimalityIndex(PEP pep,PetscInt mmidx)PEPJDSetMinimalityIndex1861,71426
PetscErrorCode PEPJDGetMinimalityIndex_JD(PEP pep,PetscInt *mmidx)PEPJDGetMinimalityIndex_JD1872,71759
PetscErrorCode PEPJDGetMinimalityIndex(PEP pep,PetscInt *mmidx)PEPJDGetMinimalityIndex1897,72226
PetscErrorCode PEPJDSetProjection_JD(PEP pep,PEPJDProjection proj)PEPJDSetProjection_JD1908,72547
PetscErrorCode PEPJDSetProjection(PEP pep,PEPJDProjection proj)PEPJDSetProjection1943,73415
PetscErrorCode PEPJDGetProjection_JD(PEP pep,PEPJDProjection *proj)PEPJDGetProjection_JD1954,73750
PetscErrorCode PEPJDGetProjection(PEP pep,PEPJDProjection *proj)PEPJDGetProjection1978,74216
PetscErrorCode PEPSetFromOptions_JD(PetscOptionItems *PetscOptionsObject,PEP pep)PEPSetFromOptions_JD1989,74535
PetscErrorCode PEPView_JD(PEP pep,PetscViewer viewer)PEPView_JD2019,76032
PetscErrorCode PEPSetDefaultST_JD(PEP pep)PEPSetDefaultST_JD2037,76962
PetscErrorCode PEPReset_JD(PEP pep)PEPReset_JD2056,77562
PetscErrorCode PEPDestroy_JD(PEP pep)PEPDestroy_JD2080,78275
SLEPC_EXTERN PetscErrorCode PEPCreate_JD(PEP pep)PEPCreate_JD2099,79413

src/pep/impls/krylov/makefile,309
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = pepkrylov.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  = pepkrylov.hSOURCEH17,465
LIBBASE  = libslepcpepLIBBASE18,488
DIRS     = qarnoldi toar stoarDIRS19,511
LOCDIR   = src/pep/impls/krylov/LOCDIR20,542
MANSEC   = PEPMANSEC21,575

src/pep/impls/krylov/pepkrylov.c,227
pepkrylov.c:^?pepkrylov.c^A,1
PetscErrorCode PEPExtractVectors_TOAR(PEP pep)PEPExtractVectors_TOAR18,572
PetscErrorCode PEPKrylovConvergence(PEP pep,PetscBool getall,PetscInt kini,PetscInt nits,PetscReal beta,PetscInt *kout)PEPKrylovConvergence187,7275

src/pep/impls/krylov/pepkrylov.h,5343
pepkrylov.h:^?pepkrylov.h^A,1
#define SLEPC_PEPKRYLOV_HSLEPC_PEPKRYLOV_H15,475
  PetscReal     keep;         /* restart parameter */keep25,858
  PetscBool     lock;         /* locking/non-locking variant */lock26,912
  BV            V;            /* tensor basis vectors object for the linearization */V27,976
} PEP_TOAR;PEP_TOAR28,1062
typedef struct _n_shift *PEP_shift;PEP_shift31,1134
struct _n_shift {_n_shift32,1170
  PetscReal     value;value33,1188
  PetscInt      inertia;inertia34,1211
  PetscBool     comp[2];      /* Shows completion of subintervals (left and right) */comp35,1236
  PEP_shift     neighb[2];    /* Adjacent shifts */neighb36,1322
  PetscInt      index;        /* Index in eig where found values are stored */index37,1374
  PetscInt      neigs;        /* Number of values found */neigs38,1453
  PetscReal     ext[2];       /* Limits for accepted values */ext39,1512
  PetscInt      nsch[2];      /* Number of missing values for each subinterval */nsch40,1575
  PetscInt      nconv[2];     /* Converged on each side (accepted or not) */nconv41,1657
  PetscInt      nq;nq46,1830
  PetscInt      *q;q47,1850
} PEP_QInfo;PEP_QInfo48,1870
struct _n_SR {_n_SR51,1942
  PetscReal     int0,int1;         /* Extremes of the interval */int052,1957
  PetscReal     int0,int1;         /* Extremes of the interval */int152,1957
  PetscInt      dir;               /* Determines the order of values in eig (+1 incr, -1 decr) */dir53,2023
  PetscBool     hasEnd;            /* Tells whether the interval has an end */hasEnd54,2121
  PetscBool     dirch;             /* Tells if dir has been changed */dirch55,2200
  PetscInt      inertia0,inertia1;inertia056,2271
  PetscInt      inertia0,inertia1;inertia156,2271
  PetscScalar   *back;back57,2306
  PetscInt      numEigs;           /* Number of eigenvalues in the interval */numEigs58,2329
  PetscInt      indexEig;indexEig59,2408
  PEP_shift     sPres;             /* Present shift */sPres60,2434
  PEP_shift     *pending;          /* Pending shifts array */pending61,2489
  PetscInt      nPend;             /* Number of pending shifts */nPend62,2551
  PetscInt      maxPend;           /* Size of "pending" array */maxPend63,2617
  PetscInt      *idxDef0,*idxDef1; /* For deflation */idxDef064,2682
  PetscInt      *idxDef0,*idxDef1; /* For deflation */idxDef164,2682
  PetscInt      ndef0,ndef1;       /* Index in deflation arrays */ndef065,2737
  PetscInt      ndef0,ndef1;       /* Index in deflation arrays */ndef165,2737
  PetscInt      nMAXCompl;nMAXCompl66,2804
  PetscInt      iterCompl;iterCompl67,2831
  PetscInt      itsKs;             /* Krylovschur restarts */itsKs68,2858
  PetscInt      nleap;nleap69,2920
  PEP_shift     s0;                /* Initial shift */s070,2943
  PEP_shift     sPrev;sPrev71,2998
  PetscInt      nv;                /* position of restart vector */nv72,3021
  BV            V;                 /* full TOAR basis */V73,3089
  PetscScalar   *S;                /* TOAR coefficients */S74,3146
  PetscInt      ld;                /* Leading dimension for each block of S */ld75,3205
  BV            Vnext;             /* temporary working basis during change of shift */Vnext76,3284
  PetscScalar   *eigr,*eigi;       /* eigenvalues */eigr77,3372
  PetscScalar   *eigr,*eigi;       /* eigenvalues */eigi77,3372
  PetscReal     *errest;           /* error estimates */errest78,3425
  PetscInt      *perm;             /* permutation */perm79,3482
  PEP_QInfo     *qinfo;            /* TOAR vectors for each eigenvector */qinfo80,3535
  PetscInt      intcorr;           /* Global inertia correction */intcorr81,3610
  PetscInt      type;              /* Global type of eigenvalues in general case */type82,3677
  PetscInt      symmlost;          /* Counter for symmetry lost */symmlost83,3761
  Vec           v[3];v84,3828
  EPS           eps;eps85,3850
  PetscReal     mu;mu86,3871
typedef struct _n_SR *PEP_SR;PEP_SR88,3894
  PetscReal     keep;           /* restart parameter */keep91,3942
  PetscBool     lock;           /* locking/non-locking variant */lock92,3998
  BV            V;              /* tensor basis vectors object for the linearization */V93,4064
  PEP_SR        sr;             /* spectrum slicing context */sr94,4152
  PetscReal     *shifts;        /* array containing global shifts */shifts95,4215
  PetscInt      *inertias;      /* array containing global inertias */inertias96,4284
  PetscInt      nshifts;        /* elements in the arrays of shifts and inertias */nshifts97,4355
  PetscInt      nev;            /* number of eigenvalues to compute */nev98,4439
  PetscInt      ncv;            /* number of basis vectors */ncv99,4510
  PetscInt      mpd;            /* maximum dimension of projected problem */mpd100,4572
  PetscBool     detect;         /* check for zeros during factorizations */detect101,4649
  PetscBool     hyperbolic;     /* hyperbolic problem flag */hyperbolic102,4725
  PetscReal     alpha,beta;     /* coefficients defining the linearization */alpha103,4787
  PetscReal     alpha,beta;     /* coefficients defining the linearization */beta103,4787
  PetscBool     checket;        /* check eigenvalue type during spectrum slicing */checket104,4865
} PEP_STOAR;PEP_STOAR105,4949

src/pep/impls/krylov/qarnoldi/makefile,285
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = qarnoldi.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  =SOURCEH17,464
LIBBASE  = libslepcpepLIBBASE18,475
DIRS     =DIRS19,498
MANSEC   = PEPMANSEC20,509
LOCDIR   = src/pep/impls/krylov/qarnoldi/LOCDIR21,524

src/pep/impls/krylov/qarnoldi/qarnoldi.c,1999
qarnoldi.c:^?qarnoldi.c^A,1
  PetscReal keep;         /* restart parameter */keep30,850
  PetscBool lock;         /* locking/non-locking variant */lock31,900
} PEP_QARNOLDI;PEP_QARNOLDI32,960
PetscErrorCode PEPSetUp_QArnoldi(PEP pep)PEPSetUp_QArnoldi34,977
PetscErrorCode PEPExtractVectors_QArnoldi(PEP pep)PEPExtractVectors_QArnoldi78,3049
static PetscErrorCode PEPQArnoldiCGS(PEP pep,PetscScalar *H,PetscBLASInt ldh,PetscScalar *h,PetscBLASInt j,BV V,Vec t,Vec v,Vec w,PetscReal *onorm,PetscReal *norm,PetscScalar *work)PEPQArnoldiCGS107,4000
static PetscErrorCode PEPQArnoldi(PEP pep,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,Vec v,Vec w,PetscReal *beta,PetscBool *breakdown,PetscScalar *work)PEPQArnoldi150,5363
PetscErrorCode PEPSolve_QArnoldi(PEP pep)PEPSolve_QArnoldi222,8043
static PetscErrorCode PEPQArnoldiSetRestart_QArnoldi(PEP pep,PetscReal keep)PEPQArnoldiSetRestart_QArnoldi331,12465
PetscErrorCode PEPQArnoldiSetRestart(PEP pep,PetscReal keep)PEPQArnoldiSetRestart365,13408
static PetscErrorCode PEPQArnoldiGetRestart_QArnoldi(PEP pep,PetscReal *keep)PEPQArnoldiGetRestart_QArnoldi376,13737
PetscErrorCode PEPQArnoldiGetRestart(PEP pep,PetscReal *keep)PEPQArnoldiGetRestart400,14220
static PetscErrorCode PEPQArnoldiSetLocking_QArnoldi(PEP pep,PetscBool lock)PEPQArnoldiSetLocking_QArnoldi411,14537
PetscErrorCode PEPQArnoldiSetLocking(PEP pep,PetscBool lock)PEPQArnoldiSetLocking445,15460
static PetscErrorCode PEPQArnoldiGetLocking_QArnoldi(PEP pep,PetscBool *lock)PEPQArnoldiGetLocking_QArnoldi456,15789
PetscErrorCode PEPQArnoldiGetLocking(PEP pep,PetscBool *lock)PEPQArnoldiGetLocking480,16262
PetscErrorCode PEPSetFromOptions_QArnoldi(PetscOptionItems *PetscOptionsObject,PEP pep)PEPSetFromOptions_QArnoldi491,16579
PetscErrorCode PEPView_QArnoldi(PEP pep,PetscViewer viewer)PEPView_QArnoldi510,17382
PetscErrorCode PEPDestroy_QArnoldi(PEP pep)PEPDestroy_QArnoldi525,17946
SLEPC_EXTERN PetscErrorCode PEPCreate_QArnoldi(PEP pep)PEPCreate_QArnoldi538,18512

src/pep/impls/krylov/stoar/ftn-custom/makefile,263
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zstoarf.cSOURCEC15,469
SOURCEF  =SOURCEF16,490
SOURCEH  =SOURCEH17,501
DIRS     =DIRS18,512
LIBBASE  = libslepcpepLIBBASE19,523
LOCDIR   = src/pep/impls/krylov/stoar/ftn-custom/LOCDIR20,546

src/pep/impls/krylov/stoar/ftn-custom/zstoarf.c,282
zstoarf.c:^?zstoarf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL pepstoargetinertias_(PEP *pep,PetscInt *nshift,PetscReal *shifts,PetscInt *inertias,PetscErrorCode *ierr)pepstoargetinertias_20,678

src/pep/impls/krylov/stoar/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = stoar.c qslice.cSOURCEC15,431
SOURCEF  =SOURCEF16,459
SOURCEH  =SOURCEH17,470
LIBBASE  = libslepcpepLIBBASE18,481
DIRS     =DIRS19,504
MANSEC   = PEPMANSEC20,515
LOCDIR   = src/pep/impls/krylov/stoar/LOCDIR21,530

src/pep/impls/krylov/stoar/qslice.c,2682
qslice.c:^?qslice.c^A,1
static PetscBool  cited = PETSC_FALSE;cited30,901
static const char citation[] =citation31,940
#define SLICE_PTOL SLICE_PTOL43,1346
static PetscErrorCode PEPQSliceResetSR(PEP pep)PEPQSliceResetSR45,1393
PetscErrorCode PEPReset_STOAR_QSlice(PEP pep)PEPReset_STOAR_QSlice75,2235
static PetscErrorCode PEPQSliceAllocateSolution(PEP pep)PEPQSliceAllocateSolution91,2666
static PetscErrorCode ConvergedPositive(EPS eps,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)ConvergedPositive132,4311
static PetscErrorCode PEPQSliceMatGetInertia(PEP pep,PetscReal shift,PetscInt *inertia,PetscInt *zeros)PEPQSliceMatGetInertia139,4536
static PetscErrorCode PEPQSliceGetInertia(PEP pep,PetscReal shift,PetscInt *inertia,PetscInt *zeros,PetscInt correction)PEPQSliceGetInertia170,5675
static PetscErrorCode PEPQSliceCheckEigenvalueType(PEP pep,PetscReal shift,PetscReal omega,PetscBool ini)PEPQSliceCheckEigenvalueType239,8724
PETSC_STATIC_INLINE PetscErrorCode PEPQSliceDiscriminant(PEP pep,Vec u,Vec w,PetscReal *d,PetscReal *smas,PetscReal *smenos)PEPQSliceDiscriminant290,11238
PETSC_STATIC_INLINE PetscErrorCode PEPQSliceEvaluateQEP(PEP pep,PetscScalar x,Mat M,MatStructure str)PEPQSliceEvaluateQEP327,12342
PetscErrorCode PEPCheckDefiniteQEP(PEP pep,PetscReal *xi,PetscReal *mu,PetscInt *definite,PetscInt *hyperbolic)PEPCheckDefiniteQEP370,13853
static PetscErrorCode PEPBackTransform_Skip(PEP pep)PEPBackTransform_Skip493,19249
PetscErrorCode PEPSetUp_STOAR_QSlice(PEP pep)PEPSetUp_STOAR_QSlice499,19355
static PetscErrorCode PEPCreateShift(PEP pep,PetscReal val,PEP_shift neighb0,PEP_shift neighb1)PEPCreateShift603,24267
static PetscErrorCode PEPExtractShift(PEP pep)PEPExtractShift640,25415
static PetscErrorCode PEPGetNewShiftValue(PEP pep,PetscInt side,PetscReal *newS)PEPGetNewShiftValue690,27266
static PetscErrorCode sortRealEigenvalues(PetscScalar *r,PetscInt *perm,PetscInt nr,PetscBool prev,PetscInt dir)sortRealEigenvalues773,31452
static PetscErrorCode PEPStoreEigenpairs(PEP pep)PEPStoreEigenpairs792,32008
static PetscErrorCode PEPLookForDeflation(PEP pep)PEPLookForDeflation957,40372
static PetscErrorCode PEPSTOARrun_QSlice(PEP pep,PetscReal *a,PetscReal *b,PetscReal *omega,PetscInt k,PetscInt *M,PetscBool *breakdown,PetscBool *symmlost,Vec *t_)PEPSTOARrun_QSlice1011,42385
static PetscErrorCode PEPSTOAR_QSlice(PEP pep,Mat B)PEPSTOAR_QSlice1098,45943
#define SWAP(SWAP1368,59091
static PetscErrorCode PEPQSliceGetInertias(PEP pep,PetscInt *n,PetscReal **shifts,PetscInt **inertias)PEPQSliceGetInertias1370,59127
PetscErrorCode PEPSolve_STOAR_QSlice(PEP pep)PEPSolve_STOAR_QSlice1425,60742

src/pep/impls/krylov/stoar/stoar.c,3765
stoar.c:^?stoar.c^A,1
static PetscBool  cited = PETSC_FALSE;cited30,875
static const char citation[] =citation31,914
  PetscReal   scal[2];scal44,1373
  Mat         A[2];A45,1396
  Vec         t;t46,1416
} ShellMatCtx;ShellMatCtx47,1433
PetscErrorCode MatMult_Func(Mat A,Vec x,Vec y)MatMult_Func49,1449
PetscErrorCode MatDestroy_Func(Mat A)MatDestroy_Func65,1880
PetscErrorCode PEPSTOARSetUpInnerMatrix(PEP pep,Mat *B)PEPSTOARSetUpInnerMatrix77,2160
PetscErrorCode PEPSetUp_STOAR(PEP pep)PEPSetUp_STOAR116,3796
static PetscErrorCode PEPSTOARrun(PEP pep,PetscReal *a,PetscReal *b,PetscReal *omega,PetscInt k,PetscInt *M,PetscBool *breakdown,PetscBool *symmlost,Vec *t_)PEPSTOARrun183,7193
PetscErrorCode PEPSolve_STOAR(PEP pep)PEPSolve_STOAR326,13166
PetscErrorCode PEPSetFromOptions_STOAR(PetscOptionItems *PetscOptionsObject,PEP pep)PEPSetFromOptions_STOAR520,21220
static PetscErrorCode PEPSTOARSetLocking_STOAR(PEP pep,PetscBool lock)PEPSTOARSetLocking_STOAR559,23323
PetscErrorCode PEPSTOARSetLocking(PEP pep,PetscBool lock)PEPSTOARSetLocking591,24141
static PetscErrorCode PEPSTOARGetLocking_STOAR(PEP pep,PetscBool *lock)PEPSTOARGetLocking_STOAR602,24464
PetscErrorCode PEPSTOARGetLocking(PEP pep,PetscBool *lock)PEPSTOARGetLocking626,24915
static PetscErrorCode PEPSTOARGetInertias_STOAR(PEP pep,PetscInt *n,PetscReal **shifts,PetscInt **inertias)PEPSTOARGetInertias_STOAR637,25226
PetscErrorCode PEPSTOARGetInertias(PEP pep,PetscInt *n,PetscReal **shifts,PetscInt **inertias)PEPSTOARGetInertias724,27977
static PetscErrorCode PEPSTOARSetDetectZeros_STOAR(PEP pep,PetscBool detect)PEPSTOARSetDetectZeros_STOAR735,28356
PetscErrorCode PEPSTOARSetDetectZeros(PEP pep,PetscBool detect)PEPSTOARSetDetectZeros770,29340
static PetscErrorCode PEPSTOARGetDetectZeros_STOAR(PEP pep,PetscBool *detect)PEPSTOARGetDetectZeros_STOAR781,29677
PetscErrorCode PEPSTOARGetDetectZeros(PEP pep,PetscBool *detect)PEPSTOARGetDetectZeros806,30208
static PetscErrorCode PEPSTOARSetLinearization_STOAR(PEP pep,PetscReal alpha,PetscReal beta)PEPSTOARSetLinearization_STOAR817,30533
PetscErrorCode PEPSTOARSetLinearization(PEP pep,PetscReal alpha,PetscReal beta)PEPSTOARSetLinearization850,31481
static PetscErrorCode PEPSTOARGetLinearization_STOAR(PEP pep,PetscReal *alpha,PetscReal *beta)PEPSTOARGetLinearization_STOAR862,31896
PetscErrorCode PEPSTOARGetLinearization(PEP pep,PetscReal *alpha,PetscReal *beta)PEPSTOARGetLinearization889,32544
static PetscErrorCode PEPSTOARSetDimensions_STOAR(PEP pep,PetscInt nev,PetscInt ncv,PetscInt mpd)PEPSTOARSetDimensions_STOAR899,32868
PetscErrorCode PEPSTOARSetDimensions(PEP pep,PetscInt nev,PetscInt ncv,PetscInt mpd)PEPSTOARSetDimensions944,34481
static PetscErrorCode PEPSTOARGetDimensions_STOAR(PEP pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)PEPSTOARGetDimensions_STOAR957,34946
PetscErrorCode PEPSTOARGetDimensions(PEP pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)PEPSTOARGetDimensions986,35717
static PetscErrorCode PEPSTOARSetCheckEigenvalueType_STOAR(PEP pep,PetscBool checket)PEPSTOARSetCheckEigenvalueType_STOAR996,36053
PetscErrorCode PEPSTOARSetCheckEigenvalueType(PEP pep,PetscBool checket)PEPSTOARSetCheckEigenvalueType1034,37302
static PetscErrorCode PEPSTOARGetCheckEigenvalueType_STOAR(PEP pep,PetscBool *checket)PEPSTOARGetCheckEigenvalueType_STOAR1045,37658
PetscErrorCode PEPSTOARGetCheckEigenvalueType(PEP pep,PetscBool *checket)PEPSTOARGetCheckEigenvalueType1070,38223
PetscErrorCode PEPView_STOAR(PEP pep,PetscViewer viewer)PEPView_STOAR1081,38567
PetscErrorCode PEPReset_STOAR(PEP pep)PEPReset_STOAR1099,39328
PetscErrorCode PEPDestroy_STOAR(PEP pep)PEPDestroy_STOAR1110,39530
SLEPC_EXTERN PetscErrorCode PEPCreate_STOAR(PEP pep)PEPCreate_STOAR1132,40901

src/pep/impls/krylov/toar/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = ptoar.c nrefine.cSOURCEC15,431
SOURCEF  =SOURCEF16,460
SOURCEH  =SOURCEH17,471
LIBBASE  = libslepcpepLIBBASE18,482
DIRS     =DIRS19,505
MANSEC   = PEPMANSEC20,516
LOCDIR   = src/pep/impls/krylov/toar/LOCDIR21,531

src/pep/impls/krylov/toar/nrefine.c,5259
nrefine.c:^?nrefine.c^A,1
  Mat          *A,M1;A28,921
  Mat          *A,M1;M128,921
  BV           V,M2,M3,W;V29,943
  BV           V,M2,M3,W;M229,943
  BV           V,M2,M3,W;M329,943
  BV           V,M2,M3,W;W29,943
  PetscInt     k,nmat;k30,969
  PetscInt     k,nmat;nmat30,969
  PetscScalar  *fih,*work,*M4;fih31,992
  PetscScalar  *fih,*work,*M4;work31,992
  PetscScalar  *fih,*work,*M4;M431,992
  PetscBLASInt *pM4;pM432,1023
  PetscBool    compM1;compM133,1044
  Vec          t;t34,1067
} FSubctx;FSubctx35,1085
  Mat          E[2],M1;E38,1114
  Mat          E[2],M1;M138,1114
  Vec          tN,ttN,t1,vseq;tN39,1138
  Vec          tN,ttN,t1,vseq;ttN39,1138
  Vec          tN,ttN,t1,vseq;t139,1138
  Vec          tN,ttN,t1,vseq;vseq39,1138
  VecScatter   scatterctx;scatterctx40,1169
  PetscBool    compM1;compM141,1196
  PetscInt     *map0,*map1,*idxg,*idxp;map042,1219
  PetscInt     *map0,*map1,*idxg,*idxp;map142,1219
  PetscInt     *map0,*map1,*idxg,*idxp;idxg42,1219
  PetscInt     *map0,*map1,*idxg,*idxp;idxp42,1219
  PetscSubcomm subc;subc43,1259
  VecScatter   scatter_sub;scatter_sub44,1280
  VecScatter   *scatter_id,*scatterp_id;scatter_id45,1308
  VecScatter   *scatter_id,*scatterp_id;scatterp_id45,1308
  Mat          *A;A46,1349
  BV           V,W,M2,M3,Wt;V47,1368
  BV           V,W,M2,M3,Wt;W47,1368
  BV           V,W,M2,M3,Wt;M247,1368
  BV           V,W,M2,M3,Wt;M347,1368
  BV           V,W,M2,M3,Wt;Wt47,1368
  PetscScalar  *M4,*w,*wt,*d,*dt;M448,1397
  PetscScalar  *M4,*w,*wt,*d,*dt;w48,1397
  PetscScalar  *M4,*w,*wt,*d,*dt;wt48,1397
  PetscScalar  *M4,*w,*wt,*d,*dt;d48,1397
  PetscScalar  *M4,*w,*wt,*d,*dt;dt48,1397
  Vec          t,tg,Rv,Vi,tp,tpg;t49,1431
  Vec          t,tg,Rv,Vi,tp,tpg;tg49,1431
  Vec          t,tg,Rv,Vi,tp,tpg;Rv49,1431
  Vec          t,tg,Rv,Vi,tp,tpg;Vi49,1431
  Vec          t,tg,Rv,Vi,tp,tpg;tp49,1431
  Vec          t,tg,Rv,Vi,tp,tpg;tpg49,1431
  PetscInt     idx,*cols;idx50,1465
  PetscInt     idx,*cols;cols50,1465
} MatExplicitCtx;MatExplicitCtx51,1491
static PetscErrorCode MatFSMult(Mat M ,Vec x,Vec y)MatFSMult53,1510
static PetscErrorCode PEPEvaluateBasisforMatrix(PEP pep,PetscInt nm,PetscInt k,PetscScalar *H,PetscInt ldh,PetscScalar *fH)PEPEvaluateBasisforMatrix86,2570
static PetscErrorCode NRefSysSetup_shell(PEP pep,PetscInt k,PetscScalar *fH,PetscScalar *S,PetscInt lds,PetscScalar *fh,PetscScalar h,FSubctx *ctx)NRefSysSetup_shell130,3928
static PetscErrorCode NRefSysSolve_shell(KSP ksp,PetscInt nmat,Vec Rv,PetscScalar *Rh,PetscInt k,Vec dVi,PetscScalar *dHi)NRefSysSolve_shell237,8462
static PetscErrorCode NRefRightSide(PetscInt nmat,PetscReal *pcf,Mat *A,PetscInt k,BV V,PetscScalar *S,PetscInt lds,PetscInt j,PetscScalar *H,PetscInt ldh,PetscScalar *fH,PetscScalar *DfH,PetscScalar *dH,BV dV,PetscScalar *dVS,PetscInt rds,Vec Rv,PetscScalar *Rh,BV W,Vec t)NRefRightSide275,9900
static PetscErrorCode NRefSysSolve_mbe(PetscInt k,PetscInt sz,BV W,PetscScalar *w,BV Wt,PetscScalar *wt,PetscScalar *d,PetscScalar *dt,KSP ksp,BV T2,BV T3 ,PetscScalar *T4,PetscBool trans,Vec x1,PetscScalar *x2,Vec sol1,PetscScalar *sol2,Vec vw)NRefSysSolve_mbe361,13699
static PetscErrorCode NRefSysSetup_mbe(PEP pep,PetscInt k,KSP ksp,PetscScalar *fH,PetscScalar *S,PetscInt lds,PetscScalar *fh,PetscScalar h,BV V,MatExplicitCtx *matctx)NRefSysSetup_mbe422,15958
static PetscErrorCode NRefSysSetup_explicit(PEP pep,PetscInt k,KSP ksp,PetscScalar *fH,PetscScalar *S,PetscInt lds,PetscScalar *fh,PetscScalar h,BV V,MatExplicitCtx *matctx,BV W)NRefSysSetup_explicit553,21113
static PetscErrorCode NRefSysSolve_explicit(PetscInt k,KSP ksp,Vec Rv,PetscScalar *Rh,Vec dVi,PetscScalar *dHi,MatExplicitCtx *matctx)NRefSysSolve_explicit698,26948
static PetscErrorCode NRefSysIter(PetscInt i,PEP pep,PetscInt k,KSP ksp,PetscScalar *fH,PetscScalar *S,PetscInt lds,PetscScalar *fh,PetscScalar *H,PetscInt ldh,Vec Rv,PetscScalar *Rh,BV V,Vec dVi,PetscScalar *dHi,MatExplicitCtx *matctx,BV W)NRefSysIter739,28793
static PetscErrorCode PEPNRefForwardSubstitution(PEP pep,PetscInt k,PetscScalar *S,PetscInt lds,PetscScalar *H,PetscInt ldh,PetscScalar *fH,BV dV,PetscScalar *dVS,PetscInt *rds,PetscScalar *dH,PetscInt lddh,KSP ksp,MatExplicitCtx *matctx)PEPNRefForwardSubstitution849,33730
static PetscErrorCode NRefOrthogStep(PEP pep,PetscInt k,PetscScalar *H,PetscInt ldh,PetscScalar *fH,PetscScalar *S,PetscInt lds)NRefOrthogStep938,37174
static PetscErrorCode PEPNRefUpdateInvPair(PEP pep,PetscInt k,PetscScalar *H,PetscInt ldh,PetscScalar *fH,PetscScalar *dH,PetscScalar *S,PetscInt lds,BV dV,PetscScalar *dVS,PetscInt rds)PEPNRefUpdateInvPair976,38801
static PetscErrorCode PEPNRefSetUp(PEP pep,PetscInt k,PetscScalar *H,PetscInt ldh,MatExplicitCtx *matctx,PetscBool ini)PEPNRefSetUp1037,41254
static PetscErrorCode NRefSubcommSetup(PEP pep,PetscInt k,MatExplicitCtx *matctx,PetscInt nsubc)NRefSubcommSetup1253,51357
static PetscErrorCode NRefSubcommDestroy(PEP pep,MatExplicitCtx *matctx)NRefSubcommDestroy1342,55214
PetscErrorCode PEPNewtonRefinement_TOAR(PEP pep,PetscScalar sigma,PetscInt *maxits,PetscReal *tol,PetscInt k,PetscScalar *S,PetscInt lds)PEPNewtonRefinement_TOAR1372,56281

src/pep/impls/krylov/toar/ptoar.c,2231
ptoar.c:^?ptoar.c^A,1
static PetscBool  cited = PETSC_FALSE;cited37,1168
static const char citation[] =citation38,1207
PetscErrorCode PEPSetUp_TOAR(PEP pep)PEPSetUp_TOAR50,1631
static PetscErrorCode PEPTOARExtendBasis(PEP pep,PetscBool sinvert,PetscScalar sigma,PetscScalar *S,PetscInt ls,PetscInt nv,BV V,Vec t,PetscScalar *r,PetscInt lr,Vec *t_)PEPTOARExtendBasis112,4264
static PetscErrorCode PEPTOARCoefficients(PEP pep,PetscBool sinvert,PetscScalar sigma,PetscInt nv,PetscScalar *S,PetscInt ls,PetscScalar *r,PetscInt lr,PetscScalar *x)PEPTOARCoefficients187,6949
static PetscErrorCode PEPTOARrun(PEP pep,PetscScalar sigma,PetscScalar *H,PetscInt ldh,PetscInt k,PetscInt *M,PetscBool *breakdown,Vec *t_)PEPTOARrun214,7862
static PetscErrorCode PEPEvaluateBasisM(PEP pep,PetscInt k,PetscScalar *T,PetscInt ldt,PetscInt idx,PetscScalar **Tp,PetscScalar **Tj)PEPEvaluateBasisM279,10401
static PetscErrorCode PEPExtractInvariantPair(PEP pep,PetscScalar sigma,PetscInt sr,PetscInt k,PetscScalar *S,PetscInt ld,PetscInt deg,PetscScalar *H,PetscInt ldh)PEPExtractInvariantPair306,11353
PetscErrorCode PEPSolve_TOAR(PEP pep)PEPSolve_TOAR468,17342
static PetscErrorCode PEPTOARSetRestart_TOAR(PEP pep,PetscReal keep)PEPTOARSetRestart_TOAR654,25167
PetscErrorCode PEPTOARSetRestart(PEP pep,PetscReal keep)PEPTOARSetRestart688,26077
static PetscErrorCode PEPTOARGetRestart_TOAR(PEP pep,PetscReal *keep)PEPTOARGetRestart_TOAR699,26398
PetscErrorCode PEPTOARGetRestart(PEP pep,PetscReal *keep)PEPTOARGetRestart723,26852
static PetscErrorCode PEPTOARSetLocking_TOAR(PEP pep,PetscBool lock)PEPTOARSetLocking_TOAR734,27161
PetscErrorCode PEPTOARSetLocking(PEP pep,PetscBool lock)PEPTOARSetLocking766,27971
static PetscErrorCode PEPTOARGetLocking_TOAR(PEP pep,PetscBool *lock)PEPTOARGetLocking_TOAR777,28292
PetscErrorCode PEPTOARGetLocking(PEP pep,PetscBool *lock)PEPTOARGetLocking801,28736
PetscErrorCode PEPSetFromOptions_TOAR(PetscOptionItems *PetscOptionsObject,PEP pep)PEPSetFromOptions_TOAR812,29045
PetscErrorCode PEPView_TOAR(PEP pep,PetscViewer viewer)PEPView_TOAR831,29815
PetscErrorCode PEPDestroy_TOAR(PEP pep)PEPDestroy_TOAR846,30371
SLEPC_EXTERN PetscErrorCode PEPCreate_TOAR(PEP pep)PEPCreate_TOAR861,31006

src/pep/impls/linear/linear.c,2971
linear.c:^?linear.c^A,1
static PetscErrorCode MatMult_Linear_Shift(Mat M,Vec x,Vec y)MatMult_Linear_Shift17,546
static PetscErrorCode MatMult_Linear_Sinvert(Mat M,Vec x,Vec y)MatMult_Linear_Sinvert99,3322
static PetscErrorCode BackTransform_Linear(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)BackTransform_Linear213,7291
static PetscErrorCode BackTransform_Skip(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)BackTransform_Skip229,7720
static PetscErrorCode Apply_Linear(ST st,Vec x,Vec y)Apply_Linear235,7868
PetscErrorCode PEPSetUp_Linear(PEP pep)PEPSetUp_Linear246,8125
static PetscErrorCode PEPLinearExtract_Residual(PEP pep,EPS eps)PEPLinearExtract_Residual453,18800
static PetscErrorCode PEPLinearExtract_None(PEP pep,EPS eps)PEPLinearExtract_None545,22366
static PetscErrorCode PEPLinearExtract_Norm(PEP pep,EPS eps)PEPLinearExtract_Norm605,24500
PetscErrorCode PEPExtractVectors_Linear(PEP pep)PEPExtractVectors_Linear659,26399
PetscErrorCode PEPSolve_Linear(PEP pep)PEPSolve_Linear681,27042
static PetscErrorCode EPSMonitor_Linear(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitor_Linear726,28461
PetscErrorCode PEPSetFromOptions_Linear(PetscOptionItems *PetscOptionsObject,PEP pep)PEPSetFromOptions_Linear736,28798
static PetscErrorCode PEPLinearSetLinearization_Linear(PEP pep,PetscReal alpha,PetscReal beta)PEPLinearSetLinearization_Linear764,29873
PetscErrorCode PEPLinearSetLinearization(PEP pep,PetscReal alpha,PetscReal beta)PEPLinearSetLinearization797,30828
static PetscErrorCode PEPLinearGetLinearization_Linear(PEP pep,PetscReal *alpha,PetscReal *beta)PEPLinearGetLinearization_Linear809,31245
PetscErrorCode PEPLinearGetLinearization(PEP pep,PetscReal *alpha,PetscReal *beta)PEPLinearGetLinearization836,31899
static PetscErrorCode PEPLinearSetExplicitMatrix_Linear(PEP pep,PetscBool explicitmatrix)PEPLinearSetExplicitMatrix_Linear846,32225
PetscErrorCode PEPLinearSetExplicitMatrix(PEP pep,PetscBool explicitmatrix)PEPLinearSetExplicitMatrix875,33008
static PetscErrorCode PEPLinearGetExplicitMatrix_Linear(PEP pep,PetscBool *explicitmatrix)PEPLinearGetExplicitMatrix_Linear886,33377
PetscErrorCode PEPLinearGetExplicitMatrix(PEP pep,PetscBool *explicitmatrix)PEPLinearGetExplicitMatrix911,33941
static PetscErrorCode PEPLinearSetEPS_Linear(PEP pep,EPS eps)PEPLinearSetEPS_Linear922,34298
PetscErrorCode PEPLinearSetEPS(PEP pep,EPS eps)PEPLinearSetEPS951,35030
static PetscErrorCode PEPLinearGetEPS_Linear(PEP pep,EPS *eps)PEPLinearGetEPS_Linear963,35368
PetscErrorCode PEPLinearGetEPS(PEP pep,EPS *eps)PEPLinearGetEPS998,36494
PetscErrorCode PEPView_Linear(PEP pep,PetscViewer viewer)PEPView_Linear1009,36780
PetscErrorCode PEPReset_Linear(PEP pep)PEPReset_Linear1028,37608
PetscErrorCode PEPDestroy_Linear(PEP pep)PEPDestroy_Linear1046,38205
SLEPC_EXTERN PetscErrorCode PEPCreate_Linear(PEP pep)PEPCreate_Linear1063,39069

src/pep/impls/linear/linear.h,1151
linear.h:^?linear.h^A,1
#define SLEPC_LINEAR_HSLEPC_LINEAR_H15,467
  PetscBool  explicitmatrix;explicitmatrix18,508
  PEP        pep;pep19,537
  PetscReal  sfactor,dsfactor; /* scaling factors */sfactor20,555
  PetscReal  sfactor,dsfactor; /* scaling factors */dsfactor20,555
  Mat        A,B;              /* matrices of generalized eigenproblem */A21,608
  Mat        A,B;              /* matrices of generalized eigenproblem */B21,608
  EPS        eps;              /* linear eigensolver for Az=lBz */eps22,682
  PetscBool  usereps;          /* eps provided by user */usereps23,749
  Mat        M,C,K;            /* copy of PEP coefficient matrices */M24,807
  Mat        M,C,K;            /* copy of PEP coefficient matrices */C24,807
  Mat        M,C,K;            /* copy of PEP coefficient matrices */K24,807
  Vec        w[6];             /* work vectors */w25,877
  PetscReal   alpha,beta;      /* coefficients defining the linearization */alpha26,927
  PetscReal   alpha,beta;      /* coefficients defining the linearization */beta26,927
  PetscBool  setfromoptionscalled;setfromoptionscalled27,1004
} PEP_LINEAR;PEP_LINEAR28,1039

src/pep/impls/linear/makefile,292
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = linear.c qeplin.cSOURCEC15,431
SOURCEF  =SOURCEF16,460
SOURCEH  = linear.hSOURCEH17,471
LIBBASE  = libslepcpepLIBBASE18,491
DIRS     =DIRS19,514
MANSEC   = PEPMANSEC20,525
LOCDIR   = src/pep/impls/linear/LOCDIR21,540

src/pep/impls/linear/qeplin.c,706
qeplin.c:^?qeplin.c^A,1
PetscErrorCode MatCreateExplicit_Linear_NA(MPI_Comm comm,PEP_LINEAR *ctx,Mat *A)MatCreateExplicit_Linear_NA39,1245
PetscErrorCode MatCreateExplicit_Linear_NB(MPI_Comm comm,PEP_LINEAR *ctx,Mat *B)MatCreateExplicit_Linear_NB76,2670
PetscErrorCode MatCreateExplicit_Linear_SA(MPI_Comm comm,PEP_LINEAR *ctx,Mat *A)MatCreateExplicit_Linear_SA115,4218
PetscErrorCode MatCreateExplicit_Linear_SB(MPI_Comm comm,PEP_LINEAR *ctx,Mat *B)MatCreateExplicit_Linear_SB138,5095
PetscErrorCode MatCreateExplicit_Linear_HA(MPI_Comm comm,PEP_LINEAR *ctx,Mat *A)MatCreateExplicit_Linear_HA163,6076
PetscErrorCode MatCreateExplicit_Linear_HB(MPI_Comm comm,PEP_LINEAR *ctx,Mat *B)MatCreateExplicit_Linear_HB186,6952

src/pep/impls/makefile,287
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = peputils.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  = SOURCEH17,464
LIBBASE  = libslepcpepLIBBASE18,476
DIRS     = linear krylov jdDIRS19,499
LOCDIR   = src/pep/impls/LOCDIR20,527
MANSEC   = PEPMANSEC21,553

src/pep/impls/peputils.c,515
peputils.c:^?peputils.c^A,1
PetscErrorCode PEPEvaluateBasisMat(PEP pep,PetscInt k,PetscScalar *T,PetscInt ldt,PetscInt idx,PetscScalar *Tpp,PetscInt ldtpp,PetscScalar *Tp,PetscInt ldtp,PetscScalar *Tj,PetscInt ldtj)PEPEvaluateBasisMat22,684
PetscErrorCode PEPEvaluateBasis(PEP pep,PetscScalar sigma,PetscScalar isigma,PetscScalar *vals,PetscScalar *ivals)PEPEvaluateBasis59,1959
PetscErrorCode PEPEvaluateBasisDerivative(PEP pep,PetscScalar sigma,PetscScalar isigma,PetscScalar *vals,PetscScalar *ivals)PEPEvaluateBasisDerivative84,2791

src/pep/interface/dlregispep.c,1546
dlregispep.c:^?dlregispep.c^A,1
static PetscBool PEPPackageInitialized = PETSC_FALSE;PEPPackageInitialized13,436
const char *PEPBasisTypes[] = {"MONOMIAL","CHEBYSHEV1","CHEBYSHEV2","LEGENDRE","LAGUERRE","HERMITE","PEPBasis","PEP_BASIS_",0};PEPBasisTypes15,491
const char *PEPScaleTypes[] = {"NONE","SCALAR","DIAGONAL","BOTH","PEPScale","PEP_SCALE_",0};PEPScaleTypes16,619
const char *PEPRefineTypes[] = {"NONE","SIMPLE","MULTIPLE","PEPRefine","PEP_REFINE_",0};PEPRefineTypes17,712
const char *PEPRefineSchemes[] = {"","SCHUR","MBE","EXPLICIT","PEPRefineScheme","PEP_REFINE_SCHEME_",0};PEPRefineSchemes18,801
const char *PEPExtractTypes[] = {"","NONE","NORM","RESIDUAL","STRUCTURED","PEPExtract","PEP_EXTRACT_",0};PEPExtractTypes19,906
const char *PEPErrorTypes[] = {"ABSOLUTE","RELATIVE","BACKWARD","PEPErrorType","PEP_ERROR_",0};PEPErrorTypes20,1012
const char *const PEPConvergedReasons_Shifted[] = {"","DIVERGED_SYMMETRY_LOST","DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","CONVERGED_USER","PEPConvergedReason","PEP_",0};PEPConvergedReasons_Shifted21,1108
const char *const*PEPConvergedReasons = PEPConvergedReasons_Shifted + 4;PEPConvergedReasons22,1310
const char *PEPJDProjectionTypes[] = {"HARMONIC","ORTHOGONAL","PEPJDProjection","PEP_JD_PROJECTION_",0};PEPJDProjectionTypes23,1383
PetscErrorCode PEPFinalizePackage(void)PEPFinalizePackage33,1685
PetscErrorCode PEPInitializePackage(void)PEPInitializePackage53,2226
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepcpep()PetscDLLibraryRegister_slepcpep95,3863

src/pep/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zpepf.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepcpepLIBBASE19,521
LOCDIR   = src/pep/interface/ftn-custom/LOCDIR20,544

src/pep/interface/ftn-custom/zpepf.c,17013
zpepf.c:^?zpepf.c^A,1
SLEPC_EXTERN void pepmonitorall_(PEP *pep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)pepmonitorall_129,7050
SLEPC_EXTERN void pepmonitorconverged_(PEP *pep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,SlepcConvMonitor *ctx,PetscErrorCode *ierr)pepmonitorconverged_134,7314
SLEPC_EXTERN void pepmonitorfirst_(PEP *pep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)pepmonitorfirst_139,7585
SLEPC_EXTERN void pepmonitorlg_(PEP *pep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)pepmonitorlg_144,7853
SLEPC_EXTERN void pepmonitorlgall_(PEP *pep,PetscInt *it,PetscInt *nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)pepmonitorlgall_149,8097
  PetscFortranCallbackId monitor;monitor155,8363
  PetscFortranCallbackId monitordestroy;monitordestroy156,8397
  PetscFortranCallbackId convergence;convergence157,8438
  PetscFortranCallbackId convdestroy;convdestroy158,8476
  PetscFortranCallbackId stopping;stopping159,8514
  PetscFortranCallbackId stopdestroy;stopdestroy160,8549
  PetscFortranCallbackId comparison;comparison161,8587
} _cb;_cb162,8624
static PetscErrorCode ourmonitor(PEP pep,PetscInt i,PetscInt nc,PetscScalar *er,PetscScalar *ei,PetscReal *d,PetscInt l,void* ctx)ourmonitor165,8724
static PetscErrorCode ourdestroy(void** ctx)ourdestroy170,9042
static PetscErrorCode ourconvergence(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)ourconvergence176,9209
static PetscErrorCode ourconvdestroy(void *ctx)ourconvdestroy181,9509
static PetscErrorCode ourstopping(PEP pep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,PEPConvergedReason *reason,void *ctx)ourstopping187,9675
static PetscErrorCode ourstopdestroy(void *ctx)ourstopdestroy192,10007
static PetscErrorCode oureigenvaluecomparison(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *r,void *ctx)oureigenvaluecomparison198,10173
SLEPC_EXTERN void PETSC_STDCALL pepview_(PEP *pep,PetscViewer *viewer,PetscErrorCode *ierr)pepview_204,10499
SLEPC_EXTERN void PETSC_STDCALL pepreasonview_(PEP *pep,PetscViewer *viewer,PetscErrorCode *ierr)pepreasonview_211,10686
SLEPC_EXTERN void PETSC_STDCALL peperrorview_(PEP *pep,PEPErrorType *etype,PetscViewer *viewer,PetscErrorCode *ierr)peperrorview_218,10885
SLEPC_EXTERN void PETSC_STDCALL pepvaluesview_(PEP *pep,PetscViewer *viewer,PetscErrorCode *ierr)pepvaluesview_225,11109
SLEPC_EXTERN void PETSC_STDCALL pepvectorsview_(PEP *pep,PetscViewer *viewer,PetscErrorCode *ierr)pepvectorsview_232,11308
SLEPC_EXTERN void PETSC_STDCALL pepsettype_(PEP *pep,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))pepsettype_239,11509
SLEPC_EXTERN void PETSC_STDCALL pepgettype_(PEP *pep,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))pepgettype_248,11743
SLEPC_EXTERN void PETSC_STDCALL pepsetoptionsprefix_(PEP *pep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))pepsetoptionsprefix_257,12041
SLEPC_EXTERN void PETSC_STDCALL pepappendoptionsprefix_(PEP *pep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))pepappendoptionsprefix_266,12299
SLEPC_EXTERN void PETSC_STDCALL pepgetoptionsprefix_(PEP *pep,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))pepgetoptionsprefix_275,12563
SLEPC_EXTERN void PETSC_STDCALL pepmonitorset_(PEP *pep,void (PETSC_STDCALL *monitor)(PEP*,PetscInt*,PetscInt*,PetscScalar*,PetscScalar*,PetscReal*,PetscInt*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)pepmonitorset_284,12890
SLEPC_EXTERN void PETSC_STDCALL pepconvergedabsolute_(PEP *pep,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)pepconvergedabsolute_305,14829
SLEPC_EXTERN void PETSC_STDCALL pepconvergedrelative_(PEP *pep,PetscScalar *eigr,PetscScalar *eigi,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)pepconvergedrelative_310,15064
SLEPC_EXTERN void PETSC_STDCALL pepsetconvergencetestfunction_(PEP *pep,void (PETSC_STDCALL *func)(PEP*,PetscScalar*,PetscScalar*,PetscReal*,PetscReal*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)pepsetconvergencetestfunction_315,15299
SLEPC_EXTERN void PETSC_STDCALL pepstoppingbasic_(PEP *pep,PetscInt *its,PetscInt *max_it,PetscInt *nconv,PetscInt *nev,PEPConvergedReason *reason,void *ctx,PetscErrorCode *ierr)pepstoppingbasic_330,16309
SLEPC_EXTERN void PETSC_STDCALL pepsetstoppingtestfunction_(PEP *pep,void (PETSC_STDCALL *func)(PEP*,PetscInt,PetscInt,PetscInt,PetscInt,PEPConvergedReason*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)pepsetstoppingtestfunction_335,16563
SLEPC_EXTERN void PETSC_STDCALL pepseteigenvaluecomparison_(PEP *pep,void (PETSC_STDCALL *func)(PetscScalar*,PetscScalar*,PetscScalar*,PetscScalar*,PetscInt*,void*),void* ctx,PetscErrorCode *ierr)pepseteigenvaluecomparison_348,17426
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions_355,17882
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions000_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions000_363,18135
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions100_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions100_368,18298
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions010_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions010_373,18461
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions001_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions001_378,18624
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions110_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions110_383,18787
SLEPC_EXTERN void PETSC_STDCALL pepgetdimensions011_(PEP *pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)pepgetdimensions011_388,18950
SLEPC_EXTERN void PETSC_STDCALL pepgeteigenpair_(PEP *pep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)pepgeteigenpair_393,19113
SLEPC_EXTERN void PETSC_STDCALL pepgeteigenpair00_(PEP *pep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)pepgeteigenpair00_400,19365
SLEPC_EXTERN void PETSC_STDCALL pepgeteigenpair10_(PEP *pep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)pepgeteigenpair10_405,19553
SLEPC_EXTERN void PETSC_STDCALL pepgeteigenpair01_(PEP *pep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)pepgeteigenpair01_410,19741
SLEPC_EXTERN void PETSC_STDCALL pepgeteigenpair11_(PEP *pep,PetscInt *i,PetscScalar *eigr,PetscScalar *eigi,Vec *Vr,Vec *Vi,int *ierr)pepgeteigenpair11_415,19929
SLEPC_EXTERN void PETSC_STDCALL pepgettolerances_(PEP *pep,PetscReal *tol,PetscInt *maxits,int *ierr)pepgettolerances_420,20117
SLEPC_EXTERN void PETSC_STDCALL pepgettolerances00_(PEP *pep,PetscReal *tol,PetscInt *maxits,int *ierr)pepgettolerances00_427,20329
SLEPC_EXTERN void PETSC_STDCALL pepgettolerances10_(PEP *pep,PetscReal *tol,PetscInt *maxits,int *ierr)pepgettolerances10_432,20480
SLEPC_EXTERN void PETSC_STDCALL pepgettolerances01_(PEP *pep,PetscReal *tol,PetscInt *maxits,int *ierr)pepgettolerances01_437,20631
SLEPC_EXTERN void PETSC_STDCALL pepgetscale_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale_442,20782
SLEPC_EXTERN void PETSC_STDCALL pepgetscale000_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale000_450,21080
SLEPC_EXTERN void PETSC_STDCALL pepgetscale100_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale100_455,21289
SLEPC_EXTERN void PETSC_STDCALL pepgetscale010_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale010_460,21498
SLEPC_EXTERN void PETSC_STDCALL pepgetscale001_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale001_465,21707
SLEPC_EXTERN void PETSC_STDCALL pepgetscale110_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale110_470,21916
SLEPC_EXTERN void PETSC_STDCALL pepgetscale011_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale011_475,22125
SLEPC_EXTERN void PETSC_STDCALL pepgetscale101_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale101_480,22334
SLEPC_EXTERN void PETSC_STDCALL pepgetscale111_(PEP *pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda,int *ierr)pepgetscale111_485,22543
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine_490,22752
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine000_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine000_498,23057
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine100_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine100_503,23273
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine010_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine010_508,23489
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine001_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine001_513,23705
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine110_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine110_518,23921
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine011_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine011_523,24137
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine101_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine101_528,24353
SLEPC_EXTERN void PETSC_STDCALL pepgetrefine111_(PEP *pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme,int *ierr)pepgetrefine111_533,24569
SLEPC_EXTERN void PETSC_STDCALL pepsetinitialspace0_(PEP *pep,PetscInt *n,Vec *is,int *ierr)pepsetinitialspace0_538,24785
SLEPC_EXTERN void PETSC_STDCALL pepsetinitialspace1_(PEP *pep,PetscInt *n,Vec *is,int *ierr)pepsetinitialspace1_544,24953

src/pep/interface/makefile,373
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = pepmon.c pepbasic.c pepview.c pepdefault.c pepregis.c pepopts.c pepsetup.c pepsolve.c peprefine.c dlregispep.cSOURCEC15,431
SOURCEF  =SOURCEF16,553
SOURCEH  =SOURCEH17,564
LIBBASE  = libslepcpepLIBBASE18,575
DIRS     =DIRS19,598
MANSEC   = PEPMANSEC20,609
LOCDIR   = src/pep/interface/LOCDIR21,624

src/pep/interface/pepbasic.c,1722
pepbasic.c:^?pepbasic.c^A,1
PetscFunctionList PEPList = 0;PEPList16,490
PetscBool         PEPRegisterAllCalled = PETSC_FALSE;PEPRegisterAllCalled17,521
PetscClassId      PEP_CLASSID = 0;PEP_CLASSID18,575
PetscLogEvent     PEP_SetUp = 0,PEP_Solve = 0,PEP_Refine = 0;PEP_SetUp19,610
PetscLogEvent     PEP_SetUp = 0,PEP_Solve = 0,PEP_Refine = 0;PEP_Solve19,610
PetscLogEvent     PEP_SetUp = 0,PEP_Solve = 0,PEP_Refine = 0;PEP_Refine19,610
PetscErrorCode PEPCreate(MPI_Comm comm,PEP *outpep)PEPCreate39,973
PetscErrorCode PEPSetType(PEP pep,PEPType type)PEPSetType150,4414
PetscErrorCode PEPGetType(PEP pep,PEPType *type)PEPGetType189,5486
PetscErrorCode PEPRegister(const char *name,PetscErrorCode (*function)(PEP))PEPRegister224,6303
PetscErrorCode PEPReset(PEP pep)PEPReset247,6843
PetscErrorCode PEPDestroy(PEP *pep)PEPDestroy284,7930
PetscErrorCode PEPSetBV(PEP pep,BV bv)PEPSetBV330,9491
PetscErrorCode PEPGetBV(PEP pep,BV *bv)PEPGetBV361,10232
PetscErrorCode PEPSetRG(PEP pep,RG rg)PEPSetRG395,11183
PetscErrorCode PEPGetRG(PEP pep,RG *rg)PEPGetRG426,11913
PetscErrorCode PEPSetDS(PEP pep,DS ds)PEPSetDS460,12891
PetscErrorCode PEPGetDS(PEP pep,DS *ds)PEPGetDS491,13635
PetscErrorCode PEPSetST(PEP pep,ST st)PEPSetST525,14633
PetscErrorCode PEPGetST(PEP pep,ST *st)PEPGetST556,15395
PetscErrorCode PEPRefineGetKSP(PEP pep,KSP *ksp)PEPRefineGetKSP589,16279
PetscErrorCode PEPSetTarget(PEP pep,PetscScalar target)PEPSetTarget640,18341
PetscErrorCode PEPGetTarget(PEP pep,PetscScalar* target)PEPGetTarget671,19027
PetscErrorCode PEPSetInterval(PEP pep,PetscReal inta,PetscReal intb)PEPSetInterval708,20200
PetscErrorCode PEPGetInterval(PEP pep,PetscReal* inta,PetscReal* intb)PEPGetInterval742,21096

src/pep/interface/pepdefault.c,1094
pepdefault.c:^?pepdefault.c^A,1
PetscErrorCode PEPSetWorkVecs(PEP pep,PetscInt nw)PEPSetWorkVecs31,857
PetscErrorCode PEPConvergedRelative(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)PEPConvergedRelative51,1429
PetscErrorCode PEPConvergedNorm(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)PEPConvergedNorm64,1751
PetscErrorCode PEPConvergedAbsolute(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx)PEPConvergedAbsolute91,2618
PetscErrorCode PEPStoppingBasic(PEP pep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,PEPConvergedReason *reason,void *ctx)PEPStoppingBasic130,3896
PetscErrorCode PEPBackTransform_Default(PEP pep)PEPBackTransform_Default146,4533
PetscErrorCode PEPComputeVectors_Default(PEP pep)PEPComputeVectors_Default155,4739
PetscErrorCode PEPBuildDiagonalScaling(PEP pep)PEPBuildDiagonalScaling201,6232
PetscErrorCode PEPComputeScaleFactor(PEP pep)PEPComputeScaleFactor350,12046
PetscErrorCode PEPBasisCoefficients(PEP pep,PetscReal *pbc)PEPBasisCoefficients407,14005

src/pep/interface/pepmon.c,1683
pepmon.c:^?pepmon.c^A,1
PetscErrorCode PEPMonitor(PEP pep,PetscInt it,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest)PEPMonitor20,585
PetscErrorCode PEPMonitorSet(PEP pep,PetscErrorCode (*monitor)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))PEPMonitorSet79,2957
PetscErrorCode PEPMonitorCancel(PEP pep)PEPMonitorCancel107,4008
PetscErrorCode PEPGetMonitorContext(PEP pep,void **ctx)PEPGetMonitorContext139,4717
static PetscErrorCode PEPMonitorGetTrueEig(PEP pep,PetscScalar *er,PetscScalar *ei)PEPMonitorGetTrueEig150,4985
PetscErrorCode PEPMonitorAll(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)PEPMonitorAll189,6146
PetscErrorCode PEPMonitorFirst(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)PEPMonitorFirst246,8552
PetscErrorCode PEPMonitorConverged(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,SlepcConvMonitor ctx)PEPMonitorConverged301,10859
PetscErrorCode PEPMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)PEPMonitorLGCreate369,13465
PetscErrorCode PEPMonitorLG(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)PEPMonitorLG385,14011
PetscErrorCode PEPMonitorLGAll(PEP pep,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)PEPMonitorLGAll409,14857

src/pep/interface/pepopts.c,3696
pepopts.c:^?pepopts.c^A,1
PetscErrorCode PEPMonitorSetFromOptions(PEP pep,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscBool trackall)PEPMonitorSetFromOptions36,1177
PetscErrorCode PEPConvMonitorSetFromOptions(PEP pep,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,SlepcConvMonitor))PEPConvMonitorSetFromOptions74,2802
PetscErrorCode PEPSetFromOptions(PEP pep)PEPSetFromOptions107,4093
PetscErrorCode PEPGetTolerances(PEP pep,PetscReal *tol,PetscInt *maxits)PEPGetTolerances308,17553
PetscErrorCode PEPSetTolerances(PEP pep,PetscReal tol,PetscInt maxits)PEPSetTolerances339,18384
PetscErrorCode PEPGetDimensions(PEP pep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)PEPGetDimensions383,19723
PetscErrorCode PEPSetDimensions(PEP pep,PetscInt nev,PetscInt ncv,PetscInt mpd)PEPSetDimensions430,21430
PetscErrorCode PEPSetWhichEigenpairs(PEP pep,PEPWhich which)PEPSetWhichEigenpairs513,24919
PetscErrorCode PEPGetWhichEigenpairs(PEP pep,PEPWhich *which)PEPGetWhichEigenpairs562,26154
PetscErrorCode PEPSetEigenvalueComparison(PEP pep,PetscErrorCode (*func)(PetscScalar,PetscScalar,PetscScalar,PetscScalar,PetscInt*,void*),void* ctx)PEPSetEigenvalueComparison602,27464
PetscErrorCode PEPSetProblemType(PEP pep,PEPProblemType type)PEPSetProblemType644,29111
PetscErrorCode PEPGetProblemType(PEP pep,PEPProblemType *type)PEPGetProblemType672,29897
PetscErrorCode PEPSetBasis(PEP pep,PEPBasis basis)PEPSetBasis705,30853
PetscErrorCode PEPGetBasis(PEP pep,PEPBasis *basis)PEPGetBasis729,31351
PetscErrorCode PEPSetTrackAll(PEP pep,PetscBool trackall)PEPSetTrackAll760,32255
PetscErrorCode PEPGetTrackAll(PEP pep,PetscBool *trackall)PEPGetTrackAll785,32779
PetscErrorCode PEPSetConvergenceTestFunction(PEP pep,PetscErrorCode (*func)(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*),void* ctx,PetscErrorCode (*destroy)(void*))PEPSetConvergenceTestFunction824,34114
PetscErrorCode PEPSetConvergenceTest(PEP pep,PEPConv conv)PEPSetConvergenceTest873,35912
PetscErrorCode PEPGetConvergenceTest(PEP pep,PEPConv *conv)PEPGetConvergenceTest909,37046
PetscErrorCode PEPSetStoppingTestFunction(PEP pep,PetscErrorCode (*func)(PEP,PetscInt,PetscInt,PetscInt,PetscInt,PEPConvergedReason*,void*),void* ctx,PetscErrorCode (*destroy)(void*))PEPSetStoppingTestFunction951,38535
PetscErrorCode PEPSetStoppingTest(PEP pep,PEPStop stop)PEPSetStoppingTest994,39877
PetscErrorCode PEPGetStoppingTest(PEP pep,PEPStop *stop)PEPGetStoppingTest1028,40853
PetscErrorCode PEPSetScale(PEP pep,PEPScale scale,PetscReal alpha,Vec Dl,Vec Dr,PetscInt its,PetscReal lambda)PEPSetScale1080,42963
PetscErrorCode PEPGetScale(PEP pep,PEPScale *scale,PetscReal *alpha,Vec *Dl,Vec *Dr,PetscInt *its,PetscReal *lambda)PEPGetScale1153,45628
PetscErrorCode PEPSetExtract(PEP pep,PEPExtract extract)PEPSetExtract1182,46414
PetscErrorCode PEPGetExtract(PEP pep,PEPExtract *extract)PEPGetExtract1206,46906
PetscErrorCode PEPSetRefine(PEP pep,PEPRefine refine,PetscInt npart,PetscReal tol,PetscInt its,PEPRefineScheme scheme)PEPSetRefine1262,49151
PetscErrorCode PEPGetRefine(PEP pep,PEPRefine *refine,PetscInt *npart,PetscReal *tol,PetscInt *its,PEPRefineScheme *scheme)PEPGetRefine1328,51378
PetscErrorCode PEPSetOptionsPrefix(PEP pep,const char *prefix)PEPSetOptionsPrefix1366,52496
PetscErrorCode PEPAppendOptionsPrefix(PEP pep,const char *prefix)PEPAppendOptionsPrefix1402,53770
PetscErrorCode PEPGetOptionsPrefix(PEP pep,const char *prefix[])PEPGetOptionsPrefix1440,55019

src/pep/interface/peprefine.c,1429
peprefine.c:^?peprefine.c^A,1
#define NREF_MAXIT NREF_MAXIT17,516
  VecScatter *scatter_id,nst;scatter_id20,556
  VecScatter *scatter_id,nst;nst20,556
  Mat        *A;A21,586
  Vec        nv,vg,v,w;nv22,603
  Vec        nv,vg,v,w;vg22,603
  Vec        nv,vg,v,w;v22,603
  Vec        nv,vg,v,w;w22,603
} PEPSimpNRefctx;PEPSimpNRefctx23,627
  Mat          M1;M126,663
  Vec          M2,M3;M227,682
  Vec          M2,M3;M327,682
  PetscScalar  M4,m3;M428,704
  PetscScalar  M4,m3;m328,704
} FSubctx;FSubctx29,726
static PetscErrorCode MatFSMult(Mat M ,Vec x,Vec y)MatFSMult31,738
static PetscErrorCode PEPSimpleNRefSetUp(PEP pep,PEPSimpNRefctx **ctx_)PEPSimpleNRefSetUp46,1121
static PetscErrorCode PEPSimpleNRefGatherEigenpair(PEP pep,PEPSimpNRefctx *ctx,PetscInt sc,PetscInt idx,PetscInt *fail)PEPSimpleNRefGatherEigenpair121,4203
static PetscErrorCode PEPSimpleNRefScatterEigenvector(PEP pep,PEPSimpNRefctx *ctx,PetscInt sc,PetscInt idx)PEPSimpleNRefScatterEigenvector160,5825
static PetscErrorCode PEPEvaluateFunctionDerivatives(PEP pep,PetscScalar alpha,PetscScalar *vals)PEPEvaluateFunctionDerivatives184,6722
static PetscErrorCode PEPSimpleNRefSetUpSystem(PEP pep,Mat *A,PEPSimpNRefctx *ctx,PetscInt idx,Mat *Mt,Mat *T,Mat *P,PetscBool ini,Vec t,Vec v)PEPSimpleNRefSetUpSystem203,7217
PetscErrorCode PEPNewtonRefinementSimple(PEP pep,PetscInt *maxits,PetscReal tol,PetscInt k)PEPNewtonRefinementSimple374,13999

src/pep/interface/pepregis.c,58
pepregis.c:^?pepregis.c^A,1
PetscErrorCode PEPRegisterAll(void)PEPRegisterAll28,853

src/pep/interface/pepsetup.c,759
pepsetup.c:^?pepsetup.c^A,1
PetscErrorCode PEPSetDefaultST(PEP pep)PEPSetDefaultST22,748
PetscErrorCode PEPSetDefaultST_Transform(PEP pep)PEPSetDefaultST_Transform38,1199
PetscErrorCode PEPSetUp(PEP pep)PEPSetUp65,1834
PetscErrorCode PEPSetOperators(PEP pep,PetscInt nmat,Mat A[])PEPSetOperators277,9963
PetscErrorCode PEPGetOperators(PEP pep,PetscInt k,Mat *A)PEPGetOperators334,12103
PetscErrorCode PEPGetNumMatrices(PEP pep,PetscInt *nmat)PEPGetNumMatrices359,12726
PetscErrorCode PEPSetInitialSpace(PEP pep,PetscInt n,Vec is[])PEPSetInitialSpace394,13803
PetscErrorCode PEPSetDimensions_Default(PEP pep,PetscInt nev,PetscInt *ncv,PetscInt *mpd)PEPSetDimensions_Default415,14483
PetscErrorCode PEPAllocateSolution(PEP pep,PetscInt extra)PEPAllocateSolution460,15908

src/pep/interface/pepsolve.c,1096
pepsolve.c:^?pepsolve.c^A,1
static PetscBool  cited = PETSC_FALSE;cited18,601
static const char citation[] =citation19,640
PetscErrorCode PEPComputeVectors(PEP pep)PEPComputeVectors31,1061
PetscErrorCode PEPExtractVectors(PEP pep)PEPExtractVectors44,1373
PetscErrorCode PEPSolve(PEP pep)PEPSolve79,2545
#define OPTLEN OPTLEN84,2656
PetscErrorCode PEPGetIterationNumber(PEP pep,PetscInt *its)PEPGetIterationNumber191,6238
PetscErrorCode PEPGetConverged(PEP pep,PetscInt *nconv)PEPGetConverged218,6803
PetscErrorCode PEPGetConvergedReason(PEP pep,PEPConvergedReason *reason)PEPGetConvergedReason255,7839
PetscErrorCode PEPGetEigenpair(PEP pep,PetscInt i,PetscScalar *eigr,PetscScalar *eigi,Vec Vr,Vec Vi)PEPGetEigenpair300,9373
PetscErrorCode PEPGetErrorEstimate(PEP pep,PetscInt i,PetscReal *errest)PEPGetErrorEstimate352,10839
PetscErrorCode PEPComputeResidualNorm_Private(PEP pep,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec *z,PetscReal *norm)PEPComputeResidualNorm_Private372,11504
PetscErrorCode PEPComputeError(PEP pep,PetscInt i,PEPErrorType type,PetscReal *error)PEPComputeError470,14124

src/pep/interface/pepview.c,1490
pepview.c:^?pepview.c^A,1
PetscErrorCode PEPView(PEP pep,PetscViewer viewer)PEPView44,1308
#define HERM HERM62,1845
PetscErrorCode PEPReasonView(PEP pep,PetscViewer viewer)PEPReasonView229,10023
PetscErrorCode PEPReasonViewFromOptions(PEP pep)PEPReasonViewFromOptions259,11254
static PetscErrorCode PEPErrorView_ASCII(PEP pep,PEPErrorType etype,PetscViewer viewer)PEPErrorView_ASCII281,12013
static PetscErrorCode PEPErrorView_DETAIL(PEP pep,PEPErrorType etype,PetscViewer viewer)PEPErrorView_DETAIL312,13268
#define EXLEN EXLEN318,13456
static PetscErrorCode PEPErrorView_MATLAB(PEP pep,PEPErrorType etype,PetscViewer viewer)PEPErrorView_MATLAB355,14734
PetscErrorCode PEPErrorView(PEP pep,PEPErrorType etype,PetscViewer viewer)PEPErrorView399,16204
PetscErrorCode PEPErrorViewFromOptions(PEP pep)PEPErrorViewFromOptions445,17659
static PetscErrorCode PEPValuesView_DRAW(PEP pep,PetscViewer viewer)PEPValuesView_DRAW481,19309
static PetscErrorCode PEPValuesView_ASCII(PEP pep,PetscViewer viewer)PEPValuesView_ASCII511,20233
static PetscErrorCode PEPValuesView_MATLAB(PEP pep,PetscViewer viewer)PEPValuesView_MATLAB528,20804
PetscErrorCode PEPValuesView(PEP pep,PetscViewer viewer)PEPValuesView573,22012
PetscErrorCode PEPValuesViewFromOptions(PEP pep)PEPValuesViewFromOptions620,23535
PetscErrorCode PEPVectorsView(PEP pep,PetscViewer viewer)PEPVectorsView663,24821
#define NMLEN NMLEN668,24946
PetscErrorCode PEPVectorsViewFromOptions(PEP pep)PEPVectorsViewFromOptions706,26099

src/pep/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/pepimpl.h ../../include/slepcpep.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/pep/LOCDIR15,527
MANSEC   = PEPMANSEC16,547

src/svd/examples/makefile,82
makefile:^?makefile^A,1
LOCDIR   = src/svd/examples/LOCDIR13,405
DIRS     = tests tutorialsDIRS14,434

src/svd/examples/tests/makefile,456
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/svd/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c test10.c \EXAMPLESC16,488
EXAMPLESF  = test4f.FEXAMPLESF18,624
MANSEC     = SVDMANSEC19,646
TESTS      = test1 test2 test3 test4 test4f test5 test6 test7 test8 test9 test10 test11 test12 \TESTS20,663

src/svd/examples/tests/test1.c,162
test1.c:^?test1.c^A,1
static char help[] = "Test the solution of a SVD without calling SVDSetFromOptions (based on ex8.c).\n\n"help11,400
int main(int argc,char **argv)main34,1179

src/svd/examples/tests/test10.c,136
test10.c:^?test10.c^A,1
static char help[] = "Lanczos SVD. Also illustrates the use of SVDSetBV().\n\n"help11,400
int main(int argc,char **argv)main30,1043

src/svd/examples/tests/test11.c,259
test11.c:^?test11.c^A,1
static char help[] = "Tests a user-defined convergence test (based on ex8.c).\n\n"help11,400
PetscErrorCode MyConvergedRel(SVD svd,PetscReal sigma,PetscReal res,PetscReal *errest,void *ctx)MyConvergedRel36,1195
int main(int argc,char **argv)main45,1405

src/svd/examples/tests/test12.c,284
test12.c:^?test12.c^A,1
static char help[] = "SVD problem with user-defined stopping test.\n\n"help11,400
PetscErrorCode MyStoppingTest(SVD svd,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,SVDConvergedReason *reason,void *ctx)MyStoppingTest36,1176
int main(int argc,char **argv)main52,1758

src/svd/examples/tests/test13.c,126
test13.c:^?test13.c^A,1
static char help[] = "Test interface to external package PRIMME.\n\n"help11,400
int main(int argc,char **argv)main30,1033

src/svd/examples/tests/test2.c,142
test2.c:^?test2.c^A,1
static char help[] = "Test SVD with different builds with a matrix loaded from a file"help11,400
int main(int argc,char **argv)main16,567

src/svd/examples/tests/test3.c,128
test3.c:^?test3.c^A,1
static char help[] = "Test SVD with user-provided initial vectors.\n\n"help11,400
int main(int argc,char **argv)main31,1022

src/svd/examples/tests/test4.c,132
test4.c:^?test4.c^A,1
static char help[] = "Test an SVD problem with more columns than rows.\n\n"help11,400
int main(int argc,char **argv)main30,1039

src/svd/examples/tests/test4f.F,363
test4f.F:^?test4f.F^A,1
      program mainmain28,1091
 100  format (/'Bidiagonal matrix, m =',I3,', n=',I3,' (Fortran)')10066,2372
 110  format (/' Transpose mode is',A9)110117,4086
 120  format (' Convergence test is',I2)120122,4240
 130  format (' Stopping test is',I2)130127,4390
 140  format (' Which =',A9)140136,4658
 150  format (' Converged reason:',I2)150144,4861

src/svd/examples/tests/test5.c,124
test5.c:^?test5.c^A,1
static char help[] = "Test SVD view and monitor functionality.\n\n";help11,400
int main(int argc,char **argv)main15,493

src/svd/examples/tests/test6.c,142
test6.c:^?test6.c^A,1
static char help[] = "SVD via the cross-product matrix with a user-provided EPS.\n\n"help11,400
int main(int argc,char **argv)main30,1049

src/svd/examples/tests/test7.c,135
test7.c:^?test7.c^A,1
static char help[] = "SVD via the cyclic matrix with a user-provided EPS.\n\n"help11,400
int main(int argc,char **argv)main30,1042

src/svd/examples/tests/test8.c,130
test8.c:^?test8.c^A,1
static char help[] = "Tests multiple calls to SVDSolve changing ncv.\n\n"help11,400
int main(int argc,char **argv)main33,1102

src/svd/examples/tests/test9.c,144
test9.c:^?test9.c^A,1
static char help[] = "Tests multiple calls to SVDSolve with different matrix size.\n\n"help11,400
int main(int argc,char **argv)main33,1116

src/svd/examples/tutorials/ex14.c,148
ex14.c:^?ex14.c^A,1
static char help[] = "Solves a singular value problem with the matrix loaded from a file.\n"help11,400
int main(int argc,char **argv)main18,697

src/svd/examples/tutorials/ex15.c,132
ex15.c:^?ex15.c^A,1
static char help[] = "Singular value decomposition of the Lauchli matrix.\n"help11,400
int main(int argc,char **argv)main18,636

src/svd/examples/tutorials/ex15f.F,529
ex15f.F:^?ex15f.F^A,1
      program mainmain20,760
 100  format (/'Lauchli SVD, n =',I3,', mu=',E12.4,' (Fortran)')10060,2056
 110  format (/' Number of iterations of the method:',I4)110112,3797
 120  format (' Solution method: ',A)120119,4032
 130  format (' Number of requested singular values:',I2)130125,4262
 140  format (' Stopping condition: tol=',1P,E11.4,', maxit=',I4)140130,4440
 150  format (' Number of converged approximate singular triplets:',I2/)150141,4853
 160      format (1P,'   ',E12.4,'       ',E12.4)160159,5563

src/svd/examples/tutorials/ex8.c,205
ex8.c:^?ex8.c^A,1
static char help[] = "Estimates the 2-norm condition number of a matrix A, that is, the ratio of the largest to the smallest singular values of A. "help11,400
int main(int argc,char **argv)main34,1215

src/svd/examples/tutorials/makefile,286
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/svd/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex8.c ex14.c ex15.cEXAMPLESC16,492
EXAMPLESF  = ex15f.FEXAMPLESF17,525
MANSEC     = SVDMANSEC18,546

src/svd/f90-mod/makefile,328
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcsvdmod.FSOURCEF17,514
SOURCEH    = slepcsvd.h slepcsvd.h90SOURCEH18,541
LIBBASE    = libslepcsvdLIBBASE19,578
MANSEC     = SVDMANSEC20,603
LOCDIR     = src/svd/f90-mod/LOCDIR21,620
CLEANFILES = *.modCLEANFILES22,650

src/svd/f90-mod/slepcsvd.h,146
slepcsvd.h:^?slepcsvd.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      SVD, parameter :: SLEPC_NULL_SVD = tSVD(0)SVD18,593

src/svd/f90-mod/slepcsvdmod.F,86
slepcsvdmod.F:^?slepcsvdmod.F^A,1
        module slepcsvddefslepcsvddef10,398
        module slepcsvdslepcsvd16,533

src/svd/impls/cross/cross.c,2019
cross.c:^?cross.c^A,1
  PetscBool explicitmatrix;explicitmatrix20,657
  EPS       eps;eps21,685
  PetscBool usereps;usereps22,702
  Mat       mat;mat23,723
  Vec       w,diag;w24,740
  Vec       w,diag;diag24,740
} SVD_CROSS;SVD_CROSS25,760
static PetscErrorCode MatMult_Cross(Mat B,Vec x,Vec y)MatMult_Cross27,774
static PetscErrorCode MatCreateVecs_Cross(Mat B,Vec *right,Vec *left)MatCreateVecs_Cross41,1170
static PetscErrorCode MatGetDiagonal_Cross(Mat B,Vec d)MatGetDiagonal_Cross57,1611
PetscErrorCode SVDSetUp_Cross(SVD svd)SVDSetUp_Cross106,3557
PetscErrorCode SVDSolve_Cross(SVD svd)SVDSolve_Cross176,7155
static PetscErrorCode EPSMonitor_Cross(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitor_Cross205,8264
PetscErrorCode SVDSetFromOptions_Cross(PetscOptionItems *PetscOptionsObject,SVD svd)SVDSetFromOptions_Cross223,8891
static PetscErrorCode SVDCrossSetExplicitMatrix_Cross(SVD svd,PetscBool explicitmatrix)SVDCrossSetExplicitMatrix_Cross248,9867
PetscErrorCode SVDCrossSetExplicitMatrix(SVD svd,PetscBool explicitmatrix)SVDCrossSetExplicitMatrix277,10610
static PetscErrorCode SVDCrossGetExplicitMatrix_Cross(SVD svd,PetscBool *explicitmatrix)SVDCrossGetExplicitMatrix_Cross288,10977
PetscErrorCode SVDCrossGetExplicitMatrix(SVD svd,PetscBool *explicitmatrix)SVDCrossGetExplicitMatrix312,11485
static PetscErrorCode SVDCrossSetEPS_Cross(SVD svd,EPS eps)SVDCrossSetEPS_Cross323,11840
PetscErrorCode SVDCrossSetEPS(SVD svd,EPS eps)SVDCrossSetEPS352,12563
static PetscErrorCode SVDCrossGetEPS_Cross(SVD svd,EPS *eps)SVDCrossGetEPS_Cross364,12899
PetscErrorCode SVDCrossGetEPS(SVD svd,EPS *eps)SVDCrossGetEPS400,14101
PetscErrorCode SVDView_Cross(SVD svd,PetscViewer viewer)SVDView_Cross411,14385
PetscErrorCode SVDReset_Cross(SVD svd)SVDReset_Cross429,15073
PetscErrorCode SVDDestroy_Cross(SVD svd)SVDDestroy_Cross442,15426
SLEPC_EXTERN PetscErrorCode SVDCreate_Cross(SVD svd)SVDCreate_Cross457,16080

src/svd/impls/cross/makefile,272
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = cross.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsvdLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = SVDMANSEC20,506
LOCDIR   = src/svd/impls/cross/LOCDIR21,521

src/svd/impls/cyclic/cyclic.c,1737
cyclic.c:^?cyclic.c^A,1
static PetscErrorCode MatMult_Cyclic(Mat B,Vec x,Vec y)MatMult_Cyclic20,679
static PetscErrorCode MatGetDiagonal_Cyclic(Mat B,Vec diag)MatGetDiagonal_Cyclic50,1843
PetscErrorCode SVDSetUp_Cyclic(SVD svd)SVDSetUp_Cyclic59,2021
PetscErrorCode SVDSolve_Cyclic(SVD svd)SVDSolve_Cyclic201,9307
static PetscErrorCode EPSMonitor_Cyclic(EPS eps,PetscInt its,PetscInt nconv,PetscScalar *eigr,PetscScalar *eigi,PetscReal *errest,PetscInt nest,void *ctx)EPSMonitor_Cyclic245,10996
PetscErrorCode SVDSetFromOptions_Cyclic(PetscOptionItems *PetscOptionsObject,SVD svd)SVDSetFromOptions_Cyclic269,11736
static PetscErrorCode SVDCyclicSetExplicitMatrix_Cyclic(SVD svd,PetscBool explicitmatrix)SVDCyclicSetExplicitMatrix_Cyclic294,12728
PetscErrorCode SVDCyclicSetExplicitMatrix(SVD svd,PetscBool explicitmatrix)SVDCyclicSetExplicitMatrix323,13498
static PetscErrorCode SVDCyclicGetExplicitMatrix_Cyclic(SVD svd,PetscBool *explicitmatrix)SVDCyclicGetExplicitMatrix_Cyclic334,13867
PetscErrorCode SVDCyclicGetExplicitMatrix(SVD svd,PetscBool *explicitmatrix)SVDCyclicGetExplicitMatrix358,14382
static PetscErrorCode SVDCyclicSetEPS_Cyclic(SVD svd,EPS eps)SVDCyclicSetEPS_Cyclic369,14739
PetscErrorCode SVDCyclicSetEPS(SVD svd,EPS eps)SVDCyclicSetEPS398,15474
static PetscErrorCode SVDCyclicGetEPS_Cyclic(SVD svd,EPS *eps)SVDCyclicGetEPS_Cyclic410,15812
PetscErrorCode SVDCyclicGetEPS(SVD svd,EPS *eps)SVDCyclicGetEPS446,17032
PetscErrorCode SVDView_Cyclic(SVD svd,PetscViewer viewer)SVDView_Cyclic457,17318
PetscErrorCode SVDReset_Cyclic(SVD svd)SVDReset_Cyclic475,18014
PetscErrorCode SVDDestroy_Cyclic(SVD svd)SVDDestroy_Cyclic490,18469
SLEPC_EXTERN PetscErrorCode SVDCreate_Cyclic(SVD svd)SVDCreate_Cyclic505,19131

src/svd/impls/cyclic/cyclic.h,359
cyclic.h:^?cyclic.h^A,1
#define SLEPC_CYCLIC_HSLEPC_CYCLIC_H12,429
  PetscBool explicitmatrix;explicitmatrix15,470
  EPS       eps;eps16,498
  PetscBool usereps;usereps17,515
  Mat       mat;mat18,536
  Vec       x1,x2,y1,y2;x119,553
  Vec       x1,x2,y1,y2;x219,553
  Vec       x1,x2,y1,y2;y119,553
  Vec       x1,x2,y1,y2;y219,553
} SVD_CYCLIC;SVD_CYCLIC20,578

src/svd/impls/cyclic/cycliccuda/makefile,291
makefile:^?makefile^A,1
CFLAGS   =CFLAGS14,444
FFLAGS   =FFLAGS15,455
SOURCECU = cycliccuda.cuSOURCECU16,466
SOURCEF  =SOURCEF17,491
SOURCEH  =SOURCEH18,502
LIBBASE  = libslepcsvdLIBBASE19,513
DIRS     =DIRS20,536
MANSEC   = SVDMANSEC21,547
LOCDIR   = src/svd/impls/cyclic/cycliccuda/LOCDIR22,562

src/svd/impls/cyclic/makefile,294
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = cyclic.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  = cyclic.hSOURCEH17,462
LIBBASE  = libslepcsvdLIBBASE18,482
DIRS     = cycliccudaDIRS19,505
MANSEC   = SVDMANSEC20,527
LOCDIR   = src/svd/impls/cyclic/LOCDIR21,542

src/svd/impls/external/makefile,146
makefile:^?makefile^A,1
LIBBASE  = libslepcsvdLIBBASE13,409
DIRS     = primmeDIRS14,432
LOCDIR   = src/svd/impls/external/LOCDIR15,450
MANSEC   = SVDMANSEC16,485

src/svd/impls/external/primme/makefile,302
makefile:^?makefile^A,1
CFLAGS   = ${PRIMME_FLAGS}CFLAGS15,447
FFLAGS   =FFLAGS16,474
SOURCEC  = svdprimme.cSOURCEC17,485
SOURCEF  =SOURCEF18,508
SOURCEH  =SOURCEH19,519
LIBBASE  = libslepcsvdLIBBASE20,530
DIRS     =DIRS21,553
MANSEC   = SVDMANSEC22,564
LOCDIR   = src/svd/impls/external/primme/LOCDIR23,579

src/svd/impls/external/primme/svdprimme.c,2258
svdprimme.c:^?svdprimme.c^A,1
#define PRIMME_DRIVER PRIMME_DRIVER20,612
#define PRIMME_DRIVER PRIMME_DRIVER22,653
#define PRIMME_DRIVER PRIMME_DRIVER26,736
#define PRIMME_DRIVER PRIMME_DRIVER28,777
  primme_svds_params primme;         /* param struct */primme33,844
  primme_svds_preset_method method;  /* primme method */method34,900
  SVD       svd;                     /* reference to the solver */svd35,957
  Vec       x,y;                     /* auxiliary vectors */x36,1024
  Vec       x,y;                     /* auxiliary vectors */y36,1024
} SVD_PRIMME;SVD_PRIMME37,1085
static void par_GlobalSumReal(void *sendBuf,void *recvBuf,int *count,primme_svds_params *primme,int *ierr)par_GlobalSumReal41,1211
PetscErrorCode SVDSetUp_PRIMME(SVD svd)SVDSetUp_PRIMME46,1504
PetscErrorCode SVDSolve_PRIMME(SVD svd)SVDSolve_PRIMME115,4190
static void multMatvec_PRIMME(void *xa,PRIMME_INT *ldx,void *ya,PRIMME_INT *ldy,int *blockSize,int *transpose,struct primme_svds_params *primme,int *ierr)multMatvec_PRIMME155,5854
PetscErrorCode SVDReset_PRIMME(SVD svd)SVDReset_PRIMME179,7081
PetscErrorCode SVDDestroy_PRIMME(SVD svd)SVDDestroy_PRIMME191,7368
PetscErrorCode SVDView_PRIMME(SVD svd,PetscViewer viewer)SVDView_PRIMME204,7926
PetscErrorCode SVDSetFromOptions_PRIMME(PetscOptionItems *PetscOptionsObject,SVD svd)SVDSetFromOptions_PRIMME226,8763
static PetscErrorCode SVDPRIMMESetBlockSize_PRIMME(SVD svd,PetscInt bs)SVDPRIMMESetBlockSize_PRIMME247,9653
PetscErrorCode SVDPRIMMESetBlockSize(SVD svd,PetscInt bs)SVDPRIMMESetBlockSize283,10792
static PetscErrorCode SVDPRIMMEGetBlockSize_PRIMME(SVD svd,PetscInt *bs)SVDPRIMMEGetBlockSize_PRIMME294,11112
PetscErrorCode SVDPRIMMEGetBlockSize(SVD svd,PetscInt *bs)SVDPRIMMEGetBlockSize318,11593
static PetscErrorCode SVDPRIMMESetMethod_PRIMME(SVD svd,SVDPRIMMEMethod method)SVDPRIMMESetMethod_PRIMME329,11901
PetscErrorCode SVDPRIMMESetMethod(SVD svd,SVDPRIMMEMethod method)SVDPRIMMESetMethod357,12577
static PetscErrorCode SVDPRIMMEGetMethod_PRIMME(SVD svd,SVDPRIMMEMethod *method)SVDPRIMMEGetMethod_PRIMME368,12918
PetscErrorCode SVDPRIMMEGetMethod(SVD svd,SVDPRIMMEMethod *method)SVDPRIMMEGetMethod392,13435
SLEPC_EXTERN PetscErrorCode SVDCreate_PRIMME(SVD svd)SVDCreate_PRIMME403,13760

src/svd/impls/lanczos/gklanczos.c,1292
gklanczos.c:^?gklanczos.c^A,1
  PetscBool oneside;oneside34,1066
} SVD_LANCZOS;SVD_LANCZOS35,1087
PetscErrorCode SVDSetUp_Lanczos(SVD svd)SVDSetUp_Lanczos37,1103
PetscErrorCode SVDTwoSideLanczos(SVD svd,PetscReal *alpha,PetscReal *beta,BV V,BV U,PetscInt k,PetscInt n)SVDTwoSideLanczos56,1847
static PetscErrorCode SVDOneSideLanczos(SVD svd,PetscReal *alpha,PetscReal *beta,BV V,Vec u,Vec u_1,PetscInt k,PetscInt n,PetscScalar* work)SVDOneSideLanczos98,3645
PetscErrorCode SVDSolve_Lanczos(SVD svd)SVDSolve_Lanczos162,6100
PetscErrorCode SVDSetFromOptions_Lanczos(PetscOptionItems *PetscOptionsObject,SVD svd)SVDSetFromOptions_Lanczos273,10298
static PetscErrorCode SVDLanczosSetOneSide_Lanczos(SVD svd,PetscBool oneside)SVDLanczosSetOneSide_Lanczos289,10890
PetscErrorCode SVDLanczosSetOneSide(SVD svd,PetscBool oneside)SVDLanczosSetOneSide324,11893
static PetscErrorCode SVDLanczosGetOneSide_Lanczos(SVD svd,PetscBool *oneside)SVDLanczosGetOneSide_Lanczos335,12229
PetscErrorCode SVDLanczosGetOneSide(SVD svd,PetscBool *oneside)SVDLanczosGetOneSide360,12784
PetscErrorCode SVDDestroy_Lanczos(SVD svd)SVDDestroy_Lanczos371,13108
PetscErrorCode SVDView_Lanczos(SVD svd,PetscViewer viewer)SVDView_Lanczos382,13471
SLEPC_EXTERN PetscErrorCode SVDCreate_Lanczos(SVD svd)SVDCreate_Lanczos396,13924

src/svd/impls/lanczos/makefile,278
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = gklanczos.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsvdLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = SVDMANSEC20,510
LOCDIR   = src/svd/impls/lanczos/LOCDIR21,525

src/svd/impls/lapack/makefile,277
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = svdlapack.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsvdLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = SVDMANSEC20,510
LOCDIR   = src/svd/impls/lapack/LOCDIR21,525

src/svd/impls/lapack/svdlapack.c,207
svdlapack.c:^?svdlapack.c^A,1
PetscErrorCode SVDSetUp_LAPACK(SVD svd)SVDSetUp_LAPACK16,506
PetscErrorCode SVDSolve_LAPACK(SVD svd)SVDSolve_LAPACK34,1159
SLEPC_EXTERN PetscErrorCode SVDCreate_LAPACK(SVD svd)SVDCreate_LAPACK100,3731

src/svd/impls/makefile,177
makefile:^?makefile^A,1
LIBBASE  = libslepcsvdLIBBASE13,409
DIRS     = cross cyclic lapack lanczos trlanczos externalDIRS14,432
LOCDIR   = src/svd/impls/LOCDIR15,490
MANSEC   = SVDMANSEC16,516

src/svd/impls/trlanczos/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = trlanczos.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsvdLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = SVDMANSEC20,510
LOCDIR   = src/svd/impls/trlanczos/LOCDIR21,525

src/svd/impls/trlanczos/trlanczos.c,1683
trlanczos.c:^?trlanczos.c^A,1
static PetscBool  cited = PETSC_FALSE;cited33,1035
static const char citation[] =citation34,1074
  PetscBool oneside;oneside45,1486
} SVD_TRLANCZOS;SVD_TRLANCZOS46,1507
PetscErrorCode SVDSetUp_TRLanczos(SVD svd)SVDSetUp_TRLanczos48,1525
static PetscErrorCode SVDOneSideTRLanczosMGS(SVD svd,PetscReal *alpha,PetscReal *beta,BV V,BV U,PetscInt nconv,PetscInt l,PetscInt n,PetscScalar* work)SVDOneSideTRLanczosMGS66,2202
static PetscErrorCode SVDOrthogonalizeCGS(BV V,PetscInt i,PetscScalar* h,PetscReal a,BVOrthogRefineType refine,PetscReal eta,PetscReal *norm)SVDOrthogonalizeCGS123,4363
static PetscErrorCode SVDOneSideTRLanczosCGS(SVD svd,PetscReal *alpha,PetscReal *beta,BV V,BV U,PetscInt nconv,PetscInt l,PetscInt n,PetscScalar* work)SVDOneSideTRLanczosCGS164,5653
PetscErrorCode SVDSolve_TRLanczos(SVD svd)SVDSolve_TRLanczos261,9579
PetscErrorCode SVDSetFromOptions_TRLanczos(PetscOptionItems *PetscOptionsObject,SVD svd)SVDSetFromOptions_TRLanczos376,13940
static PetscErrorCode SVDTRLanczosSetOneSide_TRLanczos(SVD svd,PetscBool oneside)SVDTRLanczosSetOneSide_TRLanczos392,14544
PetscErrorCode SVDTRLanczosSetOneSide(SVD svd,PetscBool oneside)SVDTRLanczosSetOneSide426,15494
static PetscErrorCode SVDTRLanczosGetOneSide_TRLanczos(SVD svd,PetscBool *oneside)SVDTRLanczosGetOneSide_TRLanczos437,15834
PetscErrorCode SVDTRLanczosGetOneSide(SVD svd,PetscBool *oneside)SVDTRLanczosGetOneSide462,16401
PetscErrorCode SVDDestroy_TRLanczos(SVD svd)SVDDestroy_TRLanczos473,16729
PetscErrorCode SVDView_TRLanczos(SVD svd,PetscViewer viewer)SVDView_TRLanczos484,17098
SLEPC_EXTERN PetscErrorCode SVDCreate_TRLanczos(SVD svd)SVDCreate_TRLanczos498,17555

src/svd/interface/dlregissvd.c,880
dlregissvd.c:^?dlregissvd.c^A,1
static PetscBool SVDPackageInitialized = PETSC_FALSE;SVDPackageInitialized13,436
const char *SVDErrorTypes[] = {"ABSOLUTE","RELATIVE","SVDErrorType","SVD_ERROR_",0};SVDErrorTypes15,491
const char *SVDPRIMMEMethods[] = {"","HYBRID","NORMALEQUATIONS","AUGMENTED","SVDPRIMMEMethod","SVD_PRIMME_",0};SVDPRIMMEMethods16,576
const char *const SVDConvergedReasons_Shifted[] = {"","","DIVERGED_BREAKDOWN","DIVERGED_ITS","CONVERGED_ITERATING","CONVERGED_TOL","CONVERGED_USER","SVDConvergedReason","SVD_",0};SVDConvergedReasons_Shifted17,688
const char *const*SVDConvergedReasons = SVDConvergedReasons_Shifted + 4;SVDConvergedReasons18,868
PetscErrorCode SVDFinalizePackage(void)SVDFinalizePackage28,1138
PetscErrorCode SVDInitializePackage(void)SVDInitializePackage48,1679
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepcsvd()PetscDLLibraryRegister_slepcsvd89,3233

src/svd/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zsvdf.cSOURCEC15,469
SOURCEF  =SOURCEF16,488
SOURCEH  =SOURCEH17,499
DIRS     =DIRS18,510
LIBBASE  = libslepcsvdLIBBASE19,521
LOCDIR   = src/svd/interface/ftn-custom/LOCDIR20,544

src/svd/interface/ftn-custom/zsvdf.c,11757
zsvdf.c:^?zsvdf.c^A,1
SLEPC_EXTERN void svdmonitorall_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)svdmonitorall_95,5103
SLEPC_EXTERN void svdmonitorconverged_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,SlepcConvMonitor *ctx,PetscErrorCode *ierr)svdmonitorconverged_100,5344
SLEPC_EXTERN void svdmonitorfirst_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **ctx,PetscErrorCode *ierr)svdmonitorfirst_105,5592
SLEPC_EXTERN void svdmonitorlg_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)svdmonitorlg_110,5837
SLEPC_EXTERN void svdmonitorlgall_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,void *ctx,PetscErrorCode *ierr)svdmonitorlgall_115,6058
  PetscFortranCallbackId monitor;monitor121,6301
  PetscFortranCallbackId monitordestroy;monitordestroy122,6335
  PetscFortranCallbackId convergence;convergence123,6376
  PetscFortranCallbackId convdestroy;convdestroy124,6414
  PetscFortranCallbackId stopping;stopping125,6452
  PetscFortranCallbackId stopdestroy;stopdestroy126,6487
} _cb;_cb127,6525
static PetscErrorCode ourmonitor(SVD svd,PetscInt i,PetscInt nc,PetscReal *sigma,PetscReal *d,PetscInt l,void* ctx)ourmonitor130,6625
static PetscErrorCode ourdestroy(void** ctx)ourdestroy135,6913
static PetscErrorCode ourconvergence(SVD svd,PetscReal sigma,PetscReal res,PetscReal *errest,void *ctx)ourconvergence141,7080
static PetscErrorCode ourconvdestroy(void *ctx)ourconvdestroy146,7342
static PetscErrorCode ourstopping(SVD svd,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nsv,SVDConvergedReason *reason,void *ctx)ourstopping152,7508
static PetscErrorCode ourstopdestroy(void *ctx)ourstopdestroy157,7840
SLEPC_EXTERN void PETSC_STDCALL svdview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)svdview_163,8006
SLEPC_EXTERN void PETSC_STDCALL svdreasonview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)svdreasonview_170,8193
SLEPC_EXTERN void PETSC_STDCALL svderrorview_(SVD *svd,SVDErrorType *etype,PetscViewer *viewer,PetscErrorCode *ierr)svderrorview_177,8392
SLEPC_EXTERN void PETSC_STDCALL svdvaluesview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)svdvaluesview_184,8616
SLEPC_EXTERN void PETSC_STDCALL svdvectorsview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)svdvectorsview_191,8815
SLEPC_EXTERN void PETSC_STDCALL svdsettype_(SVD *svd,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))svdsettype_198,9016
SLEPC_EXTERN void PETSC_STDCALL svdgettype_(SVD *svd,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))svdgettype_207,9250
SLEPC_EXTERN void PETSC_STDCALL svdmonitorset_(SVD *svd,void (PETSC_STDCALL *monitor)(SVD*,PetscInt*,PetscInt*,PetscReal*,PetscReal*,PetscInt*,void*,PetscErrorCode*),void *mctx,void (PETSC_STDCALL *monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)svdmonitorset_216,9548
SLEPC_EXTERN void PETSC_STDCALL svdsetoptionsprefix_(SVD *svd,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))svdsetoptionsprefix_237,11427
SLEPC_EXTERN void PETSC_STDCALL svdappendoptionsprefix_(SVD *svd,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))svdappendoptionsprefix_246,11685
SLEPC_EXTERN void PETSC_STDCALL svdgetoptionsprefix_(SVD *svd,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))svdgetoptionsprefix_255,11949
SLEPC_EXTERN void PETSC_STDCALL svdconvergedabsolute_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)svdconvergedabsolute_264,12276
SLEPC_EXTERN void PETSC_STDCALL svdconvergedrelative_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)svdconvergedrelative_269,12487
SLEPC_EXTERN void PETSC_STDCALL svdsetconvergencetestfunction_(SVD *svd,void (PETSC_STDCALL *func)(SVD*,PetscReal*,PetscReal*,PetscReal*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)svdsetconvergencetestfunction_274,12698
SLEPC_EXTERN void PETSC_STDCALL svdstoppingbasic_(SVD *svd,PetscInt *its,PetscInt *max_it,PetscInt *nconv,PetscInt *nsv,SVDConvergedReason *reason,void *ctx,PetscErrorCode *ierr)svdstoppingbasic_289,13693
SLEPC_EXTERN void PETSC_STDCALL svdsetstoppingtestfunction_(SVD *svd,void (PETSC_STDCALL *func)(SVD*,PetscInt,PetscInt,PetscInt,PetscInt,SVDConvergedReason*,void*,PetscErrorCode*),void* ctx,void (PETSC_STDCALL *destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)svdsetstoppingtestfunction_294,13947
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions_307,14810
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions000_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions000_315,15063
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions100_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions100_320,15226
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions010_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions010_325,15389
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions001_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions001_330,15552
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions110_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions110_335,15715
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions011_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions011_340,15878
SLEPC_EXTERN void PETSC_STDCALL svdgetdimensions101_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,int *ierr)svdgetdimensions101_345,16041
SLEPC_EXTERN void PETSC_STDCALL svdgetsingulartriplet_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v,int *ierr)svdgetsingulartriplet_350,16204
SLEPC_EXTERN void PETSC_STDCALL svdgetsingulartriplet0_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v, int *ierr)svdgetsingulartriplet0_356,16410
SLEPC_EXTERN void PETSC_STDCALL svdgetsingulartriplet1_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v, int *ierr)svdgetsingulartriplet1_361,16583
SLEPC_EXTERN void PETSC_STDCALL svdgettolerances_(SVD *svd,PetscReal *tol,PetscInt *maxits,int *ierr)svdgettolerances_366,16756
SLEPC_EXTERN void PETSC_STDCALL svdgettolerances00_(SVD *svd,PetscReal *tol,PetscInt *maxits,int *ierr)svdgettolerances00_373,16968
SLEPC_EXTERN void PETSC_STDCALL svdgettolerances10_(SVD *svd,PetscReal *tol,PetscInt *maxits,int *ierr)svdgettolerances10_378,17119
SLEPC_EXTERN void PETSC_STDCALL svdgettolerances01_(SVD *svd,PetscReal *tol,PetscInt *maxits,int *ierr)svdgettolerances01_383,17270
SLEPC_EXTERN void PETSC_STDCALL svdsetinitialspaces_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,int *ierr)svdsetinitialspaces_388,17421
SLEPC_EXTERN void PETSC_STDCALL svdsetinitialspaces00_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,int *ierr)svdsetinitialspaces00_395,17654
SLEPC_EXTERN void PETSC_STDCALL svdsetinitialspaces01_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,int *ierr)svdsetinitialspaces01_400,17826
SLEPC_EXTERN void PETSC_STDCALL svdsetinitialspaces10_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,int *ierr)svdsetinitialspaces10_405,17998
SLEPC_EXTERN void PETSC_STDCALL svdsetinitialspaces11_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,int *ierr)svdsetinitialspaces11_410,18170

src/svd/interface/makefile,361
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = svdregis.c svdbasic.c svddefault.c svdview.c svdopts.c svdsetup.c svdsolve.c svdmon.c dlregissvd.cSOURCEC15,431
SOURCEF  =SOURCEF16,541
SOURCEH  =SOURCEH17,552
LIBBASE  = libslepcsvdLIBBASE18,563
DIRS     =DIRS19,586
MANSEC   = SVDMANSEC20,597
LOCDIR   = src/svd/interface/LOCDIR21,612

src/svd/interface/svdbasic.c,962
svdbasic.c:^?svdbasic.c^A,1
PetscFunctionList SVDList = 0;SVDList16,490
PetscBool         SVDRegisterAllCalled = PETSC_FALSE;SVDRegisterAllCalled17,521
PetscClassId      SVD_CLASSID = 0;SVD_CLASSID18,575
PetscLogEvent     SVD_SetUp = 0,SVD_Solve = 0;SVD_SetUp19,610
PetscLogEvent     SVD_SetUp = 0,SVD_Solve = 0;SVD_Solve19,610
PetscErrorCode SVDCreate(MPI_Comm comm,SVD *outsvd)SVDCreate39,959
PetscErrorCode SVDReset(SVD svd)SVDReset110,2985
PetscErrorCode SVDDestroy(SVD *svd)SVDDestroy139,3738
PetscErrorCode SVDSetType(SVD svd,SVDType type)SVDSetType191,5568
PetscErrorCode SVDGetType(SVD svd,SVDType *type)SVDGetType230,6650
PetscErrorCode SVDRegister(const char *name,PetscErrorCode (*function)(SVD))SVDRegister265,7458
PetscErrorCode SVDSetBV(SVD svd,BV V,BV U)SVDSetBV293,8215
PetscErrorCode SVDGetBV(SVD svd,BV *V,BV *U)SVDGetBV335,9379
PetscErrorCode SVDSetDS(SVD svd,DS ds)SVDSetDS379,10786
PetscErrorCode SVDGetDS(SVD svd,DS *ds)SVDGetDS410,11539

src/svd/interface/svddefault.c,422
svddefault.c:^?svddefault.c^A,1
PetscErrorCode SVDConvergedRelative(SVD svd,PetscReal sigma,PetscReal res,PetscReal *errest,void *ctx)SVDConvergedRelative19,599
PetscErrorCode SVDConvergedAbsolute(SVD svd,PetscReal sigma,PetscReal res,PetscReal *errest,void *ctx)SVDConvergedAbsolute29,840
PetscErrorCode SVDStoppingBasic(SVD svd,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nsv,SVDConvergedReason *reason,void *ctx)SVDStoppingBasic68,2138

src/svd/interface/svdmon.c,1439
svdmon.c:^?svdmon.c^A,1
PetscErrorCode SVDMonitor(SVD svd,PetscInt it,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest)SVDMonitor20,582
PetscErrorCode SVDMonitorSet(SVD svd,PetscErrorCode (*monitor)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))SVDMonitorSet77,2820
PetscErrorCode SVDMonitorCancel(SVD svd)SVDMonitorCancel105,3857
PetscErrorCode SVDGetMonitorContext(SVD svd,void **ctx)SVDGetMonitorContext137,4555
PetscErrorCode SVDMonitorAll(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)SVDMonitorAll164,5295
PetscErrorCode SVDMonitorFirst(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)SVDMonitorFirst211,7199
PetscErrorCode SVDMonitorConverged(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,SlepcConvMonitor ctx)SVDMonitorConverged255,8992
PetscErrorCode SVDMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)SVDMonitorLGCreate314,11134
PetscErrorCode SVDMonitorLG(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,void *ctx)SVDMonitorLG330,11680
PetscErrorCode SVDMonitorLGAll(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,void *ctx)SVDMonitorLGAll354,12507

src/svd/interface/svdopts.c,2618
svdopts.c:^?svdopts.c^A,1
PetscErrorCode SVDSetImplicitTranspose(SVD svd,PetscBool impl)SVDSetImplicitTranspose44,1467
PetscErrorCode SVDGetImplicitTranspose(SVD svd,PetscBool *impl)SVDGetImplicitTranspose72,2170
PetscErrorCode SVDSetTolerances(SVD svd,PetscReal tol,PetscInt maxits)SVDSetTolerances103,2988
PetscErrorCode SVDGetTolerances(SVD svd,PetscReal *tol,PetscInt *maxits)SVDGetTolerances146,4236
PetscErrorCode SVDSetDimensions(SVD svd,PetscInt nsv,PetscInt ncv,PetscInt mpd)SVDSetDimensions189,5768
PetscErrorCode SVDGetDimensions(SVD svd,PetscInt *nsv,PetscInt *ncv,PetscInt *mpd)SVDGetDimensions235,7234
PetscErrorCode SVDSetWhichSingularTriplets(SVD svd,SVDWhich which)SVDSetWhichSingularTriplets271,8168
PetscErrorCode SVDGetWhichSingularTriplets(SVD svd,SVDWhich *which)SVDGetWhichSingularTriplets309,9120
PetscErrorCode SVDSetConvergenceTestFunction(SVD svd,PetscErrorCode (*func)(SVD,PetscReal,PetscReal,PetscReal*,void*),void* ctx,PetscErrorCode (*destroy)(void*))SVDSetConvergenceTestFunction347,10414
PetscErrorCode SVDSetConvergenceTest(SVD svd,SVDConv conv)SVDSetConvergenceTest393,11987
PetscErrorCode SVDGetConvergenceTest(SVD svd,SVDConv *conv)SVDGetConvergenceTest428,13065
PetscErrorCode SVDSetStoppingTestFunction(SVD svd,PetscErrorCode (*func)(SVD,PetscInt,PetscInt,PetscInt,PetscInt,SVDConvergedReason*,void*),void* ctx,PetscErrorCode (*destroy)(void*))SVDSetStoppingTestFunction470,14608
PetscErrorCode SVDSetStoppingTest(SVD svd,SVDStop stop)SVDSetStoppingTest513,15970
PetscErrorCode SVDGetStoppingTest(SVD svd,SVDStop *stop)SVDGetStoppingTest547,16966
PetscErrorCode SVDMonitorSetFromOptions(SVD svd,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscBool trackall)SVDMonitorSetFromOptions574,17770
PetscErrorCode SVDConvMonitorSetFromOptions(SVD svd,const char name[],const char help[],const char manual[],PetscErrorCode (*monitor)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,SlepcConvMonitor))SVDConvMonitorSetFromOptions612,19364
PetscErrorCode SVDSetFromOptions(SVD svd)SVDSetFromOptions647,20635
PetscErrorCode SVDSetTrackAll(SVD svd,PetscBool trackall)SVDSetTrackAll776,28341
PetscErrorCode SVDGetTrackAll(SVD svd,PetscBool *trackall)SVDGetTrackAll801,28875
PetscErrorCode SVDSetOptionsPrefix(SVD svd,const char *prefix)SVDSetOptionsPrefix837,29812
PetscErrorCode SVDAppendOptionsPrefix(SVD svd,const char *prefix)SVDAppendOptionsPrefix870,30903
PetscErrorCode SVDGetOptionsPrefix(SVD svd,const char *prefix[])SVDGetOptionsPrefix905,31966

src/svd/interface/svdregis.c,58
svdregis.c:^?svdregis.c^A,1
PetscErrorCode SVDRegisterAll(void)SVDRegisterAll31,966

src/svd/interface/svdsetup.c,476
svdsetup.c:^?svdsetup.c^A,1
PetscErrorCode SVDSetOperator(SVD svd,Mat mat)SVDSetOperator29,806
PetscErrorCode SVDGetOperator(SVD svd,Mat *A)SVDGetOperator60,1660
PetscErrorCode SVDSetUp(SVD svd)SVDSetUp87,2323
PetscErrorCode SVDSetInitialSpaces(SVD svd,PetscInt nr,Vec isr[],PetscInt nl,Vec isl[])SVDSetInitialSpaces231,7249
PetscErrorCode SVDSetDimensions_Default(SVD svd)SVDSetDimensions_Default259,8309
PetscErrorCode SVDAllocateSolution(SVD svd,PetscInt extra)SVDAllocateSolution300,9557

src/svd/interface/svdsolve.c,771
svdsolve.c:^?svdsolve.c^A,1
PetscErrorCode SVDComputeVectors(SVD svd)SVDComputeVectors16,513
PetscErrorCode SVDSolve(SVD svd)SVDSolve70,2448
PetscErrorCode SVDGetIterationNumber(SVD svd,PetscInt *its)SVDGetIterationNumber144,4881
PetscErrorCode SVDGetConvergedReason(SVD svd,SVDConvergedReason *reason)SVDGetConvergedReason180,5840
PetscErrorCode SVDGetConverged(SVD svd,PetscInt *nconv)SVDGetConverged207,6420
PetscErrorCode SVDGetSingularTriplet(SVD svd,PetscInt i,PetscReal *sigma,Vec u,Vec v)SVDGetSingularTriplet246,7660
static PetscErrorCode SVDComputeResidualNorms_Private(SVD svd,PetscInt i,PetscReal *norm1,PetscReal *norm2)SVDComputeResidualNorms_Private276,8758
PetscErrorCode SVDComputeError(SVD svd,PetscInt i,SVDErrorType type,PetscReal *error)SVDComputeError345,10821

src/svd/interface/svdview.c,1457
svdview.c:^?svdview.c^A,1
PetscErrorCode SVDView(SVD svd,PetscViewer viewer)SVDView44,1309
PetscErrorCode SVDReasonView(SVD svd,PetscViewer viewer)SVDReasonView126,4970
PetscErrorCode SVDReasonViewFromOptions(SVD svd)SVDReasonViewFromOptions156,6194
static PetscErrorCode SVDErrorView_ASCII(SVD svd,SVDErrorType etype,PetscViewer viewer)SVDErrorView_ASCII178,6953
static PetscErrorCode SVDErrorView_DETAIL(SVD svd,SVDErrorType etype,PetscViewer viewer)SVDErrorView_DETAIL209,8262
#define EXLEN EXLEN214,8426
static PetscErrorCode SVDErrorView_MATLAB(SVD svd,SVDErrorType etype,PetscViewer viewer)SVDErrorView_MATLAB237,9314
PetscErrorCode SVDErrorView(SVD svd,SVDErrorType etype,PetscViewer viewer)SVDErrorView280,10762
PetscErrorCode SVDErrorViewFromOptions(SVD svd)SVDErrorViewFromOptions326,12227
static PetscErrorCode SVDValuesView_DRAW(SVD svd,PetscViewer viewer)SVDValuesView_DRAW355,13439
static PetscErrorCode SVDValuesView_ASCII(SVD svd,PetscViewer viewer)SVDValuesView_ASCII378,14211
static PetscErrorCode SVDValuesView_MATLAB(SVD svd,PetscViewer viewer)SVDValuesView_MATLAB392,14653
PetscErrorCode SVDValuesView(SVD svd,PetscViewer viewer)SVDValuesView424,15539
PetscErrorCode SVDValuesViewFromOptions(SVD svd)SVDValuesViewFromOptions471,17076
PetscErrorCode SVDVectorsView(SVD svd,PetscViewer viewer)SVDVectorsView513,18314
#define NMLEN NMLEN518,18439
PetscErrorCode SVDVectorsViewFromOptions(SVD svd)SVDVectorsViewFromOptions561,19908

src/svd/makefile,208
makefile:^?makefile^A,1
SOURCEH  = ../../include/slepc/private/svdimpl.h ../../include/slepcsvd.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,483
LOCDIR   = src/svd/LOCDIR15,527
MANSEC   = SVDMANSEC16,547

src/sys/classes/bv/examples/makefile,83
makefile:^?makefile^A,1
LOCDIR   = src/sys/classes/bv/examples/LOCDIR13,405
DIRS     = testsDIRS14,445

src/sys/classes/bv/examples/tests/makefile,468
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/classes/bv/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c test10.c \EXAMPLESC16,499
EXAMPLESF  = test1f.F90EXAMPLESF18,671
MANSEC     = BVMANSEC19,695
TESTS      = test1 test1f test2 test3 test4 test5 test6 test7 test8 test9 test10 test11 test12 \TESTS20,711

src/sys/classes/bv/examples/tests/test1.c,103
test1.c:^?test1.c^A,1
static char help[] = "Test BV operations.\n\n";help11,400
int main(int argc,char **argv)main15,471

src/sys/classes/bv/examples/tests/test10.c,112
test10.c:^?test10.c^A,1
static char help[] = "Test split reductions in BV.\n\n";help11,400
int main(int argc,char **argv)main15,480

src/sys/classes/bv/examples/tests/test11.c,234
test11.c:^?test11.c^A,1
static char help[] = "Test BV block orthogonalization.\n\n";help11,400
PetscErrorCode MyMatNorm(Mat A,PetscInt lda,PetscInt l,PetscInt k,PetscScalar diag,PetscReal *norm)MyMatNorm18,543
int main(int argc,char **argv)main39,1090

src/sys/classes/bv/examples/tests/test12.c,136
test12.c:^?test12.c^A,1
static char help[] = "Test block orthogonalization on a rank-deficient BV.\n\n";help11,400
int main(int argc,char **argv)main15,504

src/sys/classes/bv/examples/tests/test13.c,152
test13.c:^?test13.c^A,1
static char help[] = "Test BV operations using internal buffer instead of array arguments.\n\n";help11,400
int main(int argc,char **argv)main15,520

src/sys/classes/bv/examples/tests/test14.c,117
test14.c:^?test14.c^A,1
static char help[] = "Test BV created from a dense Mat.\n\n";help11,400
int main(int argc,char **argv)main15,485

src/sys/classes/bv/examples/tests/test15.c,159
test15.c:^?test15.c^A,1
static char help[] = "Test BVGetSplit().\n\n";help11,400
PetscErrorCode PrintFirstRow(BV X)PrintFirstRow18,508
int main(int argc,char **argv)main44,1486

src/sys/classes/bv/examples/tests/test16.c,99
test16.c:^?test16.c^A,1
static char help[] = "Test tensor BV.\n\n";help11,400
int main(int argc,char **argv)main15,467

src/sys/classes/bv/examples/tests/test17.c,123
test17.c:^?test17.c^A,1
static char help[] = "Test BV bi-orthogonalization functions.\n\n";help11,400
int main(int argc,char **argv)main15,491

src/sys/classes/bv/examples/tests/test1f.F90,225
test1f.F90:^?test1f.F90^A,1
      program mainmain16,594
 110  format (/'Test BV with',I3,' columns of length',I3,' (Fortran)')11065,2172
 120  format ('2-Norm of X[0] = ',f8.4)120161,5501
 130  format ('Frobenius Norm of X = ',f8.4)130166,5665

src/sys/classes/bv/examples/tests/test2.c,120
test2.c:^?test2.c^A,1
static char help[] = "Test BV orthogonalization functions.\n\n";help11,400
int main(int argc,char **argv)main15,488

src/sys/classes/bv/examples/tests/test3.c,135
test3.c:^?test3.c^A,1
static char help[] = "Test BV operations with non-standard inner product.\n\n";help11,400
int main(int argc,char **argv)main15,503

src/sys/classes/bv/examples/tests/test4.c,142
test4.c:^?test4.c^A,1
static char help[] = "Test BV operations, changing the number of active columns.\n\n";help11,400
int main(int argc,char **argv)main15,510

src/sys/classes/bv/examples/tests/test5.c,133
test5.c:^?test5.c^A,1
static char help[] = "Test BV operations with indefinite inner product.\n\n";help11,400
int main(int argc,char **argv)main15,501

src/sys/classes/bv/examples/tests/test6.c,137
test6.c:^?test6.c^A,1
static char help[] = "Test BV orthogonalization functions with constraints.\n\n";help11,400
int main(int argc,char **argv)main15,505

src/sys/classes/bv/examples/tests/test7.c,124
test7.c:^?test7.c^A,1
static char help[] = "Test multiplication of a Mat times a BV.\n\n";help11,400
int main(int argc,char **argv)main15,492

src/sys/classes/bv/examples/tests/test8.c,132
test8.c:^?test8.c^A,1
static char help[] = "Test BV orthogonalization with selected columns.\n\n";help11,400
int main(int argc,char **argv)main15,500

src/sys/classes/bv/examples/tests/test9.c,110
test9.c:^?test9.c^A,1
static char help[] = "Test BV matrix projection.\n\n";help11,400
int main(int argc,char **argv)main15,478

src/sys/classes/bv/f90-mod/makefile,335
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcbvmod.FSOURCEF17,514
SOURCEH    = slepcbv.h slepcbv.h90SOURCEH18,540
LIBBASE    = libslepcsysLIBBASE19,575
MANSEC     = BVMANSEC20,600
LOCDIR     = src/sys/classes/bv/f90-mod/LOCDIR21,616
CLEANFILES = *.modCLEANFILES22,657

src/sys/classes/bv/f90-mod/slepcbv.h,142
slepcbv.h:^?slepcbv.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      BV, parameter :: SLEPC_NULL_BV = tBV(0)BV18,589

src/sys/classes/bv/f90-mod/slepcbvmod.F,82
slepcbvmod.F:^?slepcbvmod.F^A,1
        module slepcbvdefslepcbvdef10,398
        module slepcbvslepcbv17,558

src/sys/classes/bv/impls/contiguous/contig.c,1991
contig.c:^?contig.c^A,1
  Vec         *V;V17,536
  PetscScalar *array;array18,554
  PetscBool   mpi;mpi19,576
} BV_CONTIGUOUS;BV_CONTIGUOUS20,595
PetscErrorCode BVMult_Contiguous(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)BVMult_Contiguous22,613
PetscErrorCode BVMultVec_Contiguous(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)BVMultVec_Contiguous41,1360
PetscErrorCode BVMultInPlace_Contiguous(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Contiguous56,1939
PetscErrorCode BVMultInPlaceTranspose_Contiguous(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose_Contiguous71,2472
PetscErrorCode BVDot_Contiguous(BV X,BV Y,Mat M)BVDot_Contiguous86,3013
PetscErrorCode BVDotVec_Contiguous(BV X,Vec y,PetscScalar *q)BVDotVec_Contiguous101,3556
PetscErrorCode BVDotVec_Local_Contiguous(BV X,Vec y,PetscScalar *m)BVDotVec_Local_Contiguous122,4241
PetscErrorCode BVScale_Contiguous(BV bv,PetscInt j,PetscScalar alpha)BVScale_Contiguous140,4759
PetscErrorCode BVNorm_Contiguous(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Contiguous154,5184
PetscErrorCode BVNorm_Local_Contiguous(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Local_Contiguous168,5645
PetscErrorCode BVMatMult_Contiguous(BV V,Mat A,BV W)BVMatMult_Contiguous182,6118
PetscErrorCode BVCopy_Contiguous(BV V,BV W)BVCopy_Contiguous206,6876
PetscErrorCode BVCopyColumn_Contiguous(BV V,PetscInt j,PetscInt i)BVCopyColumn_Contiguous219,7237
PetscErrorCode BVResize_Contiguous(BV bv,PetscInt m,PetscBool copy)BVResize_Contiguous229,7520
PetscErrorCode BVGetColumn_Contiguous(BV bv,PetscInt j,Vec *v)BVGetColumn_Contiguous275,9197
PetscErrorCode BVGetArray_Contiguous(BV bv,PetscScalar **a)BVGetArray_Contiguous286,9436
PetscErrorCode BVGetArrayRead_Contiguous(BV bv,const PetscScalar **a)BVGetArrayRead_Contiguous295,9618
PetscErrorCode BVDestroy_Contiguous(BV bv)BVDestroy_Contiguous304,9810
SLEPC_EXTERN PetscErrorCode BVCreate_Contiguous(BV bv)BVCreate_Contiguous318,10161

src/sys/classes/bv/impls/contiguous/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = contig.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = BVMANSEC20,507
LOCDIR   = src/sys/classes/bv/impls/contiguous/LOCDIR21,521

src/sys/classes/bv/impls/makefile,172
makefile:^?makefile^A,1
LIBBASE  = libslepcsysLIBBASE13,409
DIRS     = vecs contiguous svec mat tensorDIRS14,432
LOCDIR   = src/sys/classes/bv/impls/LOCDIR15,475
MANSEC   = BVMANSEC16,512

src/sys/classes/bv/impls/mat/bvmat.c,2024
bvmat.c:^?bvmat.c^A,1
  Mat       A;A17,493
  PetscBool mpi;mpi18,508
} BV_MAT;BV_MAT19,525
PetscErrorCode BVMult_Mat(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)BVMult_Mat21,536
PetscErrorCode BVMultVec_Mat(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)BVMultVec_Mat44,1458
PetscErrorCode BVMultInPlace_Mat(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Mat61,2127
PetscErrorCode BVMultInPlaceTranspose_Mat(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose_Mat78,2752
PetscErrorCode BVDot_Mat(BV X,BV Y,Mat M)BVDot_Mat95,3385
PetscErrorCode BVDotVec_Mat(BV X,Vec y,PetscScalar *q)BVDotVec_Mat114,4115
PetscErrorCode BVDotVec_Local_Mat(BV X,Vec y,PetscScalar *m)BVDotVec_Local_Mat137,4890
PetscErrorCode BVScale_Mat(BV bv,PetscInt j,PetscScalar alpha)BVScale_Mat157,5498
PetscErrorCode BVNorm_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Mat174,6040
PetscErrorCode BVNorm_Local_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Local_Mat191,6618
PetscErrorCode BVMatMult_Mat(BV V,Mat A,BV W)BVMatMult_Mat208,7208
PetscErrorCode BVCopy_Mat(BV V,BV W)BVCopy_Mat241,8425
PetscErrorCode BVCopyColumn_Mat(BV V,PetscInt j,PetscInt i)BVCopyColumn_Mat258,8973
PetscErrorCode BVResize_Mat(BV bv,PetscInt m,PetscBool copy)BVResize_Mat271,9358
PetscErrorCode BVGetColumn_Mat(BV bv,PetscInt j,Vec *v)BVGetColumn_Mat311,10941
PetscErrorCode BVRestoreColumn_Mat(BV bv,PetscInt j,Vec *v)BVRestoreColumn_Mat325,11303
PetscErrorCode BVGetArray_Mat(BV bv,PetscScalar **a)BVGetArray_Mat339,11659
PetscErrorCode BVRestoreArray_Mat(BV bv,PetscScalar **a)BVRestoreArray_Mat349,11883
PetscErrorCode BVGetArrayRead_Mat(BV bv,const PetscScalar **a)BVGetArrayRead_Mat359,12126
PetscErrorCode BVRestoreArrayRead_Mat(BV bv,const PetscScalar **a)BVRestoreArrayRead_Mat369,12375
PetscErrorCode BVView_Mat(BV bv,PetscViewer viewer)BVView_Mat379,12643
PetscErrorCode BVDestroy_Mat(BV bv)BVDestroy_Mat407,13738
SLEPC_EXTERN PetscErrorCode BVCreate_Mat(BV bv)BVCreate_Mat420,14076

src/sys/classes/bv/impls/mat/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = bvmat.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = BVMANSEC20,506
LOCDIR   = src/sys/classes/bv/impls/mat/LOCDIR21,520

src/sys/classes/bv/impls/svec/makefile,296
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = svec.cSOURCEC15,431
SOURCEF  =SOURCEF16,449
SOURCEH  = svec.hSOURCEH17,460
LIBBASE  = libslepcsysLIBBASE18,478
DIRS     = sveccudaDIRS19,501
MANSEC   = BVMANSEC20,521
LOCDIR   = src/sys/classes/bv/impls/svec/LOCDIR21,535

src/sys/classes/bv/impls/svec/svec.c,1994
svec.c:^?svec.c^A,1
PetscErrorCode BVMult_Svec(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)BVMult_Svec17,493
PetscErrorCode BVMultVec_Svec(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)BVMultVec_Svec41,1439
PetscErrorCode BVMultInPlace_Svec(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Svec58,2100
PetscErrorCode BVMultInPlaceTranspose_Svec(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose_Svec75,2717
PetscErrorCode BVDot_Svec(BV X,BV Y,Mat M)BVDot_Svec92,3342
PetscErrorCode BVDotVec_Svec(BV X,Vec y,PetscScalar *q)BVDotVec_Svec112,4104
PetscErrorCode BVDotVec_Local_Svec(BV X,Vec y,PetscScalar *m)BVDotVec_Local_Svec135,4879
PetscErrorCode BVScale_Svec(BV bv,PetscInt j,PetscScalar alpha)BVScale_Svec155,5479
PetscErrorCode BVNorm_Svec(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Svec172,6013
PetscErrorCode BVNorm_Local_Svec(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Local_Svec189,6583
PetscErrorCode BVMatMult_Svec(BV V,Mat A,BV W)BVMatMult_Svec206,7165
PetscErrorCode BVCopy_Svec(BV V,BV W)BVCopy_Svec249,8794
PetscErrorCode BVCopyColumn_Svec(BV V,PetscInt j,PetscInt i)BVCopyColumn_Svec266,9325
PetscErrorCode BVResize_Svec(BV bv,PetscInt m,PetscBool copy)BVResize_Svec279,9702
PetscErrorCode BVGetColumn_Svec(BV bv,PetscInt j,Vec *v)BVGetColumn_Svec323,11421
PetscErrorCode BVRestoreColumn_Svec(BV bv,PetscInt j,Vec *v)BVRestoreColumn_Svec337,11780
PetscErrorCode BVGetArray_Svec(BV bv,PetscScalar **a)BVGetArray_Svec350,12112
PetscErrorCode BVRestoreArray_Svec(BV bv,PetscScalar **a)BVRestoreArray_Svec360,12333
PetscErrorCode BVGetArrayRead_Svec(BV bv,const PetscScalar **a)BVGetArrayRead_Svec370,12562
PetscErrorCode BVRestoreArrayRead_Svec(BV bv,const PetscScalar **a)BVRestoreArrayRead_Svec380,12797
PetscErrorCode BVView_Svec(BV bv,PetscViewer viewer)BVView_Svec390,13040
PetscErrorCode BVDestroy_Svec(BV bv)BVDestroy_Svec418,14171
SLEPC_EXTERN PetscErrorCode BVCreate_Svec(BV bv)BVCreate_Svec432,14537

src/sys/classes/bv/impls/svec/svec.h,164
svec.h:^?svec.h^A,1
#define SLEPC_SVEC_HSLEPC_SVEC_H12,427
  Vec       v;v15,466
  PetscBool mpi;    /* true if either VECMPI or VECMPICUDA */mpi16,481
} BV_SVEC;BV_SVEC17,543

src/sys/classes/bv/impls/svec/sveccuda/makefile,295
makefile:^?makefile^A,1
CFLAGS   =CFLAGS14,444
FFLAGS   =FFLAGS15,455
SOURCECU = sveccuda.cuSOURCECU16,466
SOURCEF  =SOURCEF17,489
SOURCEH  =SOURCEH18,500
LIBBASE  = libslepcsysLIBBASE19,511
DIRS     =DIRS20,534
MANSEC   = BVMANSEC21,545
LOCDIR   = src/sys/classes/bv/impls/svec/sveccuda/LOCDIR22,559

src/sys/classes/bv/impls/tensor/bvtensor.c,2747
bvtensor.c:^?bvtensor.c^A,1
  BV          U;        /* first factor */U18,583
  Mat         S;        /* second factor */S19,626
  PetscScalar *qB;      /* auxiliary matrix used in non-standard inner products */qB20,670
  PetscScalar *sw;      /* work space */sw21,753
  PetscInt    d;        /* degree of the tensor BV */d22,794
  PetscInt    ld;       /* leading dimension of a single block in S */ld23,848
  PetscInt    puk;      /* copy of the k value */puk24,919
  Vec         u;        /* auxiliary work vector */u25,969
} BV_TENSOR;BV_TENSOR26,1021
PetscErrorCode BVMultInPlace_Tensor(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Tensor28,1035
PetscErrorCode BVMultInPlaceTranspose_Tensor(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose_Tensor45,1685
PetscErrorCode BVDot_Tensor(BV X,BV Y,Mat M)BVDot_Tensor62,2343
PetscErrorCode BVScale_Tensor(BV bv,PetscInt j,PetscScalar alpha)BVScale_Tensor83,3383
PetscErrorCode BVNorm_Tensor(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Tensor101,3947
PetscErrorCode BVCopyColumn_Tensor(BV V,PetscInt j,PetscInt i)BVCopyColumn_Tensor119,4553
static PetscErrorCode BVTensorNormColumn(BV bv,PetscInt j,PetscReal *norm)BVTensorNormColumn133,4986
PetscErrorCode BVOrthogonalizeGS1_Tensor(BV bv,PetscInt k,Vec v,PetscBool *which,PetscScalar *h,PetscScalar *c,PetscReal *onorm,PetscReal *norm)BVOrthogonalizeGS1_Tensor170,6169
PetscErrorCode BVView_Tensor(BV bv,PetscViewer viewer)BVView_Tensor232,8777
static PetscErrorCode BVTensorUpdateMatrix(BV V,PetscInt ini,PetscInt end)BVTensorUpdateMatrix264,10183
static PetscErrorCode BVTensorBuildFirstColumn_Tensor(BV V,PetscInt k)BVTensorBuildFirstColumn_Tensor310,11647
PetscErrorCode BVTensorBuildFirstColumn(BV V,PetscInt k)BVTensorBuildFirstColumn374,13803
static PetscErrorCode BVTensorCompress_Tensor(BV V,PetscInt newc)BVTensorCompress_Tensor385,14113
PetscErrorCode BVTensorCompress(BV V,PetscInt newc)BVTensorCompress592,22724
static PetscErrorCode BVTensorGetDegree_Tensor(BV bv,PetscInt *d)BVTensorGetDegree_Tensor603,23027
PetscErrorCode BVTensorGetDegree(BV bv,PetscInt *d)BVTensorGetDegree627,23452
static PetscErrorCode BVTensorGetFactors_Tensor(BV V,BV *U,Mat *S)BVTensorGetFactors_Tensor638,23742
PetscErrorCode BVTensorGetFactors(BV V,BV *U,Mat *S)BVTensorGetFactors678,24957
static PetscErrorCode BVTensorRestoreFactors_Tensor(BV V,BV *U,Mat *S)BVTensorRestoreFactors_Tensor688,25218
PetscErrorCode BVTensorRestoreFactors(BV V,BV *U,Mat *S)BVTensorRestoreFactors720,25996
PetscErrorCode BVDestroy_Tensor(BV bv)BVDestroy_Tensor732,26370
SLEPC_EXTERN PetscErrorCode BVCreate_Tensor(BV bv)BVCreate_Tensor753,27270
PetscErrorCode BVCreateTensor(BV U,PetscInt d,BV *V)BVCreateTensor814,29749

src/sys/classes/bv/impls/tensor/makefile,286
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = bvtensor.cSOURCEC15,431
SOURCEF  =SOURCEF16,453
SOURCEH  =SOURCEH17,464
LIBBASE  = libslepcsysLIBBASE18,475
DIRS     =DIRS19,498
MANSEC   = BVMANSEC20,509
LOCDIR   = src/sys/classes/bv/impls/tensor/LOCDIR21,523

src/sys/classes/bv/impls/vecs/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = vecs.cSOURCEC15,431
SOURCEF  =SOURCEF16,449
SOURCEH  =SOURCEH17,460
LIBBASE  = libslepcsysLIBBASE18,471
DIRS     =DIRS19,494
MANSEC   = BVMANSEC20,505
LOCDIR   = src/sys/classes/bv/impls/vecs/LOCDIR21,519

src/sys/classes/bv/impls/vecs/vecs.c,2596
vecs.c:^?vecs.c^A,1
  Vec      *V;V17,508
  PetscInt vmip;   /* Version of BVMultInPlace:vmip18,523
} BV_VECS;BV_VECS21,727
PetscErrorCode BVMult_Vecs(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)BVMult_Vecs23,739
PetscErrorCode BVMultVec_Vecs(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)BVMultVec_Vecs55,1774
PetscErrorCode BVMultInPlace_Vecs_ME(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Vecs_ME86,2785
PetscErrorCode BVMultInPlace_Vecs_Alloc(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace_Vecs_Alloc116,3731
PetscErrorCode BVMultInPlaceTranspose_Vecs(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose_Vecs142,4519
PetscErrorCode BVDot_Vecs(BV X,BV Y,Mat M)BVDot_Vecs167,5312
PetscErrorCode BVDotVec_Vecs(BV X,Vec y,PetscScalar *q)BVDotVec_Vecs184,5807
PetscErrorCode BVDotVec_Begin_Vecs(BV X,Vec y,PetscScalar *m)BVDotVec_Begin_Vecs202,6305
PetscErrorCode BVDotVec_End_Vecs(BV X,Vec y,PetscScalar *m)BVDotVec_End_Vecs217,6659
PetscErrorCode BVScale_Vecs(BV bv,PetscInt j,PetscScalar alpha)BVScale_Vecs227,6903
PetscErrorCode BVNorm_Vecs(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Vecs244,7294
PetscErrorCode BVNorm_Begin_Vecs(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_Begin_Vecs267,7950
PetscErrorCode BVNorm_End_Vecs(BV bv,PetscInt j,NormType type,PetscReal *val)BVNorm_End_Vecs280,8341
PetscErrorCode BVMatMult_Vecs(BV V,Mat A,BV W)BVMatMult_Vecs293,8728
PetscErrorCode BVCopy_Vecs(BV V,BV W)BVCopy_Vecs317,9468
PetscErrorCode BVCopyColumn_Vecs(BV V,PetscInt j,PetscInt i)BVCopyColumn_Vecs330,9774
PetscErrorCode BVResize_Vecs(BV bv,PetscInt m,PetscBool copy)BVResize_Vecs340,10014
PetscErrorCode BVGetColumn_Vecs(BV bv,PetscInt j,Vec *v)BVGetColumn_Vecs374,11021
PetscErrorCode BVGetArray_Vecs(BV bv,PetscScalar **a)BVGetArray_Vecs385,11238
PetscErrorCode BVRestoreArray_Vecs(BV bv,PetscScalar **a)BVRestoreArray_Vecs402,11740
PetscErrorCode BVGetArrayRead_Vecs(BV bv,const PetscScalar **a)BVGetArrayRead_Vecs419,12203
PetscErrorCode BVRestoreArrayRead_Vecs(BV bv,const PetscScalar **a)BVRestoreArrayRead_Vecs436,12744
PETSC_STATIC_INLINE PetscErrorCode BVVecsSetVmip(BV bv,PetscInt vmip)BVVecsSetVmip448,13005
PetscErrorCode BVSetFromOptions_Vecs(PetscOptionItems *PetscOptionsObject,BV bv)BVSetFromOptions_Vecs460,13397
PetscErrorCode BVView_Vecs(BV bv,PetscViewer viewer)BVView_Vecs475,13911
PetscErrorCode BVDestroy_Vecs(BV bv)BVDestroy_Vecs505,15055
PetscErrorCode BVDuplicate_Vecs(BV V,BV W)BVDuplicate_Vecs516,15340
SLEPC_EXTERN PetscErrorCode BVCreate_Vecs(BV bv)BVCreate_Vecs526,15554

src/sys/classes/bv/interface/bvbasic.c,3774
bvbasic.c:^?bvbasic.c^A,1
PetscBool         BVRegisterAllCalled = PETSC_FALSE;BVRegisterAllCalled16,487
PetscFunctionList BVList = 0;BVList17,540
PetscErrorCode BVSetType(BV bv,BVType type)BVSetType35,849
PetscErrorCode BVGetType(BV bv,BVType *type)BVGetType81,2271
PetscErrorCode BVSetSizes(BV bv,PetscInt n,PetscInt N,PetscInt m)BVSetSizes110,3008
PetscErrorCode BVSetSizesFromVec(BV bv,Vec t,PetscInt m)BVSetSizesFromVec163,5391
PetscErrorCode BVGetSizes(BV bv,PetscInt *n,PetscInt *N,PetscInt *m)BVGetSizes217,7292
PetscErrorCode BVSetNumConstraints(BV V,PetscInt nc)BVSetNumConstraints254,8277
PetscErrorCode BVGetNumConstraints(BV bv,PetscInt *nc)BVGetNumConstraints306,9873
PetscErrorCode BVResize(BV bv,PetscInt m,PetscBool copy)BVResize333,10511
PetscErrorCode BVSetActiveColumns(BV bv,PetscInt l,PetscInt k)BVSetActiveColumns413,13376
PetscErrorCode BVGetActiveColumns(BV bv,PetscInt *l,PetscInt *k)BVGetActiveColumns451,14393
PetscErrorCode BVSetMatrix(BV bv,Mat B,PetscBool indef)BVSetMatrix489,15643
PetscErrorCode BVGetMatrix(BV bv,Mat *B,PetscBool *indef)BVGetMatrix527,16854
PetscErrorCode BVApplyMatrix(BV bv,Vec x,Vec y)BVApplyMatrix556,17465
PetscErrorCode BVApplyMatrixBV(BV X,BV Y)BVApplyMatrixBV596,18528
PetscErrorCode BVSetSignature(BV bv,Vec omega)BVSetSignature631,19337
PetscErrorCode BVGetSignature(BV bv,Vec omega)BVGetSignature678,20804
PetscErrorCode BVSetBufferVec(BV bv,Vec buffer)BVSetBufferVec726,22261
PetscErrorCode BVGetBufferVec(BV bv,Vec *buffer)BVGetBufferVec783,24290
PetscErrorCode BVSetRandomContext(BV bv,PetscRandom rand)BVSetRandomContext817,25264
PetscErrorCode BVGetRandomContext(BV bv,PetscRandom* rand)BVGetRandomContext847,26071
PetscErrorCode BVSetFromOptions(BV bv)BVSetFromOptions876,26818
PetscErrorCode BVSetOrthogonalization(BV bv,BVOrthogType type,BVOrthogRefineType refine,PetscReal eta,BVOrthogBlockType block)BVSetOrthogonalization961,30968
PetscErrorCode BVGetOrthogonalization(BV bv,BVOrthogType *type,BVOrthogRefineType *refine,PetscReal *eta,BVOrthogBlockType *block)BVGetOrthogonalization1024,32950
PetscErrorCode BVSetMatMultMethod(BV bv,BVMatMultType method)BVSetMatMultMethod1059,34032
PetscErrorCode BVGetMatMultMethod(BV bv,BVMatMultType *method)BVGetMatMultMethod1096,34969
PetscErrorCode BVGetColumn(BV bv,PetscInt j,Vec *v)BVGetColumn1134,36089
PetscErrorCode BVRestoreColumn(BV bv,PetscInt j,Vec *v)BVRestoreColumn1175,37661
PetscErrorCode BVGetArray(BV bv,PetscScalar **a)BVGetArray1233,39824
PetscErrorCode BVRestoreArray(BV bv,PetscScalar **a)BVRestoreArray1263,40517
PetscErrorCode BVGetArrayRead(BV bv,const PetscScalar **a)BVGetArrayRead1303,41617
PetscErrorCode BVRestoreArrayRead(BV bv,const PetscScalar **a)BVRestoreArrayRead1330,42217
PetscErrorCode BVCreateVec(BV bv,Vec *v)BVCreateVec1364,42937
PetscErrorCode BVCreateMat(BV bv,Mat *A)BVCreateMat1397,43653
PetscErrorCode BVGetMat(BV bv,Mat *A)BVGetMat1443,45011
PetscErrorCode BVRestoreMat(BV bv,Mat *A)BVRestoreMat1494,46695
PETSC_STATIC_INLINE PetscErrorCode BVDuplicate_Private(BV V,BV W)BVDuplicate_Private1516,47497
PetscErrorCode BVDuplicate(BV V,BV *W)BVDuplicate1560,48859
PetscErrorCode BVDuplicateResize(BV V,PetscInt m,BV *W)BVDuplicateResize1596,49775
PetscErrorCode BVGetCachedBV(BV bv,BV *cached)BVGetCachedBV1631,50608
PetscErrorCode BVCopy(BV V,BV W)BVCopy1670,51731
PetscErrorCode BVCopyVec(BV V,PetscInt j,Vec w)BVCopyVec1724,53604
PetscErrorCode BVCopyColumn(BV V,PetscInt j,PetscInt i)BVCopyColumn1764,54794
static PetscErrorCode BVGetSplit_Private(BV bv,PetscBool left,BV *split)BVGetSplit_Private1798,55854
PetscErrorCode BVGetSplit(BV bv,BV *L,BV *R)BVGetSplit1863,58117
PetscErrorCode BVRestoreSplit(BV bv,BV *L,BV *R)BVRestoreSplit1898,59225

src/sys/classes/bv/interface/bvbiorthog.c,594
bvbiorthog.c:^?bvbiorthog.c^A,1
static PetscErrorCode BVBiorthogonalizeMGS1(BV V,BV W,Vec v,PetscScalar *h,PetscScalar *c)BVBiorthogonalizeMGS119,606
static PetscErrorCode BVBiorthogonalizeCGS1(BV V,BV W,Vec v,PetscScalar *h,PetscScalar *c)BVBiorthogonalizeCGS145,1411
#define BVBiorthogonalizeGS1(BVBiorthogonalizeGS160,1763
static PetscErrorCode BVBiorthogonalizeGS(BV V,BV W,Vec v)BVBiorthogonalizeGS68,2062
PetscErrorCode BVBiorthogonalizeColumn(BV V,BV W,PetscInt j)BVBiorthogonalizeColumn101,2911
PetscErrorCode BVBiorthonormalizeColumn(BV V,BV W,PetscInt j,PetscReal *delta)BVBiorthonormalizeColumn172,5823

src/sys/classes/bv/interface/bvblas.c,1446
bvblas.c:^?bvblas.c^A,1
#define BLOCKSIZE BLOCKSIZE17,510
PetscErrorCode BVMult_BLAS_Private(BV bv,PetscInt m_,PetscInt n_,PetscInt k_,PetscInt ldb_,PetscScalar alpha,const PetscScalar *A,const PetscScalar *B,PetscScalar beta,PetscScalar *C)BVMult_BLAS_Private24,623
PetscErrorCode BVMultVec_BLAS_Private(BV bv,PetscInt n_,PetscInt k_,PetscScalar alpha,const PetscScalar *A,const PetscScalar *x,PetscScalar beta,PetscScalar *y)BVMultVec_BLAS_Private55,1831
PetscErrorCode BVMultInPlace_BLAS_Private(BV bv,PetscInt m_,PetscInt k_,PetscInt ldb_,PetscInt s,PetscInt e,PetscScalar *A,const PetscScalar *B,PetscBool btrans)BVMultInPlace_BLAS_Private73,2418
PetscErrorCode BVMultInPlace_Vecs_Private(BV bv,PetscInt m_,PetscInt n_,PetscInt k_,Vec *V,const PetscScalar *B,PetscBool btrans)BVMultInPlace_Vecs_Private116,3729
PetscErrorCode BVAXPY_BLAS_Private(BV bv,PetscInt n_,PetscInt k_,PetscScalar alpha,const PetscScalar *A,PetscScalar beta,PetscScalar *B)BVAXPY_BLAS_Private169,5584
PetscErrorCode BVDot_BLAS_Private(BV bv,PetscInt m_,PetscInt n_,PetscInt k_,PetscInt ldc_,const PetscScalar *A,const PetscScalar *B,PetscScalar *C,PetscBool mpi)BVDot_BLAS_Private190,6209
PetscErrorCode BVDotVec_BLAS_Private(BV bv,PetscInt n_,PetscInt k_,const PetscScalar *A,const PetscScalar *x,PetscScalar *y,PetscBool mpi)BVDotVec_BLAS_Private232,7993
PetscErrorCode BVScale_BLAS_Private(BV bv,PetscInt n_,PetscScalar *A,PetscScalar alpha)BVScale_BLAS_Private261,8986

src/sys/classes/bv/interface/bvfunc.c,6586
bvfunc.c:^?bvfunc.c^A,1
PetscClassId     BV_CLASSID = 0;BV_CLASSID16,532
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Create17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Copy17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Mult17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_MultVec17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_MultInPlace17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Dot17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_DotVec17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Orthogonalize17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_OrthogonalizeVec17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Scale17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_Norm17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_NormVec17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_SetRandom17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_MatMult17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_MatMultVec17,565
PetscLogEvent    BV_Create = 0,BV_Copy = 0,BV_Mult = 0,BV_MultVec = 0,BV_MultInPlace = 0,BV_Dot = 0,BV_DotVec = 0,BV_Orthogonalize = 0,BV_OrthogonalizeVec = 0,BV_Scale = 0,BV_Norm = 0,BV_NormVec = 0,BV_SetRandom = 0,BV_MatMult = 0,BV_MatMultVec = 0,BV_MatProject = 0;BV_MatProject17,565
static PetscBool BVPackageInitialized = PETSC_FALSE;BVPackageInitialized18,833
MPI_Op MPIU_TSQR = 0;MPIU_TSQR19,886
const char *BVOrthogTypes[] = {"CGS","MGS","BVOrthogType","BV_ORTHOG_",0};BVOrthogTypes21,909
const char *BVOrthogRefineTypes[] = {"IFNEEDED","NEVER","ALWAYS","BVOrthogRefineType","BV_ORTHOG_REFINE_",0};BVOrthogRefineTypes22,984
const char *BVOrthogBlockTypes[] = {"GS","CHOL","TSQR","TSQRCHOL","SVQB","BVOrthogBlockType","BV_ORTHOG_BLOCK_",0};BVOrthogBlockTypes23,1094
const char *BVMatMultTypes[] = {"VECS","MAT","MAT_SAVE","BVMatMultType","BV_MATMULT_",0};BVMatMultTypes24,1210
PetscErrorCode BVFinalizePackage(void)BVFinalizePackage34,1495
PetscErrorCode BVInitializePackage(void)BVInitializePackage55,2077
PetscErrorCode BVDestroy(BV *bv)BVDestroy116,4882
PetscErrorCode BVCreate(MPI_Comm comm,BV *newbv)BVCreate159,6368
PetscErrorCode BVCreateFromMat(Mat A,BV *bv)BVCreateFromMat245,8532
PetscErrorCode BVInsertVec(BV V,PetscInt j,Vec w)BVInsertVec280,9496
PetscErrorCode BVInsertVecs(BV V,PetscInt s,PetscInt *m,Vec *W,PetscBool orth)BVInsertVecs331,11274
PetscErrorCode BVInsertConstraints(BV V,PetscInt *nc,Vec *C)BVInsertConstraints414,14553
PetscErrorCode BVSetOptionsPrefix(BV bv,const char *prefix)BVSetOptionsPrefix464,16349
PetscErrorCode BVAppendOptionsPrefix(BV bv,const char *prefix)BVAppendOptionsPrefix493,17115
PetscErrorCode BVGetOptionsPrefix(BV bv,const char *prefix[])BVGetOptionsPrefix523,17840
static PetscErrorCode BVView_Default(BV bv,PetscViewer viewer)BVView_Default534,18131
PetscErrorCode BVView(BV bv,PetscViewer viewer)BVView589,19890
PetscErrorCode BVRegister(const char *name,PetscErrorCode (*function)(BV))BVRegister679,23792
PetscErrorCode BVAllocateWork_Private(BV bv,PetscInt s)BVAllocateWork_Private689,24058
PETSC_UNUSED PetscErrorCode SlepcDebugBVView(BV bv,PetscInt ini,PetscInt end,const char *s,const char *filename)SlepcDebugBVView711,24670

src/sys/classes/bv/interface/bvglobal.c,2291
bvglobal.c:^?bvglobal.c^A,1
PETSC_STATIC_INLINE PetscErrorCode BVDot_Private(BV X,BV Y,Mat M)BVDot_Private20,655
PetscErrorCode BVDot(BV X,BV Y,Mat M)BVDot87,2827
PetscErrorCode BVDotVec(BV X,Vec y,PetscScalar m[])BVDotVec159,5497
PetscErrorCode BVDotVecBegin(BV X,Vec y,PetscScalar *m)BVDotVecBegin197,6544
PetscErrorCode BVDotVecEnd(BV X,Vec y,PetscScalar *m)BVDotVecEnd253,8360
PetscErrorCode BVDotColumn(BV X,PetscInt j,PetscScalar *q)BVDotColumn317,10671
PetscErrorCode BVDotColumnBegin(BV X,PetscInt j,PetscScalar *m)BVDotColumnBegin360,11988
PetscErrorCode BVDotColumnEnd(BV X,PetscInt j,PetscScalar *m)BVDotColumnEnd420,14002
PETSC_STATIC_INLINE PetscErrorCode BVNorm_Private(BV bv,Vec z,NormType type,PetscReal *val)BVNorm_Private465,15860
PETSC_STATIC_INLINE PetscErrorCode BVNorm_Begin_Private(BV bv,Vec z,NormType type,PetscReal *val)BVNorm_Begin_Private477,16182
PETSC_STATIC_INLINE PetscErrorCode BVNorm_End_Private(BV bv,Vec z,NormType type,PetscReal *val)BVNorm_End_Private488,16469
PetscErrorCode BVNorm(BV bv,NormType type,PetscReal *val)BVNorm522,17297
PetscErrorCode BVNormVec(BV bv,Vec v,NormType type,PetscReal *val)BVNormVec565,18641
PetscErrorCode BVNormVecBegin(BV bv,Vec v,NormType type,PetscReal *val)BVNormVecBegin610,20009
PetscErrorCode BVNormVecEnd(BV bv,Vec v,NormType type,PetscReal *val)BVNormVecEnd655,21398
PetscErrorCode BVNormColumn(BV bv,PetscInt j,NormType type,PetscReal *val)BVNormColumn699,22613
PetscErrorCode BVNormColumnBegin(BV bv,PetscInt j,NormType type,PetscReal *val)BVNormColumnBegin743,24050
PetscErrorCode BVNormColumnEnd(BV bv,PetscInt j,NormType type,PetscReal *val)BVNormColumnEnd804,26381
PETSC_STATIC_INLINE PetscErrorCode BVMatProject_Vec(BV X,Mat A,BV Y,PetscScalar *marray,PetscInt ldm,PetscBool symm)BVMatProject_Vec850,28465
PETSC_STATIC_INLINE PetscErrorCode BVMatProject_MatMult(BV X,Mat A,BV Y,PetscScalar *marray,PetscInt ldm)BVMatProject_MatMult898,30022
PETSC_STATIC_INLINE PetscErrorCode BVMatProject_MatMult_2(BV X,Mat A,BV Y,PetscScalar *marray,PetscInt ldm,PetscBool symm)BVMatProject_MatMult_2954,31827
PETSC_STATIC_INLINE PetscErrorCode BVMatProject_Dot(BV X,BV Y,PetscScalar *marray,PetscInt ldm)BVMatProject_Dot1017,33881
PetscErrorCode BVMatProject(BV X,Mat A,BV Y,Mat M)BVMatProject1103,36871

src/sys/classes/bv/interface/bvlapack.c,904
bvlapack.c:^?bvlapack.c^A,1
PetscErrorCode BVNorm_LAPACK_Private(BV bv,PetscInt m_,PetscInt n_,const PetscScalar *A,NormType type,PetscReal *nrm,PetscBool mpi)BVNorm_LAPACK_Private20,554
PetscErrorCode BVMatCholInv_LAPACK_Private(BV bv,Mat R,Mat S)BVMatCholInv_LAPACK_Private76,2708
PetscErrorCode BVMatTriInv_LAPACK_Private(BV bv,Mat R,Mat S)BVMatTriInv_LAPACK_Private156,5325
PetscErrorCode BVMatSVQB_LAPACK_Private(BV bv,Mat R,Mat S)BVMatSVQB_LAPACK_Private215,7145
PetscErrorCode BVOrthogonalize_LAPACK_TSQR(BV bv,PetscInt m_,PetscInt n_,PetscScalar *Q,PetscScalar *R,PetscInt ldr)BVOrthogonalize_LAPACK_TSQR305,10151
SLEPC_EXTERN void MPIAPI SlepcGivensPacked(void *in,void *inout,PetscMPIInt *len,MPI_Datatype *datatype)SlepcGivensPacked448,16037
PetscErrorCode BVOrthogonalize_LAPACK_TSQR_OnlyR(BV bv,PetscInt m_,PetscInt n_,PetscScalar *Q,PetscScalar *R,PetscInt ldr)BVOrthogonalize_LAPACK_TSQR_OnlyR474,16898

src/sys/classes/bv/interface/bvops.c,1229
bvops.c:^?bvops.c^A,1
PetscErrorCode BVMult(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)BVMult50,1744
PetscErrorCode BVMultVec(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar q[])BVMultVec116,4234
PetscErrorCode BVMultColumn(BV X,PetscScalar alpha,PetscScalar beta,PetscInt j,PetscScalar *q)BVMultColumn171,6151
PetscErrorCode BVMultInPlace(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlace227,8107
PetscErrorCode BVMultInPlaceTranspose(BV V,Mat Q,PetscInt s,PetscInt e)BVMultInPlaceTranspose279,10137
PetscErrorCode BVScale(BV bv,PetscScalar alpha)BVScale326,12037
PetscErrorCode BVScaleColumn(BV bv,PetscInt j,PetscScalar alpha)BVScaleColumn360,12886
PETSC_STATIC_INLINE PetscErrorCode BVSetRandomColumn_Private(BV bv,PetscInt k)BVSetRandomColumn_Private383,13693
PetscErrorCode BVSetRandom(BV bv)BVSetRandom422,14793
PetscErrorCode BVSetRandomColumn(BV bv,PetscInt j)BVSetRandomColumn455,15630
PetscErrorCode BVSetRandomCond(BV bv,PetscReal condn)BVSetRandomCond491,16775
PetscErrorCode BVMatMult(BV V,Mat A,BV Y)BVMatMult574,19947
PetscErrorCode BVMatMultHermitianTranspose(BV V,Mat A,BV Y)BVMatMultHermitianTranspose625,21681
PetscErrorCode BVMatMultColumn(BV V,Mat A,PetscInt j)BVMatMultColumn676,23321

src/sys/classes/bv/interface/bvorthog.c,2145
bvorthog.c:^?bvorthog.c^A,1
PETSC_STATIC_INLINE PetscErrorCode BV_NormVecOrColumn(BV bv,PetscInt j,Vec v,PetscReal *nrm)BV_NormVecOrColumn20,631
PETSC_STATIC_INLINE PetscErrorCode BVDotColumnInc(BV X,PetscInt j,PetscScalar *q)BVDotColumnInc34,1036
static PetscErrorCode BVOrthogonalizeMGS1(BV bv,PetscInt j,Vec v,PetscBool *which,PetscScalar *h,PetscScalar *c,PetscReal *onrm,PetscReal *nrm)BVOrthogonalizeMGS155,1621
static PetscErrorCode BVOrthogonalizeCGS1(BV bv,PetscInt j,Vec v,PetscBool *which,PetscScalar *h,PetscScalar *c,PetscReal *onorm,PetscReal *norm)BVOrthogonalizeCGS198,3071
#define BVOrthogonalizeGS1(BVOrthogonalizeGS1144,4537
static PetscErrorCode BVOrthogonalizeGS(BV bv,PetscInt j,Vec v,PetscBool *which,PetscReal *norm,PetscBool *lindep)BVOrthogonalizeGS155,5133
PetscErrorCode BVOrthogonalizeVec(BV bv,Vec v,PetscScalar *H,PetscReal *norm,PetscBool *lindep)BVOrthogonalizeVec262,8927
PetscErrorCode BVOrthogonalizeColumn(BV bv,PetscInt j,PetscScalar *H,PetscReal *norm,PetscBool *lindep)BVOrthogonalizeColumn329,11508
PetscErrorCode BVOrthonormalizeColumn(BV bv,PetscInt j,PetscBool replace,PetscReal *norm,PetscBool *lindep)BVOrthonormalizeColumn393,14339
PetscErrorCode BVOrthogonalizeSomeColumn(BV bv,PetscInt j,PetscBool *which,PetscScalar *H,PetscReal *norm,PetscBool *lindep)BVOrthogonalizeSomeColumn476,17426
static PetscErrorCode BVOrthogonalize_BlockGS(BV V,Mat R)BVOrthogonalize_BlockGS509,18917
static PetscErrorCode BVOrthogonalize_GS(BV V,Mat R)BVOrthogonalize_GS525,19335
PETSC_STATIC_INLINE PetscErrorCode BV_GetBufferMat(BV bv)BV_GetBufferMat575,21101
PETSC_STATIC_INLINE PetscErrorCode BV_StoreCoeffsBlock_Default(BV bv,Mat R,PetscBool tri)BV_StoreCoeffsBlock_Default598,21915
static PetscErrorCode BVOrthogonalize_Chol(BV V,Mat Rin)BVOrthogonalize_Chol621,22652
static PetscErrorCode BVOrthogonalize_TSQR(BV V,Mat Rin)BVOrthogonalize_TSQR642,23311
static PetscErrorCode BVOrthogonalize_TSQRCHOL(BV V,Mat Rin)BVOrthogonalize_TSQRCHOL666,24169
static PetscErrorCode BVOrthogonalize_SVQB(BV V,Mat Rin)BVOrthogonalize_SVQB694,25176
PetscErrorCode BVOrthogonalize(BV V,Mat R)BVOrthogonalize759,27685

src/sys/classes/bv/interface/bvregis.c,56
bvregis.c:^?bvregis.c^A,1
PetscErrorCode BVRegisterAll(void)BVRegisterAll28,859

src/sys/classes/bv/interface/cuda/makefile,294
makefile:^?makefile^A,1
CFLAGS   =CFLAGS14,444
FFLAGS   =FFLAGS15,455
SOURCECU = bvorthogcuda.cuSOURCECU16,466
SOURCEF  =SOURCEF17,493
SOURCEH  =SOURCEH18,504
LIBBASE  = libslepcsysLIBBASE19,515
DIRS     =DIRS20,538
MANSEC   = BVMANSEC21,549
LOCDIR   = src/sys/classes/bv/interface/cuda/LOCDIR22,563

src/sys/classes/bv/interface/ftn-custom/makefile,262
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zbvf.cSOURCEC15,469
SOURCEF  =SOURCEF16,487
SOURCEH  =SOURCEH17,498
DIRS     =DIRS18,509
LIBBASE  = libslepcsysLIBBASE19,520
LOCDIR   = src/sys/classes/bv/interface/ftn-custom/LOCDIR20,543

src/sys/classes/bv/interface/ftn-custom/zbvf.c,1447
zbvf.c:^?zbvf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL bvsettype_(BV *bv,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))bvsettype_30,1134
SLEPC_EXTERN void PETSC_STDCALL bvgettype_(BV *bv,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))bvgettype_39,1363
SLEPC_EXTERN void PETSC_STDCALL bvsetoptionsprefix_(BV *bv,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))bvsetoptionsprefix_48,1656
SLEPC_EXTERN void PETSC_STDCALL bvappendoptionsprefix_(BV *bv,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))bvappendoptionsprefix_57,1909
SLEPC_EXTERN void PETSC_STDCALL bvgetoptionsprefix_(BV *bv,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))bvgetoptionsprefix_66,2168
SLEPC_EXTERN void PETSC_STDCALL bvview_(BV *bv,PetscViewer *viewer,PetscErrorCode *ierr)bvview_75,2490

src/sys/classes/bv/interface/makefile,369
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = bvbasic.c bvfunc.c bvops.c bvglobal.c bvblas.c bvlapack.c bvorthog.c bvbiorthog.c bvregis.cSOURCEC15,431
SOURCEF  =SOURCEF16,534
SOURCEH  =SOURCEH17,545
LIBBASE  = libslepcsysLIBBASE18,556
DIRS     = cudaDIRS19,579
MANSEC   = BVMANSEC20,595
LOCDIR   = src/sys/classes/bv/interface/LOCDIR21,609

src/sys/classes/bv/makefile,228
makefile:^?makefile^A,1
SOURCEH  = ../../../../include/slepc/private/bvimpl.h ../../../../include/slepcbv.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,493
LOCDIR   = src/sys/classes/bv/LOCDIR15,537
MANSEC   = BVMANSEC16,568

src/sys/classes/ds/examples/makefile,83
makefile:^?makefile^A,1
LOCDIR   = src/sys/classes/ds/examples/LOCDIR13,405
DIRS     = testsDIRS14,445

src/sys/classes/ds/examples/tests/makefile,446
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/classes/ds/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c \EXAMPLESC16,499
EXAMPLESF  = test14f.F90EXAMPLESF18,671
MANSEC     = DSMANSEC19,696
TESTS      = test1 test2 test3 test4 test5 test6 test7 test8 test9 test12 test13 \TESTS20,712

src/sys/classes/ds/examples/tests/test1.c,96
test1.c:^?test1.c^A,1
static char help[] = "Test DSNHEP.\n\n";help11,400
int main(int argc,char **argv)main15,464

src/sys/classes/ds/examples/tests/test12.c,95
test12.c:^?test12.c^A,1
static char help[] = "Test DSNEP.\n\n";help11,400
int main(int argc,char **argv)main15,463

src/sys/classes/ds/examples/tests/test13.c,127
test13.c:^?test13.c^A,1
static char help[] = "Test DSHEP with block size larger than one.\n\n";help11,400
int main(int argc,char **argv)main15,495

src/sys/classes/ds/examples/tests/test14f.F90,257
test14f.F90:^?test14f.F90^A,1
      program mainmain19,698
 110  format (/'Solve a Dense System of type NHEP, n =',I3,' (Fortran)')11060,1960
 120  format ('  ',F8.5)120108,3760
 130  format ('  ',F8.5,SP,F8.5,'i')130109,3785
      subroutine FillUpMatrix(FillUpMatrix118,3997

src/sys/classes/ds/examples/tests/test15.c,95
test15.c:^?test15.c^A,1
static char help[] = "Test DSPEP.\n\n";help11,400
int main(int argc,char **argv)main15,463

src/sys/classes/ds/examples/tests/test16.c,114
test16.c:^?test16.c^A,1
static char help[] = "Test pseudo-orthogonalization.\n\n";help11,400
int main(int argc,char **argv)main15,482

src/sys/classes/ds/examples/tests/test17.c,120
test17.c:^?test17.c^A,1
static char help[] = "Test DSPEP with complex eigenvalues.\n\n";help11,400
int main(int argc,char **argv)main15,488

src/sys/classes/ds/examples/tests/test18.c,205
test18.c:^?test18.c^A,1
static char help[] = "Test DSSynchronize() on a NHEP.\n\n";help11,400
PetscErrorCode CheckArray(PetscScalar *A,const char *label,PetscInt k)CheckArray15,483
int main(int argc,char **argv)main44,1454

src/sys/classes/ds/examples/tests/test19.c,123
test19.c:^?test19.c^A,1
static char help[] = "Test DSSortWithPermutation() on a NHEP.\n\n";help11,400
int main(int argc,char **argv)main15,491

src/sys/classes/ds/examples/tests/test2.c,95
test2.c:^?test2.c^A,1
static char help[] = "Test DSHEP.\n\n";help11,400
int main(int argc,char **argv)main15,463

src/sys/classes/ds/examples/tests/test20.c,137
test20.c:^?test20.c^A,1
static char help[] = "Test DSGNHEP with upper quasi-triangular matrix pair.\n\n";help11,400
int main(int argc,char **argv)main15,505

src/sys/classes/ds/examples/tests/test3.c,116
test3.c:^?test3.c^A,1
static char help[] = "Test DSHEP with compact storage.\n\n";help11,400
int main(int argc,char **argv)main15,484

src/sys/classes/ds/examples/tests/test4.c,97
test4.c:^?test4.c^A,1
static char help[] = "Test DSGNHEP.\n\n";help11,400
int main(int argc,char **argv)main15,465

src/sys/classes/ds/examples/tests/test5.c,97
test5.c:^?test5.c^A,1
static char help[] = "Test DSGHIEP.\n\n";help11,400
int main(int argc,char **argv)main15,465

src/sys/classes/ds/examples/tests/test6.c,118
test6.c:^?test6.c^A,1
static char help[] = "Test DSGHIEP with compact storage.\n\n";help11,400
int main(int argc,char **argv)main15,486

src/sys/classes/ds/examples/tests/test7.c,95
test7.c:^?test7.c^A,1
static char help[] = "Test DSSVD.\n\n";help11,400
int main(int argc,char **argv)main15,463

src/sys/classes/ds/examples/tests/test8.c,116
test8.c:^?test8.c^A,1
static char help[] = "Test DSSVD with compact storage.\n\n";help11,400
int main(int argc,char **argv)main15,484

src/sys/classes/ds/examples/tests/test9.c,191
test9.c:^?test9.c^A,1
static char help[] = "Test DSGHEP.\n\n";help11,400
PetscErrorCode ComputeNorm(DS ds,DSMatType mat,PetscInt j,PetscReal *onrm)ComputeNorm18,530
int main(int argc,char **argv)main38,1092

src/sys/classes/ds/f90-mod/makefile,335
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcdsmod.FSOURCEF17,514
SOURCEH    = slepcds.h slepcds.h90SOURCEH18,540
LIBBASE    = libslepcsysLIBBASE19,575
MANSEC     = DSMANSEC20,600
LOCDIR     = src/sys/classes/ds/f90-mod/LOCDIR21,616
CLEANFILES = *.modCLEANFILES22,657

src/sys/classes/ds/f90-mod/slepcds.h,142
slepcds.h:^?slepcds.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      DS, parameter :: SLEPC_NULL_DS = tDS(0)DS18,589

src/sys/classes/ds/f90-mod/slepcdsmod.F,82
slepcdsmod.F:^?slepcdsmod.F^A,1
        module slepcdsdefslepcdsdef10,398
        module slepcdsslepcds16,539

src/sys/classes/ds/impls/ghep/dsghep.c,738
dsghep.c:^?dsghep.c^A,1
PetscErrorCode DSAllocate_GHEP(DS ds,PetscInt ld)DSAllocate_GHEP14,464
PetscErrorCode DSView_GHEP(DS ds,PetscViewer viewer)DSView_GHEP28,945
PetscErrorCode DSVectors_GHEP(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_GHEP43,1560
PetscErrorCode DSSort_GHEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_GHEP80,2780
PetscErrorCode DSSolve_GHEP(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_GHEP104,3519
PetscErrorCode DSSynchronize_GHEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_GHEP160,5500
PetscErrorCode DSHermitian_GHEP(DS ds,DSMatType m,PetscBool *flg)DSHermitian_GHEP199,7398
SLEPC_EXTERN PetscErrorCode DSCreate_GHEP(DS ds)DSCreate_GHEP207,7597

src/sys/classes/ds/impls/ghep/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsghep.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = DSMANSEC20,507
LOCDIR   = src/sys/classes/ds/impls/ghep/LOCDIR21,521

src/sys/classes/ds/impls/ghiep/dsghiep.c,1394
dsghiep.c:^?dsghiep.c^A,1
PetscErrorCode DSAllocate_GHIEP(DS ds,PetscInt ld)DSAllocate_GHIEP14,464
PetscErrorCode DSSwitchFormat_GHIEP(DS ds,PetscBool tocompact)DSSwitchFormat_GHIEP30,1072
PetscErrorCode DSView_GHIEP(DS ds,PetscViewer viewer)DSView_GHIEP74,2383
static PetscErrorCode DSVectors_GHIEP_Eigen_Some(DS ds,PetscInt *idx,PetscReal *rnorm)DSVectors_GHIEP_Eigen_Some158,6407
PetscErrorCode DSVectors_GHIEP(DS ds,DSMatType mat,PetscInt *k,PetscReal *rnorm)DSVectors_GHIEP260,10140
PetscErrorCode DSGHIEPComplexEigs(DS ds,PetscInt n0,PetscInt n1,PetscScalar *wr,PetscScalar *wi)DSGHIEPComplexEigs302,11519
PetscErrorCode DSSort_GHIEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_GHIEP376,13727
PetscErrorCode DSGHIEPInverseIteration(DS ds,PetscScalar *wr,PetscScalar *wi)DSGHIEPInverseIteration422,15320
PetscErrorCode DSGHIEPRealBlocks(DS ds)DSGHIEPRealBlocks503,18144
PetscErrorCode DSSolve_GHIEP_QR_II(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_GHIEP_QR_II627,22464
PetscErrorCode DSSolve_GHIEP_QR(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_GHIEP_QR737,26258
PetscErrorCode DSSynchronize_GHIEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_GHIEP867,30548
PetscErrorCode DSHermitian_GHIEP(DS ds,DSMatType m,PetscBool *flg)DSHermitian_GHIEP926,33505
SLEPC_EXTERN PetscErrorCode DSCreate_GHIEP(DS ds)DSCreate_GHIEP934,33705

src/sys/classes/ds/impls/ghiep/hz.c,613
hz.c:^?hz.c^A,1
static PetscErrorCode UnifiedRotation(PetscReal x,PetscReal y,PetscReal sygn,PetscReal *rot,PetscReal *rcond,PetscBool *swap)UnifiedRotation31,1075
static PetscErrorCode HZStep(PetscBLASInt ntop,PetscBLASInt nn,PetscReal tr,PetscReal dt,PetscReal *aa,PetscReal *bb,PetscReal *dd,PetscScalar *uu,PetscInt n,PetscInt ld,PetscBool *flag)HZStep65,2301
static PetscErrorCode HZIteration(PetscBLASInt nn,PetscBLASInt cgd,PetscReal *aa,PetscReal *bb,PetscReal *dd,PetscScalar *uu,PetscBLASInt ld)HZIteration222,8456
PetscErrorCode DSSolve_GHIEP_HZ(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_GHIEP_HZ288,10849

src/sys/classes/ds/impls/ghiep/invit.c,1737
invit.c:^?invit.c^A,1
struct HRtrHRtr14,464
  PetscScalar *data;data16,478
  PetscInt    m;m17,499
  PetscInt    idx[2];idx18,516
  PetscInt    n[2];n19,538
  PetscScalar tau[2];tau20,558
  PetscReal   alpha;alpha21,580
  PetscReal   cs;cs22,601
  PetscReal   sn;sn23,619
  PetscInt    type;type24,637
static PetscErrorCode HRGen(PetscReal x1,PetscReal x2,PetscInt *type,PetscReal *c,PetscReal *s,PetscReal *r,PetscReal *cond)HRGen38,934
static PetscErrorCode HRApply(PetscInt n,PetscScalar *x1,PetscInt inc1,PetscScalar *x2,PetscInt inc2,PetscReal c,PetscReal s)HRApply79,2018
static PetscErrorCode TridiagDiag_HHR(PetscInt n,PetscScalar *A,PetscInt lda,PetscReal *s,PetscScalar* Q,PetscInt ldq,PetscBool flip,PetscReal *d,PetscReal *e,PetscInt *perm_,PetscScalar *work,PetscReal *rwork,PetscBLASInt *iwork)TridiagDiag_HHR114,2920
static PetscErrorCode MadeHRtr(PetscInt sz,PetscInt n,PetscInt idx0,PetscInt n0,PetscInt idx1,PetscInt n1,struct HRtr *tr1,struct HRtr *tr2,PetscReal *ncond,PetscScalar *work)MadeHRtr287,8755
static PetscErrorCode TryHRIt(PetscInt n,PetscInt j,PetscInt sz,PetscScalar *H,PetscInt ldh,PetscScalar *R,PetscInt ldr,PetscReal *s,PetscBool *exg,PetscBool *ok,PetscInt *n0,PetscInt *n1,PetscInt *idx0,PetscInt *idx1,PetscReal *cond,PetscScalar *work)TryHRIt373,12158
static PetscErrorCode PseudoOrthog_HR(PetscInt *nv,PetscScalar *V,PetscInt ldv,PetscReal *s,PetscScalar *R,PetscInt ldr,PetscBLASInt *perm,PetscBLASInt *cmplxEig,PetscBool *breakdown,PetscScalar *work)PseudoOrthog_HR522,18372
PetscErrorCode DSGHIEPOrthogEigenv(DS ds,DSMatType mat,PetscScalar *wr,PetscScalar *wi,PetscBool accum)DSGHIEPOrthogEigenv612,21157
PetscErrorCode DSIntermediate_GHIEP(DS ds)DSIntermediate_GHIEP711,24245

src/sys/classes/ds/impls/ghiep/makefile,297
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsghiep.c invit.c hz.cSOURCEC15,431
SOURCEF  =SOURCEF16,465
SOURCEH  =SOURCEH17,476
LIBBASE  = libslepcsysLIBBASE18,487
DIRS     =DIRS19,510
MANSEC   = DSMANSEC20,521
LOCDIR   = src/sys/classes/ds/impls/ghiep/LOCDIR21,535

src/sys/classes/ds/impls/gnhep/dsgnhep.c,1376
dsgnhep.c:^?dsgnhep.c^A,1
PetscErrorCode DSAllocate_GNHEP(DS ds,PetscInt ld)DSAllocate_GNHEP33,1209
PetscErrorCode DSView_GNHEP(DS ds,PetscViewer viewer)DSView_GNHEP48,1750
static PetscErrorCode DSVectors_GNHEP_Eigen_Some(DS ds,PetscInt *k,PetscReal *rnorm,PetscBool left)DSVectors_GNHEP_Eigen_Some67,2509
static PetscErrorCode DSVectors_GNHEP_Eigen_All(DS ds,PetscBool left)DSVectors_GNHEP_Eigen_All146,5497
PetscErrorCode DSVectors_GNHEP(DS ds,DSMatType mat,PetscInt *k,PetscReal *rnorm)DSVectors_GNHEP216,7862
static PetscErrorCode DSSort_GNHEP_Arbitrary(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_GNHEP_Arbitrary236,8448
static PetscErrorCode DSSort_GNHEP_Total(DS ds,PetscScalar *wr,PetscScalar *wi)DSSort_GNHEP_Total287,10479
PetscErrorCode DSSort_GNHEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_GNHEP385,13752
static PetscErrorCode CleanDenseSchur(PetscInt n,PetscInt k,PetscScalar *S,PetscInt ldS,PetscScalar *T,PetscInt ldT,PetscScalar *X,PetscInt ldX,PetscScalar *Y,PetscInt ldY)CleanDenseSchur403,14296
PetscErrorCode DSSolve_GNHEP(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_GNHEP483,17840
PetscErrorCode DSSynchronize_GNHEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_GNHEP534,19945
SLEPC_EXTERN PetscErrorCode DSCreate_GNHEP(DS ds)DSCreate_GNHEP582,22402

src/sys/classes/ds/impls/gnhep/makefile,284
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsgnhep.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcsysLIBBASE18,474
DIRS     =DIRS19,497
MANSEC   = DSMANSEC20,508
LOCDIR   = src/sys/classes/ds/impls/gnhep/LOCDIR21,522

src/sys/classes/ds/impls/hep/bdc/dibtdc.c,197
dibtdc.c:^?dibtdc.c^A,1
static PetscErrorCode cutlr_(PetscBLASInt start,PetscBLASInt n,PetscBLASInt blkct,cutlr_17,537
PetscErrorCode BDC_dibtdc_(const char *jobz,PetscBLASInt n,PetscBLASInt nblks,BDC_dibtdc_164,5375

src/sys/classes/ds/impls/hep/bdc/dlaed3m.c,113
dlaed3m.c:^?dlaed3m.c^A,1
PetscErrorCode BDC_dlaed3m_(const char *jobz,const char *defl,PetscBLASInt k,PetscBLASInt n,BDC_dlaed3m_17,537

src/sys/classes/ds/impls/hep/bdc/dmerg2.c,97
dmerg2.c:^?dmerg2.c^A,1
PetscErrorCode BDC_dmerg2_(const char *jobz,PetscBLASInt rkct,PetscBLASInt n,BDC_dmerg2_17,537

src/sys/classes/ds/impls/hep/bdc/dsbtdc.c,131
dsbtdc.c:^?dsbtdc.c^A,1
PetscErrorCode BDC_dsbtdc_(const char *jobz,const char *jobacc,PetscBLASInt n,BDC_dsbtdc_17,537
#define TOLMAX TOLMAX254,13173

src/sys/classes/ds/impls/hep/bdc/dsrtdf.c,94
dsrtdf.c:^?dsrtdf.c^A,1
PetscErrorCode BDC_dsrtdf_(PetscBLASInt *k,PetscBLASInt n,PetscBLASInt n1,BDC_dsrtdf_17,537

src/sys/classes/ds/impls/hep/bdc/makefile,322
makefile:^?makefile^A,1
CFLAGS   =CFLAGS15,434
FFLAGS   =FFLAGS16,445
SOURCEC  = dibtdc.c dlaed3m.c dmerg2.c dsbtdc.c dsrtdf.cSOURCEC17,456
SOURCEF  =SOURCEF18,513
SOURCEH  =SOURCEH19,524
LIBBASE  = libslepcsysLIBBASE20,535
DIRS     =DIRS21,558
MANSEC   = DSMANSEC22,569
LOCDIR   = src/sys/classes/ds/impls/hep/bdc/LOCDIR23,583

src/sys/classes/ds/impls/hep/dshep.c,1610
dshep.c:^?dshep.c^A,1
PetscErrorCode DSAllocate_HEP(DS ds,PetscInt ld)DSAllocate_HEP14,464
static PetscErrorCode DSSwitchFormat_HEP(DS ds)DSSwitchFormat_HEP53,2011
PetscErrorCode DSView_HEP(DS ds,PetscViewer viewer)DSView_HEP78,2647
PetscErrorCode DSVectors_HEP(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_HEP144,5688
static PetscErrorCode ArrowTridiag(PetscBLASInt n,PetscReal *d,PetscReal *e,PetscScalar *Q,PetscBLASInt ld)ArrowTridiag228,8271
static PetscErrorCode DSIntermediate_HEP(DS ds)DSIntermediate_HEP280,9761
PetscErrorCode DSSort_HEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_HEP335,11677
PetscErrorCode DSUpdateExtraRow_HEP(DS ds)DSUpdateExtraRow_HEP363,12481
PetscErrorCode DSSolve_HEP_QR(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_HEP_QR394,13422
PetscErrorCode DSSolve_HEP_MRRR(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_HEP_MRRR447,15129
PetscErrorCode DSSolve_HEP_DC(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_HEP_DC530,18151
PetscErrorCode DSSolve_HEP_BDC(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_HEP_BDC596,20263
PetscErrorCode DSTruncate_HEP(DS ds,PetscInt n)DSTruncate_HEP663,22419
PetscErrorCode DSSynchronize_HEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_HEP680,22820
PetscErrorCode DSCond_HEP(DS ds,PetscReal *cond)DSCond_HEP727,24916
PetscErrorCode DSTranslateRKS_HEP(DS ds,PetscScalar alpha)DSTranslateRKS_HEP771,26332
PetscErrorCode DSHermitian_HEP(DS ds,DSMatType m,PetscBool *flg)DSHermitian_HEP828,28137
SLEPC_EXTERN PetscErrorCode DSCreate_HEP(DS ds)DSCreate_HEP836,28337

src/sys/classes/ds/impls/hep/makefile,284
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dshep.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     = bdcDIRS19,495
MANSEC   = DSMANSEC20,510
LOCDIR   = src/sys/classes/ds/impls/hep/LOCDIR21,524

src/sys/classes/ds/impls/makefile,178
makefile:^?makefile^A,1
LIBBASE  = libslepcsysLIBBASE13,409
DIRS     = hep nhep ghep ghiep gnhep svd pep nepDIRS14,432
LOCDIR   = src/sys/classes/ds/impls/LOCDIR15,481
MANSEC   = DSMANSEC16,518

src/sys/classes/ds/impls/nep/dsnep.c,2100
dsnep.c:^?dsnep.c^A,1
  PetscInt       nf;                 /* number of functions in f[] */nf15,507
  FN             f[DS_NUM_EXTRA];    /* functions defining the nonlinear operator */f16,577
  PetscInt       neig;               /* number of available eigenpairs */neig17,662
  void           *computematrixctx;computematrixctx18,736
  PetscErrorCode (*computematrix)(DS,PetscScalar,PetscBool,DSMatType,void*);computematrix19,772
} DS_NEP;DS_NEP20,849
static PetscErrorCode DSNEPComputeMatrix(DS ds,PetscScalar lambda,PetscBool deriv,DSMatType mat)DSNEPComputeMatrix27,1089
PetscErrorCode DSAllocate_NEP(DS ds,PetscInt ld)DSAllocate_NEP60,2301
PetscErrorCode DSView_NEP(DS ds,PetscViewer viewer)DSView_NEP78,2962
PetscErrorCode DSVectors_NEP(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_NEP97,3691
PetscErrorCode DSSort_NEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *dummy)DSSort_NEP113,4196
PetscErrorCode DSSolve_NEP_SLP(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_NEP_SLP154,5474
PetscErrorCode DSSynchronize_NEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_NEP281,9754
static PetscErrorCode DSNEPSetFN_NEP(DS ds,PetscInt n,FN fn[])DSNEPSetFN_NEP321,11308
PetscErrorCode DSNEPSetFN(DS ds,PetscInt n,FN fn[])DSNEPSetFN365,12714
static PetscErrorCode DSNEPGetFN_NEP(DS ds,PetscInt k,FN *fn)DSNEPGetFN_NEP382,13178
PetscErrorCode DSNEPGetFN(DS ds,PetscInt k,FN *fn)DSNEPGetFN408,13835
static PetscErrorCode DSNEPGetNumFN_NEP(DS ds,PetscInt *n)DSNEPGetNumFN_NEP419,14121
PetscErrorCode DSNEPGetNumFN(DS ds,PetscInt *n)DSNEPGetNumFN444,14571
static PetscErrorCode DSNEPSetComputeMatrixFunction_NEP(DS ds,PetscErrorCode (*fun)(DS,PetscScalar,PetscBool,DSMatType,void*),void *ctx)DSNEPSetComputeMatrixFunction_NEP455,14853
PetscErrorCode DSNEPSetComputeMatrixFunction(DS ds,PetscErrorCode (*fun)(DS,PetscScalar,PetscBool,DSMatType,void*),void *ctx)DSNEPSetComputeMatrixFunction491,16013
PetscErrorCode DSDestroy_NEP(DS ds)DSDestroy_NEP501,16423
SLEPC_EXTERN PetscErrorCode DSCreate_NEP(DS ds)DSCreate_NEP519,17097

src/sys/classes/ds/impls/nep/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsnep.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = DSMANSEC20,506
LOCDIR   = src/sys/classes/ds/impls/nep/LOCDIR21,520

src/sys/classes/ds/impls/nhep/dsnhep.c,2119
dsnhep.c:^?dsnhep.c^A,1
PetscErrorCode DSAllocate_NHEP(DS ds,PetscInt ld)DSAllocate_NHEP14,464
PetscErrorCode DSView_NHEP(DS ds,PetscViewer viewer)DSView_NHEP27,886
static PetscErrorCode DSVectors_NHEP_Refined_Some(DS ds,PetscInt *k,PetscReal *rnorm,PetscBool left)DSVectors_NHEP_Refined_Some42,1528
static PetscErrorCode DSVectors_NHEP_Refined_All(DS ds,PetscBool left)DSVectors_NHEP_Refined_All97,3623
static PetscErrorCode DSVectors_NHEP_Eigen_Some(DS ds,PetscInt *k,PetscReal *rnorm,PetscBool left)DSVectors_NHEP_Eigen_Some109,3892
static PetscErrorCode DSVectors_NHEP_Eigen_All(DS ds,PetscBool left)DSVectors_NHEP_Eigen_All180,6565
PetscErrorCode DSVectors_NHEP(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_NHEP242,8529
static PetscErrorCode DSSort_NHEP_Arbitrary(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_NHEP_Arbitrary285,9997
static PetscErrorCode DSSort_NHEP_Total(DS ds,PetscScalar *wr,PetscScalar *wi)DSSort_NHEP_Total333,11753
PetscErrorCode DSSort_NHEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_NHEP420,14222
static PetscErrorCode DSSortWithPermutation_NHEP(DS ds,PetscInt *perm,PetscScalar *wr,PetscScalar *wi)DSSortWithPermutation_NHEP433,14569
PetscErrorCode DSUpdateExtraRow_NHEP(DS ds)DSUpdateExtraRow_NHEP502,16749
static PetscErrorCode ArrowHessenberg(PetscBLASInt n,PetscBLASInt k,PetscBLASInt ilo,PetscScalar *A,PetscBLASInt lda,PetscScalar *Q,PetscBLASInt ldq,PetscScalar *work)ArrowHessenberg541,18083
PetscErrorCode DSSolve_NHEP(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_NHEP577,19518
PetscErrorCode DSSynchronize_NHEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_NHEP657,22090
PetscErrorCode DSTruncate_NHEP(DS ds,PetscInt n)DSTruncate_NHEP701,24022
PetscErrorCode DSCond_NHEP(DS ds,PetscReal *cond)DSCond_NHEP725,24664
PetscErrorCode DSTranslateHarmonic_NHEP(DS ds,PetscScalar tau,PetscReal beta,PetscBool recover,PetscScalar *gin,PetscReal *gamma)DSTranslateHarmonic_NHEP769,26162
SLEPC_EXTERN PetscErrorCode DSCreate_NHEP(DS ds)DSCreate_NHEP845,28698

src/sys/classes/ds/impls/nhep/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsnhep.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = DSMANSEC20,507
LOCDIR   = src/sys/classes/ds/impls/nhep/LOCDIR21,521

src/sys/classes/ds/impls/pep/dspep.c,1683
dspep.c:^?dspep.c^A,1
  PetscInt  d;              /* polynomial degree */d15,507
  PetscReal *pbc;           /* polynomial basis coefficients */pbc16,559
} DS_PEP;DS_PEP17,623
PetscErrorCode DSAllocate_PEP(DS ds,PetscInt ld)DSAllocate_PEP19,634
PetscErrorCode DSView_PEP(DS ds,PetscViewer viewer)DSView_PEP38,1384
PetscErrorCode DSVectors_PEP(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_PEP56,2059
PetscErrorCode DSSort_PEP(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *kout)DSSort_PEP71,2479
PetscErrorCode DSSolve_PEP_QZ(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_PEP_QZ116,3892
PetscErrorCode DSSynchronize_PEP(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_PEP267,8981
static PetscErrorCode DSPEPSetDegree_PEP(DS ds,PetscInt d)DSPEPSetDegree_PEP311,10961
PetscErrorCode DSPEPSetDegree(DS ds,PetscInt d)DSPEPSetDegree335,11635
static PetscErrorCode DSPEPGetDegree_PEP(DS ds,PetscInt *d)DSPEPGetDegree_PEP346,11930
PetscErrorCode DSPEPGetDegree(DS ds,PetscInt *d)DSPEPGetDegree370,12332
static PetscErrorCode DSPEPSetCoefficients_PEP(DS ds,PetscReal *pbc)DSPEPSetCoefficients_PEP381,12616
PetscErrorCode DSPEPSetCoefficients(DS ds,PetscReal *pbc)DSPEPSetCoefficients422,14175
static PetscErrorCode DSPEPGetCoefficients_PEP(DS ds,PetscReal **pbc)DSPEPGetCoefficients_PEP432,14448
PetscErrorCode DSPEPGetCoefficients(DS ds,PetscReal **pbc)DSPEPGetCoefficients471,15487
PetscErrorCode DSDestroy_PEP(DS ds)DSDestroy_PEP482,15790
PetscErrorCode DSMatGetSize_PEP(DS ds,DSMatType t,PetscInt *rows,PetscInt *cols)DSMatGetSize_PEP497,16432
SLEPC_EXTERN PetscErrorCode DSCreate_PEP(DS ds)DSCreate_PEP510,16982

src/sys/classes/ds/impls/pep/ftn-custom/makefile,265
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zdspepf.cSOURCEC15,469
SOURCEF  =SOURCEF16,490
SOURCEH  =SOURCEH17,501
DIRS     =DIRS18,512
LIBBASE  = libslepcsysLIBBASE19,523
LOCDIR   = src/sys/classes/ds/impls/pep/ftn-custom/LOCDIR20,546

src/sys/classes/ds/impls/pep/ftn-custom/zdspepf.c,494
zdspepf.c:^?zdspepf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL dspepsetcoefficients_(DS *ds,PetscReal *pbc,PetscErrorCode *ierr)dspepsetcoefficients_22,781
SLEPC_EXTERN void PETSC_STDCALL dspepgetcoefficients_(DS *ds,PetscReal *pbc,PetscErrorCode *ierr)dspepgetcoefficients_28,952

src/sys/classes/ds/impls/pep/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dspep.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = DSMANSEC20,506
LOCDIR   = src/sys/classes/ds/impls/pep/LOCDIR21,520

src/sys/classes/ds/impls/svd/dssvd.c,825
dssvd.c:^?dssvd.c^A,1
PetscErrorCode DSAllocate_SVD(DS ds,PetscInt ld)DSAllocate_SVD14,464
static PetscErrorCode DSSwitchFormat_SVD(DS ds)DSSwitchFormat_SVD54,2071
PetscErrorCode DSView_SVD(DS ds,PetscViewer viewer)DSView_SVD77,2689
PetscErrorCode DSVectors_SVD(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors_SVD127,4929
PetscErrorCode DSSort_SVD(DS ds,PetscScalar *wr,PetscScalar *wi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort_SVD141,5276
PetscErrorCode DSSolve_SVD_DC(DS ds,PetscScalar *wr,PetscScalar *wi)DSSolve_SVD_DC169,6103
PetscErrorCode DSSynchronize_SVD(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize_SVD266,9746
PetscErrorCode DSMatGetSize_SVD(DS ds,DSMatType t,PetscInt *rows,PetscInt *cols)DSMatGetSize_SVD315,12104
SLEPC_EXTERN PetscErrorCode DSCreate_SVD(DS ds)DSCreate_SVD338,12608

src/sys/classes/ds/impls/svd/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dssvd.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = DSMANSEC20,506
LOCDIR   = src/sys/classes/ds/impls/svd/LOCDIR21,520

src/sys/classes/ds/interface/dsbasic.c,3352
dsbasic.c:^?dsbasic.c^A,1
PetscFunctionList DSList = 0;DSList16,487
PetscBool         DSRegisterAllCalled = PETSC_FALSE;DSRegisterAllCalled17,517
PetscClassId      DS_CLASSID = 0;DS_CLASSID18,570
PetscLogEvent     DS_Solve = 0,DS_Vectors = 0,DS_Synchronize = 0,DS_Other = 0;DS_Solve19,604
PetscLogEvent     DS_Solve = 0,DS_Vectors = 0,DS_Synchronize = 0,DS_Other = 0;DS_Vectors19,604
PetscLogEvent     DS_Solve = 0,DS_Vectors = 0,DS_Synchronize = 0,DS_Other = 0;DS_Synchronize19,604
PetscLogEvent     DS_Solve = 0,DS_Vectors = 0,DS_Synchronize = 0,DS_Other = 0;DS_Other19,604
static PetscBool  DSPackageInitialized = PETSC_FALSE;DSPackageInitialized20,683
const char *DSStateTypes[] = {"RAW","INTERMEDIATE","CONDENSED","TRUNCATED","DSStateType","DS_STATE_",0};DSStateTypes22,738
const char *DSParallelTypes[] = {"REDUNDANT","SYNCHRONIZED","DSParallelType","DS_PARALLEL_",0};DSParallelTypes23,843
const char *DSMatName[DS_NUM_MAT] = {"A","B","C","T","D","Q","Z","X","Y","U","VT","W","E0","E1","E2","E3","E4","E5","E6","E7","E8","E9"};DSMatName24,939
DSMatType  DSMatExtra[DS_NUM_EXTRA] = {DS_MAT_E0,DS_MAT_E1,DS_MAT_E2,DS_MAT_E3,DS_MAT_E4,DS_MAT_E5,DS_MAT_E6,DS_MAT_E7,DS_MAT_E8,DS_MAT_E9};DSMatExtra25,1077
PetscErrorCode DSFinalizePackage(void)DSFinalizePackage35,1413
PetscErrorCode DSInitializePackage()DSInitializePackage55,1943
PetscErrorCode DSCreate(MPI_Comm comm,DS *newds)DSCreate109,3765
PetscErrorCode DSSetOptionsPrefix(DS ds,const char *prefix)DSSetOptionsPrefix174,5422
PetscErrorCode DSAppendOptionsPrefix(DS ds,const char *prefix)DSAppendOptionsPrefix202,6159
PetscErrorCode DSGetOptionsPrefix(DS ds,const char *prefix[])DSGetOptionsPrefix232,6883
PetscErrorCode DSSetType(DS ds,DSType type)DSSetType256,7392
PetscErrorCode DSGetType(DS ds,DSType *type)DSGetType293,8361
PetscErrorCode DSDuplicate(DS ds,DS *dsnew)DSDuplicate324,9112
PetscErrorCode DSSetMethod(DS ds,PetscInt meth)DSSetMethod359,10007
PetscErrorCode DSGetMethod(DS ds,PetscInt *meth)DSGetMethod385,10718
PetscErrorCode DSSetParallel(DS ds,DSParallelType pmode)DSSetParallel421,11902
PetscErrorCode DSGetParallel(DS ds,DSParallelType *pmode)DSGetParallel445,12369
PetscErrorCode DSSetCompact(DS ds,PetscBool comp)DSSetCompact475,13105
PetscErrorCode DSGetCompact(DS ds,PetscBool *comp)DSGetCompact499,13539
PetscErrorCode DSSetExtraRow(DS ds,PetscBool ext)DSSetExtraRow530,14384
PetscErrorCode DSGetExtraRow(DS ds,PetscBool *ext)DSGetExtraRow555,14945
PetscErrorCode DSSetRefined(DS ds,PetscBool ref)DSSetRefined588,15816
PetscErrorCode DSGetRefined(DS ds,PetscBool *ref)DSGetRefined612,16246
PetscErrorCode DSSetBlockSize(DS ds,PetscInt bs)DSSetBlockSize637,16729
PetscErrorCode DSGetBlockSize(DS ds,PetscInt *bs)DSGetBlockSize662,17268
PetscErrorCode DSSetSlepcSC(DS ds,SlepcSC sc)DSSetSlepcSC684,17708
PetscErrorCode DSGetSlepcSC(DS ds,SlepcSC *sc)DSGetSlepcSC714,18293
PetscErrorCode DSSetFromOptions(DS ds)DSSetFromOptions741,18820
PetscErrorCode DSView(DS ds,PetscViewer viewer)DSView795,20746
PetscErrorCode DSAllocate(DS ds,PetscInt ld)DSAllocate859,23359
PetscErrorCode DSReset(DS ds)DSReset892,24158
PetscErrorCode DSDestroy(DS *ds)DSDestroy927,24926
PetscErrorCode DSRegister(const char *name,PetscErrorCode (*function)(DS))DSRegister962,25914
PetscErrorCode DSRegisterAll(void)DSRegisterAll988,26677

src/sys/classes/ds/interface/dsops.c,2264
dsops.c:^?dsops.c^A,1
PetscErrorCode DSGetLeadingDimension(DS ds,PetscInt *ld)DSGetLeadingDimension32,837
PetscErrorCode DSSetState(DS ds,DSStateType state)DSSetState63,1638
PetscErrorCode DSGetState(DS ds,DSStateType *state)DSGetState99,2443
PetscErrorCode DSSetDimensions(DS ds,PetscInt n,PetscInt m,PetscInt l,PetscInt k)DSSetDimensions129,3171
PetscErrorCode DSGetDimensions(DS ds,PetscInt *n,PetscInt *m,PetscInt *l,PetscInt *k,PetscInt *t)DSGetDimensions192,5273
PetscErrorCode DSTruncate(DS ds,PetscInt n)DSTruncate222,6011
PetscErrorCode DSMatGetSize(DS ds,DSMatType t,PetscInt *m,PetscInt *n)DSMatGetSize264,7382
PetscErrorCode DSMatIsHermitian(DS ds,DSMatType t,PetscBool *flg)DSMatIsHermitian305,8397
PetscErrorCode DSGetMat(DS ds,DSMatType m,Mat *A)DSGetMat347,9630
PetscErrorCode DSRestoreMat(DS ds,DSMatType m,Mat *A)DSRestoreMat412,11640
PetscErrorCode DSGetArray(DS ds,DSMatType m,PetscScalar *a[])DSGetArray455,12956
PetscErrorCode DSRestoreArray(DS ds,DSMatType m,PetscScalar *a[])DSRestoreArray481,13497
PetscErrorCode DSGetArrayReal(DS ds,DSMatType m,PetscReal *a[])DSGetArrayReal514,14265
PetscErrorCode DSRestoreArrayReal(DS ds,DSMatType m,PetscReal *a[])DSRestoreArrayReal540,14821
PetscErrorCode DSSolve(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSolve573,15643
PetscErrorCode DSSort(DS ds,PetscScalar *eigr,PetscScalar *eigi,PetscScalar *rr,PetscScalar *ri,PetscInt *k)DSSort627,17862
PetscErrorCode DSSortWithPermutation(DS ds,PetscInt *perm,PetscScalar *eigr,PetscScalar *eigi)DSSortWithPermutation676,19877
PetscErrorCode DSSynchronize(DS ds,PetscScalar eigr[],PetscScalar eigi[])DSSynchronize728,21953
PetscErrorCode DSVectors(DS ds,DSMatType mat,PetscInt *j,PetscReal *rnorm)DSVectors786,23863
PetscErrorCode DSUpdateExtraRow(DS ds)DSUpdateExtraRow821,25176
PetscErrorCode DSCond(DS ds,PetscReal *cond)DSCond853,26172
PetscErrorCode DSTranslateHarmonic(DS ds,PetscScalar tau,PetscReal beta,PetscBool recover,PetscScalar *g,PetscReal *gamma)DSTranslateHarmonic901,27869
PetscErrorCode DSTranslateRKS(DS ds,PetscScalar alpha)DSTranslateRKS944,29514
PetscErrorCode DSCopyMat(DS ds,DSMatType m,PetscInt mr,PetscInt mc,Mat A,PetscInt Ar,PetscInt Ac,PetscInt rows,PetscInt cols,PetscBool out)DSCopyMat990,30978

src/sys/classes/ds/interface/dspriv.c,1674
dspriv.c:^?dspriv.c^A,1
PetscErrorCode DSAllocateMatrix_Private(DS ds,DSMatType m,PetscBool isreal)DSAllocateMatrix_Private17,518
PetscErrorCode DSAllocateWork_Private(DS ds,PetscInt s,PetscInt r,PetscInt i)DSAllocateWork_Private67,1839
PetscErrorCode DSViewMat(DS ds,PetscViewer viewer,DSMatType m)DSViewMat111,3081
PetscErrorCode DSSortEigenvalues_Private(DS ds,PetscScalar *wr,PetscScalar *wi,PetscInt *perm,PetscBool isghiep)DSSortEigenvalues_Private173,5356
PetscErrorCode DSSortEigenvaluesReal_Private(DS ds,PetscReal *eig,PetscInt *perm)DSSortEigenvaluesReal_Private226,6830
PetscErrorCode DSCopyMatrix_Private(DS ds,DSMatType dst,DSMatType src)DSCopyMatrix_Private254,7597
PetscErrorCode DSPermuteColumns_Private(DS ds,PetscInt l,PetscInt n,DSMatType mat,PetscInt *perm)DSPermuteColumns_Private272,7988
PetscErrorCode DSPermuteRows_Private(DS ds,PetscInt l,PetscInt n,DSMatType mat,PetscInt *perm)DSPermuteRows_Private295,8507
PetscErrorCode DSPermuteBoth_Private(DS ds,PetscInt l,PetscInt n,DSMatType mat1,DSMatType mat2,PetscInt *perm)DSPermuteBoth_Private319,9117
PetscErrorCode DSSetIdentity(DS ds,DSMatType mat)DSSetIdentity360,10171
PetscErrorCode DSOrthogonalize(DS ds,DSMatType mat,PetscInt cols,PetscInt *lindcols)DSOrthogonalize399,11304
static PetscErrorCode SlepcMatDenseMult(PetscScalar *C,PetscInt _ldC,PetscScalar b,PetscScalar a,const PetscScalar *A,PetscInt _ldA,PetscInt rA,PetscInt cA,PetscBool At,const PetscScalar *B,PetscInt _ldB,PetscInt rB,PetscInt cB,PetscBool Bt)SlepcMatDenseMult461,13746
PetscErrorCode DSPseudoOrthogonalize(DS ds,DSMatType mat,PetscInt cols,PetscReal *s,PetscInt *lindcols,PetscReal *ns)DSPseudoOrthogonalize520,15703

src/sys/classes/ds/interface/ftn-custom/makefile,262
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zdsf.cSOURCEC15,469
SOURCEF  =SOURCEF16,487
SOURCEH  =SOURCEH17,498
DIRS     =DIRS18,509
LIBBASE  = libslepcsysLIBBASE19,520
LOCDIR   = src/sys/classes/ds/interface/ftn-custom/LOCDIR20,543

src/sys/classes/ds/interface/ftn-custom/zdsf.c,2094
zdsf.c:^?zdsf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL dssettype_(DS *ds,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))dssettype_36,1392
SLEPC_EXTERN void PETSC_STDCALL dsgettype_(DS *ds,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))dsgettype_45,1621
SLEPC_EXTERN void PETSC_STDCALL dssetoptionsprefix_(DS *ds,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))dssetoptionsprefix_54,1913
SLEPC_EXTERN void PETSC_STDCALL dsappendoptionsprefix_(DS *ds,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))dsappendoptionsprefix_63,2166
SLEPC_EXTERN void PETSC_STDCALL dsgetoptionsprefix_(DS *ds,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))dsgetoptionsprefix_72,2425
SLEPC_EXTERN void PETSC_STDCALL dsview_(DS *ds,PetscViewer *viewer,PetscErrorCode *ierr)dsview_81,2747
SLEPC_EXTERN void PETSC_STDCALL dsviewmat_(DS *ds,PetscViewer *viewer,DSMatType *m,PetscErrorCode *ierr)dsviewmat_88,2929
SLEPC_EXTERN void PETSC_STDCALL dsvectors_(DS *ds,DSMatType *mat,PetscInt *j,PetscReal *rnorm,PetscErrorCode *ierr)dsvectors_95,3133
SLEPC_EXTERN void PETSC_STDCALL dssort_(DS *ds,PetscScalar *eigr,PetscScalar *eigi,PetscScalar *rr,PetscScalar *ri,PetscInt *k,PetscErrorCode *ierr)dssort_102,3350

src/sys/classes/ds/interface/makefile,299
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = dsbasic.c dsops.c dspriv.cSOURCEC15,431
SOURCEF  =SOURCEF16,469
SOURCEH  =SOURCEH17,480
LIBBASE  = libslepcsysLIBBASE18,491
DIRS     =DIRS19,514
MANSEC   = DSMANSEC20,525
LOCDIR   = src/sys/classes/ds/interface/LOCDIR21,539

src/sys/classes/ds/makefile,228
makefile:^?makefile^A,1
SOURCEH  = ../../../../include/slepc/private/dsimpl.h ../../../../include/slepcds.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,493
LOCDIR   = src/sys/classes/ds/LOCDIR15,537
MANSEC   = DSMANSEC16,568

src/sys/classes/fn/examples/makefile,83
makefile:^?makefile^A,1
LOCDIR   = src/sys/classes/fn/examples/LOCDIR13,405
DIRS     = testsDIRS14,445

src/sys/classes/fn/examples/tests/makefile,512
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/classes/fn/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.c test6.c test7.c test8.c test9.c test10.c test11.c test12.c test13.cEXAMPLESC16,499
EXAMPLESF  = test1f.F test7f.FEXAMPLESF17,620
MANSEC     = FNMANSEC18,651
TESTS      = test1 test1f test2 test3 test4 test5 test6 test7 test7f test8 test9 test10 test11 test12 test13TESTS19,667

src/sys/classes/fn/examples/tests/test1.c,107
test1.c:^?test1.c^A,1
static char help[] = "Test rational function.\n\n";help11,400
int main(int argc,char **argv)main15,475

src/sys/classes/fn/examples/tests/test10.c,203
test10.c:^?test10.c^A,1
static char help[] = "Test Phi functions.\n\n";help11,400
PetscErrorCode TestPhiFunction(FN fn,PetscScalar x,Mat A,PetscBool verbose)TestPhiFunction18,534
int main(int argc,char **argv)main56,2174

src/sys/classes/fn/examples/tests/test11.c,241
test11.c:^?test11.c^A,1
static char help[] = "Another test of a combined function.\n\n";help24,856
PetscErrorCode TestMatCombine(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatCombine31,995
int main(int argc,char **argv)main77,2874

src/sys/classes/fn/examples/tests/test12.c,136
test12.c:^?test12.c^A,1
static char help[] = "Test matrix function evaluation via diagonalization.\n\n";help11,400
int main(int argc,char **argv)main15,504

src/sys/classes/fn/examples/tests/test13.c,219
test13.c:^?test13.c^A,1
static char help[] = "Test matrix logarithm.\n\n";help11,400
PetscErrorCode TestMatLog(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatLog18,521
int main(int argc,char **argv)main83,3210

src/sys/classes/fn/examples/tests/test1f.F,235
test1f.F:^?test1f.F^A,1
      program mainmain16,579
 100  format (A15,10F6.1)100104,3461
      subroutine PrintInfo(PrintInfo128,4190
 110  format (A2,'(',F4.1,') = ',F10.5)110154,4966
 120  format (A2,'(',F4.1,') = ',F10.5,SP,F9.5,'i')120155,5006

src/sys/classes/fn/examples/tests/test2.c,110
test2.c:^?test2.c^A,1
static char help[] = "Test exponential function.\n\n";help11,400
int main(int argc,char **argv)main15,478

src/sys/classes/fn/examples/tests/test3.c,242
test3.c:^?test3.c^A,1
static char help[] = "Test matrix exponential.\n\n";help11,400
PetscErrorCode TestMatExp(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace,PetscBool checkerror)TestMatExp18,525
int main(int argc,char **argv)main96,3956

src/sys/classes/fn/examples/tests/test4.c,133
test4.c:^?test4.c^A,1
static char help[] = "Test setting FN parameters from the command line.\n\n";help11,400
int main(int argc,char **argv)main15,501

src/sys/classes/fn/examples/tests/test5.c,237
test5.c:^?test5.c^A,1
static char help[] = "Test matrix rational function.\n\n";help11,400
PetscErrorCode TestMatRational(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatRational18,539
int main(int argc,char **argv)main64,2416

src/sys/classes/fn/examples/tests/test6.c,228
test6.c:^?test6.c^A,1
static char help[] = "Test combined function.\n\n";help24,845
PetscErrorCode TestMatCombine(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatCombine31,982
int main(int argc,char **argv)main77,2861

src/sys/classes/fn/examples/tests/test7.c,223
test7.c:^?test7.c^A,1
static char help[] = "Test matrix square root.\n\n";help11,400
PetscErrorCode TestMatSqrt(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatSqrt19,557
int main(int argc,char **argv)main77,2890

src/sys/classes/fn/examples/tests/test7f.F,319
test7f.F:^?test7f.F^A,1
      program mainmain16,625
 100  format (/'Matrix square root, n =',I3,' (Fortran)')10052,1881
 110  format (A2,'(',F4.1,') = ',F8.5)11099,3498
 120  format (A2,'(',F4.1,') = ',F8.5,SP,F8.5,'i')120100,3537
 130  format ('||S*S-A||_F = ',F8.5)130137,4912
      subroutine FillUpMatrix(FillUpMatrix149,5200

src/sys/classes/fn/examples/tests/test8.c,237
test8.c:^?test8.c^A,1
static char help[] = "Test matrix inverse square root.\n\n";help11,400
PetscErrorCode TestMatInvSqrt(FN fn,Mat A,PetscViewer viewer,PetscBool verbose,PetscBool inplace)TestMatInvSqrt19,580
int main(int argc,char **argv)main83,3150

src/sys/classes/fn/examples/tests/test9.c,108
test9.c:^?test9.c^A,1
static char help[] = "Test logarithm function.\n\n";help11,400
int main(int argc,char **argv)main15,476

src/sys/classes/fn/f90-mod/makefile,335
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcfnmod.FSOURCEF17,514
SOURCEH    = slepcfn.h slepcfn.h90SOURCEH18,540
LIBBASE    = libslepcsysLIBBASE19,575
MANSEC     = FNMANSEC20,600
LOCDIR     = src/sys/classes/fn/f90-mod/LOCDIR21,616
CLEANFILES = *.modCLEANFILES22,657

src/sys/classes/fn/f90-mod/slepcfn.h,142
slepcfn.h:^?slepcfn.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      FN, parameter :: SLEPC_NULL_FN = tFN(0)FN18,589

src/sys/classes/fn/f90-mod/slepcfnmod.F,82
slepcfnmod.F:^?slepcfnmod.F^A,1
        module slepcfndefslepcfndef10,398
        module slepcfnslepcfn15,516

src/sys/classes/fn/impls/combine/fncombine.c,1446
fncombine.c:^?fncombine.c^A,1
  FN            f1,f2;    /* functions */f124,840
  FN            f1,f2;    /* functions */f224,840
  FNCombineType comb;     /* how the functions are combined */comb25,882
} FN_COMBINE;FN_COMBINE26,945
PetscErrorCode FNEvaluateFunction_Combine(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Combine28,960
PetscErrorCode FNEvaluateDerivative_Combine(FN fn,PetscScalar x,PetscScalar *yp)FNEvaluateDerivative_Combine57,1815
PetscErrorCode FNEvaluateFunctionMat_Combine(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Combine95,3239
PetscErrorCode FNEvaluateFunctionMatVec_Combine(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Combine158,5873
PetscErrorCode FNView_Combine(FN fn,PetscViewer viewer)FNView_Combine222,8450
static PetscErrorCode FNCombineSetChildren_Combine(FN fn,FNCombineType comb,FN f1,FN f2)FNCombineSetChildren_Combine253,9587
PetscErrorCode FNCombineSetChildren(FN fn,FNCombineType comb,FN f1,FN f2)FNCombineSetChildren287,10660
static PetscErrorCode FNCombineGetChildren_Combine(FN fn,FNCombineType *comb,FN *f1,FN *f2)FNCombineGetChildren_Combine300,11101
PetscErrorCode FNCombineGetChildren(FN fn,FNCombineType *comb,FN *f1,FN *f2)FNCombineGetChildren342,12240
PetscErrorCode FNDuplicate_Combine(FN fn,MPI_Comm comm,FN *newfn)FNDuplicate_Combine352,12551
PetscErrorCode FNDestroy_Combine(FN fn)FNDestroy_Combine364,12923
SLEPC_EXTERN PetscErrorCode FNCreate_Combine(FN fn)FNCreate_Combine378,13415

src/sys/classes/fn/impls/combine/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fncombine.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsysLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = FNMANSEC20,510
LOCDIR   = src/sys/classes/fn/impls/combine/LOCDIR21,524

src/sys/classes/fn/impls/exp/fnexp.c,1561
fnexp.c:^?fnexp.c^A,1
PetscErrorCode FNEvaluateFunction_Exp(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Exp17,527
PetscErrorCode FNEvaluateDerivative_Exp(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative_Exp24,680
#define MAX_PADE MAX_PADE31,835
#define SWAP(SWAP32,854
PetscErrorCode FNEvaluateFunctionMat_Exp_Pade(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Exp_Pade34,890
static PetscErrorCode sexpm_params(PetscReal nrm,PetscInt *s,PetscInt *k,PetscInt *m)sexpm_params136,4670
static PetscErrorCode getcoeffs(PetscInt k,PetscInt m,PetscComplex *r,PetscComplex *q,PetscComplex *remain,PetscBool query)getcoeffs167,5893
static PetscErrorCode getcoeffsproduct(PetscInt k,PetscInt m,PetscComplex *p,PetscComplex *q,PetscComplex *mult,PetscBool query)getcoeffsproduct287,11471
static PetscErrorCode getisreal(PetscInt n,PetscComplex *a,PetscBool *result)getisreal394,16215
PetscErrorCode FNEvaluateFunctionMat_Exp_GuettelNakatsukasa(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Exp_GuettelNakatsukasa416,16839
#define SMALLN SMALLN706,28516
static PetscInt ell(PetscBLASInt n,PetscScalar *A,PetscReal coeff,PetscInt m,PetscScalar *work,PetscRandom rand)ell711,28622
static PetscErrorCode expm_params(PetscInt n,PetscScalar **Apowers,PetscInt *s,PetscInt *m,PetscScalar *work)expm_params735,29466
PetscErrorCode FNEvaluateFunctionMat_Exp_Higham(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Exp_Higham819,32833
PetscErrorCode FNView_Exp(FN fn,PetscViewer viewer)FNView_Exp963,39955
SLEPC_EXTERN PetscErrorCode FNCreate_Exp(FN fn)FNCreate_Exp1005,41830

src/sys/classes/fn/impls/exp/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnexp.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = FNMANSEC20,506
LOCDIR   = src/sys/classes/fn/impls/exp/LOCDIR21,520

src/sys/classes/fn/impls/fnutil.c,983
fnutil.c:^?fnutil.c^A,1
PetscErrorCode SlepcMatDenseSqrt(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld)SlepcMatDenseSqrt21,691
#define BLOCKSIZE BLOCKSIZE80,2824
PetscErrorCode SlepcSqrtmSchur(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld,PetscBool firstonly)SlepcSqrtmSchur87,3041
#define DBMAXIT DBMAXIT163,5860
PetscErrorCode SlepcSqrtmDenmanBeavers(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld,PetscBool inv)SlepcSqrtmDenmanBeavers170,6074
#define NSMAXIT NSMAXIT260,9854
PetscErrorCode SlepcSqrtmNewtonSchulz(PetscBLASInt n,PetscScalar *A,PetscBLASInt ld,PetscBool inv)SlepcSqrtmNewtonSchulz266,10044
#define ITMAX ITMAX337,12762
#define SWAP(SWAP338,12778
static PetscErrorCode SlepcNormEst1(PetscBLASInt n,PetscScalar *A,PetscInt m,PetscScalar *work,PetscRandom rand,PetscReal *nrm)SlepcNormEst1343,12902
#define SMALLN SMALLN419,15270
PetscErrorCode SlepcNormAm(PetscBLASInt n,PetscScalar *A,PetscInt m,PetscScalar *work,PetscRandom rand,PetscReal *nrm)SlepcNormAm424,15350

src/sys/classes/fn/impls/invsqrt/fninvsqrt.c,840
fninvsqrt.c:^?fninvsqrt.c^A,1
PetscErrorCode FNEvaluateFunction_Invsqrt(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Invsqrt17,537
PetscErrorCode FNEvaluateDerivative_Invsqrt(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative_Invsqrt28,913
PetscErrorCode FNEvaluateFunctionMat_Invsqrt_Schur(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Invsqrt_Schur39,1309
PetscErrorCode FNEvaluateFunctionMatVec_Invsqrt_Schur(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Invsqrt_Schur74,2564
PetscErrorCode FNEvaluateFunctionMat_Invsqrt_DBP(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Invsqrt_DBP110,3854
PetscErrorCode FNEvaluateFunctionMat_Invsqrt_NS(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Invsqrt_NS127,4389
PetscErrorCode FNView_Invsqrt(FN fn,PetscViewer viewer)FNView_Invsqrt144,4922
SLEPC_EXTERN PetscErrorCode FNCreate_Invsqrt(FN fn)FNCreate_Invsqrt185,6684

src/sys/classes/fn/impls/invsqrt/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fninvsqrt.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsysLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = FNMANSEC20,510
LOCDIR   = src/sys/classes/fn/impls/invsqrt/LOCDIR21,524

src/sys/classes/fn/impls/log/fnlog.c,1988
fnlog.c:^?fnlog.c^A,1
PetscErrorCode FNEvaluateFunction_Log(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Log17,525
PetscErrorCode FNEvaluateDerivative_Log(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative_Log27,804
static PetscErrorCode qtri_struct(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld,PetscInt *structure)qtri_struct45,1474
static PetscErrorCode logm_params(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld,PetscScalar *wr,PetscScalar *wi,PetscInt maxroots,PetscInt *s,PetscInt *m,PetscScalar *Troot,PetscScalar *work)logm_params83,2576
static PetscScalar sqrt_obo(PetscScalar a,PetscInt s)sqrt_obo195,6399
static PetscErrorCode sqrtm_tbt(PetscScalar *T)sqrtm_tbt226,7037
PETSC_STATIC_INLINE PetscReal unwinding(PetscScalar z)unwinding264,8090
static PetscScalar powerm2by2(PetscScalar A11,PetscScalar A22,PetscScalar A12,PetscReal p)powerm2by2278,8431
static PetscErrorCode recompute_diag_blocks_sqrt(PetscBLASInt n,PetscScalar *Troot,PetscScalar *T,PetscBLASInt ld,PetscInt *blockStruct,PetscInt s)recompute_diag_blocks_sqrt307,9331
static PetscErrorCode gauss_legendre(PetscBLASInt n,PetscScalar *x,PetscScalar *w,PetscScalar *Q)gauss_legendre393,12455
static PetscErrorCode pade_approx(PetscBLASInt n,PetscScalar *T,PetscScalar *L,PetscBLASInt ld,PetscInt m,PetscScalar *work)pade_approx452,14322
static PetscErrorCode recompute_diag_blocks_log(PetscBLASInt n,PetscScalar *L,PetscScalar *T,PetscBLASInt ld,PetscInt *blockStruct)recompute_diag_blocks_log485,15384
static PetscErrorCode SlepcLogmPade(PetscBLASInt n,PetscScalar *T,PetscBLASInt ld,PetscBool firstonly)SlepcLogmPade554,17836
PetscErrorCode FNEvaluateFunctionMat_Log_Higham(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Log_Higham629,20621
PetscErrorCode FNEvaluateFunctionMatVec_Log_Higham(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Log_Higham646,21146
PetscErrorCode FNView_Log(FN fn,PetscViewer viewer)FNView_Log666,21769
SLEPC_EXTERN PetscErrorCode FNCreate_Log(FN fn)FNCreate_Log705,23398

src/sys/classes/fn/impls/log/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnlog.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = FNMANSEC20,506
LOCDIR   = src/sys/classes/fn/impls/log/LOCDIR21,520

src/sys/classes/fn/impls/makefile,319
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnutil.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     = combine exp log phi rational sqrt invsqrtDIRS19,496
LOCDIR   = src/sys/classes/fn/impls/LOCDIR20,549
MANSEC   = FNMANSEC21,586

src/sys/classes/fn/impls/phi/fnphi.c,1460
fnphi.c:^?fnphi.c^A,1
  PetscInt k;    /* index of the phi-function, defaults to k=1 */k20,597
  Mat      H;    /* auxiliary matrix of order m+k */H21,663
  Mat      F;    /* auxiliary matrix to store exp(H) */F22,716
} FN_PHI;FN_PHI23,772
#define MAX_INDEX MAX_INDEX25,783
const static PetscReal rfactorial[MAX_INDEX+2] = { 1, 1, 0.5, 1.0/6, 1.0/24, 1.0/120, 1.0/720, 1.0/5040, 1.0/40320, 1.0/362880, 1.0/3628800, 1.0/39916800 };rfactorial27,805
PetscErrorCode FNEvaluateFunction_Phi(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Phi29,963
PetscErrorCode FNEvaluateDerivative_Phi(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative_Phi45,1353
PetscErrorCode FNEvaluateFunctionMatVec_Phi(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Phi61,1783
static PetscErrorCode FNPhiSetIndex_Phi(FN fn,PetscInt k)FNPhiSetIndex_Phi111,3440
PetscErrorCode FNPhiSetIndex(FN fn,PetscInt k)FNPhiSetIndex148,4396
static PetscErrorCode FNPhiGetIndex_Phi(FN fn,PetscInt *k)FNPhiGetIndex_Phi159,4689
PetscErrorCode FNPhiGetIndex(FN fn,PetscInt *k)FNPhiGetIndex183,5080
PetscErrorCode FNView_Phi(FN fn,PetscViewer viewer)FNView_Phi194,5362
PetscErrorCode FNSetFromOptions_Phi(PetscOptionItems *PetscOptionsObject,FN fn)FNSetFromOptions_Phi228,6712
PetscErrorCode FNDuplicate_Phi(FN fn,MPI_Comm comm,FN *newfn)FNDuplicate_Phi245,7257
PetscErrorCode FNDestroy_Phi(FN fn)FNDestroy_Phi254,7460
SLEPC_EXTERN PetscErrorCode FNCreate_Phi(FN fn)FNCreate_Phi268,7930

src/sys/classes/fn/impls/phi/makefile,280
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnphi.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = FNMANSEC20,506
LOCDIR   = src/sys/classes/fn/impls/phi/LOCDIR21,520

src/sys/classes/fn/impls/rational/fnrational.c,2469
fnrational.c:^?fnrational.c^A,1
  PetscScalar *pcoeff;    /* numerator coefficients */pcoeff18,588
  PetscInt    np;         /* length of array pcoeff, p(x) has degree np-1 */np19,643
  PetscScalar *qcoeff;    /* denominator coefficients */qcoeff20,720
  PetscInt    nq;         /* length of array qcoeff, q(x) has degree nq-1 */nq21,777
} FN_RATIONAL;FN_RATIONAL22,854
PetscErrorCode FNEvaluateFunction_Rational(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Rational24,870
static PetscErrorCode FNEvaluateFunctionMat_Rational_Private(FN fn,PetscScalar *Aa,PetscScalar *Ba,PetscInt m,PetscBool firstonly)FNEvaluateFunctionMat_Rational_Private48,1427
PetscErrorCode FNEvaluateFunctionMat_Rational(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Rational104,3404
PetscErrorCode FNEvaluateFunctionMatVec_Rational(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Rational120,3925
PetscErrorCode FNEvaluateDerivative_Rational(FN fn,PetscScalar x,PetscScalar *yp)FNEvaluateDerivative_Rational140,4616
PetscErrorCode FNView_Rational(FN fn,PetscViewer viewer)FNView_Rational172,5305
static PetscErrorCode FNRationalSetNumerator_Rational(FN fn,PetscInt np,PetscScalar *pcoeff)FNRationalSetNumerator_Rational239,8804
PetscErrorCode FNRationalSetNumerator(FN fn,PetscInt np,PetscScalar *pcoeff)FNRationalSetNumerator281,10191
static PetscErrorCode FNRationalGetNumerator_Rational(FN fn,PetscInt *np,PetscScalar *pcoeff[])FNRationalGetNumerator_Rational293,10590
PetscErrorCode FNRationalGetNumerator(FN fn,PetscInt *np,PetscScalar *pcoeff[])FNRationalGetNumerator333,11601
static PetscErrorCode FNRationalSetDenominator_Rational(FN fn,PetscInt nq,PetscScalar *qcoeff)FNRationalSetDenominator_Rational343,11917
PetscErrorCode FNRationalSetDenominator(FN fn,PetscInt nq,PetscScalar *qcoeff)FNRationalSetDenominator385,13328
static PetscErrorCode FNRationalGetDenominator_Rational(FN fn,PetscInt *nq,PetscScalar *qcoeff[])FNRationalGetDenominator_Rational397,13731
PetscErrorCode FNRationalGetDenominator(FN fn,PetscInt *nq,PetscScalar *qcoeff[])FNRationalGetDenominator437,14752
PetscErrorCode FNSetFromOptions_Rational(PetscOptionItems *PetscOptionsObject,FN fn)FNSetFromOptions_Rational447,15072
#define PARMAX PARMAX450,15182
PetscErrorCode FNDuplicate_Rational(FN fn,MPI_Comm comm,FN *newfn)FNDuplicate_Rational472,16129
PetscErrorCode FNDestroy_Rational(FN fn)FNDestroy_Rational494,16908
SLEPC_EXTERN PetscErrorCode FNCreate_Rational(FN fn)FNCreate_Rational510,17616

src/sys/classes/fn/impls/rational/ftn-custom/makefile,272
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zrational.cSOURCEC15,469
SOURCEF  =SOURCEF16,492
SOURCEH  =SOURCEH17,503
DIRS     =DIRS18,514
LIBBASE  = libslepcsysLIBBASE19,525
LOCDIR   = src/sys/classes/fn/impls/rational/ftn-custom/LOCDIR20,548

src/sys/classes/fn/impls/rational/ftn-custom/zrational.c,3981
zrational.c:^?zrational.c^A,1
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetnumerator_(FN *fn,PetscInt *np,PetscScalar *pcoeff,int *ierr)fnrationalsetnumerator_42,2045
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetnumerator0_(FN *fn,PetscInt *np,PetscScalar *pcoeff,int *ierr)fnrationalsetnumerator0_48,2239
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetnumerator1_(FN *fn,PetscInt *np,PetscScalar *pcoeff,int *ierr)fnrationalsetnumerator1_53,2398
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetdenominator_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalsetdenominator_58,2557
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetdenominator0_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalsetdenominator0_64,2755
SLEPC_EXTERN void PETSC_STDCALL fnrationalsetdenominator1_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalsetdenominator1_69,2918
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetnumerator_(FN *fn,PetscInt *np,PetscScalar *pcoeff,int *ierr)fnrationalgetnumerator_74,3081
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetnumerator00_(FN *fn,PetscInt *np,PetscScalar *qcoeff,int *ierr)fnrationalgetnumerator00_86,3452
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetnumerator10_(FN *fn,PetscInt *np,PetscScalar *qcoeff,int *ierr)fnrationalgetnumerator10_91,3612
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetnumerator01_(FN *fn,PetscInt *np,PetscScalar *qcoeff,int *ierr)fnrationalgetnumerator01_96,3772
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetnumerator11_(FN *fn,PetscInt *np,PetscScalar *qcoeff,int *ierr)fnrationalgetnumerator11_101,3932
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetdenominator_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalgetdenominator_106,4092
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetdenominator00_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalgetdenominator00_118,4467
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetdenominator10_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalgetdenominator10_123,4631
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetdenominator01_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalgetdenominator01_128,4795
SLEPC_EXTERN void PETSC_STDCALL fnrationalgetdenominator11_(FN *fn,PetscInt *nq,PetscScalar *qcoeff,int *ierr)fnrationalgetdenominator11_133,4959

src/sys/classes/fn/impls/rational/makefile,290
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnrational.cSOURCEC15,431
SOURCEF  =SOURCEF16,455
SOURCEH  =SOURCEH17,466
LIBBASE  = libslepcsysLIBBASE18,477
DIRS     =DIRS19,500
MANSEC   = FNMANSEC20,511
LOCDIR   = src/sys/classes/fn/impls/rational/LOCDIR21,525

src/sys/classes/fn/impls/sqrt/fnsqrt.c,1047
fnsqrt.c:^?fnsqrt.c^A,1
PetscErrorCode FNEvaluateFunction_Sqrt(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction_Sqrt17,528
PetscErrorCode FNEvaluateDerivative_Sqrt(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative_Sqrt27,809
PetscErrorCode FNEvaluateFunctionMat_Sqrt_Schur(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Sqrt_Schur38,1194
PetscErrorCode FNEvaluateFunctionMatVec_Sqrt_Schur(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Sqrt_Schur55,1721
PetscErrorCode FNEvaluateFunctionMat_Sqrt_DBP(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Sqrt_DBP75,2346
PetscErrorCode FNEvaluateFunctionMat_Sqrt_NS(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Sqrt_NS92,2879
#define MAXIT MAXIT109,3414
static PetscErrorCode SlepcSqrtmSadeghi(PetscBLASInt n,PetscScalar *A,PetscBLASInt ld)SlepcSqrtmSadeghi115,3557
PetscErrorCode FNEvaluateFunctionMat_Sqrt_Sadeghi(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Sqrt_Sadeghi200,6971
PetscErrorCode FNView_Sqrt(FN fn,PetscViewer viewer)FNView_Sqrt217,7494
SLEPC_EXTERN PetscErrorCode FNCreate_Sqrt(FN fn)FNCreate_Sqrt259,9252

src/sys/classes/fn/impls/sqrt/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnsqrt.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = FNMANSEC20,507
LOCDIR   = src/sys/classes/fn/impls/sqrt/LOCDIR21,521

src/sys/classes/fn/interface/fnbasic.c,3033
fnbasic.c:^?fnbasic.c^A,1
PetscFunctionList FNList = 0;FNList17,516
PetscBool         FNRegisterAllCalled = PETSC_FALSE;FNRegisterAllCalled18,546
PetscClassId      FN_CLASSID = 0;FN_CLASSID19,599
PetscLogEvent     FN_Evaluate = 0;FN_Evaluate20,633
static PetscBool  FNPackageInitialized = PETSC_FALSE;FNPackageInitialized21,668
const char *FNParallelTypes[] = {"REDUNDANT","SYNCHRONIZED","FNParallelType","FN_PARALLEL_",0};FNParallelTypes23,723
PetscErrorCode FNFinalizePackage(void)FNFinalizePackage33,1014
PetscErrorCode FNInitializePackage(void)FNInitializePackage53,1544
PetscErrorCode FNCreate(MPI_Comm comm,FN *newfn)FNCreate100,2992
PetscErrorCode FNSetOptionsPrefix(FN fn,const char *prefix)FNSetOptionsPrefix142,3955
PetscErrorCode FNAppendOptionsPrefix(FN fn,const char *prefix)FNAppendOptionsPrefix170,4692
PetscErrorCode FNGetOptionsPrefix(FN fn,const char *prefix[])FNGetOptionsPrefix200,5416
PetscErrorCode FNSetType(FN fn,FNType type)FNSetType228,6079
PetscErrorCode FNGetType(FN fn,FNType *type)FNGetType266,7122
PetscErrorCode FNSetScale(FN fn,PetscScalar alpha,PetscScalar beta)FNSetScale299,8158
PetscErrorCode FNGetScale(FN fn,PetscScalar *alpha,PetscScalar *beta)FNGetScale327,8930
PetscErrorCode FNSetMethod(FN fn,PetscInt meth)FNSetMethod360,9938
PetscErrorCode FNGetMethod(FN fn,PetscInt *meth)FNGetMethod386,10649
PetscErrorCode FNSetParallel(FN fn,FNParallelType pmode)FNSetParallel425,12021
PetscErrorCode FNGetParallel(FN fn,FNParallelType *pmode)FNGetParallel449,12488
PetscErrorCode FNEvaluateFunction(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateFunction478,13178
PetscErrorCode FNEvaluateDerivative(FN fn,PetscScalar x,PetscScalar *y)FNEvaluateDerivative515,14140
static PetscErrorCode FNEvaluateFunctionMat_Sym_Private(FN fn,PetscScalar *As,PetscScalar *Bs,PetscInt m,PetscBool firstonly)FNEvaluateFunctionMat_Sym_Private532,14658
static PetscErrorCode FNEvaluateFunctionMat_Sym_Default(FN fn,Mat A,Mat B)FNEvaluateFunctionMat_Sym_Default596,17054
PetscErrorCode FNEvaluateFunctionMat_Private(FN fn,Mat A,Mat B,PetscBool sync)FNEvaluateFunctionMat_Private612,17580
PetscErrorCode FNEvaluateFunctionMat(FN fn,Mat A,Mat B)FNEvaluateFunctionMat695,20913
static PetscErrorCode FNEvaluateFunctionMatVec_Default(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Default734,22584
static PetscErrorCode FNEvaluateFunctionMatVec_Sym_Default(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec_Sym_Default755,23516
PetscErrorCode FNEvaluateFunctionMatVec_Private(FN fn,Mat A,Vec v,PetscBool sync)FNEvaluateFunctionMatVec_Private771,24034
PetscErrorCode FNEvaluateFunctionMatVec(FN fn,Mat A,Vec v)FNEvaluateFunctionMatVec844,26583
PetscErrorCode FNSetFromOptions(FN fn)FNSetFromOptions882,27933
PetscErrorCode FNView(FN fn,PetscViewer viewer)FNView946,30346
PetscErrorCode FNDuplicate(FN fn,MPI_Comm comm,FN *newfn)FNDuplicate996,31867
PetscErrorCode FNDestroy(FN *fn)FNDestroy1035,32928
PetscErrorCode FNRegister(const char *name,PetscErrorCode (*function)(FN))FNRegister1068,33767

src/sys/classes/fn/interface/fnregis.c,56
fnregis.c:^?fnregis.c^A,1
PetscErrorCode FNRegisterAll(void)FNRegisterAll28,919

src/sys/classes/fn/interface/ftn-custom/makefile,252
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zfnf.cSOURCEC15,469
SOURCEF  =SOURCEF16,487
SOURCEH  =SOURCEH17,498
DIRS     =DIRS18,509
LIBBASE  = libslepcsysLIBBASE19,520
LOCDIR   = src/sys/classes/fn/ftn-custom/LOCDIR20,543

src/sys/classes/fn/interface/ftn-custom/zfnf.c,1448
zfnf.c:^?zfnf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL fnview_(FN *fn,PetscViewer *viewer,PetscErrorCode *ierr)fnview_31,1196
SLEPC_EXTERN void PETSC_STDCALL fnsetoptionsprefix_(FN *fn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))fnsetoptionsprefix_38,1378
SLEPC_EXTERN void PETSC_STDCALL fnappendoptionsprefix_(FN *fn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))fnappendoptionsprefix_47,1631
SLEPC_EXTERN void PETSC_STDCALL fngetoptionsprefix_(FN *fn,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))fngetoptionsprefix_56,1890
SLEPC_EXTERN void PETSC_STDCALL fnsettype_(FN *fn,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))fnsettype_65,2212
SLEPC_EXTERN void PETSC_STDCALL fngettype_(FN *fn,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))fngettype_74,2441

src/sys/classes/fn/interface/makefile,292
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = fnbasic.c fnregis.cSOURCEC15,431
SOURCEF  =SOURCEF16,462
SOURCEH  =SOURCEH17,473
LIBBASE  = libslepcsysLIBBASE18,484
DIRS     =DIRS19,507
MANSEC   = FNMANSEC20,518
LOCDIR   = src/sys/classes/fn/interface/LOCDIR21,532

src/sys/classes/fn/makefile,228
makefile:^?makefile^A,1
SOURCEH  = ../../../../include/slepc/private/fnimpl.h ../../../../include/slepcfn.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,493
LOCDIR   = src/sys/classes/fn/LOCDIR15,537
MANSEC   = FNMANSEC16,568

src/sys/classes/makefile,275
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  =SOURCEC15,431
SOURCEF  =SOURCEF16,442
SOURCEH  =SOURCEH17,453
LIBBASE  = libslepcsysLIBBASE18,464
MANSEC   = sysMANSEC19,487
LOCDIR   = src/sys/classes/LOCDIR20,502
DIRS     = fn ds bv st rgDIRS21,530

src/sys/classes/rg/examples/makefile,83
makefile:^?makefile^A,1
LOCDIR   = src/sys/classes/rg/examples/LOCDIR13,405
DIRS     = testsDIRS14,445

src/sys/classes/rg/examples/tests/makefile,334
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/classes/rg/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.cEXAMPLESC16,499
EXAMPLESF  = test1f.FEXAMPLESF17,528
MANSEC     = RGMANSEC18,550
TESTS      = test1 test1f test2TESTS19,566

src/sys/classes/rg/examples/tests/test1.c,112
test1.c:^?test1.c^A,1
static char help[] = "Test RG interface functions.\n\n";help11,400
int main(int argc,char **argv)main15,480

src/sys/classes/rg/examples/tests/test1f.F,239
test1f.F:^?test1f.F^A,1
      program mainmain16,594
 110  format ('Point (',F4.1,',',F4.1,') is ',A7,' the region')11072,2244
 115  format ('Bounding box: [',F4.1,',',F4.1,']x[',F4.1,',',F4.1,']')11578,2430
 120  format ('(',F7.4,',',F7.4,')')12097,2894

src/sys/classes/rg/examples/tests/test2.c,214
test2.c:^?test2.c^A,1
static char help[] = "Test the ring region.\n\n";help11,400
#define NPOINTS NPOINTS15,473
PetscErrorCode CheckPoint(RG rg,PetscReal re,PetscReal im)CheckPoint17,493
int main(int argc,char **argv)main34,960

src/sys/classes/rg/f90-mod/makefile,335
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcrgmod.FSOURCEF17,514
SOURCEH    = slepcrg.h slepcrg.h90SOURCEH18,540
LIBBASE    = libslepcsysLIBBASE19,575
MANSEC     = RGMANSEC20,600
LOCDIR     = src/sys/classes/rg/f90-mod/LOCDIR21,616
CLEANFILES = *.modCLEANFILES22,657

src/sys/classes/rg/f90-mod/slepcrg.h,142
slepcrg.h:^?slepcrg.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      RG, parameter :: SLEPC_NULL_RG = tRG(0)RG18,589

src/sys/classes/rg/f90-mod/slepcrgmod.F,82
slepcrgmod.F:^?slepcrgmod.F^A,1
        module slepcrgdefslepcrgdef10,398
        module slepcrgslepcrg15,516

src/sys/classes/rg/impls/ellipse/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rgellipse.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsysLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = RGMANSEC20,510
LOCDIR   = src/sys/classes/rg/impls/ellipse/LOCDIR21,524

src/sys/classes/rg/impls/ellipse/rgellipse.c,1628
rgellipse.c:^?rgellipse.c^A,1
  PetscScalar center;     /* center of the ellipse */center18,574
  PetscReal   radius;     /* radius of the ellipse */radius19,628
  PetscReal   vscale;     /* vertical scale of the ellipse */vscale20,682
} RG_ELLIPSE;RG_ELLIPSE21,744
static PetscErrorCode RGEllipseSetParameters_Ellipse(RG rg,PetscScalar center,PetscReal radius,PetscReal vscale)RGEllipseSetParameters_Ellipse23,759
PetscErrorCode RGEllipseSetParameters(RG rg,PetscScalar center,PetscReal radius,PetscReal vscale)RGEllipseSetParameters67,2130
static PetscErrorCode RGEllipseGetParameters_Ellipse(RG rg,PetscScalar *center,PetscReal *radius,PetscReal *vscale)RGEllipseGetParameters_Ellipse80,2629
PetscErrorCode RGEllipseGetParameters(RG rg,PetscScalar *center,PetscReal *radius,PetscReal *vscale)RGEllipseGetParameters108,3298
PetscErrorCode RGView_Ellipse(RG rg,PetscViewer viewer)RGView_Ellipse118,3657
PetscErrorCode RGIsTrivial_Ellipse(RG rg,PetscBool *trivial)RGIsTrivial_Ellipse162,5572
PetscErrorCode RGComputeContour_Ellipse(RG rg,PetscInt n,PetscScalar *cr,PetscScalar *ci)RGComputeContour_Ellipse172,5842
PetscErrorCode RGComputeBoundingBox_Ellipse(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGComputeBoundingBox_Ellipse191,6390
PetscErrorCode RGCheckInside_Ellipse(RG rg,PetscReal px,PetscReal py,PetscInt *inside)RGCheckInside_Ellipse203,6848
PetscErrorCode RGSetFromOptions_Ellipse(PetscOptionItems *PetscOptionsObject,RG rg)RGSetFromOptions_Ellipse221,7344
PetscErrorCode RGDestroy_Ellipse(RG rg)RGDestroy_Ellipse241,8241
SLEPC_EXTERN PetscErrorCode RGCreate_Ellipse(RG rg)RGCreate_Ellipse252,8602

src/sys/classes/rg/impls/interval/makefile,290
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rginterval.cSOURCEC15,431
SOURCEF  =SOURCEF16,455
SOURCEH  =SOURCEH17,466
LIBBASE  = libslepcsysLIBBASE18,477
DIRS     =DIRS19,500
MANSEC   = RGMANSEC20,511
LOCDIR   = src/sys/classes/rg/impls/interval/LOCDIR21,525

src/sys/classes/rg/impls/interval/rginterval.c,1686
rginterval.c:^?rginterval.c^A,1
  PetscReal   a,b;     /* interval in the real axis */a19,605
  PetscReal   a,b;     /* interval in the real axis */b19,605
  PetscReal   c,d;     /* interval in the imaginary axis */c20,660
  PetscReal   c,d;     /* interval in the imaginary axis */d20,660
} RG_INTERVAL;RG_INTERVAL21,720
static PetscErrorCode RGIntervalSetEndpoints_Interval(RG rg,PetscReal a,PetscReal b,PetscReal c,PetscReal d)RGIntervalSetEndpoints_Interval23,736
PetscErrorCode RGIntervalSetEndpoints(RG rg,PetscReal a,PetscReal b,PetscReal c,PetscReal d)RGIntervalSetEndpoints68,2559
static PetscErrorCode RGIntervalGetEndpoints_Interval(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGIntervalGetEndpoints_Interval82,3074
PetscErrorCode RGIntervalGetEndpoints(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGIntervalGetEndpoints110,3718
PetscErrorCode RGView_Interval(RG rg,PetscViewer viewer)RGView_Interval120,4069
PetscErrorCode RGIsTrivial_Interval(RG rg,PetscBool *trivial)RGIsTrivial_Interval163,5906
PetscErrorCode RGComputeContour_Interval(RG rg,PetscInt n,PetscScalar *cr,PetscScalar *ci)RGComputeContour_Interval173,6310
PetscErrorCode RGComputeBoundingBox_Interval(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGComputeBoundingBox_Interval222,8050
PetscErrorCode RGCheckInside_Interval(RG rg,PetscReal dx,PetscReal dy,PetscInt *inside)RGCheckInside_Interval234,8341
PetscErrorCode RGSetFromOptions_Interval(PetscOptionItems *PetscOptionsObject,RG rg)RGSetFromOptions_Interval250,8775
PetscErrorCode RGDestroy_Interval(RG rg)RGDestroy_Interval271,9632
SLEPC_EXTERN PetscErrorCode RGCreate_Interval(RG rg)RGCreate_Interval282,9994

src/sys/classes/rg/impls/makefile,170
makefile:^?makefile^A,1
LIBBASE  = libslepcsysLIBBASE13,409
DIRS     = ellipse interval polygon ringDIRS14,432
LOCDIR   = src/sys/classes/rg/impls/LOCDIR15,473
MANSEC   = RGMANSEC16,510

src/sys/classes/rg/impls/polygon/makefile,288
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rgpolygon.cSOURCEC15,431
SOURCEF  =SOURCEF16,454
SOURCEH  =SOURCEH17,465
LIBBASE  = libslepcsysLIBBASE18,476
DIRS     =DIRS19,499
MANSEC   = RGMANSEC20,510
LOCDIR   = src/sys/classes/rg/impls/polygon/LOCDIR21,524

src/sys/classes/rg/impls/polygon/rgpolygon.c,1740
rgpolygon.c:^?rgpolygon.c^A,1
#define VERTMAX VERTMAX17,538
  PetscInt    n;         /* number of vertices */n20,575
  PetscScalar *vr,*vi;   /* array of vertices (vi not used in complex scalars) */vr21,625
  PetscScalar *vr,*vi;   /* array of vertices (vi not used in complex scalars) */vi21,625
} RG_POLYGON;RG_POLYGON22,707
static PetscBool CheckSymmetry(PetscInt n,PetscScalar *vr,PetscScalar *vi)CheckSymmetry27,848
static PetscErrorCode RGPolygonSetVertices_Polygon(RG rg,PetscInt n,PetscScalar *vr,PetscScalar *vi)RGPolygonSetVertices_Polygon49,1351
PetscErrorCode RGPolygonSetVertices(RG rg,PetscInt n,PetscScalar vr[],PetscScalar vi[])RGPolygonSetVertices111,3429
static PetscErrorCode RGPolygonGetVertices_Polygon(RG rg,PetscInt *n,PetscScalar **vr,PetscScalar **vi)RGPolygonGetVertices_Polygon126,3907
PetscErrorCode RGPolygonGetVertices(RG rg,PetscInt *n,PetscScalar **vr,PetscScalar **vi)RGPolygonGetVertices157,4590
PetscErrorCode RGView_Polygon(RG rg,PetscViewer viewer)RGView_Polygon167,4925
PetscErrorCode RGIsTrivial_Polygon(RG rg,PetscBool *trivial)RGIsTrivial_Polygon245,7986
PetscErrorCode RGComputeContour_Polygon(RG rg,PetscInt n,PetscScalar *cr,PetscScalar *ci)RGComputeContour_Polygon254,8175
PetscErrorCode RGComputeBoundingBox_Polygon(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGComputeBoundingBox_Polygon320,10028
PetscErrorCode RGCheckInside_Polygon(RG rg,PetscReal px,PetscReal py,PetscInt *inout)RGCheckInside_Polygon346,10813
PetscErrorCode RGSetFromOptions_Polygon(PetscOptionItems *PetscOptionsObject,RG rg)RGSetFromOptions_Polygon384,11815
PetscErrorCode RGDestroy_Polygon(RG rg)RGDestroy_Polygon415,12992
SLEPC_EXTERN PetscErrorCode RGCreate_Polygon(RG rg)RGCreate_Polygon433,13545

src/sys/classes/rg/impls/ring/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rgring.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = RGMANSEC20,507
LOCDIR   = src/sys/classes/rg/impls/ring/LOCDIR21,521

src/sys/classes/rg/impls/ring/rgring.c,1942
rgring.c:^?rgring.c^A,1
  PetscScalar center;     /* center of the ellipse */center19,604
  PetscReal   radius;     /* radius of the ellipse */radius20,658
  PetscReal   vscale;     /* vertical scale of the ellipse */vscale21,712
  PetscReal   start_ang;  /* start angle */start_ang22,774
  PetscReal   end_ang;    /* end angle */end_ang23,818
  PetscReal   width;      /* ring width */width24,860
} RG_RING;RG_RING25,903
static PetscErrorCode RGRingSetParameters_Ring(RG rg,PetscScalar center,PetscReal radius,PetscReal vscale,PetscReal start_ang,PetscReal end_ang,PetscReal width)RGRingSetParameters_Ring27,915
PetscErrorCode RGRingSetParameters(RG rg,PetscScalar center,PetscReal radius,PetscReal vscale,PetscReal start_ang,PetscReal end_ang,PetscReal width)RGRingSetParameters113,4504
static PetscErrorCode RGRingGetParameters_Ring(RG rg,PetscScalar *center,PetscReal *radius,PetscReal *vscale,PetscReal *start_ang,PetscReal *end_ang,PetscReal *width)RGRingGetParameters_Ring129,5252
PetscErrorCode RGRingGetParameters(RG rg,PetscScalar *center,PetscReal *radius,PetscReal *vscale,PetscReal *start_ang,PetscReal *end_ang,PetscReal *width)RGRingGetParameters163,6230
PetscErrorCode RGView_Ring(RG rg,PetscViewer viewer)RGView_Ring173,6697
PetscErrorCode RGIsTrivial_Ring(RG rg,PetscBool *trivial)RGIsTrivial_Ring237,9930
PetscErrorCode RGComputeContour_Ring(RG rg,PetscInt n,PetscScalar *cr,PetscScalar *ci)RGComputeContour_Ring247,10191
PetscErrorCode RGComputeBoundingBox_Ring(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGComputeBoundingBox_Ring277,11352
PetscErrorCode RGCheckInside_Ring(RG rg,PetscReal px,PetscReal py,PetscInt *inside)RGCheckInside_Ring290,11937
PetscErrorCode RGSetFromOptions_Ring(PetscOptionItems *PetscOptionsObject,RG rg)RGSetFromOptions_Ring342,13600
PetscErrorCode RGDestroy_Ring(RG rg)RGDestroy_Ring365,14895
SLEPC_EXTERN PetscErrorCode RGCreate_Ring(RG rg)RGCreate_Ring376,15247

src/sys/classes/rg/interface/ftn-custom/makefile,262
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zrgf.cSOURCEC15,469
SOURCEF  =SOURCEF16,487
SOURCEH  =SOURCEH17,498
DIRS     =DIRS18,509
LIBBASE  = libslepcsysLIBBASE19,520
LOCDIR   = src/sys/classes/rg/interface/ftn-custom/LOCDIR20,543

src/sys/classes/rg/interface/ftn-custom/zrgf.c,1447
zrgf.c:^?zrgf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL rgsettype_(RG *rg,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))rgsettype_30,1134
SLEPC_EXTERN void PETSC_STDCALL rggettype_(RG *rg,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))rggettype_39,1345
SLEPC_EXTERN void PETSC_STDCALL rgsetoptionsprefix_(RG *rg,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))rgsetoptionsprefix_48,1638
SLEPC_EXTERN void PETSC_STDCALL rgappendoptionsprefix_(RG *rg,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))rgappendoptionsprefix_57,1891
SLEPC_EXTERN void PETSC_STDCALL rggetoptionsprefix_(RG *rg,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))rggetoptionsprefix_66,2150
SLEPC_EXTERN void PETSC_STDCALL rgview_(RG *rg,PetscViewer *viewer,PetscErrorCode *ierr)rgview_75,2472

src/sys/classes/rg/interface/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = rgbasic.c rgregis.cSOURCEC15,431
SOURCEF  =SOURCEF16,462
SOURCEH  =SOURCEH17,473
LIBBASE  = libslepcsysLIBBASE18,484
DIRS     =DIRS19,507
MANSEC   = RGMANSEC20,518
LOCDIR   = src/sys/classes/rg/LOCDIR21,532

src/sys/classes/rg/interface/rgbasic.c,1996
rgbasic.c:^?rgbasic.c^A,1
PetscFunctionList RGList = 0;RGList16,487
PetscBool         RGRegisterAllCalled = PETSC_FALSE;RGRegisterAllCalled17,517
PetscClassId      RG_CLASSID = 0;RG_CLASSID18,570
static PetscBool  RGPackageInitialized = PETSC_FALSE;RGPackageInitialized19,604
PetscErrorCode RGFinalizePackage(void)RGFinalizePackage29,853
PetscErrorCode RGInitializePackage(void)RGInitializePackage49,1383
PetscErrorCode RGCreate(MPI_Comm comm,RG *newrg)RGCreate94,2716
PetscErrorCode RGSetOptionsPrefix(RG rg,const char *prefix)RGSetOptionsPrefix132,3645
PetscErrorCode RGAppendOptionsPrefix(RG rg,const char *prefix)RGAppendOptionsPrefix160,4379
PetscErrorCode RGGetOptionsPrefix(RG rg,const char *prefix[])RGGetOptionsPrefix190,5096
PetscErrorCode RGSetType(RG rg,RGType type)RGSetType214,5598
PetscErrorCode RGGetType(RG rg,RGType *type)RGGetType252,6627
PetscErrorCode RGSetFromOptions(RG rg)RGSetFromOptions274,7076
PetscErrorCode RGView(RG rg,PetscViewer viewer)RGView327,8978
PetscErrorCode RGIsTrivial(RG rg,PetscBool *trivial)RGIsTrivial375,10662
PetscErrorCode RGCheckInside(RG rg,PetscInt n,PetscScalar *ar,PetscScalar *ai,PetscInt *inside)RGCheckInside414,11734
PetscErrorCode RGComputeContour(RG rg,PetscInt n,PetscScalar cr[],PetscScalar ci[])RGComputeContour463,12874
PetscErrorCode RGComputeBoundingBox(RG rg,PetscReal *a,PetscReal *b,PetscReal *c,PetscReal *d)RGComputeBoundingBox506,14127
PetscErrorCode RGSetComplement(RG rg,PetscBool flg)RGSetComplement546,15228
PetscErrorCode RGGetComplement(RG rg,PetscBool *flg)RGGetComplement571,15714
PetscErrorCode RGSetScale(RG rg,PetscReal sfactor)RGSetScale597,16314
PetscErrorCode RGGetScale(RG rg,PetscReal *sfactor)RGGetScale625,16967
PetscErrorCode RGPushScale(RG rg,PetscReal sfactor)RGPushScale654,17669
PetscErrorCode RGPopScale(RG rg)RGPopScale678,18393
PetscErrorCode RGDestroy(RG *rg)RGDestroy700,18875
PetscErrorCode RGRegister(const char *name,PetscErrorCode (*function)(RG))RGRegister729,19592

src/sys/classes/rg/interface/rgregis.c,56
rgregis.c:^?rgregis.c^A,1
PetscErrorCode RGRegisterAll(void)RGRegisterAll25,774

src/sys/classes/rg/makefile,263
makefile:^?makefile^A,1
SOURCEH  = ../../../../include/slepc/private/rgimpl.h ../../../../include/slepcrg.h ../../../../include/slepcrgtypes.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,528
LOCDIR   = src/sys/classes/rg/LOCDIR15,572
MANSEC   = RGMANSEC16,603

src/sys/classes/st/examples/makefile,83
makefile:^?makefile^A,1
LOCDIR   = src/sys/classes/st/examples/LOCDIR13,405
DIRS     = testsDIRS14,445

src/sys/classes/st/examples/tests/makefile,360
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/classes/st/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.c test3.c test4.c test5.cEXAMPLESC16,499
EXAMPLESF  =EXAMPLESF17,552
MANSEC     = STMANSEC18,565
TESTS      = test1 test2 test3 test4 test5TESTS19,581

src/sys/classes/st/examples/tests/test1.c,559
test1.c:^?test1.c^A,1
static char help[] = "Test ST with shell matrices.\n\n";help11,400
static PetscErrorCode MyShellMatCreate(Mat *A,Mat *M)MyShellMatCreate20,740
int main(int argc,char **argv)main37,1510
static PetscErrorCode MatMult_Shell(Mat S,Vec x,Vec y)MatMult_Shell141,5591
static PetscErrorCode MatMultTranspose_Shell(Mat S,Vec x,Vec y)MatMultTranspose_Shell152,5843
static PetscErrorCode MatGetDiagonal_Shell(Mat S,Vec diag)MatGetDiagonal_Shell163,6113
static PetscErrorCode MatDuplicate_Shell(Mat S,MatDuplicateOption op,Mat *M)MatDuplicate_Shell174,6377

src/sys/classes/st/examples/tests/test2.c,108
test2.c:^?test2.c^A,1
static char help[] = "Test ST with one matrix.\n\n";help11,400
int main(int argc,char **argv)main15,476

src/sys/classes/st/examples/tests/test3.c,110
test3.c:^?test3.c^A,1
static char help[] = "Test ST with two matrices.\n\n";help11,400
int main(int argc,char **argv)main15,478

src/sys/classes/st/examples/tests/test4.c,111
test4.c:^?test4.c^A,1
static char help[] = "Test ST with four matrices.\n\n";help11,400
int main(int argc,char **argv)main15,479

src/sys/classes/st/examples/tests/test5.c,121
test5.c:^?test5.c^A,1
static char help[] = "Test various ST interface functions.\n\n";help11,400
int main (int argc,char **argv)main15,489

src/sys/classes/st/f90-mod/makefile,335
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcstmod.FSOURCEF17,514
SOURCEH    = slepcst.h slepcst.h90SOURCEH18,540
LIBBASE    = libslepcsysLIBBASE19,575
MANSEC     = STMANSEC20,600
LOCDIR     = src/sys/classes/st/f90-mod/LOCDIR21,616
CLEANFILES = *.modCLEANFILES22,657

src/sys/classes/st/f90-mod/slepcst.h,142
slepcst.h:^?slepcst.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
      ST, parameter :: SLEPC_NULL_ST = tST(0)ST18,589

src/sys/classes/st/f90-mod/slepcstmod.F,82
slepcstmod.F:^?slepcstmod.F^A,1
        module slepcstdefslepcstdef10,398
        module slepcstslepcst17,560

src/sys/classes/st/impls/cayley/cayley.c,1599
cayley.c:^?cayley.c^A,1
  PetscScalar nu;nu17,531
  PetscBool   nu_set;nu_set18,549
} ST_CAYLEY;ST_CAYLEY19,571
PetscErrorCode STApply_Cayley(ST st,Vec x,Vec y)STApply_Cayley21,585
PetscErrorCode STApplyTranspose_Cayley(ST st,Vec x,Vec y)STApplyTranspose_Cayley33,937
static PetscErrorCode MatMult_Cayley(Mat B,Vec x,Vec y)MatMult_Cayley45,1323
static PetscErrorCode MatMultTranspose_Cayley(Mat B,Vec x,Vec y)MatMultTranspose_Cayley72,2074
PetscErrorCode STGetBilinearForm_Cayley(ST st,Mat *B)STGetBilinearForm_Cayley100,2883
PetscErrorCode STBackTransform_Cayley(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_Cayley111,3129
PetscErrorCode STPostSolve_Cayley(ST st)STPostSolve_Cayley141,3886
PetscErrorCode STSetUp_Cayley(ST st)STSetUp_Cayley158,4308
PetscErrorCode STSetShift_Cayley(ST st,PetscScalar newshift)STSetShift_Cayley197,6159
PetscErrorCode STSetFromOptions_Cayley(PetscOptionItems *PetscOptionsObject,ST st)STSetFromOptions_Cayley223,7224
static PetscErrorCode STCayleySetAntishift_Cayley(ST st,PetscScalar newshift)STCayleySetAntishift_Cayley240,7800
PetscErrorCode STCayleySetAntishift(ST st,PetscScalar nu)STCayleySetAntishift276,8823
static PetscErrorCode STCayleyGetAntishift_Cayley(ST st,PetscScalar *nu)STCayleyGetAntishift_Cayley287,9142
PetscErrorCode STCayleyGetAntishift(ST st,PetscScalar *nu)STCayleyGetAntishift312,9644
PetscErrorCode STView_Cayley(ST st,PetscViewer viewer)STView_Cayley323,9952
PetscErrorCode STDestroy_Cayley(ST st)STDestroy_Cayley339,10452
SLEPC_EXTERN PetscErrorCode STCreate_Cayley(ST st)STCreate_Cayley350,10808

src/sys/classes/st/impls/cayley/makefile,284
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = cayley.cSOURCEC15,431
SOURCEF  =SOURCEF16,451
SOURCEH  =SOURCEH17,462
LIBBASE  = libslepcsysLIBBASE18,473
DIRS     =DIRS19,496
MANSEC   = STMANSEC20,507
LOCDIR   = src/sys/classes/st/impls/cayley/LOCDIR21,521

src/sys/classes/st/impls/filter/filter.c,1975
filter.c:^?filter.c^A,1
PetscErrorCode STApply_Filter(ST st,Vec x,Vec y)STApply_Filter17,558
PetscErrorCode STSetUp_Filter(ST st)STSetUp_Filter26,739
PetscErrorCode STSetFromOptions_Filter(PetscOptionItems *PetscOptionsObject,ST st)STSetFromOptions_Filter46,1851
static PetscErrorCode STFilterSetInterval_Filter(ST st,PetscReal inta,PetscReal intb)STFilterSetInterval_Filter75,3312
PetscErrorCode STFilterSetInterval(ST st,PetscReal inta,PetscReal intb)STFilterSetInterval116,4605
static PetscErrorCode STFilterGetInterval_Filter(ST st,PetscReal *inta,PetscReal *intb)STFilterGetInterval_Filter128,4998
PetscErrorCode STFilterGetInterval(ST st,PetscReal *inta,PetscReal *intb)STFilterGetInterval154,5565
static PetscErrorCode STFilterSetRange_Filter(ST st,PetscReal left,PetscReal right)STFilterSetRange_Filter164,5870
PetscErrorCode STFilterSetRange(ST st,PetscReal left,PetscReal right)STFilterSetRange200,6984
static PetscErrorCode STFilterGetRange_Filter(ST st,PetscReal *left,PetscReal *right)STFilterGetRange_Filter212,7374
PetscErrorCode STFilterGetRange(ST st,PetscReal *left,PetscReal *right)STFilterGetRange238,7932
static PetscErrorCode STFilterSetDegree_Filter(ST st,PetscInt deg)STFilterSetDegree_Filter248,8233
PetscErrorCode STFilterSetDegree(ST st,PetscInt deg)STFilterSetDegree282,9099
static PetscErrorCode STFilterGetDegree_Filter(ST st,PetscInt *deg)STFilterGetDegree_Filter293,9406
PetscErrorCode STFilterGetDegree(ST st,PetscInt *deg)STFilterGetDegree317,9857
static PetscErrorCode STFilterGetThreshold_Filter(ST st,PetscReal *gamma)STFilterGetThreshold_Filter328,10153
PetscErrorCode STFilterGetThreshold(ST st,PetscReal *gamma)STFilterGetThreshold351,10705
PetscErrorCode STReset_Filter(ST st)STReset_Filter362,11016
PetscErrorCode STView_Filter(ST st,PetscViewer viewer)STView_Filter372,11188
PetscErrorCode STDestroy_Filter(ST st)STDestroy_Filter391,12091
SLEPC_EXTERN PetscErrorCode STCreate_Filter(ST st)STCreate_Filter411,13114

src/sys/classes/st/impls/filter/filter.h,4956
filter.h:^?filter.h^A,1
#define SLEPC_FILTER_HSLEPC_FILTER_H12,429
struct _n_FILTLAN_IOP {_n_FILTLAN_IOP15,506
  PetscReal   intervalWeights[5];  /* weight of the subintervals (5 in mid-pass, 3 in high-pass) */intervalWeights16,530
  PetscReal   transIntervalRatio;  /* the (relative) length of transition interval */transIntervalRatio17,630
  PetscBool   reverseInterval;     /* whether to reverse the interval or not; effective only for mid-pass filters */reverseInterval18,716
  PetscReal   initialPlateau;      /* initial plateau relative to the length of interval */initialPlateau19,833
  PetscReal   plateauShrinkRate;   /* the rate at which the plateau shrinks at each iteration */plateauShrinkRate20,925
  PetscReal   initialShiftStep;    /* initial shift step relative to the length of interval */initialShiftStep21,1022
  PetscReal   shiftStepExpanRate;  /* the rate at which the shift step expands */shiftStepExpanRate22,1117
  PetscInt    maxInnerIter;        /* maximum number of inner iterations to determine the (transition) intervals */maxInnerIter23,1199
  PetscReal   yLimitTol;           /* tolerance allowed for |p(inta)-p(intb)| in a mid-pass filter p(x) */yLimitTol24,1315
  PetscInt    maxOuterIter;        /* maximum number of outer iterations to determine the (transition) intervals */maxOuterIter25,1422
  PetscInt    numGridPoints;       /* number of grid points, used to measure the maximum p(z) for z not in the interval*/numGridPoints26,1538
  PetscReal   yBottomLine;         /* p(x) should be greater than this value for x in the interval */yBottomLine27,1660
  PetscReal   yRippleLimit;        /* limit of height of ripples relative to the bottom of polynomial values */yRippleLimit28,1762
typedef struct _n_FILTLAN_IOP *FILTLAN_IOP;FILTLAN_IOP30,1877
struct _n_FILTLAN_PFI {_n_FILTLAN_PFI33,1982
  PetscInt    filterType;          /* 1 = high-pass filter (or low-pass filter with conversion); 2 = mid-pass filter */filterType34,2006
  PetscInt    filterOK;            /* 0 = no acceptable found; 1 = OK filter found; 2 = optimal filter found */filterOK35,2126
  PetscReal   filterQualityIndex;  /* between 0.0 and 1.0; the higher the better quality of the filter */filterQualityIndex36,2238
  PetscInt    numIter;             /* number of iterations to get the (transition) intervals */numIter37,2344
  PetscInt    totalNumIter;        /* total number of iterations performed */totalNumIter38,2440
  PetscReal   yLimit;              /* lowest polynomial value P(z) for z in the interval [a1,b1] of desired eigenvalues */yLimit39,2518
  PetscReal   ySummit;             /* height of (highest, if more than one) summit in interval [a1,b1] of desired evals */ySummit40,2641
  PetscInt    numLeftSteps;        /* number of steps moving leftward */numLeftSteps41,2764
  PetscReal   yLeftSummit;         /* height of highest summit in the left-hand side of the interval of desired evals */yLeftSummit42,2837
  PetscReal   yLeftBottom;         /* height of lowest bottom in the left-hand side of the interval of desired evals */yLeftBottom43,2958
  PetscReal   yLimitGap;           /* |p(a1)-p(b1)|, where [a1,b1] is the interval of desired eigenvalues */yLimitGap44,3078
  PetscInt    numRightSteps;       /* number of steps moving rightward */numRightSteps45,3187
  PetscReal   yRightSummit;        /* height of highest summit in the right-hand side of the interval of desired evals */yRightSummit46,3261
  PetscReal   yRightBottom;        /* height of lowest bottom in the right-hand side of the interval of desired evals */yRightBottom47,3383
typedef struct _n_FILTLAN_PFI *FILTLAN_PFI;FILTLAN_PFI49,3507
  PetscReal   inta,intb;           /* bounds of the interval of desired eigenvalues */inta53,3590
  PetscReal   inta,intb;           /* bounds of the interval of desired eigenvalues */intb53,3590
  PetscReal   left,right;          /* approximate left and right bounds of the interval containing all eigenvalues */left54,3677
  PetscReal   left,right;          /* approximate left and right bounds of the interval containing all eigenvalues */right54,3677
  PetscInt    polyDegree;          /* degree of s(z), with z*s(z) the polynomial filter */polyDegree55,3795
  PetscInt    baseDegree;          /* left and right degrees of the base filter for each interval */baseDegree56,3886
  FILTLAN_IOP opts;                /* interval options */opts57,3987
  FILTLAN_PFI filterInfo;          /* polynomial filter info */filterInfo59,4072
  PetscReal   frame[4];            /* outer and inner intervals:frame60,4136
  PetscReal   intervals[6];        /* the range of eigenvalues is partitioned into intervals which determineintervals63,4407
  PetscReal   intervals2[6];       /* modified intervals */intervals266,4699
  PetscReal   *baseFilter;         /* coefficients of the base filter (a piecewise polynomial) */baseFilter67,4759
} ST_FILTER;ST_FILTER68,4857

src/sys/classes/st/impls/filter/filtlan.c,2723
filtlan.c:^?filtlan.c^A,1
PETSC_STATIC_INLINE PetscErrorCode FILTLAN_NewtonPolynomial(PetscInt n,PetscReal *x,PetscReal *y,PetscReal *sa,PetscReal *sf)FILTLAN_NewtonPolynomial46,2118
static PetscErrorCode FILTLAN_HermiteBaseFilterInChebyshevBasis(PetscReal *baseFilter,PetscReal *intv,PetscInt npoints,const PetscInt *HighLowFlags,PetscInt baseDeg)FILTLAN_HermiteBaseFilterInChebyshevBasis103,4725
static PetscErrorCode FILTLAN_GetIntervals(PetscReal *intervals,PetscReal *frame,PetscInt polyDeg,PetscInt baseDeg,FILTLAN_IOP opts,FILTLAN_PFI filterInfo)FILTLAN_GetIntervals209,8983
PETSC_STATIC_INLINE PetscErrorCode FILTLAN_ExpandNewtonPolynomialInChebyshevBasis(PetscInt n,PetscReal aa,PetscReal bb,PetscReal *a,PetscReal *x,PetscReal *q,PetscReal *q2)FILTLAN_ExpandNewtonPolynomialInChebyshevBasis479,22182
PETSC_STATIC_INLINE PetscReal FILTLAN_PolynomialEvaluationInChebyshevBasis(PetscReal *pp,PetscInt m,PetscInt idx,PetscReal z0,PetscReal aa,PetscReal bb)FILTLAN_PolynomialEvaluationInChebyshevBasis543,24072
#define basisTranslated basisTranslated570,25077
PETSC_STATIC_INLINE PetscReal FILTLAN_PiecewisePolynomialEvaluationInChebyshevBasis(PetscReal *pp,PetscInt m,PetscReal *intv,PetscInt npoints,PetscReal z0)FILTLAN_PiecewisePolynomialEvaluationInChebyshevBasis597,26597
PETSC_STATIC_INLINE PetscReal FILTLAN_PiecewisePolynomialInnerProductInChebyshevBasis(PetscReal *pp,PetscInt prows,PetscInt pcols,PetscInt ldp,PetscReal *qq,PetscInt qrows,PetscInt qcols,PetscInt ldq,const PetscReal *intervalWeights)FILTLAN_PiecewisePolynomialInnerProductInChebyshevBasis657,29109
PETSC_STATIC_INLINE PetscErrorCode FILTLAN_PiecewisePolynomialInChebyshevBasisMultiplyX(PetscReal *pp,PetscInt deg1,PetscInt ldp,PetscReal *intv,PetscInt nintv,PetscReal *qq,PetscInt ldq)FILTLAN_PiecewisePolynomialInChebyshevBasisMultiplyX698,31221
PETSC_STATIC_INLINE PetscErrorCode Mat_AXPY_BLAS(PetscInt n,PetscInt k,PetscReal alpha,const PetscReal *A,PetscInt lda,PetscReal beta,PetscReal *B,PetscInt ldb)Mat_AXPY_BLAS735,32581
static PetscErrorCode FILTLAN_FilteredConjugateResidualPolynomial(PetscReal *cpol,PetscReal *baseFilter,PetscInt nbase,PetscReal *intv,PetscInt m,PetscReal *intervalWeights,PetscInt niter)FILTLAN_FilteredConjugateResidualPolynomial789,35451
static PetscErrorCode FILTLAN_FilteredConjugateResidualMatrixPolynomialVectorProduct(Mat A,Vec b,Vec x,PetscReal *baseFilter,PetscInt nbase,PetscReal *intv,PetscInt nintv,PetscReal *intervalWeights,PetscInt niter,Vec *work)FILTLAN_FilteredConjugateResidualMatrixPolynomialVectorProduct885,40532
PetscErrorCode STFilter_FILTLAN_Apply(ST st,Vec x,Vec y)STFilter_FILTLAN_Apply964,44029
PetscErrorCode STFilter_FILTLAN_setFilter(ST st)STFilter_FILTLAN_setFilter983,44738

src/sys/classes/st/impls/filter/makefile,303
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = filter.c filtlan.cSOURCEC15,431
SOURCEF  =SOURCEF16,461
SOURCEH  = filter.hSOURCEH17,472
LIBBASE  = libslepcsysLIBBASE18,492
DIRS     =DIRS19,515
MANSEC   = STMANSEC20,526
LOCDIR   = src/sys/classes/st/impls/filter/LOCDIR21,540

src/sys/classes/st/impls/makefile,182
makefile:^?makefile^A,1
LIBBASE  = libslepcsysLIBBASE13,409
DIRS     = shell shift sinvert cayley precond filterDIRS14,432
LOCDIR   = src/sys/classes/st/impls/LOCDIR15,485
MANSEC   = STMANSEC16,522

src/sys/classes/st/impls/precond/makefile,286
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = precond.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcsysLIBBASE18,474
DIRS     =DIRS19,497
MANSEC   = STMANSEC20,508
LOCDIR   = src/sys/classes/st/impls/precond/LOCDIR21,522

src/sys/classes/st/impls/precond/precond.c,1236
precond.c:^?precond.c^A,1
  PetscBool setmat;setmat17,552
} ST_PRECOND;ST_PRECOND18,572
static PetscErrorCode STSetDefaultKSP_Precond(ST st)STSetDefaultKSP_Precond20,587
PetscErrorCode STSetUp_Precond(ST st)STSetUp_Precond47,1472
PetscErrorCode STSetShift_Precond(ST st,PetscScalar newshift)STSetShift_Precond130,4291
static PetscErrorCode STPrecondGetMatForPC_Precond(ST st,Mat *mat)STPrecondGetMatForPC_Precond144,4649
PetscErrorCode STPrecondGetMatForPC(ST st,Mat *mat)STPrecondGetMatForPC176,5540
static PetscErrorCode STPrecondSetMatForPC_Precond(ST st,Mat mat)STPrecondSetMatForPC_Precond187,5829
PetscErrorCode STPrecondSetMatForPC(ST st,Mat mat)STPrecondSetMatForPC231,7330
static PetscErrorCode STPrecondSetKSPHasMat_Precond(ST st,PetscBool setmat)STPrecondSetKSPHasMat_Precond243,7670
PetscErrorCode STPrecondSetKSPHasMat(ST st,PetscBool setmat)STPrecondSetKSPHasMat272,8428
static PetscErrorCode STPrecondGetKSPHasMat_Precond(ST st,PetscBool *setmat)STPrecondGetKSPHasMat_Precond283,8755
PetscErrorCode STPrecondGetKSPHasMat(ST st,PetscBool *setmat)STPrecondGetKSPHasMat309,9333
PetscErrorCode STDestroy_Precond(ST st)STDestroy_Precond320,9649
SLEPC_EXTERN PetscErrorCode STCreate_Precond(ST st)STCreate_Precond333,10204

src/sys/classes/st/impls/shell/ftn-custom/makefile,266
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zshell.cSOURCEC15,469
SOURCEF  =SOURCEF16,489
SOURCEH  =SOURCEH17,500
DIRS     =DIRS18,511
LIBBASE  = libslepcsysLIBBASE19,522
LOCDIR   = src/sys/classes/st/impls/shell/ftn-custom/LOCDIR20,545

src/sys/classes/st/impls/shell/ftn-custom/zshell.c,1644
zshell.c:^?zshell.c^A,1
  PetscFortranCallbackId apply;apply27,1006
  PetscFortranCallbackId applytranspose;applytranspose28,1038
  PetscFortranCallbackId backtransform;backtransform29,1079
} _cb;_cb30,1119
static PetscErrorCode ourshellapply(ST st,Vec x,Vec y)ourshellapply33,1219
static PetscErrorCode ourshellapplytranspose(ST st,Vec x,Vec y)ourshellapplytranspose38,1376
static PetscErrorCode ourshellbacktransform(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)ourshellbacktransform43,1551
SLEPC_EXTERN void PETSC_STDCALL stshellgetcontext_(ST *st,void **ctx,PetscErrorCode *ierr)stshellgetcontext_48,1792
SLEPC_EXTERN void PETSC_STDCALL stshellsetapply_(ST *st,void (PETSC_STDCALL *apply)(void*,Vec*,Vec*,PetscErrorCode*),PetscErrorCode *ierr)stshellsetapply_53,1926
SLEPC_EXTERN void PETSC_STDCALL stshellsetapplytranspose_(ST *st,void (PETSC_STDCALL *applytranspose)(void*,Vec*,Vec*,PetscErrorCode*),PetscErrorCode *ierr)stshellsetapplytranspose_59,2264
SLEPC_EXTERN void PETSC_STDCALL stshellsetbacktransform_(ST *st,void (PETSC_STDCALL *backtransform)(void*,PetscScalar*,PetscScalar*,PetscErrorCode*),PetscErrorCode *ierr)stshellsetbacktransform_65,2656

src/sys/classes/st/impls/shell/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = shell.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = STMANSEC20,506
LOCDIR   = src/sys/classes/st/impls/shell/LOCDIR21,520

src/sys/classes/st/impls/shell/shell.c,1764
shell.c:^?shell.c^A,1
  void           *ctx;                       /* user provided context */ctx18,627
  PetscErrorCode (*apply)(ST,Vec,Vec);apply19,700
  PetscErrorCode (*applytrans)(ST,Vec,Vec);applytrans20,739
  PetscErrorCode (*backtransform)(ST,PetscInt n,PetscScalar*,PetscScalar*);backtransform21,783
} ST_SHELL;ST_SHELL22,859
PetscErrorCode STShellGetContext(ST st,void **ctx)STShellGetContext42,1230
PetscErrorCode STShellSetContext(ST st,void *ctx)STShellSetContext74,2021
PetscErrorCode STApply_Shell(ST st,Vec x,Vec y)STApply_Shell87,2368
PetscErrorCode STApplyTranspose_Shell(ST st,Vec x,Vec y)STApplyTranspose_Shell105,3102
PetscErrorCode STBackTransform_Shell(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_Shell123,3865
PetscErrorCode STIsInjective_Shell(ST st,PetscBool* is)STIsInjective_Shell136,4317
PetscErrorCode STDestroy_Shell(ST st)STDestroy_Shell145,4523
static PetscErrorCode STShellSetApply_Shell(ST st,PetscErrorCode (*apply)(ST,Vec,Vec))STShellSetApply_Shell157,4978
PetscErrorCode STShellSetApply(ST st,PetscErrorCode (*apply)(ST,Vec,Vec))STShellSetApply187,5732
static PetscErrorCode STShellSetApplyTranspose_Shell(ST st,PetscErrorCode (*applytrans)(ST,Vec,Vec))STShellSetApplyTranspose_Shell197,6038
PetscErrorCode STShellSetApplyTranspose(ST st,PetscErrorCode (*applytrans)(ST,Vec,Vec))STShellSetApplyTranspose227,6842
static PetscErrorCode STShellSetBackTransform_Shell(ST st,PetscErrorCode (*backtr)(ST,PetscInt,PetscScalar*,PetscScalar*))STShellSetBackTransform_Shell237,7176
PetscErrorCode STShellSetBackTransform(ST st,PetscErrorCode (*backtr)(ST,PetscInt,PetscScalar*,PetscScalar*))STShellSetBackTransform268,8080
SLEPC_EXTERN PetscErrorCode STCreate_Shell(ST st)STCreate_Shell297,9115

src/sys/classes/st/impls/shift/makefile,282
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = shift.cSOURCEC15,431
SOURCEF  =SOURCEF16,450
SOURCEH  =SOURCEH17,461
LIBBASE  = libslepcsysLIBBASE18,472
DIRS     =DIRS19,495
MANSEC   = STMANSEC20,506
LOCDIR   = src/sys/classes/st/impls/shift/LOCDIR21,520

src/sys/classes/st/impls/shift/shift.c,561
shift.c:^?shift.c^A,1
PetscErrorCode STApply_Shift(ST st,Vec x,Vec y)STApply_Shift17,561
PetscErrorCode STApplyTranspose_Shift(ST st,Vec x,Vec y)STApplyTranspose_Shift33,986
PetscErrorCode STBackTransform_Shift(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_Shift49,1452
PetscErrorCode STPostSolve_Shift(ST st)STPostSolve_Shift60,1663
PetscErrorCode STSetUp_Shift(ST st)STSetUp_Shift77,2084
PetscErrorCode STSetShift_Shift(ST st,PetscScalar newshift)STSetShift_Shift125,3703
SLEPC_EXTERN PetscErrorCode STCreate_Shift(ST st)STCreate_Shift149,4485

src/sys/classes/st/impls/sinvert/makefile,286
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = sinvert.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcsysLIBBASE18,474
DIRS     =DIRS19,497
MANSEC   = STMANSEC20,508
LOCDIR   = src/sys/classes/st/impls/sinvert/LOCDIR21,522

src/sys/classes/st/impls/sinvert/sinvert.c,589
sinvert.c:^?sinvert.c^A,1
PetscErrorCode STApply_Sinvert(ST st,Vec x,Vec y)STApply_Sinvert16,510
PetscErrorCode STApplyTranspose_Sinvert(ST st,Vec x,Vec y)STApplyTranspose_Sinvert32,937
PetscErrorCode STBackTransform_Sinvert(ST st,PetscInt n,PetscScalar *eigr,PetscScalar *eigi)STBackTransform_Sinvert48,1402
PetscErrorCode STPostSolve_Sinvert(ST st)STPostSolve_Sinvert73,1957
PetscErrorCode STSetUp_Sinvert(ST st)STSetUp_Sinvert90,2380
PetscErrorCode STSetShift_Sinvert(ST st,PetscScalar newshift)STSetShift_Sinvert137,4002
SLEPC_EXTERN PetscErrorCode STCreate_Sinvert(ST st)STCreate_Sinvert171,5160

src/sys/classes/st/interface/ftn-custom/makefile,262
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zstf.cSOURCEC15,469
SOURCEF  =SOURCEF16,487
SOURCEH  =SOURCEH17,498
DIRS     =DIRS18,509
LIBBASE  = libslepcsysLIBBASE19,520
LOCDIR   = src/sys/classes/st/interface/ftn-custom/LOCDIR20,543

src/sys/classes/st/interface/ftn-custom/zstf.c,1447
zstf.c:^?zstf.c^A,1
SLEPC_EXTERN void PETSC_STDCALL stsettype_(ST *st,char *type PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))stsettype_30,1134
SLEPC_EXTERN void PETSC_STDCALL stgettype_(ST *st,char *name PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))stgettype_39,1363
SLEPC_EXTERN void PETSC_STDCALL stsetoptionsprefix_(ST *st,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))stsetoptionsprefix_48,1656
SLEPC_EXTERN void PETSC_STDCALL stappendoptionsprefix_(ST *st,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))stappendoptionsprefix_57,1909
SLEPC_EXTERN void PETSC_STDCALL stgetoptionsprefix_(ST *st,char *prefix PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))stgetoptionsprefix_66,2168
SLEPC_EXTERN void PETSC_STDCALL stview_(ST *st,PetscViewer *viewer,PetscErrorCode *ierr)stview_75,2490

src/sys/classes/st/interface/makefile,331
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = stfunc.c stset.c stsolve.c stsles.c stregis.c stshellmat.cSOURCEC15,431
SOURCEF  =SOURCEF16,501
SOURCEH  =SOURCEH17,512
LIBBASE  = libslepcsysLIBBASE18,523
DIRS     =DIRS19,546
MANSEC   = STMANSEC20,557
LOCDIR   = src/sys/classes/st/interface/LOCDIR21,571

src/sys/classes/st/interface/stfunc.c,3649
stfunc.c:^?stfunc.c^A,1
PetscClassId     ST_CLASSID = 0;ST_CLASSID16,520
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_SetUp17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_Apply17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_ApplyTranspose17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_MatSetUp17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_MatMult17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_MatMultTranspose17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_MatSolve17,553
PetscLogEvent    ST_SetUp = 0,ST_Apply = 0,ST_ApplyTranspose = 0,ST_MatSetUp = 0,ST_MatMult = 0,ST_MatMultTranspose = 0,ST_MatSolve = 0,ST_MatSolveTranspose = 0;ST_MatSolveTranspose17,553
static PetscBool STPackageInitialized = PETSC_FALSE;STPackageInitialized18,715
const char *STMatModes[] = {"COPY","INPLACE","SHELL","STMatMode","ST_MATMODE_",0};STMatModes20,769
PetscErrorCode STFinalizePackage(void)STFinalizePackage30,1047
PetscErrorCode STInitializePackage(void)STInitializePackage50,1581
PetscErrorCode STReset(ST st)STReset102,3690
PetscErrorCode STDestroy(ST *st)STDestroy135,4659
PetscErrorCode STCreate(MPI_Comm comm,ST *newst)STCreate165,5421
PetscErrorCode STSetMatrices(ST st,PetscInt n,Mat A[])STSetMatrices219,6845
PetscErrorCode STGetMatrix(ST st,PetscInt k,Mat *A)STGetMatrix279,8807
PetscErrorCode STGetMatrixTransformed(ST st,PetscInt k,Mat *T)STGetMatrixTransformed308,9784
PetscErrorCode STGetNumMatrices(ST st,PetscInt *n)STGetNumMatrices336,10594
PetscErrorCode STResetMatrixState(ST st)STResetMatrixState363,11313
PetscErrorCode STSetShift(ST st,PetscScalar shift)STSetShift393,12104
PetscErrorCode STGetShift(ST st,PetscScalar* shift)STGetShift426,12828
PetscErrorCode STSetDefaultShift(ST st,PetscScalar defaultshift)STSetDefaultShift449,13346
PetscErrorCode STScaleShift(ST st,PetscScalar factor)STScaleShift475,13942
PetscErrorCode STSetBalanceMatrix(ST st,Vec D)STSetBalanceMatrix504,14731
PetscErrorCode STGetBalanceMatrix(ST st,Vec *D)STGetBalanceMatrix539,15584
PetscErrorCode STMatCreateVecs(ST st,Vec *right,Vec *left)STMatCreateVecs562,16125
PetscErrorCode STMatCreateVecsEmpty(ST st,Vec *right,Vec *left)STMatCreateVecsEmpty589,16804
PetscErrorCode STMatGetSize(ST st,PetscInt *m,PetscInt *n)STMatGetSize613,17316
PetscErrorCode STMatGetLocalSize(ST st,PetscInt *m,PetscInt *n)STMatGetLocalSize637,17817
PetscErrorCode STSetOptionsPrefix(ST st,const char *prefix)STSetOptionsPrefix666,18549
PetscErrorCode STAppendOptionsPrefix(ST st,const char *prefix)STAppendOptionsPrefix698,19511
PetscErrorCode STGetOptionsPrefix(ST st,const char *prefix[])STGetOptionsPrefix731,20451
PetscErrorCode STView(ST st,PetscViewer viewer)STView766,21413
PetscErrorCode STRegister(const char *name,PetscErrorCode (*function)(ST))STRegister856,24677

src/sys/classes/st/interface/stregis.c,56
stregis.c:^?stregis.c^A,1
PetscErrorCode STRegisterAll(void)STRegisterAll29,919

src/sys/classes/st/interface/stset.c,781
stset.c:^?stset.c^A,1
PetscBool         STRegisterAllCalled = PETSC_FALSE;STRegisterAllCalled16,508
PetscFunctionList STList = 0;STList17,561
PetscErrorCode STSetType(ST st,STType type)STSetType46,1303
PetscErrorCode STGetType(ST st,STType *type)STGetType86,2399
PetscErrorCode STSetFromOptions(ST st)STSetFromOptions107,2905
PetscErrorCode STSetMatStructure(ST st,MatStructure str)STSetMatStructure180,5914
PetscErrorCode STGetMatStructure(ST st,MatStructure *str)STGetMatStructure214,6825
PetscErrorCode STSetMatMode(ST st,STMatMode mode)STSetMatMode261,8559
PetscErrorCode STGetMatMode(ST st,STMatMode *mode)STGetMatMode289,9160
PetscErrorCode STSetTransform(ST st,PetscBool flg)STSetTransform321,10073
PetscErrorCode STGetTransform(ST st,PetscBool *flg)STGetTransform349,10650

src/sys/classes/st/interface/stshellmat.c,782
stshellmat.c:^?stshellmat.c^A,1
  PetscScalar alpha;alpha18,595
  PetscScalar *coeffs;coeffs19,616
  ST          st;st20,639
  Vec         z;z21,657
  PetscInt    nmat;nmat22,674
  PetscInt    *matIdx;matIdx23,694
} ST_SHELLMAT;ST_SHELLMAT24,717
PetscErrorCode STMatShellShift(Mat A,PetscScalar alpha)STMatShellShift26,733
static PetscErrorCode MatMult_Shell(Mat A,Vec x,Vec y)MatMult_Shell41,1094
static PetscErrorCode MatMultTranspose_Shell(Mat A,Vec x,Vec y)MatMultTranspose_Shell70,1912
static PetscErrorCode MatGetDiagonal_Shell(Mat A,Vec diag)MatGetDiagonal_Shell99,2757
static PetscErrorCode MatDestroy_Shell(Mat A)MatDestroy_Shell132,3748
PetscErrorCode STMatShellCreate(ST st,PetscScalar alpha,PetscInt nmat,PetscInt *matIdx,PetscScalar *coeffs,Mat *mat)STMatShellCreate146,4130

src/sys/classes/st/interface/stsles.c,985
stsles.c:^?stsles.c^A,1
PetscErrorCode STSetDefaultKSP(ST st)STSetDefaultKSP21,743
PETSC_STATIC_INLINE PetscErrorCode STMatIsSymmetricKnown(ST st,PetscBool *symm)STMatIsSymmetricKnown36,1128
PetscErrorCode STSetDefaultKSP_Default(ST st)STSetDefaultKSP_Default68,2148
PetscErrorCode STMatMult(ST st,PetscInt k,Vec x,Vec y)STMatMult112,3365
PetscErrorCode STMatMultTranspose(ST st,PetscInt k,Vec x,Vec y)STMatMultTranspose158,4847
PetscErrorCode STMatSolve(ST st,Vec b,Vec x)STMatSolve203,6337
PetscErrorCode STMatSolveTranspose(ST st,Vec b,Vec x)STMatSolveTranspose252,7940
PetscErrorCode STMatSetHermitian(ST st,Mat M)STMatSetHermitian291,9378
PetscErrorCode STCheckFactorPackage(ST st)STCheckFactorPackage322,10360
PetscErrorCode STSetKSP(ST st,KSP ksp)STSetKSP354,11382
PetscErrorCode STGetKSP(ST st,KSP* ksp)STGetKSP383,12088
PetscErrorCode STCheckNullSpace_Default(ST st,BV V)STCheckNullSpace_Default403,12931
PetscErrorCode STCheckNullSpace(ST st,BV V)STCheckNullSpace465,14913

src/sys/classes/st/interface/stsolve.c,1261
stsolve.c:^?stsolve.c^A,1
PetscErrorCode STApply(ST st,Vec x,Vec y)STApply34,911
PetscErrorCode STApplyTranspose(ST st,Vec x,Vec y)STApplyTranspose82,2423
PetscErrorCode STGetBilinearForm(ST st,Mat *B)STGetBilinearForm130,4026
PetscErrorCode STGetBilinearForm_Default(ST st,Mat *B)STGetBilinearForm_Default143,4328
static PetscErrorCode MatMult_STOperator(Mat Op,Vec x,Vec y)MatMult_STOperator156,4586
static PetscErrorCode MatMultTranspose_STOperator(Mat Op,Vec x,Vec y)MatMultTranspose_STOperator167,4844
PetscErrorCode STGetOperator(ST st,Mat *Op)STGetOperator197,5559
PetscErrorCode STSetUp(ST st)STSetUp228,6455
PetscErrorCode STMatMAXPY_Private(ST st,PetscScalar alpha,PetscScalar beta,PetscInt k,PetscScalar *coeffs,PetscBool initial,Mat *S)STMatMAXPY_Private287,8672
PetscErrorCode STCoeffs_Monomial(ST st, PetscScalar *coeffs)STCoeffs_Monomial373,11713
PetscErrorCode STPostSolve(ST st)STPostSolve403,12432
PetscErrorCode STBackTransform(ST st,PetscInt n,PetscScalar* eigr,PetscScalar* eigi)STBackTransform432,13119
PetscErrorCode STIsInjective(ST st,PetscBool* is)STIsInjective462,13837
PetscErrorCode STMatSetUp(ST st,PetscScalar sigma,PetscScalar *coeffs)STMatSetUp501,14873
PetscErrorCode STSetWorkVecs(ST st,PetscInt nw)STSetWorkVecs534,15883

src/sys/classes/st/makefile,228
makefile:^?makefile^A,1
SOURCEH  = ../../../../include/slepc/private/stimpl.h ../../../../include/slepcst.hSOURCEH13,409
DIRS     = interface impls examples f90-modDIRS14,493
LOCDIR   = src/sys/classes/st/LOCDIR15,537
MANSEC   = STMANSEC16,568

src/sys/dlregisslepc.c,100
dlregisslepc.c:^?dlregisslepc.c^A,1
SLEPC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepc(void)PetscDLLibraryRegister_slepc35,1204

src/sys/examples/makefile,82
makefile:^?makefile^A,1
LOCDIR   = src/sys/examples/LOCDIR13,405
DIRS     = tests tutorialsDIRS14,434

src/sys/examples/tests/makefile,308
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.c test2.cEXAMPLESC16,488
EXAMPLESF  =EXAMPLESF17,517
MANSEC     = sysMANSEC18,530
TESTS      = test1 test2TESTS19,547

src/sys/examples/tests/test1.c,43
test1.c:^?test1.c^A,1
int main(int argc,char **argv)main16,474

src/sys/examples/tests/test2.c,136
test2.c:^?test2.c^A,1
static char help[] = "Tests functions intended to be used from a debugger.\n\n";help11,400
int main(int argc,char **argv)main15,505

src/sys/examples/tutorials/ex33.c,121
ex33.c:^?ex33.c^A,1
static char help[] = "Demonstrates SlepcGetVersionNumber().\n\n";help11,400
int main(int argc,char **argv)main15,490

src/sys/examples/tutorials/makefile,265
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/examples/tutorials/LOCDIR15,451
EXAMPLESC  = ex33.cEXAMPLESC16,492
EXAMPLESF  =EXAMPLESF17,512
MANSEC     = sysMANSEC18,525

src/sys/f90-mod/makefile,304
makefile:^?makefile^A,1
CFLAGS     =CFLAGS14,475
FFLAGS     =FFLAGS15,488
SOURCEC    =SOURCEC16,501
SOURCEF    = slepcsysmod.FSOURCEF17,514
SOURCEH    =SOURCEH18,541
LIBBASE    = libslepcsysLIBBASE19,554
MANSEC     = sysMANSEC20,579
LOCDIR     = src/sys/f90-mod/LOCDIR21,596
CLEANFILES = *.modCLEANFILES22,626

src/sys/f90-mod/slepcsys.h,175
slepcsys.h:^?slepcsys.h^A,1
!  Copyright (c) 2002-2019, Universitat Politecnica de Valencia, SpainValencia4,145
! Default tolerance for the different solvers, depending on the precisionsolvers21,642

src/sys/f90-mod/slepcsysmod.F,86
slepcsysmod.F:^?slepcsysmod.F^A,1
        module slepcsysdefslepcsysdef10,398
        module slepcsysslepcsys17,555

src/sys/ftn-custom/makefile,307
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,447
FFLAGS   =FFLAGS14,458
SOURCEC  = zslepcutil.c zslepc_start.c zslepc_startf.cSOURCEC15,469
SOURCEF  =SOURCEF16,524
SOURCEH  =SOURCEH17,535
DIRS     =DIRS18,546
LIBBASE  = libslepcsysLIBBASE19,557
MANSEC   = sysMANSEC20,580
LOCDIR   = src/sys/ftn-custom/LOCDIR21,595

src/sys/ftn-custom/zslepc_start.c,1178
zslepc_start.c:^?zslepc_start.c^A,1
static void slepcinitialize_internal(char *filename,PetscInt len,PetscBool arguments,PetscErrorCode *ierr)slepcinitialize_internal43,1749
SLEPC_EXTERN void PETSC_STDCALL slepcinitialize_(char *filename PETSC_MIXED_LEN(len),PetscErrorCode *ierr PETSC_END_LEN(len))slepcinitialize_82,3062
SLEPC_EXTERN void PETSC_STDCALL slepcinitializenoarguments_(PetscErrorCode *ierr)slepcinitializenoarguments_87,3251
SLEPC_EXTERN void PETSC_STDCALL slepcfinalize_(PetscErrorCode *ierr)slepcfinalize_92,3401

src/sys/ftn-custom/zslepc_startf.c,313
zslepc_startf.c:^?zslepc_startf.c^A,1
PetscErrorCode SlepcInitializeFortran(void)SlepcInitializeFortran40,1306
SLEPC_EXTERN void PETSC_STDCALL slepcinitializefortran_(PetscErrorCode *info)slepcinitializefortran_46,1395

src/sys/ftn-custom/zslepcutil.c,1091
zslepcutil.c:^?zslepcutil.c^A,1
SLEPC_EXTERN void PETSC_STDCALL slepcconvmonitorcreate_(PetscViewer *vin,PetscViewerFormat *format,SlepcConvMonitor *ctx,PetscErrorCode *ierr)slepcconvmonitorcreate_26,1042
SLEPC_EXTERN void slepcconvmonitordestroy_(SlepcConvMonitor *ctx,PetscErrorCode *ierr)slepcconvmonitordestroy_33,1299
SLEPC_EXTERN void PETSC_STDCALL slepcgetversion_(char *version PETSC_MIXED_LEN(len1),int *ierr PETSC_END_LEN(len1))slepcgetversion_38,1431
SLEPC_EXTERN void PETSC_STDCALL slepcgetversionnumber_(PetscInt *major,PetscInt *minor,PetscInt *subminor,PetscInt *release,PetscInt *ierr)slepcgetversionnumber_44,1653

src/sys/makefile,334
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = slepcinit.c slepcutil.c slepcsc.c dlregisslepc.cSOURCEC15,431
SOURCEF  =SOURCEF16,491
SOURCEH  =SOURCEH17,502
LIBBASE  = libslepcsysLIBBASE18,513
MANSEC   = sysMANSEC19,536
LOCDIR   = src/sys/LOCDIR20,551
DIRS     = f90-mod vec mat classes examplesDIRS21,571

src/sys/mat/examples/makefile,76
makefile:^?makefile^A,1
LOCDIR   = src/sys/mat/examples/LOCDIR13,405
DIRS     = testsDIRS14,438

src/sys/mat/examples/tests/makefile,298
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/mat/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.cEXAMPLESC16,492
EXAMPLESF  =EXAMPLESF17,513
MANSEC     = sysMANSEC18,526
TESTS      = test1TESTS19,543

src/sys/mat/examples/tests/test1.c,103
test1.c:^?test1.c^A,1
static char help[] = "Test MatCreateTile.\n\n";help11,400
int main(int argc,char **argv)main15,472

src/sys/mat/makefile,275
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = matutil.cSOURCEC15,431
SOURCEF  =SOURCEF16,452
SOURCEH  =SOURCEH17,463
LIBBASE  = libslepcsysLIBBASE18,474
DIRS     = examplesDIRS19,497
MANSEC   = sysMANSEC20,517
LOCDIR   = src/sys/mat/LOCDIR21,532

src/sys/mat/matutil.c,552
matutil.c:^?matutil.c^A,1
static PetscErrorCode MatCreateTile_SeqAIJ(PetscScalar a,Mat A,PetscScalar b,Mat B,PetscScalar c,Mat C,PetscScalar d,Mat D,Mat G)MatCreateTile_SeqAIJ13,470
static PetscErrorCode MatCreateTile_MPIAIJ(PetscScalar a,Mat A,PetscScalar b,Mat B,PetscScalar c,Mat C,PetscScalar d,Mat D,Mat G)MatCreateTile_MPIAIJ119,4012
PetscErrorCode MatCreateTile(PetscScalar a,Mat A,PetscScalar b,Mat B,PetscScalar c,Mat C,PetscScalar d,Mat D,Mat *G)MatCreateTile283,10135
PetscErrorCode MatCreateVecsEmpty(Mat mat,Vec *right,Vec *left)MatCreateVecsEmpty370,13774

src/sys/slepcinit.c,1359
slepcinit.c:^?slepcinit.c^A,1
PetscErrorCode SlepcGetVersion(char version[],size_t len)SlepcGetVersion28,730
PetscErrorCode SlepcGetVersionNumber(PetscInt *major,PetscInt *minor,PetscInt *subminor,PetscInt *release)SlepcGetVersionNumber65,1992
static PetscErrorCode SlepcPrintVersion(MPI_Comm comm)SlepcPrintVersion79,2388
static PetscErrorCode SlepcPrintHelpIntro(MPI_Comm comm)SlepcPrintHelpIntro99,3128
PetscBool SlepcBeganPetsc = PETSC_FALSE;SlepcBeganPetsc115,3830
PetscBool SlepcInitializeCalled = PETSC_FALSE;SlepcInitializeCalled116,3871
static PetscErrorCode SlepcLoadDynamicLibrary(const char *name,PetscBool *found)SlepcLoadDynamicLibrary119,4000
PetscErrorCode SlepcInitialize_DynamicLibraries(void)SlepcInitialize_DynamicLibraries154,5355
PetscErrorCode SlepcCitationsInitialize()SlepcCitationsInitialize206,8251
PetscErrorCode SlepcInitialize(int *argc,char ***args,const char file[],const char help[])SlepcInitialize252,10009
PetscErrorCode SlepcFinalize(void)SlepcFinalize291,11173
PetscErrorCode SlepcInitializeNoArguments(void)SlepcInitializeNoArguments314,11657
PetscErrorCode SlepcInitialized(PetscBool *isInitialized)SlepcInitialized332,12035
PETSC_EXTERN PetscBool PetscBeganMPI;PetscBeganMPI340,12230
PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *filename,const char *help)SlepcInitializeNoPointers352,12487

src/sys/slepcsc.c,2058
slepcsc.c:^?slepcsc.c^A,1
PetscErrorCode SlepcSCCompare(SlepcSC sc,PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *res)SlepcSCCompare40,1145
PetscErrorCode SlepcSortEigenvalues(SlepcSC sc,PetscInt n,PetscScalar *eigr,PetscScalar *eigi,PetscInt *perm)SlepcSortEigenvalues96,2861
PetscErrorCode SlepcMap_ST(PetscObject obj,PetscInt n,PetscScalar* eigr,PetscScalar* eigi)SlepcMap_ST153,4430
PetscErrorCode SlepcCompareLargestMagnitude(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareLargestMagnitude162,4659
PetscErrorCode SlepcCompareSmallestMagnitude(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareSmallestMagnitude175,5002
PetscErrorCode SlepcCompareLargestReal(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareLargestReal188,5346
PetscErrorCode SlepcCompareSmallestReal(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareSmallestReal201,5668
PetscErrorCode SlepcCompareLargestImaginary(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareLargestImaginary214,5991
PetscErrorCode SlepcCompareSmallestImaginary(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareSmallestImaginary232,6420
PetscErrorCode SlepcCompareTargetMagnitude(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareTargetMagnitude250,6850
PetscErrorCode SlepcCompareTargetReal(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareTargetReal265,7315
PetscErrorCode SlepcCompareTargetImaginary(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareTargetImaginary280,7760
PetscErrorCode SlepcCompareSmallestPosReal(PetscScalar ar,PetscScalar ai,PetscScalar br,PetscScalar bi,PetscInt *result,void *ctx)SlepcCompareSmallestPosReal299,8287

src/sys/slepcutil.c,832
slepcutil.c:^?slepcutil.c^A,1
PetscErrorCode SlepcConvMonitorCreate(PetscViewer viewer,PetscViewerFormat format,SlepcConvMonitor *ctx)SlepcConvMonitorCreate36,1081
PetscErrorCode SlepcConvMonitorDestroy(SlepcConvMonitor *ctx)SlepcConvMonitorDestroy60,1645
PetscErrorCode SlepcBasisReference_Private(PetscInt n,Vec *V,PetscInt *m,Vec **W)SlepcBasisReference_Private75,2081
PetscErrorCode SlepcBasisDestroy_Private(PetscInt *m,Vec **W)SlepcBasisDestroy_Private97,2632
PetscErrorCode SlepcSNPrintfScalar(char *str,size_t len,PetscScalar val,PetscBool exp)SlepcSNPrintfScalar128,3315
PetscErrorCode SlepcDebugViewMatrix(PetscInt nrows,PetscInt ncols,PetscScalar *Xr,PetscScalar *Xi,PetscInt ldx,const char *s,const char *filename)SlepcDebugViewMatrix173,4593
PETSC_UNUSED PetscErrorCode SlepcDebugSetMatlabStdout(void)SlepcDebugSetMatlabStdout207,5900

src/sys/vec/examples/makefile,76
makefile:^?makefile^A,1
LOCDIR   = src/sys/vec/examples/LOCDIR13,405
DIRS     = testsDIRS14,438

src/sys/vec/examples/tests/makefile,298
makefile:^?makefile^A,1
CFLAGS     =CFLAGS11,399
FFLAGS     =FFLAGS12,412
CPPFLAGS   =CPPFLAGS13,425
FPPFLAGS   =FPPFLAGS14,438
LOCDIR     = src/sys/vec/examples/tests/LOCDIR15,451
EXAMPLESC  = test1.cEXAMPLESC16,492
EXAMPLESF  =EXAMPLESF17,513
MANSEC     = sysMANSEC18,526
TESTS      = test1TESTS19,543

src/sys/vec/examples/tests/test1.c,97
test1.c:^?test1.c^A,1
static char help[] = "Test VecComp.\n\n";help11,400
int main(int argc,char **argv)main15,466

src/sys/vec/makefile,303
makefile:^?makefile^A,1
CFLAGS   =CFLAGS13,409
FFLAGS   =FFLAGS14,420
SOURCEC  = veccomp.c pool.c vecutil.cSOURCEC15,431
SOURCEF  =SOURCEF16,469
SOURCEH  = veccomp0.hSOURCEH17,480
LIBBASE  = libslepcsysLIBBASE18,502
DIRS     = examplesDIRS19,525
MANSEC   = sysMANSEC20,545
LOCDIR   = src/sys/vec/LOCDIR21,560

src/sys/vec/pool.c,373
pool.c:^?pool.c^A,1
PetscErrorCode SlepcVecPoolCreate(Vec v,PetscInt init_size,VecPool *p)SlepcVecPoolCreate32,827
PetscErrorCode SlepcVecPoolDestroy(VecPool *p)SlepcVecPoolDestroy62,1597
PetscErrorCode SlepcVecPoolGetVecs(VecPool p,PetscInt n,Vec **vecs)SlepcVecPoolGetVecs96,2336
PetscErrorCode SlepcVecPoolRestoreVecs(VecPool p,PetscInt n,Vec **vecs)SlepcVecPoolRestoreVecs138,3486

src/sys/vec/veccomp.c,3505
veccomp.c:^?veccomp.c^A,1
static MPI_Datatype MPIU_NORM2=0, MPIU_NORM1_AND_2=0;MPIU_NORM214,508
static MPI_Datatype MPIU_NORM2=0, MPIU_NORM1_AND_2=0;MPIU_NORM1_AND_214,508
static PetscBool VecCompInitialized = PETSC_FALSE;VecCompInitialized15,562
MPI_Op MPIU_NORM2_SUM=0;MPIU_NORM2_SUM16,613
#define __WITH_MPI____WITH_MPI__27,1034
PETSC_STATIC_INLINE void SumNorm2(PetscReal *ssq0,PetscReal *scale0,PetscReal *ssq1,PetscReal *scale1)SumNorm230,1078
PETSC_STATIC_INLINE PetscReal GetNorm2(PetscReal ssq,PetscReal scale)GetNorm243,1379
PETSC_STATIC_INLINE void AddNorm2(PetscReal *ssq,PetscReal *scale,PetscReal x)AddNorm248,1489
SLEPC_EXTERN void MPIAPI SlepcSumNorm2_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)SlepcSumNorm2_Local64,1800
static PetscErrorCode VecCompNormEnd(void)VecCompNormEnd86,2469
static PetscErrorCode VecCompNormInit(void)VecCompNormInit98,2786
PetscErrorCode VecDestroy_Comp(Vec v)VecDestroy_Comp112,3311
static struct _VecOps DvOps = {VecDuplicate_Comp, /* 1 */DvOps135,4008
PetscErrorCode VecDuplicateVecs_Comp(Vec w,PetscInt m,Vec *V[])VecDuplicateVecs_Comp197,5746
PetscErrorCode VecDestroyVecs_Comp(PetscInt m,Vec v[])VecDestroyVecs_Comp211,6193
static PetscErrorCode VecCreate_Comp_Private(Vec v,Vec *x,PetscInt nx,PetscBool x_to_me,Vec_Comp_N *n)VecCreate_Comp_Private224,6562
SLEPC_EXTERN PetscErrorCode VecCreate_Comp(Vec V)VecCreate_Comp282,8409
PetscErrorCode VecCreateComp(MPI_Comm comm,PetscInt *Nx,PetscInt n,VecType t,Vec Vparent,Vec *V)VecCreateComp315,9263
PetscErrorCode VecCreateCompWithVecs(Vec *x,PetscInt n,Vec Vparent,Vec *V)VecCreateCompWithVecs352,10290
PetscErrorCode VecDuplicate_Comp(Vec win,Vec *V)VecDuplicate_Comp369,10850
static PetscErrorCode VecCompGetSubVecs_Comp(Vec win,PetscInt *n,const Vec **x)VecCompGetSubVecs_Comp390,11491
PetscErrorCode VecCompGetSubVecs(Vec win,PetscInt *n,const Vec **x)VecCompGetSubVecs417,12005
static PetscErrorCode VecCompSetSubVecs_Comp(Vec win,PetscInt n,Vec *x)VecCompSetSubVecs_Comp427,12301
PetscErrorCode VecCompSetSubVecs(Vec win,PetscInt n,Vec *x)VecCompSetSubVecs484,14273
PetscErrorCode VecAXPY_Comp(Vec v,PetscScalar alpha,Vec w)VecAXPY_Comp495,14596
PetscErrorCode VecAYPX_Comp(Vec v,PetscScalar alpha,Vec w)VecAYPX_Comp510,14964
PetscErrorCode VecAXPBY_Comp(Vec v,PetscScalar alpha,PetscScalar beta,Vec w)VecAXPBY_Comp525,15332
PetscErrorCode VecMAXPY_Comp(Vec v,PetscInt n,const PetscScalar *alpha,Vec *w)VecMAXPY_Comp540,15724
PetscErrorCode VecWAXPY_Comp(Vec v,PetscScalar alpha,Vec w,Vec z)VecWAXPY_Comp562,16275
PetscErrorCode VecAXPBYPCZ_Comp(Vec v,PetscScalar alpha,PetscScalar beta,PetscScalar gamma,Vec w,Vec z)VecAXPBYPCZ_Comp578,16711
PetscErrorCode VecGetSize_Comp(Vec v,PetscInt *size)VecGetSize_Comp594,17202
PetscErrorCode VecGetLocalSize_Comp(Vec v,PetscInt *size)VecGetLocalSize_Comp607,17471
PetscErrorCode VecMax_Comp(Vec v,PetscInt *idx,PetscReal *z)VecMax_Comp620,17746
PetscErrorCode VecMin_Comp(Vec v,PetscInt *idx,PetscReal *z)VecMin_Comp651,18467
PetscErrorCode VecMaxPointwiseDivide_Comp(Vec v,Vec w,PetscReal *m)VecMaxPointwiseDivide_Comp682,19188
#define __QUOTEME__(__QUOTEME__702,19749
#define __COMPOSE2__(__COMPOSE2__703,19775
#define __COMPOSE3__(__COMPOSE3__704,19806
#define __FUNC_TEMPLATE1__(__FUNC_TEMPLATE1__706,19843
#define __FUNC_TEMPLATE2__(__FUNC_TEMPLATE2__728,20374
#define __FUNC_TEMPLATE3__(__FUNC_TEMPLATE3__749,20949
#define __FUNC_TEMPLATE4__(__FUNC_TEMPLATE4__769,21457

src/sys/vec/veccomp0.h,866
veccomp0.h:^?veccomp0.h^A,1
#define __SUF__(__SUF__14,462
#define __SUF__(__SUF__16,495
#define __QUOTEME_(__QUOTEME_18,529
#define __QUOTEME(__QUOTEME19,554
#define __SUF_C__(__SUF_C__20,589
PetscErrorCode __SUF__(VecDot_Comp)(Vec a,Vec b,PetscScalar *z)VecDot_Comp22,633
PetscErrorCode __SUF__(VecMDot_Comp)(Vec a,PetscInt n,const Vec b[],PetscScalar *z)VecMDot_Comp51,1430
PetscErrorCode __SUF__(VecTDot_Comp)(Vec a,Vec b,PetscScalar *z)VecTDot_Comp103,2732
PetscErrorCode __SUF__(VecMTDot_Comp)(Vec a,PetscInt n,const Vec b[],PetscScalar *z)VecMTDot_Comp132,3533
PetscErrorCode __SUF__(VecNorm_Comp)(Vec a,NormType t,PetscReal *norm)VecNorm_Comp184,4842
PetscErrorCode __SUF__(VecDotNorm2_Comp)(Vec v,Vec w,PetscScalar *dp,PetscScalar *nm)VecDotNorm2_Comp252,7119
#undef __SUF____SUF__300,8744
#undef __QUOTEME__QUOTEME301,8759
#undef __SUF_C____SUF_C__302,8776

src/sys/vec/vecutil.c,338
vecutil.c:^?vecutil.c^A,1
PetscErrorCode VecNormalizeComplex(Vec xr,Vec xi,PetscBool iscomplex,PetscReal *norm)VecNormalizeComplex28,905
PetscErrorCode VecCheckOrthogonality(Vec V[],PetscInt nv,Vec W[],PetscInt nw,Mat B,PetscViewer viewer,PetscReal *lev)VecCheckOrthogonality87,2724
PetscErrorCode VecDuplicateEmpty(Vec v,Vec *newv)VecDuplicateEmpty164,4945
