Copy disabled (too large)
Download .txt
Showing preview only (35,157K chars total). Download the full file to get everything.
Repository: m-a-d-n-e-s-s/madness
Branch: master
Commit: 32c1b82080e8
Files: 2071
Total size: 75.9 MB
Directory structure:
gitextract_z1ik1m5j/
├── .clang-tidy
├── .github/
│ └── workflows/
│ ├── cmake.yml
│ ├── conda-deploy.yml
│ └── make_doxygen.yml
├── .gitignore
├── .readthedocs.yaml
├── AGENTS.md
├── CMakeLists.txt
├── INSTALL.md
├── LICENSE
├── README.md
├── _config.yml
├── admin/
│ ├── conda/
│ │ ├── README.md
│ │ └── recipe/
│ │ └── meta.yaml.in
│ └── docker/
│ ├── README.md
│ ├── images/
│ │ └── Makefile
│ └── ubuntu/
│ ├── Dockerfile
│ ├── Makefile
│ └── sudoers
├── bin/
│ ├── latex2oo
│ ├── taskprofile.pl
│ └── test_utilities.py
├── cmake/
│ ├── Makefile
│ ├── config.h.in
│ ├── doxygen.cfg.in
│ ├── madness-config.cmake.in
│ ├── modules/
│ │ ├── AddCustomTargetSubproject.cmake
│ │ ├── AddMADExecutable.cmake
│ │ ├── AddMADLibrary.cmake
│ │ ├── AddMPITests.cmake
│ │ ├── AddOptions.cmake
│ │ ├── AddScriptedTests.cmake
│ │ ├── AddUnittests.cmake
│ │ ├── AppendFlags.cmake
│ │ ├── CheckCFortranFunctionExists.cmake
│ │ ├── CheckDisablePIESupport.cmake
│ │ ├── ConvertIncludesListToCompilerArgs.cmake
│ │ ├── ConvertLibrariesListToCompilerArgs.cmake
│ │ ├── CopyTargetProperties.cmake
│ │ ├── EchoTargetProperty.cmake
│ │ ├── FindACML.cmake
│ │ ├── FindFFTW.cmake
│ │ ├── FindGperftools.cmake
│ │ ├── FindIntegratorXX.cmake
│ │ ├── FindLibunwind.cmake
│ │ ├── FindMKL.cmake
│ │ ├── FindOrFetchCereal.cmake
│ │ ├── FindOrFetchPARSEC.cmake
│ │ ├── FindPCM.cmake
│ │ ├── FindPapi.cmake
│ │ ├── FindTBB.cmake
│ │ ├── GetGitMetadata.cmake
│ │ └── RedefaultableOption.cmake
│ └── toolchains/
│ ├── arm-gnu-tbb.cmake
│ ├── dancer_gcc.cmake
│ ├── generic-mkl-tbb.cmake
│ ├── mira-clang11-essl.cmake
│ ├── mira-gcc-essl.cmake
│ ├── osx-clang-accelerate-tbb.cmake
│ └── osx-clang-mkl-tbb.cmake
├── conda-recipe/
│ ├── .gitignore
│ ├── build.sh
│ └── meta.yaml
├── config/
│ └── MADNESS.pc.in
├── doc/
│ ├── CMakeLists.txt
│ ├── INSTALL.md
│ ├── Latex/
│ │ ├── api.tex
│ │ ├── apps/
│ │ │ ├── lrccs/
│ │ │ │ ├── LRCCS_Manual.tex
│ │ │ │ └── references.bib
│ │ │ ├── moldft/
│ │ │ │ └── manual.tex
│ │ │ └── nemo_mp2/
│ │ │ ├── aip.bst
│ │ │ ├── aip.sty
│ │ │ ├── manual.tex
│ │ │ └── references.bib
│ │ ├── implementation.tex
│ │ └── parallel-runtime.tex
│ ├── MADNESSeverything4.odp
│ ├── Makefile
│ ├── applications.dox
│ ├── conf.py
│ ├── configuration.dox
│ ├── contribution/
│ │ └── style.dox
│ ├── contribution.dox
│ ├── getting_started/
│ │ ├── gstart_basics.dox
│ │ ├── gstart_comp_run.dox
│ │ ├── gstart_env_var.dox
│ │ ├── gstart_functions.dox
│ │ ├── gstart_io.dox
│ │ ├── gstart_load_balance.dox
│ │ └── gstart_think_madness.dox
│ ├── getting_started.dox
│ ├── index.log
│ ├── index.rst
│ ├── libraries/
│ │ ├── chemistry.dox
│ │ ├── containers.dox
│ │ ├── parallel_runtime/
│ │ │ ├── futures.dox
│ │ │ ├── mpi.dox
│ │ │ ├── serialization.dox
│ │ │ ├── threading/
│ │ │ │ ├── atomics.dox
│ │ │ │ ├── taskq.dox
│ │ │ │ └── threads.dox
│ │ │ ├── threading.dox
│ │ │ ├── world.dox
│ │ │ └── world_object.dox
│ │ └── parallel_runtime.dox
│ ├── libraries.dox
│ ├── madness.bib
│ ├── mainpage.dox
│ ├── make.bat
│ ├── numerical_library.md
│ ├── quantum.md
│ ├── requirements.txt
│ ├── runtime.md
│ └── tutorial/
│ ├── API.md
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── TODO.md
│ ├── chemistry.md
│ ├── simple_hf.cpp
│ └── test_runtime.cpp
├── external/
│ ├── boost.cmake
│ ├── elemental.cmake
│ ├── gperftools.cmake
│ ├── integratorxx.cmake
│ ├── lapack.cmake
│ ├── libunwind.cmake
│ ├── libxc.cmake
│ ├── mpi.cmake
│ ├── papi.cmake
│ ├── parsec.cmake
│ ├── pcm.cmake
│ ├── pthread.cmake
│ ├── pybind11.cmake
│ ├── tbb.cmake
│ └── versions.cmake
└── src/
├── CMakeLists.txt
├── apps/
│ ├── CMakeLists.txt
│ ├── QCSchema_json.md
│ ├── cc2/
│ │ ├── CMakeLists.txt
│ │ └── cc2.cc
│ ├── cis/
│ │ ├── CMakeLists.txt
│ │ ├── cis.cpp
│ │ └── input
│ ├── dirac/
│ │ ├── CMakeLists.txt
│ │ ├── DF.cc
│ │ ├── DF.h
│ │ ├── DFParameters.h
│ │ ├── DFdriver.cc
│ │ ├── DFinput_sample
│ │ ├── DKops.h
│ │ ├── InitParameters.h
│ │ ├── README
│ │ ├── fcwf.cc
│ │ ├── fcwf.h
│ │ ├── relops.cc
│ │ └── rk.cc
│ ├── interior_bc/
│ │ ├── CMakeLists.txt
│ │ ├── embedded_dirichlet.cc
│ │ └── test_problems.h
│ ├── madqc_v2/
│ │ ├── CMakeLists.txt
│ │ ├── mad_madqc_test_cc2_callable.py.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_energy_he.py.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_symmetry_h2o.py_a2.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_symmetry_h2o.py_b1.calc_info.ref.json
│ │ ├── mad_madqc_test_lrcc2_helium.py.calc_info.ref.json
│ │ ├── mad_madqc_test_moldft_energy.py.calc_info.ref.json
│ │ ├── mad_madqc_test_moldft_energy_mpi_parallel.py.calc_info.ref.json
│ │ ├── mad_madqc_test_mp2_helium.py.calc_info.ref.json
│ │ ├── mad_madqc_test_nemo_energy.py.calc_info.ref.json
│ │ ├── mad_madqc_test_nemo_localization.py.calc_info.ref.json
│ │ ├── mad_madqc_test_oep_energy.py.calc_info.ref.json
│ │ ├── madqc.cpp
│ │ ├── test_cc2_callable.py
│ │ ├── test_cis_energy_he.py
│ │ ├── test_cis_symmetry_h2o.py
│ │ ├── test_lrcc2_helium.py
│ │ ├── test_moldft_energy.py
│ │ ├── test_moldft_energy_mpi_parallel.py
│ │ ├── test_mp2_helium.py
│ │ ├── test_nemo_energy.py
│ │ ├── test_nemo_localization.py
│ │ └── test_oep_energy.py
│ ├── moldft/
│ │ ├── CMakeLists.txt
│ │ ├── calcguess.nw
│ │ ├── df_repo.tgz
│ │ ├── fci/
│ │ │ ├── GNUmakefile
│ │ │ ├── bitops.fh
│ │ │ ├── crayio.c
│ │ │ ├── daxpy.F
│ │ │ ├── dcopy.F
│ │ │ ├── ddot.F
│ │ │ ├── dgemm.F
│ │ │ ├── doc/
│ │ │ │ ├── GNUmakefile
│ │ │ │ ├── bibstuff.tex
│ │ │ │ ├── commands.tex
│ │ │ │ ├── matrixelements.ps
│ │ │ │ ├── matrixelements.tex
│ │ │ │ ├── matrixelements.toc
│ │ │ │ ├── mspingraph.eps
│ │ │ │ ├── mspingraph.fig
│ │ │ │ ├── orbitalarcs.eps
│ │ │ │ ├── orbitalarcs.fig
│ │ │ │ ├── orbitalgraph.eps
│ │ │ │ ├── orbitalgraph.fig
│ │ │ │ ├── psfig.sty
│ │ │ │ ├── spinarcs.eps
│ │ │ │ ├── spinarcs.fig
│ │ │ │ ├── spingraph.eps
│ │ │ │ └── spingraph.fig
│ │ │ ├── dscal.F
│ │ │ ├── fci.F
│ │ │ ├── fci_1pdm.F
│ │ │ ├── fci_2pdm.F
│ │ │ ├── fci_3pdm.F
│ │ │ ├── fci_axb.F
│ │ │ ├── fci_cntone.F
│ │ │ ├── fci_couple1.F
│ │ │ ├── fci_couple2.F
│ │ │ ├── fci_couple3.F
│ │ │ ├── fci_davids.F
│ │ │ ├── fci_detwalk.F
│ │ │ ├── fci_dfill.F
│ │ │ ├── fci_diags.F
│ │ │ ├── fci_err.F
│ │ │ ├── fci_hami.F
│ │ │ ├── fci_hmod.F
│ │ │ ├── fci_hsort.F
│ │ │ ├── fci_hv.F
│ │ │ ├── fci_ifill.F
│ │ │ ├── fci_intchk.F
│ │ │ ├── fci_load.F
│ │ │ ├── fci_make_eaj.F
│ │ │ ├── fci_mfndoc.F
│ │ │ ├── fci_mfndwt.F
│ │ │ ├── fci_mgraph.F
│ │ │ ├── fci_num.F
│ │ │ ├── fci_ofndoc.F
│ │ │ ├── fci_ofndwt.F
│ │ │ ├── fci_ograph.F
│ │ │ ├── fci_onelcc.F
│ │ │ ├── fci_onepdm.F
│ │ │ ├── fci_output.F
│ │ │ ├── fci_owalk_info.F
│ │ │ ├── fci_prntri.F
│ │ │ ├── fci_prspnad.F
│ │ │ ├── fci_prteop.F
│ │ │ ├── fci_prvec.F
│ │ │ ├── fci_setup.F
│ │ │ ├── fci_sigma.F
│ │ │ ├── fci_solve.F
│ │ │ ├── fci_spnad.F
│ │ │ ├── fci_spnfrc.F
│ │ │ ├── fci_srt1cc.F
│ │ │ ├── fci_tinit.F
│ │ │ ├── fciinfo.fh
│ │ │ ├── fciparam.fh
│ │ │ ├── fcitime.fh
│ │ │ ├── idamax.F
│ │ │ ├── ieor.c
│ │ │ ├── linux_cputime.c
│ │ │ ├── output
│ │ │ ├── renorm.F
│ │ │ ├── rsg.f
│ │ │ ├── screen.F
│ │ │ ├── timer.f
│ │ │ └── yacobi.F
│ │ ├── fitinput
│ │ ├── gth.xml
│ │ ├── gth_pbe.xml
│ │ ├── input
│ │ ├── lda.f
│ │ ├── mad_moldft_test_energy.py.calc_info.ref.json
│ │ ├── mad_moldft_test_energy_mpi_parallel.py.calc_info.ref.json
│ │ ├── mcpfit.cc
│ │ ├── moldft.cc
│ │ ├── moldx.py
│ │ ├── nwtoxml.py
│ │ ├── parsemad.py
│ │ ├── pointgroup.h
│ │ ├── preal.cc
│ │ ├── subspace.h
│ │ ├── testcosine.cc
│ │ ├── testmolbas.cc
│ │ ├── testperiodicdft.cc
│ │ ├── testpg.cc
│ │ ├── tests/
│ │ │ ├── be_lda.in
│ │ │ ├── c6h6_lda.in
│ │ │ ├── ca_lda.in
│ │ │ ├── h2o_1_lda.in
│ │ │ ├── h2o_2_lda.in
│ │ │ ├── h2o_5_lda.in
│ │ │ ├── h2o_9_lda.in
│ │ │ ├── h2o_hf.in
│ │ │ ├── h_hf.in
│ │ │ ├── h_lsda.in
│ │ │ ├── he_hf.in
│ │ │ ├── he_lda.in
│ │ │ ├── he_xpbe.in
│ │ │ ├── k_hf.in
│ │ │ ├── li_hf.in
│ │ │ ├── li_lsda.in
│ │ │ ├── mg_lda.in
│ │ │ ├── n2_hf.in
│ │ │ ├── n_lsda.in
│ │ │ ├── na_hf.in
│ │ │ ├── ne_lda.in
│ │ │ ├── nh3_planar_hf.in
│ │ │ ├── nh3_pyramidal_hf.in
│ │ │ ├── rb_hf.in
│ │ │ └── sr_lda.in
│ │ ├── vizit.cfg
│ │ ├── vizit.net
│ │ ├── wst_functional.h
│ │ └── xmlguess.py
│ ├── molresponse/
│ │ ├── CMakeLists.txt
│ │ ├── ExcitedResponse.cpp
│ │ ├── ExcitedResponse.hpp
│ │ ├── FrequencyResponse.cpp
│ │ ├── FrequencyResponse.hpp
│ │ ├── Plot_VTK.cc
│ │ ├── Plot_VTK.h
│ │ ├── ResponseBase.cpp
│ │ ├── ResponseBase.hpp
│ │ ├── ResponseExceptions.hpp
│ │ ├── basic_operators.cc
│ │ ├── basic_operators.h
│ │ ├── calc_runner.cc
│ │ ├── details.md
│ │ ├── global_functions.cc
│ │ ├── global_functions.h
│ │ ├── ground_parameters.h
│ │ ├── molresponse.cc
│ │ ├── molresponse_tutorial.md
│ │ ├── property.cc
│ │ ├── property.h
│ │ ├── response_functions.h
│ │ ├── response_macrotask.hpp
│ │ ├── response_parameters.cpp
│ │ ├── response_parameters.h
│ │ ├── timer.cc
│ │ ├── timer.h
│ │ ├── x_space.cc
│ │ └── x_space.h
│ ├── molresponse_v2/
│ │ ├── CMakeLists.txt
│ │ ├── FrequencyLoop.hpp
│ │ ├── GroundStateData.cpp
│ │ ├── GroundStateData.hpp
│ │ ├── InnerContributions.hpp
│ │ ├── MolecularProperty.hpp
│ │ ├── Perturbation.hpp
│ │ ├── PropertyManager.hpp
│ │ ├── ResponseDebugLogger.hpp
│ │ ├── ResponseDebugLoggerMacros.hpp
│ │ ├── ResponseIO.hpp
│ │ ├── ResponseInitializer.hpp
│ │ ├── ResponseManager.cpp
│ │ ├── ResponseManager.hpp
│ │ ├── ResponseMetaData.hpp
│ │ ├── ResponseSolver.cpp
│ │ ├── ResponseSolver.hpp
│ │ ├── ResponseSolverUtils.hpp
│ │ ├── ResponseState.cpp
│ │ ├── ResponseState.hpp
│ │ ├── ResponseVector.hpp
│ │ ├── StateGenerator.hpp
│ │ ├── VBCMacrotask.hpp
│ │ ├── broadcast_json.hpp
│ │ ├── molresponse2.cpp
│ │ ├── test_parameter_manager.cpp
│ │ ├── test_preliminaries.cpp
│ │ └── usage.rst
│ ├── mp2/
│ │ ├── CMakeLists.txt
│ │ └── mp2.cc
│ ├── nemo/
│ │ ├── CMakeLists.txt
│ │ ├── madtestboys.calc_info.ref.json
│ │ ├── madtestcanon.calc_info.ref.json
│ │ ├── madtestnew.calc_info.ref.json
│ │ └── nemo.cc
│ ├── oep/
│ │ ├── CMakeLists.txt
│ │ ├── madtest1.oep_calc_info.ref.json
│ │ └── oep.cc
│ ├── periodic_old/
│ │ ├── CMakeLists.txt
│ │ ├── complexfun.h
│ │ ├── dft.cc
│ │ ├── dft.h
│ │ ├── eigsolver.cc
│ │ ├── eigsolver.h
│ │ ├── electronicstructureapp.h
│ │ ├── electronicstructureparams.h
│ │ ├── esolver.h
│ │ ├── ewald.cc
│ │ ├── hartreefock.cc
│ │ ├── hartreefock.h
│ │ ├── input
│ │ ├── lda.h
│ │ ├── libxc.h
│ │ ├── matlab/
│ │ │ └── cosine_potential/
│ │ │ ├── fd_coulomb_conv.m
│ │ │ ├── test_coulomb.m
│ │ │ ├── test_coulomb1D.m
│ │ │ ├── test_coulomb1D_pw.m
│ │ │ ├── test_coulomb1D_sincos.m
│ │ │ ├── test_coulomb3D.m
│ │ │ ├── test_coulomb3D_pw.m
│ │ │ └── test_coulomb3D_sep.m
│ │ ├── mentity.cc
│ │ ├── mentity.h
│ │ ├── molecularbasis.h
│ │ ├── outputwriter.h
│ │ ├── poperator.h
│ │ ├── solver.h
│ │ ├── solver_driver.cc
│ │ ├── sto-3g
│ │ ├── test_be.cc
│ │ ├── test_comm.cc
│ │ ├── test_coulomb.cc
│ │ ├── test_he.cc
│ │ ├── test_hf.cc
│ │ ├── test_hydro.cc
│ │ ├── test_lattice.cc
│ │ ├── test_xc.cc
│ │ ├── testconv.cc
│ │ ├── util.cc
│ │ └── util.h
│ ├── plot/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── plot2cube.cpp
│ │ └── plot2plane.cpp
│ ├── pno/
│ │ ├── CMakeLists.txt
│ │ ├── auxbas
│ │ ├── input
│ │ ├── input_hylleraas_file
│ │ ├── input_hylleraas_internal
│ │ └── pno.cpp
│ ├── tdse/
│ │ ├── CMakeLists.txt
│ │ ├── graveyard
│ │ ├── hatom.job
│ │ ├── input
│ │ ├── input4
│ │ ├── restart
│ │ ├── tdse.cc
│ │ ├── tdse.confused.cc
│ │ └── tdse4.cc
│ ├── zcis/
│ │ ├── CMakeLists.txt
│ │ └── zcis.cc
│ └── znemo/
│ ├── CMakeLists.txt
│ ├── madtest1.calc_info.ref.json
│ ├── test_energy.py
│ └── znemo.cc
├── examples/
│ ├── 3dharmonic.cc
│ ├── CMakeLists.txt
│ ├── RUNALL
│ ├── ac_corr.cc
│ ├── array_worldobject.cc
│ ├── binaryop.cc
│ ├── colloid.cc
│ ├── compiler/
│ │ ├── Makefile
│ │ ├── Makefile-prog.am
│ │ ├── README
│ │ ├── eqn.tex
│ │ ├── hatom
│ │ ├── hatompolar
│ │ ├── he2el
│ │ ├── hehf
│ │ ├── hehf2
│ │ ├── mra-driver.cc
│ │ ├── mra-driver.hh
│ │ ├── mra.cc
│ │ ├── mra.ll
│ │ ├── mra.yy
│ │ └── qa
│ ├── csqrt.cc
│ ├── dataloadbal.cc
│ ├── density_smoothing.cc
│ ├── derivatives.cc
│ ├── dielectric.cc
│ ├── dielectric_external_field.cc
│ ├── dirac-hatom.cc
│ ├── functionio.cc
│ ├── gaussian.cc
│ ├── graveyard
│ ├── gygi_soltion.cc
│ ├── h2.cc
│ ├── h2dft.cc
│ ├── h2dynamic.cc
│ ├── hatom.cc
│ ├── hatom_1d.cc
│ ├── hatom_energy.cc
│ ├── hatom_sf_dirac.cc
│ ├── he.cc
│ ├── heat.cc
│ ├── heat2.cc
│ ├── hedft.cc
│ ├── hefxc.cc
│ ├── hehf.cc
│ ├── helium_exact.cc
│ ├── helium_mp2.cc
│ ├── hello.cc
│ ├── input_tdhf_virtuals
│ ├── madinfo.cc
│ ├── molecularmask.h
│ ├── molecularsurface.cc
│ ├── navstokes_cosines.cc
│ ├── newsolver.cc
│ ├── newsolver_lda.cc
│ ├── nonlinschro.cc
│ ├── pcr.cc
│ ├── periodic/
│ │ ├── CMakeLists.txt
│ │ ├── erfcr.cc
│ │ ├── test.cc
│ │ ├── testfilter.cc
│ │ ├── testfuns.cc
│ │ ├── testpc.h
│ │ └── testpercoul.cc
│ ├── ploterr.cc
│ ├── sdf_shape_tester.cc
│ ├── siam_example.cc
│ ├── sininteg.cc
│ ├── smooth
│ ├── smooth.h
│ ├── spectralprop.h
│ ├── svpe.cc
│ ├── tdhf_input
│ ├── tdse1d.cc
│ ├── tdse_example.cc
│ ├── test_derivative.cc
│ ├── test_gmres.cc
│ ├── testcomplexfunctionsolver.cc
│ ├── testspectralprop.cc
│ ├── testttg.cc
│ ├── tiny.cc
│ ├── vnucso.cc
│ ├── vtk.cc
│ ├── writecoeff.cc
│ ├── writecoeff2.cc
│ └── writecoeffs/
│ ├── CMakeLists.txt
│ ├── FunctionIO.h
│ ├── FunctionIO2.h
│ ├── FunctionIOHDF5.h
│ ├── app.cpp
│ ├── core.cpp
│ ├── core.hpp
│ ├── h2_write.cc
│ ├── h2_write_json.cc
│ ├── h2_write_json_2.cc
│ ├── h5cpp_test.cc
│ ├── writecoeff.cc
│ ├── writecoeff2.cc
│ ├── writecoeff3.cc
│ ├── writecoeff_hdf5.cc
│ └── writecoeff_json.cc
├── madchem.h
├── madness/
│ ├── CMakeLists.txt
│ ├── chem/
│ │ ├── 3-21g
│ │ ├── 6-31g
│ │ ├── 6-31gss
│ │ ├── AC.cc
│ │ ├── AC.h
│ │ ├── Applications.hpp
│ │ ├── BSHApply.h
│ │ ├── CC2.cc
│ │ ├── CC2.h
│ │ ├── CCLib.hpp
│ │ ├── CCParameters.h
│ │ ├── CCPotentials.cc
│ │ ├── CCPotentials.h
│ │ ├── CCStructures.cc
│ │ ├── CCStructures.h
│ │ ├── CMakeLists.txt
│ │ ├── CalculationParameters.h
│ │ ├── Drivers.hpp
│ │ ├── ESInterface.h
│ │ ├── GuessFactory.cc
│ │ ├── GuessFactory.h
│ │ ├── InputWriter.cpp
│ │ ├── InputWriter.hpp
│ │ ├── IntegratorXX.h
│ │ ├── MoldftLib.hpp
│ │ ├── MolecularOrbitals.cc
│ │ ├── MolecularOrbitals.h
│ │ ├── MolresponseLib.hpp
│ │ ├── NWChem.cc
│ │ ├── NWChem.h
│ │ ├── PNO.cpp
│ │ ├── PNO.h
│ │ ├── PNOF12Potentials.cpp
│ │ ├── PNOF12Potentials.h
│ │ ├── PNOGuessFunctions.cpp
│ │ ├── PNOGuessFunctions.h
│ │ ├── PNOParameters.cpp
│ │ ├── PNOParameters.h
│ │ ├── PNOStructures.cpp
│ │ ├── PNOStructures.h
│ │ ├── PNOTensors.h
│ │ ├── ParameterManager.hpp
│ │ ├── PathManager.hpp
│ │ ├── QCPropertyInterface.h
│ │ ├── ResponseParameters.hpp
│ │ ├── Results.h
│ │ ├── SAP.cc
│ │ ├── SAP.h
│ │ ├── SCF.cc
│ │ ├── SCF.h
│ │ ├── SCFOperators.cc
│ │ ├── SCFOperators.h
│ │ ├── SCFProtocol.h
│ │ ├── SCFTargetAdapter.hpp
│ │ ├── TDHF.cc
│ │ ├── TDHF.h
│ │ ├── atomutil.cc
│ │ ├── atomutil.h
│ │ ├── aug-cc-pvdz
│ │ ├── basis.h
│ │ ├── benchmark_exchange_operator.cc
│ │ ├── ccpairfunction.cc
│ │ ├── ccpairfunction.h
│ │ ├── cis_example_input
│ │ ├── coredata/
│ │ │ ├── mcp
│ │ │ ├── mcp2
│ │ │ ├── mcp2_guess
│ │ │ └── mcp_guess
│ │ ├── corepotential.cc
│ │ ├── corepotential.h
│ │ ├── correlationfactor.cc
│ │ ├── correlationfactor.h
│ │ ├── def2-SVP
│ │ ├── diamagneticpotentialfactor.cc
│ │ ├── diamagneticpotentialfactor.h
│ │ ├── distpm.cc
│ │ ├── distpm.h
│ │ ├── electronic_correlation_factor.h
│ │ ├── exchangeoperator.cc
│ │ ├── exchangeoperator.h
│ │ ├── gaussian.cc
│ │ ├── gaussian.h
│ │ ├── gth_pseudopotential.cc
│ │ ├── gth_pseudopotential.h
│ │ ├── lda.cc
│ │ ├── localizer.cc
│ │ ├── localizer.h
│ │ ├── lowrankfunction.h
│ │ ├── masks_and_boxes.h
│ │ ├── molecular_functors.h
│ │ ├── molecular_optimizer.h
│ │ ├── molecularbasis.cc
│ │ ├── molecularbasis.h
│ │ ├── molecule.cc
│ │ ├── molecule.h
│ │ ├── molopt.h
│ │ ├── mp2.cc
│ │ ├── mp2.h
│ │ ├── mp3.cc
│ │ ├── mp3.h
│ │ ├── nemo.cc
│ │ ├── nemo.h
│ │ ├── oep.cc
│ │ ├── oep.h
│ │ ├── pcm.cc
│ │ ├── pcm.h
│ │ ├── plotxc.cc
│ │ ├── pointgroupoperator.h
│ │ ├── pointgroupsymmetry.cc
│ │ ├── pointgroupsymmetry.h
│ │ ├── polynomial.cc
│ │ ├── polynomial.h
│ │ ├── potentialmanager.cc
│ │ ├── potentialmanager.h
│ │ ├── projector.h
│ │ ├── sto-3g
│ │ ├── sto-6g
│ │ ├── structure_library
│ │ ├── test_BSHApply.cc
│ │ ├── test_IntegratorXX.cc
│ │ ├── test_MolecularOrbitals.cc
│ │ ├── test_SCFOperators.cc
│ │ ├── test_ccpairfunction.cc
│ │ ├── test_dft.cc
│ │ ├── test_exchangeoperator.cc
│ │ ├── test_localizer.cc
│ │ ├── test_low_rank_function.cc
│ │ ├── test_masks_and_boxes.cc
│ │ ├── test_pointgroupsymmetry.cc
│ │ ├── test_projector.cc
│ │ ├── test_qc.cc
│ │ ├── testlda.cc
│ │ ├── testxc.cc
│ │ ├── vibanal.cc
│ │ ├── vibanal.h
│ │ ├── write_test_input.h
│ │ ├── xcfunctional.h
│ │ ├── xcfunctional_ldaonly.cc
│ │ ├── xcfunctional_libxc.cc
│ │ ├── zcis.cc
│ │ ├── zcis.h
│ │ ├── znemo.cc
│ │ └── znemo.h
│ ├── constants.h
│ ├── external/
│ │ ├── CMakeLists.txt
│ │ ├── catch/
│ │ │ └── catch.hpp
│ │ ├── elemental/
│ │ │ ├── AUTHORS
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE
│ │ │ ├── PUBLICATIONS.bib
│ │ │ ├── README.md
│ │ │ ├── REFERENCES.bib
│ │ │ ├── TODO
│ │ │ ├── cmake/
│ │ │ │ ├── ElemSub.cmake
│ │ │ │ ├── ElemVars.cmake
│ │ │ │ ├── README.md
│ │ │ │ ├── config.h.cmake
│ │ │ │ ├── tests/
│ │ │ │ │ ├── CXX.cmake
│ │ │ │ │ ├── Fortran.cmake
│ │ │ │ │ ├── MPI.cmake
│ │ │ │ │ ├── Math.cmake
│ │ │ │ │ ├── OpenMP.cmake
│ │ │ │ │ └── Qt5.cmake
│ │ │ │ └── toolchains/
│ │ │ │ ├── BGQ-Mira-clang-essl.cmake
│ │ │ │ ├── BGQ-Vesta-clang-essl.cmake
│ │ │ │ ├── BGQ-Vesta-clang-netlib.cmake
│ │ │ │ ├── BGQ-Vesta-gnu-essl.cmake
│ │ │ │ ├── BGQ-Vesta-gnu-netlib.cmake
│ │ │ │ ├── Edison-gnu-mpich-libsci.cmake
│ │ │ │ ├── Hopper-gnu-mpich2-libsci.cmake
│ │ │ │ ├── Lonestar-intel-mvapich2-mkl.cmake
│ │ │ │ ├── Longhorn-intel-mvapich2-mkl.cmake
│ │ │ │ ├── README.md
│ │ │ │ ├── Ranger-gnu-mvapich-mkl.cmake
│ │ │ │ ├── Ranger-gnu-mvapich2-mkl.cmake
│ │ │ │ ├── Ranger-intel-mvapich-mkl.cmake
│ │ │ │ ├── Ranger-intel-mvapich2-mkl.cmake
│ │ │ │ ├── Stampede-gnu-mvapich2-mkl.cmake
│ │ │ │ └── Stampede-intel-mvapich2-mkl.cmake
│ │ │ ├── examples/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── Cannon.cpp
│ │ │ │ │ ├── Gemm.cpp
│ │ │ │ │ ├── Gemv.cpp
│ │ │ │ │ └── README.md
│ │ │ │ ├── convex/
│ │ │ │ │ ├── BasisPursuit.cpp
│ │ │ │ │ ├── LinearProgram.cpp
│ │ │ │ │ ├── LogDetDiv.cpp
│ │ │ │ │ ├── QuadraticProgram.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── RPCA.cpp
│ │ │ │ │ └── SparseInvCov.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── Arbitrary.cpp
│ │ │ │ │ ├── Constructors.cpp
│ │ │ │ │ ├── LogicError.cpp
│ │ │ │ │ └── README.md
│ │ │ │ ├── io/
│ │ │ │ │ ├── Read.cpp
│ │ │ │ │ └── Write.cpp
│ │ │ │ ├── lapack-like/
│ │ │ │ │ ├── BunchKaufman.cpp
│ │ │ │ │ ├── BusingerGolub.cpp
│ │ │ │ │ ├── ChunkedPseudospectrum.cpp
│ │ │ │ │ ├── ChunkedTriangularPseudospectrum.cpp
│ │ │ │ │ ├── ComplexHermitianFunction.cpp
│ │ │ │ │ ├── GLM.cpp
│ │ │ │ │ ├── GaussianElimination.cpp
│ │ │ │ │ ├── HPDInverse.cpp
│ │ │ │ │ ├── HPSDCholesky.cpp
│ │ │ │ │ ├── HPSDSquareRoot.cpp
│ │ │ │ │ ├── HermitianEig.cpp
│ │ │ │ │ ├── HermitianEigFromSequential.cpp
│ │ │ │ │ ├── HermitianPseudoinverse.cpp
│ │ │ │ │ ├── HermitianQDWH.cpp
│ │ │ │ │ ├── HermitianSDC.cpp
│ │ │ │ │ ├── HermitianSVD.cpp
│ │ │ │ │ ├── ID.cpp
│ │ │ │ │ ├── KyFanAndSchatten.cpp
│ │ │ │ │ ├── LDL.cpp
│ │ │ │ │ ├── LDLInverse.cpp
│ │ │ │ │ ├── LSE.cpp
│ │ │ │ │ ├── LeastSquares.cpp
│ │ │ │ │ ├── Polar.cpp
│ │ │ │ │ ├── Pseudoinverse.cpp
│ │ │ │ │ ├── Pseudospectrum.cpp
│ │ │ │ │ ├── QDWH.cpp
│ │ │ │ │ ├── QR.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── RealHermitianFunction.cpp
│ │ │ │ │ ├── RealSchur.cpp
│ │ │ │ │ ├── RealSymmetricFunction.cpp
│ │ │ │ │ ├── SVD.cpp
│ │ │ │ │ ├── Schur.cpp
│ │ │ │ │ ├── SequentialBunchKaufman.cpp
│ │ │ │ │ ├── SequentialQR.cpp
│ │ │ │ │ ├── SequentialSVD.cpp
│ │ │ │ │ ├── Sign.cpp
│ │ │ │ │ ├── SimpleSVD.cpp
│ │ │ │ │ ├── Skeleton.cpp
│ │ │ │ │ ├── SkewHermitianEig.cpp
│ │ │ │ │ └── TriangularPseudospectrum.cpp
│ │ │ │ └── matrices/
│ │ │ │ ├── Cauchy.cpp
│ │ │ │ ├── CauchyLike.cpp
│ │ │ │ ├── Circulant.cpp
│ │ │ │ ├── Diagonal.cpp
│ │ │ │ ├── Egorov.cpp
│ │ │ │ ├── Fourier.cpp
│ │ │ │ ├── Hankel.cpp
│ │ │ │ ├── Helmholtz1D.cpp
│ │ │ │ ├── Helmholtz2D.cpp
│ │ │ │ ├── Helmholtz3D.cpp
│ │ │ │ ├── HermitianUniformSpectrum.cpp
│ │ │ │ ├── Hilbert.cpp
│ │ │ │ ├── Identity.cpp
│ │ │ │ ├── Kahan.cpp
│ │ │ │ ├── Legendre.cpp
│ │ │ │ ├── LehmerParterRis.cpp
│ │ │ │ ├── NormalUniformSpectrum.cpp
│ │ │ │ ├── OneTwoOne.cpp
│ │ │ │ ├── Ones.cpp
│ │ │ │ ├── PSFW.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── RiemannRedhefferGCD.cpp
│ │ │ │ ├── Toeplitz.cpp
│ │ │ │ ├── Uniform.cpp
│ │ │ │ ├── Walsh.cpp
│ │ │ │ ├── Wilkinson.cpp
│ │ │ │ └── Zeros.cpp
│ │ │ ├── experimental/
│ │ │ │ └── g3d/
│ │ │ │ └── G3DGemm.cpp
│ │ │ ├── external/
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── FindCXXFeatures/
│ │ │ │ │ │ ├── cxx11-auto.cxx
│ │ │ │ │ │ ├── cxx11-auto_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-class_override_final.cxx
│ │ │ │ │ │ ├── cxx11-class_override_final_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-constexpr.cxx
│ │ │ │ │ │ ├── cxx11-cstdint_header.cxx
│ │ │ │ │ │ ├── cxx11-decltype.cxx
│ │ │ │ │ │ ├── cxx11-defaulted_functions.cxx
│ │ │ │ │ │ ├── cxx11-delegating_constructors.cxx
│ │ │ │ │ │ ├── cxx11-deleted_functions.cxx
│ │ │ │ │ │ ├── cxx11-deleted_functions_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-func_identifier.cxx
│ │ │ │ │ │ ├── cxx11-initializer_list.cxx
│ │ │ │ │ │ ├── cxx11-lambda.cxx
│ │ │ │ │ │ ├── cxx11-long_long.cxx
│ │ │ │ │ │ ├── cxx11-nullptr.cxx
│ │ │ │ │ │ ├── cxx11-nullptr_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-rvalue_references.cxx
│ │ │ │ │ │ ├── cxx11-sizeof_member.cxx
│ │ │ │ │ │ ├── cxx11-static_assert.cxx
│ │ │ │ │ │ ├── cxx11-static_assert_fail_compile.cxx
│ │ │ │ │ │ └── cxx11-variadic_templates.cxx
│ │ │ │ │ ├── FindCXXFeatures.cmake
│ │ │ │ │ ├── FindNumPy.cmake
│ │ │ │ │ ├── FindValgrind.cmake
│ │ │ │ │ ├── GetGitRevisionDescription.cmake
│ │ │ │ │ ├── GetGitRevisionDescription.cmake.in
│ │ │ │ │ └── language_support_v2.cmake
│ │ │ │ └── pmrrr/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README
│ │ │ │ ├── include/
│ │ │ │ │ ├── counter.h
│ │ │ │ │ ├── global.h
│ │ │ │ │ ├── plarre.h
│ │ │ │ │ ├── plarrv.h
│ │ │ │ │ ├── pmrrr.h
│ │ │ │ │ ├── process_task.h
│ │ │ │ │ ├── queue.h
│ │ │ │ │ ├── rrr.h
│ │ │ │ │ ├── structs.h
│ │ │ │ │ └── tasks.h
│ │ │ │ └── src/
│ │ │ │ ├── blas/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── odcpy.c
│ │ │ │ │ ├── odscal.c
│ │ │ │ │ └── odswap.c
│ │ │ │ ├── counter.c
│ │ │ │ ├── lapack/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── ode2.c
│ │ │ │ │ ├── odebz.c
│ │ │ │ │ ├── odev2.c
│ │ │ │ │ ├── odnan.c
│ │ │ │ │ ├── odneg.c
│ │ │ │ │ ├── odnst.c
│ │ │ │ │ ├── odr1v.c
│ │ │ │ │ ├── odrnv.c
│ │ │ │ │ ├── odrra.c
│ │ │ │ │ ├── odrrb.c
│ │ │ │ │ ├── odrrc.c
│ │ │ │ │ ├── odrrd.c
│ │ │ │ │ ├── odrre.c
│ │ │ │ │ ├── odrrf.c
│ │ │ │ │ ├── odrrj.c
│ │ │ │ │ ├── odrrk.c
│ │ │ │ │ ├── odrrr.c
│ │ │ │ │ ├── odrrv.c
│ │ │ │ │ ├── odruv.c
│ │ │ │ │ ├── odset.c
│ │ │ │ │ ├── odsnan.c
│ │ │ │ │ ├── odsq2.c
│ │ │ │ │ ├── odsq3.c
│ │ │ │ │ ├── odsq4.c
│ │ │ │ │ ├── odsq5.c
│ │ │ │ │ ├── odsq6.c
│ │ │ │ │ ├── odsrt.c
│ │ │ │ │ ├── odssq.c
│ │ │ │ │ ├── odstmr.c
│ │ │ │ │ ├── oerbla.c
│ │ │ │ │ └── olsame.c
│ │ │ │ ├── plarre.c
│ │ │ │ ├── plarrv.c
│ │ │ │ ├── pmrrr.c
│ │ │ │ ├── pmrrr_dscal.c
│ │ │ │ ├── process_c_task.c
│ │ │ │ ├── process_r_task.c
│ │ │ │ ├── process_s_task.c
│ │ │ │ ├── queue.c
│ │ │ │ ├── rrr.c
│ │ │ │ └── tasks.c
│ │ │ ├── include/
│ │ │ │ ├── README.md
│ │ │ │ ├── elemental/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── blas-like/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── impl.hpp
│ │ │ │ │ │ ├── level1/
│ │ │ │ │ │ │ ├── Adjoint.hpp
│ │ │ │ │ │ │ ├── Axpy.hpp
│ │ │ │ │ │ │ ├── AxpyTriangle.hpp
│ │ │ │ │ │ │ ├── Conjugate.hpp
│ │ │ │ │ │ │ ├── Copy.hpp
│ │ │ │ │ │ │ ├── DiagonalScale.hpp
│ │ │ │ │ │ │ ├── DiagonalScaleTrapezoid.hpp
│ │ │ │ │ │ │ ├── DiagonalSolve.hpp
│ │ │ │ │ │ │ ├── Dot.hpp
│ │ │ │ │ │ │ ├── Dotu.hpp
│ │ │ │ │ │ │ ├── EntrywiseMap.hpp
│ │ │ │ │ │ │ ├── Hadamard.hpp
│ │ │ │ │ │ │ ├── HilbertSchmidt.hpp
│ │ │ │ │ │ │ ├── MakeHermitian.hpp
│ │ │ │ │ │ │ ├── MakeReal.hpp
│ │ │ │ │ │ │ ├── MakeSymmetric.hpp
│ │ │ │ │ │ │ ├── MakeTrapezoidal.hpp
│ │ │ │ │ │ │ ├── MakeTriangular.hpp
│ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ ├── MaxAbs.hpp
│ │ │ │ │ │ │ ├── Min.hpp
│ │ │ │ │ │ │ ├── MinAbs.hpp
│ │ │ │ │ │ │ ├── Nrm2.hpp
│ │ │ │ │ │ │ ├── QuasiDiagonalScale.hpp
│ │ │ │ │ │ │ ├── QuasiDiagonalSolve.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Scale.hpp
│ │ │ │ │ │ │ ├── ScaleTrapezoid.hpp
│ │ │ │ │ │ │ ├── SetDiagonal.hpp
│ │ │ │ │ │ │ ├── Swap.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Inv.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Scale.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Solve.hpp
│ │ │ │ │ │ │ ├── Transpose.hpp
│ │ │ │ │ │ │ ├── UpdateDiagonal.hpp
│ │ │ │ │ │ │ └── Zero.hpp
│ │ │ │ │ │ ├── level1.hpp
│ │ │ │ │ │ ├── level2/
│ │ │ │ │ │ │ ├── Gemv/
│ │ │ │ │ │ │ │ ├── N.hpp
│ │ │ │ │ │ │ │ └── T.hpp
│ │ │ │ │ │ │ ├── Gemv.hpp
│ │ │ │ │ │ │ ├── Ger.hpp
│ │ │ │ │ │ │ ├── Geru.hpp
│ │ │ │ │ │ │ ├── Hemv.hpp
│ │ │ │ │ │ │ ├── Her.hpp
│ │ │ │ │ │ │ ├── Her2.hpp
│ │ │ │ │ │ │ ├── QuasiTrsv/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── QuasiTrsv.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Symv/
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ └── U.hpp
│ │ │ │ │ │ │ ├── Symv.hpp
│ │ │ │ │ │ │ ├── Syr.hpp
│ │ │ │ │ │ │ ├── Syr2.hpp
│ │ │ │ │ │ │ ├── Trmv.hpp
│ │ │ │ │ │ │ ├── Trr.hpp
│ │ │ │ │ │ │ ├── Trr2.hpp
│ │ │ │ │ │ │ ├── Trsv/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ └── Trsv.hpp
│ │ │ │ │ │ ├── level2.hpp
│ │ │ │ │ │ ├── level3/
│ │ │ │ │ │ │ ├── Gemm/
│ │ │ │ │ │ │ │ ├── NN.hpp
│ │ │ │ │ │ │ │ ├── NT.hpp
│ │ │ │ │ │ │ │ ├── TN.hpp
│ │ │ │ │ │ │ │ └── TT.hpp
│ │ │ │ │ │ │ ├── Gemm.hpp
│ │ │ │ │ │ │ ├── Hemm.hpp
│ │ │ │ │ │ │ ├── Her2k.hpp
│ │ │ │ │ │ │ ├── Herk.hpp
│ │ │ │ │ │ │ ├── MultiShiftQuasiTrsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── MultiShiftQuasiTrsm.hpp
│ │ │ │ │ │ │ ├── MultiShiftTrsm/
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── MultiShiftTrsm.hpp
│ │ │ │ │ │ │ ├── QuasiTrsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── QuasiTrsm.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Symm/
│ │ │ │ │ │ │ │ ├── LL.hpp
│ │ │ │ │ │ │ │ ├── LU.hpp
│ │ │ │ │ │ │ │ ├── RL.hpp
│ │ │ │ │ │ │ │ └── RU.hpp
│ │ │ │ │ │ │ ├── Symm.hpp
│ │ │ │ │ │ │ ├── Syr2k/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── Syr2k.hpp
│ │ │ │ │ │ │ ├── Syrk/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── Syrk.hpp
│ │ │ │ │ │ │ ├── Trdtrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ └── Unblocked.hpp
│ │ │ │ │ │ │ ├── Trdtrmm.hpp
│ │ │ │ │ │ │ ├── Trmm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ ├── LUT.hpp
│ │ │ │ │ │ │ │ ├── RLN.hpp
│ │ │ │ │ │ │ │ ├── RLT.hpp
│ │ │ │ │ │ │ │ ├── RUN.hpp
│ │ │ │ │ │ │ │ └── RUT.hpp
│ │ │ │ │ │ │ ├── Trmm.hpp
│ │ │ │ │ │ │ ├── Trsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ ├── LUT.hpp
│ │ │ │ │ │ │ │ ├── RLN.hpp
│ │ │ │ │ │ │ │ ├── RLT.hpp
│ │ │ │ │ │ │ │ ├── RUN.hpp
│ │ │ │ │ │ │ │ └── RUT.hpp
│ │ │ │ │ │ │ ├── Trsm.hpp
│ │ │ │ │ │ │ ├── Trstrm/
│ │ │ │ │ │ │ │ └── LLN.hpp
│ │ │ │ │ │ │ ├── Trstrm.hpp
│ │ │ │ │ │ │ ├── Trtrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ └── Unblocked.hpp
│ │ │ │ │ │ │ ├── Trtrmm.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar4.hpp
│ │ │ │ │ │ │ │ ├── LVar5.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar4.hpp
│ │ │ │ │ │ │ │ └── UVar5.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrmm.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrsm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ ├── LVar4.hpp
│ │ │ │ │ │ │ │ ├── LVar5.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar3.hpp
│ │ │ │ │ │ │ │ ├── UVar4.hpp
│ │ │ │ │ │ │ │ └── UVar5.hpp
│ │ │ │ │ │ │ └── TwoSidedTrsm.hpp
│ │ │ │ │ │ └── level3.hpp
│ │ │ │ │ ├── blas-like.hpp
│ │ │ │ │ ├── config-internal.h
│ │ │ │ │ ├── control/
│ │ │ │ │ │ ├── Lyapunov.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Ricatti.hpp
│ │ │ │ │ │ ├── Sylvester.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── control.hpp
│ │ │ │ │ ├── convex/
│ │ │ │ │ │ ├── BasisPursuit.hpp
│ │ │ │ │ │ ├── Clip.hpp
│ │ │ │ │ │ ├── Covariance.hpp
│ │ │ │ │ │ ├── LinearProgram.hpp
│ │ │ │ │ │ ├── LogBarrier.hpp
│ │ │ │ │ │ ├── LogDetDiv.hpp
│ │ │ │ │ │ ├── QuadraticProgram.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── SVT/
│ │ │ │ │ │ │ ├── Cross.hpp
│ │ │ │ │ │ │ ├── Normal.hpp
│ │ │ │ │ │ │ ├── PivotedQR.hpp
│ │ │ │ │ │ │ └── TSQR.hpp
│ │ │ │ │ │ ├── SVT.hpp
│ │ │ │ │ │ ├── SoftThreshold.hpp
│ │ │ │ │ │ ├── SparseInvCov.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── convex.hpp
│ │ │ │ │ ├── core/
│ │ │ │ │ │ ├── AxpyInterface/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── AxpyInterface.hpp
│ │ │ │ │ │ ├── BlockDistMatrix/
│ │ │ │ │ │ │ ├── Abstract.hpp
│ │ │ │ │ │ │ ├── CIRC_CIRC.hpp
│ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ ├── MC_MR.hpp
│ │ │ │ │ │ │ ├── MC_STAR.hpp
│ │ │ │ │ │ │ ├── MD_STAR.hpp
│ │ │ │ │ │ │ ├── MR_MC.hpp
│ │ │ │ │ │ │ ├── MR_STAR.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── STAR_MC.hpp
│ │ │ │ │ │ │ ├── STAR_MD.hpp
│ │ │ │ │ │ │ ├── STAR_MR.hpp
│ │ │ │ │ │ │ ├── STAR_STAR.hpp
│ │ │ │ │ │ │ ├── STAR_VC.hpp
│ │ │ │ │ │ │ ├── STAR_VR.hpp
│ │ │ │ │ │ │ ├── VC_STAR.hpp
│ │ │ │ │ │ │ ├── VR_STAR.hpp
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── BlockDistMatrix.hpp
│ │ │ │ │ │ ├── Complex/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── Complex.hpp
│ │ │ │ │ │ ├── DistMatrix/
│ │ │ │ │ │ │ ├── Abstract.hpp
│ │ │ │ │ │ │ ├── CIRC_CIRC.hpp
│ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ ├── MC_MR.hpp
│ │ │ │ │ │ │ ├── MC_STAR.hpp
│ │ │ │ │ │ │ ├── MD_STAR.hpp
│ │ │ │ │ │ │ ├── MR_MC.hpp
│ │ │ │ │ │ │ ├── MR_STAR.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── STAR_MC.hpp
│ │ │ │ │ │ │ ├── STAR_MD.hpp
│ │ │ │ │ │ │ ├── STAR_MR.hpp
│ │ │ │ │ │ │ ├── STAR_STAR.hpp
│ │ │ │ │ │ │ ├── STAR_VC.hpp
│ │ │ │ │ │ │ ├── STAR_VR.hpp
│ │ │ │ │ │ │ ├── VC_STAR.hpp
│ │ │ │ │ │ │ ├── VR_STAR.hpp
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── DistMatrix.hpp
│ │ │ │ │ │ ├── Grid/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── Matrix/
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── Matrix.hpp
│ │ │ │ │ │ ├── Memory.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Timer/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── environment/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── imports/
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── blas.hpp
│ │ │ │ │ │ │ ├── choice.hpp
│ │ │ │ │ │ │ ├── flame.hpp
│ │ │ │ │ │ │ ├── lapack.hpp
│ │ │ │ │ │ │ ├── mpi.hpp
│ │ │ │ │ │ │ ├── mpi_choice.hpp
│ │ │ │ │ │ │ ├── pmrrr.hpp
│ │ │ │ │ │ │ └── scalapack.hpp
│ │ │ │ │ │ ├── indexing/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── random/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── types/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ └── views/
│ │ │ │ │ │ ├── Partition.hpp
│ │ │ │ │ │ ├── Repartition.hpp
│ │ │ │ │ │ ├── SlidePartition.hpp
│ │ │ │ │ │ └── View.hpp
│ │ │ │ │ ├── core.hpp
│ │ │ │ │ ├── include-paths.hpp
│ │ │ │ │ ├── io/
│ │ │ │ │ │ ├── ComplexDisplayWindow-premoc.hpp
│ │ │ │ │ │ ├── Display.hpp
│ │ │ │ │ │ ├── DisplayWidget/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── DisplayWindow-premoc.hpp
│ │ │ │ │ │ ├── Print.hpp
│ │ │ │ │ │ ├── Read/
│ │ │ │ │ │ │ ├── Ascii.hpp
│ │ │ │ │ │ │ ├── AsciiMatlab.hpp
│ │ │ │ │ │ │ ├── Binary.hpp
│ │ │ │ │ │ │ ├── BinaryFlat.hpp
│ │ │ │ │ │ │ └── MatrixMarket.hpp
│ │ │ │ │ │ ├── Read.hpp
│ │ │ │ │ │ ├── Spy.hpp
│ │ │ │ │ │ ├── SpyWidget/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── SpyWindow/
│ │ │ │ │ │ │ └── decl.hpp
│ │ │ │ │ │ ├── Write/
│ │ │ │ │ │ │ ├── Ascii.hpp
│ │ │ │ │ │ │ ├── AsciiMatlab.hpp
│ │ │ │ │ │ │ ├── Binary.hpp
│ │ │ │ │ │ │ ├── BinaryFlat.hpp
│ │ │ │ │ │ │ ├── Image.hpp
│ │ │ │ │ │ │ └── MatrixMarket.hpp
│ │ │ │ │ │ ├── Write.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── lapack-like/
│ │ │ │ │ │ ├── condense/
│ │ │ │ │ │ │ ├── Bidiag/
│ │ │ │ │ │ │ │ ├── Apply.hpp
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ │ │ │ ├── LUnb.hpp
│ │ │ │ │ │ │ │ ├── U.hpp
│ │ │ │ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ │ │ │ └── UUnb.hpp
│ │ │ │ │ │ │ ├── Bidiag.hpp
│ │ │ │ │ │ │ ├── HermitianTridiag/
│ │ │ │ │ │ │ │ └── ApplyQ.hpp
│ │ │ │ │ │ │ ├── HermitianTridiag.hpp
│ │ │ │ │ │ │ ├── Hessenberg/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ │ │ │ ├── LUnb.hpp
│ │ │ │ │ │ │ │ ├── U.hpp
│ │ │ │ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ │ │ │ └── UUnb.hpp
│ │ │ │ │ │ │ ├── Hessenberg.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── condense.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── decomp/
│ │ │ │ │ │ │ ├── HermitianEig/
│ │ │ │ │ │ │ │ └── SDC.hpp
│ │ │ │ │ │ │ ├── HermitianEig.hpp
│ │ │ │ │ │ │ ├── HermitianGenDefiniteEig.hpp
│ │ │ │ │ │ │ ├── HermitianTridiagEig/
│ │ │ │ │ │ │ │ └── Sort.hpp
│ │ │ │ │ │ │ ├── HermitianTridiagEig.hpp
│ │ │ │ │ │ │ ├── Polar/
│ │ │ │ │ │ │ │ ├── QDWH.hpp
│ │ │ │ │ │ │ │ └── SVD.hpp
│ │ │ │ │ │ │ ├── Polar.hpp
│ │ │ │ │ │ │ ├── SVD/
│ │ │ │ │ │ │ │ ├── Chan.hpp
│ │ │ │ │ │ │ │ ├── GolubReinsch.hpp
│ │ │ │ │ │ │ │ ├── Thresholded.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── SVD.hpp
│ │ │ │ │ │ │ ├── Schur/
│ │ │ │ │ │ │ │ ├── CheckReal.hpp
│ │ │ │ │ │ │ │ ├── InverseFreeSDC.hpp
│ │ │ │ │ │ │ │ ├── QR.hpp
│ │ │ │ │ │ │ │ ├── QuasiTriangEig.hpp
│ │ │ │ │ │ │ │ ├── RealToComplex.hpp
│ │ │ │ │ │ │ │ └── SDC.hpp
│ │ │ │ │ │ │ ├── Schur.hpp
│ │ │ │ │ │ │ ├── SkewHermitianEig.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── decomp.hpp
│ │ │ │ │ │ ├── factor/
│ │ │ │ │ │ │ ├── Cholesky/
│ │ │ │ │ │ │ │ ├── LMod.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ ├── LVar3Pivoted.hpp
│ │ │ │ │ │ │ │ ├── LVar3Square.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ ├── UMod.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar3.hpp
│ │ │ │ │ │ │ │ ├── UVar3Pivoted.hpp
│ │ │ │ │ │ │ │ └── UVar3Square.hpp
│ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ ├── GQR.hpp
│ │ │ │ │ │ │ ├── GRQ.hpp
│ │ │ │ │ │ │ ├── ID.hpp
│ │ │ │ │ │ │ ├── LDL/
│ │ │ │ │ │ │ │ ├── Inertia.hpp
│ │ │ │ │ │ │ │ ├── MultiplyAfter.hpp
│ │ │ │ │ │ │ │ ├── Pivoted.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ └── Var3.hpp
│ │ │ │ │ │ │ ├── LDL.hpp
│ │ │ │ │ │ │ ├── LQ/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── Explicit.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── LQ.hpp
│ │ │ │ │ │ │ ├── LU/
│ │ │ │ │ │ │ │ ├── Full.hpp
│ │ │ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ │ │ ├── Mod.hpp
│ │ │ │ │ │ │ │ ├── Panel.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── LU.hpp
│ │ │ │ │ │ │ ├── QR/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── BusingerGolub.hpp
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ ├── Explicit.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ └── TS.hpp
│ │ │ │ │ │ │ ├── QR.hpp
│ │ │ │ │ │ │ ├── RQ/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── RQ.hpp
│ │ │ │ │ │ │ ├── Skeleton.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── factor.hpp
│ │ │ │ │ │ ├── funcs/
│ │ │ │ │ │ │ ├── HermitianFunction.hpp
│ │ │ │ │ │ │ ├── Inverse/
│ │ │ │ │ │ │ │ ├── General/
│ │ │ │ │ │ │ │ │ └── LUPartialPiv.hpp
│ │ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ │ ├── HPD/
│ │ │ │ │ │ │ │ │ ├── CholeskyLVar2.hpp
│ │ │ │ │ │ │ │ │ └── CholeskyUVar2.hpp
│ │ │ │ │ │ │ │ ├── HPD.hpp
│ │ │ │ │ │ │ │ ├── Hermitian.hpp
│ │ │ │ │ │ │ │ ├── Symmetric.hpp
│ │ │ │ │ │ │ │ ├── Triangular/
│ │ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ │ └── UVar3.hpp
│ │ │ │ │ │ │ │ ├── Triangular.hpp
│ │ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ │ ├── Inverse.hpp
│ │ │ │ │ │ │ ├── Pseudoinverse.hpp
│ │ │ │ │ │ │ ├── Sign.hpp
│ │ │ │ │ │ │ ├── SquareRoot.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── funcs.hpp
│ │ │ │ │ │ ├── impl.hpp
│ │ │ │ │ │ ├── perm/
│ │ │ │ │ │ │ ├── ApplyColPivots.hpp
│ │ │ │ │ │ │ ├── ApplyRowPivots.hpp
│ │ │ │ │ │ │ ├── ApplySymmetricPivots.hpp
│ │ │ │ │ │ │ ├── ExplicitPermutation.hpp
│ │ │ │ │ │ │ ├── InvertPermutation.hpp
│ │ │ │ │ │ │ ├── PermutationMeta.hpp
│ │ │ │ │ │ │ ├── PermuteCols.hpp
│ │ │ │ │ │ │ ├── PermuteRows.hpp
│ │ │ │ │ │ │ ├── PivotsToPartialPermutation.hpp
│ │ │ │ │ │ │ ├── PivotsToPermutation.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── perm.hpp
│ │ │ │ │ │ ├── props/
│ │ │ │ │ │ │ ├── Condition/
│ │ │ │ │ │ │ │ ├── Frobenius.hpp
│ │ │ │ │ │ │ │ ├── Infinity.hpp
│ │ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ │ ├── One.hpp
│ │ │ │ │ │ │ │ └── Two.hpp
│ │ │ │ │ │ │ ├── Condition.hpp
│ │ │ │ │ │ │ ├── Determinant/
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ └── LUPartialPiv.hpp
│ │ │ │ │ │ │ ├── Determinant.hpp
│ │ │ │ │ │ │ ├── Inertia.hpp
│ │ │ │ │ │ │ ├── Norm/
│ │ │ │ │ │ │ │ ├── Entrywise.hpp
│ │ │ │ │ │ │ │ ├── EntrywiseOne.hpp
│ │ │ │ │ │ │ │ ├── Frobenius.hpp
│ │ │ │ │ │ │ │ ├── Infinity.hpp
│ │ │ │ │ │ │ │ ├── KyFan.hpp
│ │ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ │ ├── Nuclear.hpp
│ │ │ │ │ │ │ │ ├── One.hpp
│ │ │ │ │ │ │ │ ├── Schatten.hpp
│ │ │ │ │ │ │ │ ├── Two.hpp
│ │ │ │ │ │ │ │ ├── TwoEstimate.hpp
│ │ │ │ │ │ │ │ └── Zero.hpp
│ │ │ │ │ │ │ ├── Norm.hpp
│ │ │ │ │ │ │ ├── Pseudospectrum/
│ │ │ │ │ │ │ │ ├── Analytic.hpp
│ │ │ │ │ │ │ │ ├── IRA.hpp
│ │ │ │ │ │ │ │ ├── IRL.hpp
│ │ │ │ │ │ │ │ ├── Lanczos.hpp
│ │ │ │ │ │ │ │ ├── Power.hpp
│ │ │ │ │ │ │ │ ├── Util/
│ │ │ │ │ │ │ │ │ ├── BasicMath.hpp
│ │ │ │ │ │ │ │ │ ├── Rearrange.hpp
│ │ │ │ │ │ │ │ │ └── Snapshot.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── Pseudospectrum.hpp
│ │ │ │ │ │ │ ├── Trace.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── props.hpp
│ │ │ │ │ │ ├── solve/
│ │ │ │ │ │ │ ├── GLM.hpp
│ │ │ │ │ │ │ ├── GaussianElimination.hpp
│ │ │ │ │ │ │ ├── HPDSolve.hpp
│ │ │ │ │ │ │ ├── HermitianSolve.hpp
│ │ │ │ │ │ │ ├── LSE.hpp
│ │ │ │ │ │ │ ├── LeastSquares.hpp
│ │ │ │ │ │ │ ├── MultiShiftHessSolve.hpp
│ │ │ │ │ │ │ ├── SymmetricSolve.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── solve.hpp
│ │ │ │ │ │ ├── util/
│ │ │ │ │ │ │ ├── ApplyPackedReflectors/
│ │ │ │ │ │ │ │ ├── LLHB.hpp
│ │ │ │ │ │ │ │ ├── LLHF.hpp
│ │ │ │ │ │ │ │ ├── LLVB.hpp
│ │ │ │ │ │ │ │ ├── LLVF.hpp
│ │ │ │ │ │ │ │ ├── LUHB.hpp
│ │ │ │ │ │ │ │ ├── LUHF.hpp
│ │ │ │ │ │ │ │ ├── LUVB.hpp
│ │ │ │ │ │ │ │ ├── LUVF.hpp
│ │ │ │ │ │ │ │ ├── RLHB.hpp
│ │ │ │ │ │ │ │ ├── RLHF.hpp
│ │ │ │ │ │ │ │ ├── RLVB.hpp
│ │ │ │ │ │ │ │ ├── RLVF.hpp
│ │ │ │ │ │ │ │ ├── RUHB.hpp
│ │ │ │ │ │ │ │ ├── RUHF.hpp
│ │ │ │ │ │ │ │ ├── RUVB.hpp
│ │ │ │ │ │ │ │ ├── RUVF.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── ApplyPackedReflectors.hpp
│ │ │ │ │ │ │ ├── ExpandPackedReflectors/
│ │ │ │ │ │ │ │ └── LV.hpp
│ │ │ │ │ │ │ ├── ExpandPackedReflectors.hpp
│ │ │ │ │ │ │ ├── HyperbolicReflector/
│ │ │ │ │ │ │ │ ├── Col.hpp
│ │ │ │ │ │ │ │ └── Row.hpp
│ │ │ │ │ │ │ ├── HyperbolicReflector.hpp
│ │ │ │ │ │ │ ├── Median.hpp
│ │ │ │ │ │ │ ├── PermutationParity.hpp
│ │ │ │ │ │ │ ├── PivotParity.hpp
│ │ │ │ │ │ │ ├── Reflector/
│ │ │ │ │ │ │ │ ├── Col.hpp
│ │ │ │ │ │ │ │ └── Row.hpp
│ │ │ │ │ │ │ ├── Reflector.hpp
│ │ │ │ │ │ │ ├── Sort.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ └── util.hpp
│ │ │ │ │ ├── lapack-like.hpp
│ │ │ │ │ ├── matrices/
│ │ │ │ │ │ ├── BullsHead.hpp
│ │ │ │ │ │ ├── Cauchy.hpp
│ │ │ │ │ │ ├── CauchyLike.hpp
│ │ │ │ │ │ ├── Circulant.hpp
│ │ │ │ │ │ ├── Demmel.hpp
│ │ │ │ │ │ ├── Diagonal.hpp
│ │ │ │ │ │ ├── Egorov.hpp
│ │ │ │ │ │ ├── ExtendedKahan.hpp
│ │ │ │ │ │ ├── Fiedler.hpp
│ │ │ │ │ │ ├── Forsythe.hpp
│ │ │ │ │ │ ├── Fourier.hpp
│ │ │ │ │ │ ├── FoxLi.hpp
│ │ │ │ │ │ ├── GCDMatrix.hpp
│ │ │ │ │ │ ├── GKS.hpp
│ │ │ │ │ │ ├── Gaussian.hpp
│ │ │ │ │ │ ├── Gear.hpp
│ │ │ │ │ │ ├── Grcar.hpp
│ │ │ │ │ │ ├── Haar.hpp
│ │ │ │ │ │ ├── Hankel.hpp
│ │ │ │ │ │ ├── Hanowa.hpp
│ │ │ │ │ │ ├── HatanoNelson.hpp
│ │ │ │ │ │ ├── Helmholtz.hpp
│ │ │ │ │ │ ├── HelmholtzPML.hpp
│ │ │ │ │ │ ├── HermitianFromEVD.hpp
│ │ │ │ │ │ ├── HermitianUniformSpectrum.hpp
│ │ │ │ │ │ ├── Hilbert.hpp
│ │ │ │ │ │ ├── Identity.hpp
│ │ │ │ │ │ ├── Jordan.hpp
│ │ │ │ │ │ ├── KMS.hpp
│ │ │ │ │ │ ├── Kahan.hpp
│ │ │ │ │ │ ├── Laplacian.hpp
│ │ │ │ │ │ ├── Lauchli.hpp
│ │ │ │ │ │ ├── Legendre.hpp
│ │ │ │ │ │ ├── Lehmer.hpp
│ │ │ │ │ │ ├── Lotkin.hpp
│ │ │ │ │ │ ├── MinIJ.hpp
│ │ │ │ │ │ ├── NormalFromEVD.hpp
│ │ │ │ │ │ ├── NormalUniformSpectrum.hpp
│ │ │ │ │ │ ├── OneTwoOne.hpp
│ │ │ │ │ │ ├── Ones.hpp
│ │ │ │ │ │ ├── Parter.hpp
│ │ │ │ │ │ ├── Pei.hpp
│ │ │ │ │ │ ├── Redheffer.hpp
│ │ │ │ │ │ ├── Riemann.hpp
│ │ │ │ │ │ ├── Ris.hpp
│ │ │ │ │ │ ├── Toeplitz.hpp
│ │ │ │ │ │ ├── Trefethen.hpp
│ │ │ │ │ │ ├── TriW.hpp
│ │ │ │ │ │ ├── Triangle.hpp
│ │ │ │ │ │ ├── Uniform.hpp
│ │ │ │ │ │ ├── UniformHelmholtzGreens.hpp
│ │ │ │ │ │ ├── Walsh.hpp
│ │ │ │ │ │ ├── Whale.hpp
│ │ │ │ │ │ ├── Wigner.hpp
│ │ │ │ │ │ ├── Wilkinson.hpp
│ │ │ │ │ │ ├── Zeros.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ └── matrices.hpp
│ │ │ │ ├── elemental-lite.hpp
│ │ │ │ └── elemental.hpp
│ │ │ ├── octave/
│ │ │ │ ├── LUMod.m
│ │ │ │ ├── LUModDriver.m
│ │ │ │ ├── LUModSimple.m
│ │ │ │ └── LUModSimpleDriver.m
│ │ │ ├── src/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── Trr2k/
│ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ ├── NNNN.hpp
│ │ │ │ │ │ ├── NNNT.hpp
│ │ │ │ │ │ ├── NNTN.hpp
│ │ │ │ │ │ ├── NNTT.hpp
│ │ │ │ │ │ ├── NTNN.hpp
│ │ │ │ │ │ ├── NTNT.hpp
│ │ │ │ │ │ ├── NTTN.hpp
│ │ │ │ │ │ ├── NTTT.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── TNNN.hpp
│ │ │ │ │ │ ├── TNNT.hpp
│ │ │ │ │ │ ├── TNTN.hpp
│ │ │ │ │ │ ├── TNTT.hpp
│ │ │ │ │ │ ├── TTNN.hpp
│ │ │ │ │ │ ├── TTNT.hpp
│ │ │ │ │ │ ├── TTTN.hpp
│ │ │ │ │ │ └── TTTT.hpp
│ │ │ │ │ ├── Trr2k.cpp
│ │ │ │ │ ├── Trrk/
│ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ ├── NN.hpp
│ │ │ │ │ │ ├── NT.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── TN.hpp
│ │ │ │ │ │ └── TT.hpp
│ │ │ │ │ └── Trrk.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── BlockDistMatrix/
│ │ │ │ │ │ ├── Abstract.cpp
│ │ │ │ │ │ ├── CIRC_CIRC.cpp
│ │ │ │ │ │ ├── General.cpp
│ │ │ │ │ │ ├── MC_MR.cpp
│ │ │ │ │ │ ├── MC_STAR.cpp
│ │ │ │ │ │ ├── MD_STAR.cpp
│ │ │ │ │ │ ├── MR_MC.cpp
│ │ │ │ │ │ ├── MR_STAR.cpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── STAR_MC.cpp
│ │ │ │ │ │ ├── STAR_MD.cpp
│ │ │ │ │ │ ├── STAR_MR.cpp
│ │ │ │ │ │ ├── STAR_STAR.cpp
│ │ │ │ │ │ ├── STAR_VC.cpp
│ │ │ │ │ │ ├── STAR_VR.cpp
│ │ │ │ │ │ ├── VC_STAR.cpp
│ │ │ │ │ │ ├── VR_STAR.cpp
│ │ │ │ │ │ └── setup.hpp
│ │ │ │ │ ├── DistMatrix/
│ │ │ │ │ │ ├── Abstract.cpp
│ │ │ │ │ │ ├── CIRC_CIRC.cpp
│ │ │ │ │ │ ├── General.cpp
│ │ │ │ │ │ ├── MC_MR.cpp
│ │ │ │ │ │ ├── MC_STAR.cpp
│ │ │ │ │ │ ├── MD_STAR.cpp
│ │ │ │ │ │ ├── MR_MC.cpp
│ │ │ │ │ │ ├── MR_STAR.cpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── STAR_MC.cpp
│ │ │ │ │ │ ├── STAR_MD.cpp
│ │ │ │ │ │ ├── STAR_MR.cpp
│ │ │ │ │ │ ├── STAR_STAR.cpp
│ │ │ │ │ │ ├── STAR_VC.cpp
│ │ │ │ │ │ ├── STAR_VR.cpp
│ │ │ │ │ │ ├── VC_STAR.cpp
│ │ │ │ │ │ ├── VR_STAR.cpp
│ │ │ │ │ │ └── setup.hpp
│ │ │ │ │ ├── Matrix.cpp
│ │ │ │ │ ├── Memory.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── global.cpp
│ │ │ │ │ ├── imports/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── blas.cpp
│ │ │ │ │ │ ├── flame.cpp
│ │ │ │ │ │ ├── lapack.cpp
│ │ │ │ │ │ ├── mpi.cpp
│ │ │ │ │ │ ├── pmrrr.cpp
│ │ │ │ │ │ └── scalapack.cpp
│ │ │ │ │ └── mpi_register.cpp
│ │ │ │ ├── io/
│ │ │ │ │ ├── ColorMap.cpp
│ │ │ │ │ ├── ComplexDisplayWindow.cpp
│ │ │ │ │ ├── DisplayWindow.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── SpyWindow.cpp
│ │ │ │ └── lapack-like/
│ │ │ │ ├── HermitianEig.cpp
│ │ │ │ ├── HermitianTridiag/
│ │ │ │ │ ├── L.hpp
│ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ ├── LPanSquare.hpp
│ │ │ │ │ ├── LSquare.hpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── U.hpp
│ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ ├── UPanSquare.hpp
│ │ │ │ │ └── USquare.hpp
│ │ │ │ ├── HermitianTridiag.cpp
│ │ │ │ └── README.md
│ │ │ ├── tests/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── Gemm.cpp
│ │ │ │ │ ├── Hemm.cpp
│ │ │ │ │ ├── Her2k.cpp
│ │ │ │ │ ├── Herk.cpp
│ │ │ │ │ ├── MultiShiftQuasiTrsm.cpp
│ │ │ │ │ ├── QuasiTrsm.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── Symm.cpp
│ │ │ │ │ ├── Symv.cpp
│ │ │ │ │ ├── Syr2k.cpp
│ │ │ │ │ ├── Syrk.cpp
│ │ │ │ │ ├── Trmm.cpp
│ │ │ │ │ ├── Trsm.cpp
│ │ │ │ │ ├── Trsv.cpp
│ │ │ │ │ ├── TwoSidedTrmm.cpp
│ │ │ │ │ └── TwoSidedTrsm.cpp
│ │ │ │ ├── convex/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── TSSVT.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── AxpyInterface.cpp
│ │ │ │ │ ├── BasicBlockDistMatrix.cpp
│ │ │ │ │ ├── BlockDistMatrix.cpp
│ │ │ │ │ ├── Constants.cpp
│ │ │ │ │ ├── DifferentGrids.cpp
│ │ │ │ │ ├── DistMatrix.cpp
│ │ │ │ │ ├── Matrix.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── Version.cpp
│ │ │ │ └── lapack-like/
│ │ │ │ ├── ApplyPackedReflectors.cpp
│ │ │ │ ├── Bidiag.cpp
│ │ │ │ ├── Cholesky.cpp
│ │ │ │ ├── CholeskyMod.cpp
│ │ │ │ ├── CholeskyQR.cpp
│ │ │ │ ├── HermitianEig.cpp
│ │ │ │ ├── HermitianGenDefiniteEig.cpp
│ │ │ │ ├── HermitianTridiag.cpp
│ │ │ │ ├── Hessenberg.cpp
│ │ │ │ ├── LDL.cpp
│ │ │ │ ├── LQ.cpp
│ │ │ │ ├── LU.cpp
│ │ │ │ ├── LUMod.cpp
│ │ │ │ ├── MultiShiftHessSolve.cpp
│ │ │ │ ├── QR.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── RQ.cpp
│ │ │ │ ├── SequentialBidiag.cpp
│ │ │ │ ├── SequentialCholeskyMod.cpp
│ │ │ │ ├── SequentialHessenberg.cpp
│ │ │ │ ├── SequentialLU.cpp
│ │ │ │ ├── SequentialMultiShiftHessSolve.cpp
│ │ │ │ ├── TSQR.cpp
│ │ │ │ └── TriangularInverse.cpp
│ │ │ └── vagrant/
│ │ │ ├── README.md
│ │ │ ├── saucy32/
│ │ │ │ ├── Vagrantfile
│ │ │ │ └── bootstrap.sh
│ │ │ └── saucy64/
│ │ │ ├── Vagrantfile
│ │ │ └── bootstrap.sh
│ │ ├── gtest/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── gtest-all.cc
│ │ │ ├── include/
│ │ │ │ └── gtest/
│ │ │ │ ├── gtest-death-test.h
│ │ │ │ ├── gtest-message.h
│ │ │ │ ├── gtest-param-test.h
│ │ │ │ ├── gtest-param-test.h.pump
│ │ │ │ ├── gtest-printers.h
│ │ │ │ ├── gtest-spi.h
│ │ │ │ ├── gtest-test-part.h
│ │ │ │ ├── gtest-typed-test.h
│ │ │ │ ├── gtest.h
│ │ │ │ ├── gtest_pred_impl.h
│ │ │ │ ├── gtest_prod.h
│ │ │ │ └── internal/
│ │ │ │ ├── gtest-death-test-internal.h
│ │ │ │ ├── gtest-filepath.h
│ │ │ │ ├── gtest-internal.h
│ │ │ │ ├── gtest-linked_ptr.h
│ │ │ │ ├── gtest-param-util-generated.h
│ │ │ │ ├── gtest-param-util-generated.h.pump
│ │ │ │ ├── gtest-param-util.h
│ │ │ │ ├── gtest-port.h
│ │ │ │ ├── gtest-string.h
│ │ │ │ ├── gtest-tuple.h
│ │ │ │ ├── gtest-tuple.h.pump
│ │ │ │ ├── gtest-type-util.h
│ │ │ │ └── gtest-type-util.h.pump
│ │ │ └── src/
│ │ │ ├── gtest-all.cc
│ │ │ ├── gtest-death-test.cc
│ │ │ ├── gtest-filepath.cc
│ │ │ ├── gtest-internal-inl.h
│ │ │ ├── gtest-port.cc
│ │ │ ├── gtest-printers.cc
│ │ │ ├── gtest-test-part.cc
│ │ │ ├── gtest-typed-test.cc
│ │ │ ├── gtest.cc
│ │ │ └── gtest_main.cc
│ │ ├── muParser/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── muParser.cpp
│ │ │ ├── muParser.h
│ │ │ ├── muParserBase.cpp
│ │ │ ├── muParserBase.h
│ │ │ ├── muParserBytecode.cpp
│ │ │ ├── muParserBytecode.h
│ │ │ ├── muParserCallback.cpp
│ │ │ ├── muParserCallback.h
│ │ │ ├── muParserComplex.h
│ │ │ ├── muParserDLL.h
│ │ │ ├── muParserDef.h
│ │ │ ├── muParserError.cpp
│ │ │ ├── muParserError.h
│ │ │ ├── muParserFixes.h
│ │ │ ├── muParserInt.h
│ │ │ ├── muParserStack.h
│ │ │ ├── muParserTest.h
│ │ │ ├── muParserToken.h
│ │ │ ├── muParserTokenReader.cpp
│ │ │ └── muParserTokenReader.h
│ │ ├── nlohmann_json/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── json.cc
│ │ │ └── json.hpp
│ │ └── tinyxml/
│ │ ├── CMakeLists.txt
│ │ ├── README
│ │ ├── readme.txt
│ │ ├── tinystr.cc
│ │ ├── tinystr.h
│ │ ├── tinyxml.cc
│ │ ├── tinyxml.h
│ │ ├── tinyxmlerror.cc
│ │ └── tinyxmlparser.cc
│ ├── fortran_ctypes.h
│ ├── madness.cc
│ ├── madness_config.h
│ ├── misc/
│ │ ├── CMakeLists.txt
│ │ ├── array_of_bools.h
│ │ ├── cfft.cc
│ │ ├── cfft.h
│ │ ├── checksum_file.cc
│ │ ├── gnuplot.h
│ │ ├── gprofexit.cc
│ │ ├── info.cc
│ │ ├── info.h
│ │ ├── interp3.cc
│ │ ├── interpolation_1d.h
│ │ ├── kahan_accumulator.h
│ │ ├── misc.h
│ │ ├── numerics.cc
│ │ ├── phandler.h
│ │ ├── position_stream.cc
│ │ ├── ran.cc
│ │ ├── ran.h
│ │ ├── test_gnuplot.cc
│ │ └── unique_filename.cc
│ ├── mra/
│ │ ├── CMakeLists.txt
│ │ ├── QCCalculationParametersBase.cc
│ │ ├── QCCalculationParametersBase.h
│ │ ├── adquad.h
│ │ ├── autocorr
│ │ ├── b-spline-deriv1.txt
│ │ ├── b-spline-deriv2.txt
│ │ ├── b-spline-deriv3.txt
│ │ ├── bc.h
│ │ ├── ble-first.txt
│ │ ├── ble-second.txt
│ │ ├── coeffs
│ │ ├── commandlineparser.h
│ │ ├── convolution1d.h
│ │ ├── derivative.h
│ │ ├── displacements.h
│ │ ├── funcdefaults.h
│ │ ├── funcimpl.h
│ │ ├── funcplot.h
│ │ ├── function_common_data.h
│ │ ├── function_factory.h
│ │ ├── function_interface.h
│ │ ├── functypedefs.h
│ │ ├── gaussleg
│ │ ├── gfit.h
│ │ ├── graveyard
│ │ ├── indexit.h
│ │ ├── kernelrange.h
│ │ ├── key.h
│ │ ├── lbdeux.h
│ │ ├── leafop.h
│ │ ├── legendre.cc
│ │ ├── legendre.h
│ │ ├── macrotaskpartitioner.h
│ │ ├── macrotaskq.h
│ │ ├── memory_measurement.h
│ │ ├── minmax/
│ │ │ ├── Makefile
│ │ │ ├── y.cc
│ │ │ ├── y1.cc
│ │ │ ├── y_signed.cc
│ │ │ └── y_varx.cc
│ │ ├── mra.h
│ │ ├── mra1.cc
│ │ ├── mra2.cc
│ │ ├── mra3.cc
│ │ ├── mra4.cc
│ │ ├── mra5.cc
│ │ ├── mra6.cc
│ │ ├── mraimpl.h
│ │ ├── mraplot.cc
│ │ ├── mw.h
│ │ ├── mypmap.h
│ │ ├── nonlinsol.h
│ │ ├── operator.h
│ │ ├── operatorinfo.h
│ │ ├── power.h
│ │ ├── qmprop.cc
│ │ ├── qmprop.h
│ │ ├── sdf_domainmask.h
│ │ ├── sdf_shape_2D.h
│ │ ├── sdf_shape_3D.h
│ │ ├── simplecache.h
│ │ ├── startup.cc
│ │ ├── test6.cc
│ │ ├── test_QCCalculationParametersBase.cc
│ │ ├── test_cloud.cc
│ │ ├── test_keybox.cc
│ │ ├── test_macrotaskpartitioner.cc
│ │ ├── test_memory_measurement.cc
│ │ ├── test_mra6.cc
│ │ ├── test_sepop.cc
│ │ ├── test_tree_state.cc
│ │ ├── test_vectormacrotask.cc
│ │ ├── testbc.cc
│ │ ├── testbsh.cc
│ │ ├── testdiff1D.cc
│ │ ├── testdiff1Db.cc
│ │ ├── testdiff2D.cc
│ │ ├── testdiff3D.cc
│ │ ├── testgaxpyext.cc
│ │ ├── testgconv.cc
│ │ ├── testinnerext.cc
│ │ ├── testopdir.cc
│ │ ├── testpdiff.cc
│ │ ├── testper.cc
│ │ ├── testperiodic.cc
│ │ ├── testproj.cc
│ │ ├── testqm.cc
│ │ ├── testsolver.cc
│ │ ├── testsuite.cc
│ │ ├── testunaryop.cc
│ │ ├── testvmra.cc
│ │ ├── tools/
│ │ │ ├── MRAMeshOrbitalPlot3D.wl
│ │ │ ├── README.md
│ │ │ ├── autocorr.mw
│ │ │ ├── dump2.py
│ │ │ ├── h2-no1.cube
│ │ │ ├── h2-no1.tree.json
│ │ │ ├── h2-no1.wsl
│ │ │ ├── longfloat.py
│ │ │ ├── mathutil.py
│ │ │ ├── quadrature.py
│ │ │ └── twoscalecoeffs.py
│ │ ├── twoscale.cc
│ │ ├── twoscale.h
│ │ ├── vmra.h
│ │ └── vmra1.h
│ ├── tensor/
│ │ ├── CMakeLists.txt
│ │ ├── RandomizedMatrixDecomposition.cc
│ │ ├── RandomizedMatrixDecomposition.h
│ │ ├── SVDTensor.cc
│ │ ├── SVDTensor.h
│ │ ├── aligned.h
│ │ ├── basetensor.cc
│ │ ├── basetensor.h
│ │ ├── cblas.h
│ │ ├── cblas_types.h
│ │ ├── clapack.h
│ │ ├── clapack_fortran.h
│ │ ├── distributed_matrix.h
│ │ ├── dummy_main.c
│ │ ├── elem.cc
│ │ ├── elem.h
│ │ ├── fred.cc
│ │ ├── genmtxm.py
│ │ ├── gentensor.h
│ │ ├── gfit.cc
│ │ ├── gmres.h
│ │ ├── jacobi.h
│ │ ├── jimkernel.cc
│ │ ├── kain.cc
│ │ ├── lapack.cc
│ │ ├── lapacke_types.h
│ │ ├── linalg_wrappers.cc
│ │ ├── linalg_wrappers.h
│ │ ├── lowranktensor.h
│ │ ├── miketest.cc
│ │ ├── mtxmq_bg/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── bgp_cc.cc
│ │ │ ├── bgp_cr.cc
│ │ │ ├── bgp_rc.cc
│ │ │ ├── bgp_rr.cc
│ │ │ └── bgq_mtxm.cc
│ │ ├── mtxmq_graveyard/
│ │ │ ├── bgp_tuning/
│ │ │ │ ├── Makefile
│ │ │ │ ├── mTxm_tune.cc
│ │ │ │ ├── mtxmq.cc
│ │ │ │ ├── original_performance_data.145618.output
│ │ │ │ ├── submit
│ │ │ │ ├── test_Zmtxmq.cc
│ │ │ │ └── test_mtxmq.cc
│ │ │ ├── mtxm_gen.h
│ │ │ ├── mtxmq.cc
│ │ │ ├── mtxmq.h
│ │ │ ├── mtxmq_asm.S
│ │ │ ├── mtxmq_avx_rjh.cc
│ │ │ ├── new_mtxmq/
│ │ │ │ ├── README
│ │ │ │ ├── __main__.py
│ │ │ │ ├── bests/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── avx2_cc.cc
│ │ │ │ │ ├── avx2_cr.cc
│ │ │ │ │ ├── avx2_rc.cc
│ │ │ │ │ ├── avx2_rr.cc
│ │ │ │ │ ├── avx_cc.cc
│ │ │ │ │ ├── avx_cr.cc
│ │ │ │ │ ├── avx_rc.cc
│ │ │ │ │ ├── avx_rr.cc
│ │ │ │ │ ├── sse_cc.cc
│ │ │ │ │ ├── sse_cr.cc
│ │ │ │ │ ├── sse_rc.cc
│ │ │ │ │ └── sse_rr.cc
│ │ │ │ ├── bgq_results_parse.py
│ │ │ │ ├── codegen/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── bgqdriver.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ └── mtxm.py
│ │ │ │ ├── main.py
│ │ │ │ ├── results_parse.py
│ │ │ │ └── tests/
│ │ │ │ ├── __init__.py
│ │ │ │ └── testDocStrings.py
│ │ │ └── test_scott.cc
│ │ ├── mxm.h
│ │ ├── oldtest.cc
│ │ ├── slice.h
│ │ ├── solvers.cc
│ │ ├── solvers.h
│ │ ├── srconf.h
│ │ ├── systolic.h
│ │ ├── tempspec.py
│ │ ├── tensor.cc
│ │ ├── tensor.h
│ │ ├── tensor_json.hpp
│ │ ├── tensor_lapack.h
│ │ ├── tensor_macros.h
│ │ ├── tensorexcept.h
│ │ ├── tensoriter.cc
│ │ ├── tensoriter.h
│ │ ├── tensortrain.h
│ │ ├── test_RandomizedMatrixDecomposition.cc
│ │ ├── test_Zmtxmq.cc
│ │ ├── test_distributed_matrix.cc
│ │ ├── test_elemental.cc
│ │ ├── test_gentensor.cc
│ │ ├── test_jacobi.cc
│ │ ├── test_linalg.cc
│ │ ├── test_lowranktensor.cc
│ │ ├── test_mtxmq.cc
│ │ ├── test_solvers.cc
│ │ ├── test_systolic.cc
│ │ ├── test_tensor.cc
│ │ ├── testseprep.cc
│ │ ├── transform3d.cc
│ │ ├── type_data.h
│ │ ├── vector_factory.h
│ │ ├── vmath.cc
│ │ └── vmath.h
│ └── world/
│ ├── CMakeLists.txt
│ ├── MADworld.h
│ ├── README.test_renaming
│ ├── archive.cc
│ ├── archive.h
│ ├── archive_type_names.cc
│ ├── array_addons.h
│ ├── atomicint.h
│ ├── bgq_atomics.h
│ ├── binary_fstream_archive.cc
│ ├── binary_fstream_archive.h
│ ├── binsorter.h
│ ├── buffer_archive.h
│ ├── cereal_archive.h
│ ├── cloud.h
│ ├── debug.cc
│ ├── deferred_cleanup.cc
│ ├── deferred_cleanup.h
│ ├── dependency_interface.h
│ ├── dist_cache.h
│ ├── distributed_id.h
│ ├── dqueue.h
│ ├── function_traits.h
│ ├── future.cc
│ ├── future.h
│ ├── graveyard
│ ├── group.cc
│ ├── group.h
│ ├── hello_world.cu
│ ├── lookup3.c
│ ├── madness_exception.cc
│ ├── madness_exception.h
│ ├── mem_func_wrapper.h
│ ├── meta.h
│ ├── mpi_archive.h
│ ├── nodefaults.h
│ ├── parallel_archive.h
│ ├── parallel_dc_archive.h
│ ├── parsec.cc
│ ├── parsec.h
│ ├── posixmem.h
│ ├── print.cc
│ ├── print.h
│ ├── print_seq.h
│ ├── range.h
│ ├── ranks_and_hosts.cpp
│ ├── ranks_and_hosts.h
│ ├── redirectio.cc
│ ├── safempi.cc
│ ├── safempi.h
│ ├── stack.h
│ ├── stubmpi.h
│ ├── taskfn.h
│ ├── test_ar.cc
│ ├── test_atomicint.cc
│ ├── test_binsorter.cc
│ ├── test_dc.cc
│ ├── test_future.cc
│ ├── test_future2.cc
│ ├── test_future3.cc
│ ├── test_googletest.cc
│ ├── test_hashdc.cc
│ ├── test_hashthreaded.cc
│ ├── test_hello.cc
│ ├── test_list.cc
│ ├── test_mpihang.cc
│ ├── test_papi.cc
│ ├── test_prof.cc
│ ├── test_queue.cc
│ ├── test_sig.cc
│ ├── test_stack.cc
│ ├── test_sysctl.c
│ ├── test_tree.cc
│ ├── test_utilities.h
│ ├── test_vec.cc
│ ├── test_vector.cc
│ ├── test_world.cc
│ ├── test_worldprofile.cc
│ ├── test_worldptr.cc
│ ├── test_worldref.cc
│ ├── text_fstream_archive.cc
│ ├── text_fstream_archive.h
│ ├── thread.cc
│ ├── thread.h
│ ├── thread_info.h
│ ├── threadbind
│ ├── timers.cc
│ ├── timers.h
│ ├── timing_utilities.h
│ ├── type_traits.h
│ ├── uniqueid.h
│ ├── units.cc
│ ├── units.h
│ ├── vector.h
│ ├── vector_archive.h
│ ├── world.cc
│ ├── world.h
│ ├── world_object.h
│ ├── world_task_queue.cc
│ ├── world_task_queue.h
│ ├── worldam.cc
│ ├── worldam.h
│ ├── worlddc.h
│ ├── worldgop.cc
│ ├── worldgop.h
│ ├── worldhash.h
│ ├── worldhashmap.h
│ ├── worldinit.h
│ ├── worldmem.cc
│ ├── worldmem.h
│ ├── worldmpi.cc
│ ├── worldmpi.h
│ ├── worldmutex.cc
│ ├── worldmutex.h
│ ├── worldpapi.cc
│ ├── worldpapi.h
│ ├── worldprofile.cc
│ ├── worldprofile.h
│ ├── worldptr.h
│ ├── worldref.cc
│ ├── worldref.h
│ ├── worldrmi.cc
│ ├── worldrmi.h
│ └── worldtypes.h
├── madness.h
└── pymadness/
├── CMakeLists.txt
├── README.md
├── examples/
│ ├── derivatives.py
│ ├── harmonic_oscillator_1d.py
│ └── hydrogen_atom.py
├── pyproject.toml
├── src/
│ ├── _pymadness/
│ │ ├── bind_defaults.cpp
│ │ ├── bind_function.cpp
│ │ ├── bind_operators.cpp
│ │ ├── bind_tensor.cpp
│ │ ├── bind_world.cpp
│ │ ├── module.cpp
│ │ └── py_functor.h
│ └── pymadness/
│ ├── __init__.py
│ └── plotting.py
└── tests/
├── conftest.py
└── test_function.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-tidy
================================================
# Generated from CLion Inspection settings
---
Checks: '-*,
bugprone-argument-comment,
bugprone-assert-side-effect,
bugprone-bad-signal-to-kill-thread,
bugprone-branch-clone,
bugprone-copy-constructor-init,
bugprone-dangling-handle,
bugprone-dynamic-static-initializers,
bugprone-fold-init-type,
bugprone-forward-declaration-namespace,
bugprone-forwarding-reference-overload,
bugprone-inaccurate-erase,
bugprone-incorrect-roundings,
bugprone-integer-division,
bugprone-lambda-function-name,
bugprone-macro-parentheses,
bugprone-macro-repeated-side-effects,
bugprone-misplaced-operator-in-strlen-in-alloc,
bugprone-misplaced-pointer-arithmetic-in-alloc,
bugprone-misplaced-widening-cast,
bugprone-move-forwarding-reference,
bugprone-multiple-statement-macro,
bugprone-no-escape,
bugprone-not-null-terminated-result,
bugprone-parent-virtual-call,
bugprone-posix-return,
bugprone-reserved-identifier,
bugprone-sizeof-container,
bugprone-sizeof-expression,
bugprone-spuriously-wake-up-functions,
bugprone-string-constructor,
bugprone-string-integer-assignment,
bugprone-string-literal-with-embedded-nul,
bugprone-suspicious-enum-usage,
bugprone-suspicious-include,
bugprone-suspicious-memset-usage,
bugprone-suspicious-missing-comma,
bugprone-suspicious-semicolon,
bugprone-suspicious-string-compare,
bugprone-suspicious-memory-comparison,
bugprone-suspicious-realloc-usage,
bugprone-swapped-arguments,
bugprone-terminating-continue,
bugprone-throw-keyword-missing,
bugprone-too-small-loop-variable,
bugprone-undefined-memory-manipulation,
bugprone-undelegated-constructor,
bugprone-unhandled-self-assignment,
bugprone-unused-raii,
bugprone-unused-return-value,
bugprone-use-after-move,
bugprone-virtual-near-miss,
cert-dcl21-cpp,
cert-dcl58-cpp,
cert-err34-c,
cert-err52-cpp,
cert-err60-cpp,
cert-flp30-c,
cert-msc50-cpp,
cert-msc51-cpp,
cert-str34-c,
cppcoreguidelines-interfaces-global-init,
cppcoreguidelines-narrowing-conversions,
cppcoreguidelines-pro-type-member-init,
cppcoreguidelines-pro-type-static-cast-downcast,
cppcoreguidelines-slicing,
google-default-arguments,
google-explicit-constructor,
google-runtime-operator,
hicpp-exception-baseclass,
hicpp-multiway-paths-covered,
misc-misplaced-const,
misc-new-delete-overloads,
misc-no-recursion,
misc-non-copyable-objects,
misc-throw-by-value-catch-by-reference,
misc-unconventional-assign-operator,
misc-uniqueptr-reset-release,
modernize-avoid-bind,
modernize-concat-nested-namespaces,
modernize-deprecated-headers,
modernize-deprecated-ios-base-aliases,
modernize-loop-convert,
modernize-make-shared,
modernize-make-unique,
modernize-pass-by-value,
modernize-raw-string-literal,
modernize-redundant-void-arg,
modernize-replace-auto-ptr,
modernize-replace-disallow-copy-and-assign-macro,
modernize-replace-random-shuffle,
modernize-return-braced-init-list,
modernize-shrink-to-fit,
modernize-unary-static-assert,
modernize-use-auto,
modernize-use-bool-literals,
modernize-use-emplace,
modernize-use-equals-default,
modernize-use-equals-delete,
modernize-use-nodiscard,
modernize-use-noexcept,
modernize-use-nullptr,
modernize-use-override,
modernize-use-transparent-functors,
modernize-use-uncaught-exceptions,
mpi-buffer-deref,
mpi-type-mismatch,
openmp-use-default-none,
performance-faster-string-find,
performance-for-range-copy,
performance-implicit-conversion-in-loop,
performance-inefficient-algorithm,
performance-inefficient-string-concatenation,
performance-inefficient-vector-operation,
performance-move-const-arg,
performance-move-constructor-init,
performance-no-automatic-move,
performance-noexcept-move-constructor,
performance-trivially-destructible,
performance-type-promotion-in-math-fn,
performance-unnecessary-copy-initialization,
performance-unnecessary-value-param,
portability-simd-intrinsics,
readability-avoid-const-params-in-decls,
readability-const-return-type,
readability-container-size-empty,
readability-convert-member-functions-to-static,
readability-delete-null-pointer,
readability-deleted-default,
readability-inconsistent-declaration-parameter-name,
readability-make-member-function-const,
readability-misleading-indentation,
readability-misplaced-array-index,
readability-non-const-parameter,
readability-redundant-control-flow,
readability-redundant-declaration,
readability-redundant-function-ptr-dereference,
readability-redundant-smartptr-get,
readability-redundant-string-cstr,
readability-redundant-string-init,
readability-simplify-subscript-expr,
readability-static-accessed-through-instance,
readability-static-definition-in-anonymous-namespace,
readability-string-compare,
readability-uniqueptr-delete-release,
readability-use-anyofallof'
================================================
FILE: .github/workflows/cmake.yml
================================================
name: Linux/MacOS Build
on:
push:
pull_request:
branches: [master]
#env:
jobs:
build:
strategy:
fail-fast: false
matrix:
build_type : [ Release, Debug ]
os : [ macos-latest, ubuntu-24.04 ]
task_backend : [Threads, OneTBB, PaRSEC] # OneTBB and LegacyTBB control which version of TBB to install
include:
- os: ubuntu-24.04
# gcc 14 causes build issues in code that uses RapidJSON: https://github.com/Tencent/rapidjson/issues/2277
cxx: /usr/bin/g++-13
- os: macos-latest
cxx: clang++
# Add GENTENSOR test configuration
- os: ubuntu-24.04
build_type: Debug
task_backend: Threads
cxx: /usr/bin/g++-13
gentensor: ON
name: "${{ matrix.os }}: ${{ matrix.cxx }} ${{ matrix.build_type }} ${{ matrix.task_backend }}${{ matrix.gentensor && ' +GENTENSOR' || '' }}"
runs-on: ${{ matrix.os }}
env:
CXX : ${{ matrix.cxx }}
CCACHE_DIR : ${{github.workspace}}/build/.ccache
CCACHE_COMPRESS : true
CCACHE_COMPRESSLEVEL : 6
MAD_SMALL_TESTS : 1
MAD_NUM_THREADS : 3
CTEST_OUTPUT_ON_FAILURE : 1
BUILD_CONFIG : >
-G Ninja
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-DCMAKE_INSTALL_PREFIX=${{github.workspace}}/install
-DCMAKE_PREFIX_PATH="/usr/local/opt/bison;/usr/local/opt/libxc"
-DBUILD_SHARED_LIBS=OFF
-DMPIEXEC_PREFLAGS='--bind-to;none;--allow-run-as-root'
-DBUILD_TESTING=ON
-DMADNESS_ENABLE_CEREAL=ON
-DMPI_CXX_SKIP_MPICXX=ON
-DCMAKE_CXX_STANDARD=${{ matrix.task_backend == 'Threads' && matrix.build_type == 'Debug' && '20' || '17' }}
-DMADNESS_BUILD_MADWORLD_ONLY=${{ matrix.task_backend != 'Threads' }}
-DMADNESS_BUILD_LIBRARIES_ONLY=${{ matrix.build_type == 'Debug' }}
-DENABLE_GENTENSOR=${{ matrix.gentensor || 'OFF' }}
steps:
- uses: actions/checkout@v4
- name: Create Build Environment
# Some projects don't allow in-source building, so create a separate build directory
# We'll use this as our working directory for all subsequent commands
run: cmake -E make_directory ${{github.workspace}}/build
- name: Process task_backend
run: |
if [ "X${{ matrix.task_backend }}" = "XLegacyTBB" ]; then
echo "TASK_BACKEND=TBB" >> $GITHUB_ENV
fi
if [ "X${{ matrix.task_backend }}" = "XOneTBB" ]; then
echo "TASK_BACKEND=TBB" >> $GITHUB_ENV
fi
if [ "X${{ matrix.task_backend }}" = "XThreads" ]; then
echo "TASK_BACKEND=Pthreads" >> $GITHUB_ENV
fi
if [ "X${{ matrix.task_backend }}" = "XPaRSEC" ]; then
echo "TASK_BACKEND=PaRSEC" >> $GITHUB_ENV
# do not bind threads to cores to avoid oversubscription
echo "PARSEC_MCA_bind_threads=0" >> $GITHUB_ENV
fi
- name: Install prerequisite MacOS packages
if: ${{ matrix.os == 'macos-latest' }}
run: |
brew install ninja boost eigen open-mpi bison ccache libxc
if [ "X${{ matrix.task_backend }}" = "XLegacyTBB" ]; then
brew install tbb@2020
echo "TBBROOT=/usr/local/opt/tbb@2020" >> $GITHUB_ENV
fi
if [ "X${{ matrix.task_backend }}" = "XOneTBB" ]; then
brew install tbb
echo "TBBROOT=/usr/local/opt/tbb" >> $GITHUB_ENV
fi
- name: Install prerequisites Ubuntu packages
if: ${{ matrix.os == 'ubuntu-24.04' }}
run: |
sudo apt-get update
sudo apt-get install ninja-build g++-13 liblapack-dev libboost-dev libboost-serialization-dev libeigen3-dev openmpi-bin libopenmpi-dev ccache
if [ "X${{ matrix.task_backend }}" = "XOneTBB" ]; then
wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB -O - | sudo apt-key add -
sudo add-apt-repository "deb https://apt.repos.intel.com/oneapi all main"
sudo apt-get install intel-oneapi-tbb-devel
echo "TBBROOT=/opt/intel/oneapi/tbb/latest" >> $GITHUB_ENV
fi
if [ "X${{ matrix.task_backend }}" = "XLegacyTBB" ]; then
sudo apt-get install libtbb-dev
fi
if [ "X${{ matrix.build_type }}" = "XDebug" ]; then
sudo apt-get install libcereal-dev
fi
- name: Prepare ccache timestamp
id: ccache_cache_timestamp
shell: cmake -P {0}
run: |
string(TIMESTAMP current_date "%Y-%m-%d-%H;%M;%S" UTC)
message("::set-output name=timestamp::${current_date}")
- name: Setup ccache cache files
uses: actions/cache@v4
with:
path: ${{github.workspace}}/build/.ccache
key: ${{ matrix.config.name }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
restore-keys: |
${{ matrix.config.name }}-ccache-
- name: Configure CMake
# Use a bash shell so we can use the same syntax for environment variable
# access regardless of the host operating system
shell: bash
working-directory: ${{github.workspace}}/build
# Note the current convention is to use the -S and -B options here to specify source
# and build directories, but this is only available with CMake 3.13 and higher.
# The CMake binaries on the Github Actions machines are (as of this writing) 3.12
run: cmake $GITHUB_WORKSPACE $BUILD_CONFIG -DMADNESS_TASK_BACKEND=$TASK_BACKEND
- name: Build
working-directory: ${{github.workspace}}/build
shell: bash
# Execute the build. You can specify a specific target with "--target <NAME>"
run: ccache -p && ccache -z && cmake --build . && ccache -s
- name: Test
working-directory: ${{github.workspace}}/build
shell: bash
run: cmake --build . --target check-short-madness
- name: Build and Test Python bindings
if: matrix.task_backend == 'Threads' && matrix.build_type == 'Release'
working-directory: ${{github.workspace}}/build
shell: bash
run: |
pip install numpy pytest matplotlib plotly
cmake $GITHUB_WORKSPACE $BUILD_CONFIG -DMADNESS_TASK_BACKEND=$TASK_BACKEND -DENABLE_PYTHON=ON
cmake --build . --target _pymadness
cd src/pymadness
PYTHONPATH=. python -m pytest -xvs $GITHUB_WORKSPACE/src/pymadness/tests/
- name: Install
if: matrix.build_type != 'Debug'
working-directory: ${{github.workspace}}/build
shell: bash
run: cmake --build . --target install
- name: Test Install Tree
if: matrix.build_type != 'Debug'
working-directory: ${{github.workspace}}/build
shell: bash
run: |
cmake -S $GITHUB_WORKSPACE/doc/tutorial -B test_install -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
cmake --build test_install
test_install/test_runtime
# if built more than just MADWorld run the HF test
if [ "X${{ matrix.task_backend }}" = "XThreads" ]; then
test_install/simple_hf
fi
================================================
FILE: .github/workflows/conda-deploy.yml
================================================
name: Conda Deploy
on:
# Run after CI passes on master
workflow_run:
workflows: ["Linux/MacOS Build"]
types: [completed]
branches: [master]
# Also run on version tags
push:
tags:
- 'v*'
# Allow manual triggering
workflow_dispatch:
jobs:
conda-build-upload:
# Only run if CI succeeded (for workflow_run trigger) or if it's a tag/manual push
if: >
github.event_name == 'push' ||
github.event_name == 'workflow_dispatch' ||
(github.event.workflow_run.conclusion == 'success')
strategy:
fail-fast: false
matrix:
os: [ubuntu-24.04, macos-latest]
mpi: [nompi, openmpi]
name: "conda ${{ matrix.os }} ${{ matrix.mpi }}"
runs-on: ${{ matrix.os }}
permissions:
contents: read
defaults:
run:
shell: bash -el {0}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0 # full history needed for git describe
repository: ${{ github.repository }}
ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.ref }}
- name: Determine version
id: version
env:
SOURCE_SHA: ${{ github.event.workflow_run.head_sha || github.sha }}
run: |
if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
VERSION="${GITHUB_REF#refs/tags/v}"
else
# Use the most recent version tag, falling back to CMakeLists.txt
TAG_VERSION=$(git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
if [ -z "${TAG_VERSION}" ]; then
MAJOR=$(grep -m1 'set(MADNESS_MAJOR_VERSION' CMakeLists.txt | grep -oE '[0-9]+')
MINOR=$(grep -m1 'set(MADNESS_MINOR_VERSION' CMakeLists.txt | grep -oE '[0-9]+')
MICRO=$(grep -m1 'set(MADNESS_MICRO_VERSION' CMakeLists.txt | grep -oE '[0-9]+')
TAG_VERSION="${MAJOR}.${MINOR}.${MICRO}"
fi
SHORT_SHA="${SOURCE_SHA::8}"
VERSION="${TAG_VERSION}.dev$(date +%Y%m%d)+${SHORT_SHA}"
fi
echo "version=$VERSION" >> "$GITHUB_OUTPUT"
echo "GIT_DESCRIBE_TAG=$VERSION" >> "$GITHUB_ENV"
echo "Version: $VERSION"
- name: Set up Miniconda
uses: conda-incubator/setup-miniconda@v3
with:
auto-update-conda: true
python-version: "3.12"
channels: conda-forge,defaults
channel-priority: strict
- name: Install conda-build and anaconda-client
run: |
conda install -y conda-build anaconda-client
- name: Build conda package
env:
MPI_VARIANT: ${{ matrix.mpi }}
run: |
conda build conda-recipe/ \
--no-anaconda-upload \
--output-folder "${{ github.workspace }}/conda-dist/"
- name: Upload conda package as workflow artifact
uses: actions/upload-artifact@v4
with:
name: conda-${{ matrix.os }}-${{ matrix.mpi }}-${{ steps.version.outputs.version }}
path: ${{ github.workspace }}/conda-dist/**/*.conda
if-no-files-found: warn
- name: Upload to Anaconda.org
env:
ANACONDA_TOKEN: ${{ secrets.ANACONDA_TOKEN }}
run: |
find "${{ github.workspace }}/conda-dist" \( -name '*.tar.bz2' -o -name '*.conda' \) -print0 | \
while IFS= read -r -d '' pkg; do
anaconda -t "${ANACONDA_TOKEN}" upload --user m-a-d-n-e-s-s --force "$pkg"
done
================================================
FILE: .github/workflows/make_doxygen.yml
================================================
name: publish-doxygen
# Trigger this when a pull request is merged (which implies pushing to master).
on:
push:
branches:
- master
jobs:
doxygen:
runs-on: ubuntu-latest
steps:
- name: Git Checkout
uses: actions/checkout@v4
- name: Install prerequisites Ubuntu packages
run: |
sudo apt-get update
sudo apt-get install -y ninja-build g++-13 liblapack-dev openmpi-bin libopenmpi-dev libtbb-dev doxygen graphviz
- name: Configure CMake
shell: bash
working-directory: ${{github.workspace}}
run: |
cmake -E make_directory ${{github.workspace}}/build
cd build && cmake $GITHUB_WORKSPACE -G Ninja -DCMAKE_BUILD_TYPE=Release
- name: Build doxygen docs
shell: bash
working-directory: ${{github.workspace}}/build
run: cmake --build . --target html-madness
- name: Deploy to GitHub Pages
shell: bash
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
git config --global user.email "action@github.com"
git config --global user.name "GitHub Actions"
cmake -E make_directory ${{github.workspace}}/gh-pages-deploy
cp -rp ${{github.workspace}}/build/doc/html ${{github.workspace}}/gh-pages-deploy/api-doc
cd ${{github.workspace}}/gh-pages-deploy
# create a brand-new repo so that gh-pages contains no history
git init
git add .
git commit -q -m "Generated API doc via GitHub Actions (run $GITHUB_RUN_NUMBER)"
git checkout -b gh-pages
git remote add origin https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git
git push origin +gh-pages
- name: Result URLs
run: |
REPO_OWNER=$(echo $GITHUB_REPOSITORY | cut -d '/' -f 1)
REPO_NAME=$(echo $GITHUB_REPOSITORY | cut -d '/' -f 2)
echo "Formatted API docs: https://$REPO_OWNER.github.io/$REPO_NAME/api-doc"
echo ""
echo "GitHub pages branch: $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/tree/gh-pages"
================================================
FILE: .gitignore
================================================
build*
cmake-build-debug*
.history*
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
.cproject
.project
.settings
.idea
Makefile.in
src/madness/config.h.in
aclocal.m4
autom4te.cache
configure
test-driver
log.00*
org.eclipse.cdt.core.prefs
org.eclipse.cdt.ui.prefs
.autotools
.externalToolBuilders/org.eclipse.cdt.autotools.core.genmakebuilderV2.launch
compile
config.guess
config.sub
depcomp
install-sh
missing
/Default/
lt~obsolete.m4
ltversion.m4
ltsugar.m4
ltoptions.m4
ltmain.sh
libtool.m4
config.h.in~
cmake/cmake-*
cmake/bin
cmake/doc
cmake/share
Makefile-prog.in
compile_commands.json
*.idx
.clang-format
/cmake-build-debug/.ninja_deps
compile_commands
.history/src/apps/molresponse/global_functions_20230530165227.cc
.history/src/apps/molresponse/global_functions_20230530165428.cc
diff.txt
newdiff.txt
.vscode/settings.json
================================================
FILE: .readthedocs.yaml
================================================
# .readthedocs.yaml
# Read the Docs configuration file
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
# Set the version of Python and other tools you might need
build:
os: ubuntu-20.04
tools:
python: "3.9"
# You can also specify other tool versions:
# nodejs: "16"
# rust: "1.55"
# golang: "1.17"
# Build documentation in the docs/ directory with Sphinx
sphinx:
configuration: doc/conf.py
# If using Sphinx, optionally build your docs in additional formats such as PDF
# formats:
# - pdf
# Optionally declare the Python requirements required to build your docs
python:
install:
- requirements: doc/requirements.txt
================================================
FILE: AGENTS.md
================================================
# Agent Instructions for MADNESS
Canonical guidance for coding agents working on this repo. For installing
dependencies and walking through a first build, see `INSTALL.md`. This file
covers what an agent needs beyond that: the source layout, how tests are
organized, and the project-specific gotchas that are easy to get wrong.
`CLAUDE.md` is a symlink to this file; there is no vendor-specific variant.
**How to use this file.** Treat it as a starting map, not authority. The code is the source of truth — when this file disagrees with what `grep`/`Read` show you, trust the code and flag the discrepancy so this file can be updated.
_Last reviewed against master:_ 2026-04-23.
## Platforms
MADNESS targets POSIX only — Linux and macOS on x86-64, ARM64, and IBM
Power. Windows is not supported. Do not add `#ifdef _WIN32` branches, path
handling that assumes backslashes, or dependencies that are Windows-only.
POSIX facilities (`pthread`, `mmap`, `fork`, `dlopen`, `sys/stat.h`, …) may
be used directly without feature detection beyond the existing
`HAVE_*` macros.
## Source tree
- `src/madness/world` — parallel runtime, a.k.a. **MADWorld** (tasks, futures, MPI wrappers).
- `src/madness/tensor` — dense tensors and BLAS/LAPACK wrappers.
- `src/madness/mra` — multiresolution analysis (`Function<T,NDIM>`, operators).
- `src/madness/chem` — electronic-structure building blocks (SCF, XC, …).
- `src/madness/misc`, `src/madness/external` — utilities, bundled deps.
- `src/apps/*` — end-user applications (`moldft`, `nemo`, `cc2`, `mp2`, …).
- `src/examples`, `src/pymadness` — samples and Python bindings.
## Build directories
Prefer reusing an existing out-of-tree build directory over creating a new
one from scratch, so you don't re-pay CMake configure time. Common local
conventions are `cmake-build-{debug,release,relwithdebinfo}` and `build*`.
If several exist side-by-side, check their
cached CMake options (`grep … CMakeCache.txt`) — configure state often
diverges between them.
For focused iteration, these scope flags drop rebuild time substantially:
- `-DMADNESS_BUILD_MADWORLD_ONLY=ON` — build only the runtime, skipping
`tensor`/`mra`/`chem`/`apps`. Right for work confined to `src/madness/world`.
- `-DMADNESS_BUILD_LIBRARIES_ONLY=ON` — build the libraries, skip `src/apps`.
Right for changes to numerical layers when you don't need `moldft`/`nemo`/
`cc2`.
## Tests
Tests live next to the sources they exercise and are registered through
`add_unittests(component sources libs labels)` (see
`cmake/modules/AddUnittests.cmake`). The macro emits:
- one CTest entry per source file at `madness/test/<component>/<name>/run`,
with `<name>` derived from the source filename, and
- a per-component `madness/test/<component>/build` entry that builds the
unit-test targets on demand.
Both entries carry the `labels` passed to the macro. There is no filename
convention — most test sources follow `test*.cc` / `test_*.cc` by habit,
but the macro accepts any source name (e.g. `src/madness/misc/interp3.cc`,
`src/examples/periodic/erfcr.cc`).
The `check-short-madness` target runs everything labeled `short` or `medium`
via `ctest -L "short|medium"`. To run a subset without the full suite:
```
ctest -L short -R "madness/test/mra" # all mra tests in the short set
ctest -R "madness/test/mra/test_cloud/run" # a single test by name
```
Each test is also a normal binary under
`<build-dir>/<path-of-source-dir>/<name>` (mirroring the source tree, so
`src/madness/mra` tests land at `<build-dir>/src/madness/mra/<name>`, and
`src/examples/periodic` tests at `<build-dir>/src/examples/periodic/<name>`)
and can be invoked directly for debugging.
### Smoke test
`testsuite` in `src/madness/mra` is the broad numerical-library regression
harness. From a configured build directory:
```
ninja testsuite
./src/madness/mra/testsuite
```
Success: the program prints `testsuite passed: true` and exits 0. For the
MPI variant:
```
MAD_NUM_THREADS=2 mpiexec -np 2 ./src/madness/mra/testsuite
```
### moldft smoke
```
ninja moldft
./src/apps/moldft/moldft --geometry=water --dft="xc=lda"
```
Exit code 0 on success. Reference inputs for regression checks are in
`src/apps/moldft/tests/*.in`.
## Project-specific gotchas
- **BLAS must be sequential.** MADNESS owns parallelism via its own task
pool; a threaded BLAS inside a task oversubscribes cores. Use
single-threaded MKL, Accelerate, or OpenBLAS-serial.
- **Static libs are the default because ASLR is assumed.** Building shared
libs on a system without ASLR requires
`-DMADNESS_ASSUMES_ASLR_DISABLED=ON`. Do not flip `BUILD_SHARED_LIBS`
casually.
- **MPI is required by default.** `-DENABLE_MPI=OFF` is rarely used but
still supported and maintained — in that mode `stubmpi.h` stands in for
the subset of MPI that `SafeMPI` uses. Any new code that reaches for MPI
must go through `SafeMPI` / `World::mpi` (see runtime invariants below)
so this path continues to compile.
- **`-DENABLE_NEVER_SPIN=ON`** is a workaround for VMs/containers where
spinlocks burn CPU. Leave it off on bare metal.
- **`-DENABLE_GENTENSOR=ON`** swaps in a compressed-tensor code path used
for 6D work (MP2, CC2). Off by default and tested in only one CI cell,
so changes in the tensor layer should be checked with it on when
relevant.
## Runtime & deployment
These are concerns for launch scripts and performance tuning, not the source
itself — and they are largely undiscoverable by reading the code.
### Task backend
`-DMADNESS_TASK_BACKEND={Pthreads,TBB,PaRSEC}` (CMake, default `Pthreads`):
- **Pthreads** — MADNESS's own pool. Pick this when you need execution on
just the main thread; TBB and PaRSEC always spawn at least one worker.
- **PaRSEC** — preferred for production. Disable PaRSEC's own thread
binding or it will fight the launcher:
`export PARSEC_MCA_bind_threads=0`.
- **TBB** — Intel TBB task pool; autodetected when available.
### Thread count and the comm thread
Whenever `nranks > 1`, each rank spawns a dedicated MADNESS communication
thread **in addition to** the `MAD_NUM_THREADS` workers. MPI implementations
typically want a core for their own progress thread too, so the budget is:
- Comm-heavy workloads (MRA integral operators, TA tensor contractions):
`MAD_NUM_THREADS = hwthreads_per_rank − 2` (one hwthread each for the
MADNESS and MPI comm threads).
- Small ranks (≈16 hwthreads) or light comm: `... − 1` is usually fine —
the two comm threads co-exist on one core without meaningful contention.
- Never oversubscribe.
### Rank pinning
For MRA workloads, pin each rank to an L3 slice (or NUMA domain on systems
without L3-sized domains). Launch flags are deployment-specific:
- OpenMPI: `mpirun --map-by l3cache` or `--map-by numa`.
- Other MPI vendors: flags vary, some lack pinning entirely.
- SLURM: `--cpu-bind` / `--distribution` rather than the MPI flags.
Document the chosen command with the application, not here.
### Communication buffers
One-sided sends/receives use fixed-size buffers; 2-sided is supported but
much slower, so the 1-sided path should fit the common message.
- `MAD_BUFFER_SIZE` (env var, bytes) — default `3*512*1024` ≈ 1.5 MiB,
defined at `src/madness/world/worldrmi.h`.
- MRA rule of thumb: a tree-node payload is
`sizeof(T) · (2k)^NDIM + metadata`. The default comfortably holds
several nodes at typical `k ≤ 10, NDIM ≤ 3`; raise it for larger `k`,
6D work, or TiledArray-style bulk tensor transfers.
- MPI vendors have their own eager/rendezvous cutoffs (MVAPICH in
particular) — consult vendor docs when tuning comm perf.
### Apple Silicon + Homebrew OpenMPI
Homebrew's OpenMPI on Apple M-series links HWLOC, which probes hardware
via OpenCL and crashes at startup if launched outside `mpiexec`. Either:
- Always launch via `mpiexec`, even for `-np 1`, or
- `export HWLOC_COMPONENTS=darwin,no_os,-opencl` to skip the OpenCL probe.
## Coding conventions
### Error handling
MADNESS ships several macros with distinct intent (`madness_exception.h`).
Pick by *why* you're checking, not by what's short to type:
- **`MADNESS_CHECK(cond)` / `MADNESS_CHECK_THROW(cond, msg)`** — always-on
checks: state-machine preconditions, collective-ordering requirements,
user input validation. Use these for invariants that must hold in release
builds.
- **`MADNESS_ASSERT(cond)`** — debug-only, expensive invariants. Its runtime
behavior (throw / abort / std::assert / disabled) depends on the
`ASSERTION_TYPE` CMake variable; release builds often compile these out.
Do **not** use for checks that must run in production.
- **`MADNESS_EXCEPTION(msg, value)`** — explicit throw sites (unreachable
branches, unsupported configurations). Not a conditional.
- **`MADNESS_ASSERT_NOEXCEPT`** — use inside `noexcept` functions where a
throwing `MADNESS_ASSERT` would call `std::terminate`.
### CMake harness
MADNESS is designed to be consumed by parent projects both as an installed
package *and* as a subproject (via `FetchContent` / `add_subdirectory`, e.g.
from TiledArray and MPQC). Maintain both invariants when editing CMake.
- **No generic target names.** `check`, `doc`, `unittests`, `applications`
would collide with a parent project's targets. Define subproject-scoped
targets with `add_custom_target_subproject(madness <name> …)` from
`cmake/modules/AddCustomTargetSubproject.cmake`; it creates `<name>-madness`
and hooks it into `<name>` if the parent already defined it.
- **Use the `add_mad_*` wrappers**, not raw `add_library` / `add_executable`.
`add_mad_library` / `add_mad_hdr_library` / `add_mad_executable` apply
project-wide include paths, install rules, and the
`$<BUILD_INTERFACE:…>` / `$<INSTALL_INTERFACE:…>` generator expressions
that make targets consumable from both build and install trees.
- **Consumable from both install tree and build tree.** Preserved via
`install(EXPORT madness …)` plus
`export(EXPORT madness FILE ${PROJECT_BINARY_DIR}/madness-targets.cmake)`
in the top-level `CMakeLists.txt`, and the genex pair in `add_mad_library`.
Breaks in either path (missing install rules on new targets, hard-coded
paths outside the genex) are silent regressions for downstream consumers.
- **Optional dependencies follow the `FindOrFetch*` pattern** (e.g.
`FindOrFetchCereal.cmake`, `FindOrFetchPARSEC.cmake`): try `find_package`
first, fall back to `FetchContent`. Harness mantra: use preexisting deps
when available, build from source otherwise — except for the most basic
(MPI, BLAS), which must be found on the system.
- **Component libraries** (`MADworld`, `MADmra`, `MADtensor`, `MADchem`, …)
are the public link targets. The aggregate `madness` library is composed
from per-component object libraries (`MADworld-obj`, etc.), which (a) lets
downstream projects pull a lean subset via `MADNESS_BUILD_MADWORLD_ONLY` /
`MADNESS_BUILD_LIBRARIES_ONLY`, and (b) lets developers build a single
component quickly without its prerequisites — useful for shorter build
tests during iteration.
- **`CMAKE_FIND_NO_INSTALL_PREFIX=ON`** is set as a safety net so
`find_package` doesn't pick up a stale installed copy during development.
### Commit messages
Write plain commit messages describing the change. **Do not append
`Co-Authored-By: …` trailers crediting AI tooling** (Claude, Copilot,
Codex, etc.). This project does not credit tooling in commit metadata —
the same way it doesn't credit the editor, compiler, or the vast body
of prior work the tooling was trained on.
## Consumer-facing invariants
MADNESS is consumed by external projects — TiledArray leans on the parallel
runtime (`src/madness/world`), MPQC leans on MRA (`src/madness/mra`). When
editing in either area, preserve these invariants; they are not enforced at
compile time and breakage surfaces far downstream.
### Runtime (`src/madness/world`)
- `madness::initialize` must bracket all `World` / MPI use; `madness::finalize`
mirrors it. Creating a `World` or submitting tasks outside that window is
undefined.
- `World` lifetimes must nest — destroy in reverse creation order.
- `WorldObject` and `WorldContainer` require collective construction: every
rank in the enclosing `World` must create the same object in the same order.
- Active-message handlers (`World::am`) run on runtime threads and must not
block waiting on further tasks or collective ops; post continuations instead.
- **MPI is initialized at `MPI_THREAD_MULTIPLE`** — the only level tested
today, and required because tasks can spawn further (possibly remote)
tasks. This also constrains MPI-implementation choice: some MPI stacks
have performance cliffs under `THREAD_MULTIPLE`.
- **Use `SafeMPI` / `World::mpi` for every MPI call; never raw `MPI_*`.**
Three reasons: automated error checking; optional serialization fallback
when the MPI implementation is not reliably thread-safe; and the
`ENABLE_MPI=OFF` build replaces MPI with `stubmpi.h`, which only declares
the subset of MPI that `SafeMPI` uses — raw MPI calls won't compile there.
- **Never call MPI blocking collectives.** They park the calling thread
outside the task scheduler and can deadlock progress. Use MADNESS global
ops (`World::gop`) — non-blocking, composable with the runtime, and they
serialize user types via `madness::archive`.
- `madness::archive` is the public serialization extension point — downstream
code teaches `Future`, `WorldContainer`, and AM payloads to transport custom
types by specializing archive traits, not by reaching into internals.
- Outside tasks and the main thread, assume nothing in the runtime is
thread-safe unless the header documents it.
- **Prefer explicit `World&` parameters** over `World::get_default()` in any
new API. TiledArray builds with `-DMADNESS_DISABLE_WORLD_GET_DEFAULT=ON`
to surface code that implicitly assumes the default World; MADNESS itself
is laxer, but APIs written to accept an explicit `World&` work in both
settings. App-level code may use the default where it is clearly the top
level.
### MRA (`src/madness/mra`)
- `madness::startup(world, argc, argv, quiet)` is the **MRA** initializer —
loads twoscale coefficients, autocorrelation data, and populates
`FunctionDefaults`. It must be called after `madness::initialize` and
before constructing any `Function<T,NDIM>` or MRA operator. Runtime-only
(MADWorld) code does not need it.
- `Function<T,NDIM>` is a **shallow-copy handle** to a distributed
implementation — Python-like reference semantics, *not* copy-on-write.
`Function b = a;` shares the impl; mutations through `b` are observed
through `a`.
- `Function` operations enqueue **async** tasks. Results are not observable
until an implicit fence (an observing op such as `norm2`, `trace`, `inner`)
or an explicit `world.gop.fence()`.
- `Function` carries a `TreeState` (`reconstructed`, `compressed`,
`nonstandard`, `redundant`, …). Many operations assert on state — use
`change_tree_state` / `reconstruct` / `compress` rather than assuming.
- Prefer the vectorized forms in `src/madness/mra/vmra.h`
(`std::vector<Function>` arithmetic, `apply`, inner products, …) over
hand-written loops over individual `Function`s — this is the canonical
idiom and the overhead is negligible.
- `FunctionDefaults<NDIM>` is process-global mutable state (`k`, `thresh`,
cell, boundary conditions). Set it before constructing any `Function<NDIM>`;
changing it mid-run will not retroactively update existing functions.
- `SeparatedConvolution` operators are tied to a specific `k`, box size, and
threshold — reuse one across `Function`s built with different defaults and
results are undefined.
- Drive mutation from tasks or the main thread; don't mutate `Function`s
from arbitrary user threads.
- **Checkpointing.** `Function::save` / `Function::load` go through
`ParallelOutputArchive` / `ParallelInputArchive` (binary fstream under the
hood). `FunctionDefaults<NDIM>` must match between save and load — same
cell, `k`, `thresh`, and boundary conditions — or `load` throws. There
is no migration path.
For API depth, see the Doxygen groups rather than restating signatures here.
## Lint
A `.clang-tidy` configuration is checked in. Run `clang-tidy` against
changed translation units before finishing non-trivial C++ edits.
## Debugging aids
- Memory profiling of `FunctionImpl` objects is always available via
`MemoryMeasurer::measure_and_print(world)`.
- `-DENABLE_MEM_STATS=ON` and `-DENABLE_TENSOR_INSTANCE_COUNT=ON` provide
coarser, always-on counters for leak hunting (see `INSTALL.md`).
## Reviewing a PR
Guidance for agents doing PR review — focused on regressions CI won't
catch because its matrix is narrow. Flag these; don't nitpick style
(`.clang-tidy` is the source of truth).
- **Raw MPI calls.** Anything added outside `SafeMPI` / `World::mpi`
breaks `-DENABLE_MPI=OFF` and bypasses error checking / thread-safety
serialization.
- **Blocking MPI collectives** (`MPI_Barrier`, `MPI_Allreduce`, …).
Push toward `World::gop`.
- **Implicit default World.** `World::get_default()` in library code
breaks downstream builds (notably TiledArray's
`-DMADNESS_DISABLE_WORLD_GET_DEFAULT=ON`). Push for an explicit
`World&` parameter.
- **Non-collective construction** of `WorldObject` / `WorldContainer`,
or any code path where ranks can diverge on construction order.
- **Threaded-BLAS assumptions** (parallel loops around `gemm`, relying
on BLAS threading for speed).
- **`Function` mutation from user threads** (not tasks or the main
thread) or mis-handled `TreeState` preconditions.
- **Checkpoint-format breaks.** Any change to what `Function::save`
writes, or to `FunctionDefaults` fields consumed by `load`, is a
silent compat break — call it out.
- **Tensor-layer changes without GENTENSOR coverage.** CI only tests
one GENTENSOR cell; ask the author to verify with
`-DENABLE_GENTENSOR=ON` locally if the change could affect the
compressed-tensor path.
## Documentation
Developer API docs are generated by Doxygen and published at
<https://m-a-d-n-e-s-s.github.io/madness/api-doc/>. User-facing docs live at
<https://madness.readthedocs.io/en/latest/>.
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required (VERSION 3.12.0) # for FindPython
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release)
endif()
## I know this is obnoxious but I don't know any other way to keep
## things clean. Make the build verbose so that people see the warning
## messages and fix the issues --- some of them are real
#set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "ON")
# safety net for dev workflow: accidental install will not affect FindOrFetch*
if (NOT DEFINED CACHE{CMAKE_FIND_NO_INSTALL_PREFIX})
set(CMAKE_FIND_NO_INSTALL_PREFIX ON CACHE BOOL "Whether find_* commands will search CMAKE_INSTALL_PREFIX and CMAKE_STAGING_PREFIX; see https://cmake.org/cmake/help/latest/variable/CMAKE_FIND_NO_INSTALL_PREFIX.html#variable:CMAKE_FIND_NO_INSTALL_PREFIX")
endif()
# Set MADNESS version
set(MADNESS_MAJOR_VERSION 0)
set(MADNESS_MINOR_VERSION 10)
set(MADNESS_MICRO_VERSION 1)
set(MADNESS_VERSION "${MADNESS_MAJOR_VERSION}.${MADNESS_MINOR_VERSION}.${MADNESS_MICRO_VERSION}")
# Declare ourselves ============================================================
project(MADNESS
VERSION ${MADNESS_VERSION}
DESCRIPTION "MADNESS: fast, adaptive multiresolution integrodifferential calculus in 1..6 dimensions"
LANGUAGES CXX C ASM
HOMEPAGE_URL "https://madness.readthedocs.io/")
# Add source directory =========================================================
add_definitions(-DMAD_ROOT_DIR="${PROJECT_SOURCE_DIR}")
# Add module directory and modules =============================================
list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules/")
include(AddCustomTargetSubproject)
include(AddOptions)
include(AppendFlags)
include(CheckIncludeFile)
include(CheckTypeSize)
include(CheckCXXSourceCompiles)
include(CheckFunctionExists)
include(CMakeDependentOption)
include(AddMADLibrary)
include(AddMADExecutable)
include(AddUnittests)
include(AddMPITests)
include(AddScriptedTests)
include(CMakePackageConfigHelpers)
include(CopyTargetProperties)
include(FeatureSummary)
include(RedefaultableOption)
include(FetchContent)
# Check compiler feature support ===============================================
set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ ISO Standard version")
if (NOT(CMAKE_CXX_STANDARD EQUAL 17 OR CMAKE_CXX_STANDARD EQUAL 20))
message(FATAL_ERROR "C++ 2017 ISO Standard or higher is required to compile MADNESS")
endif()
# C++20 is only configurable via compile features with cmake 3.12 and older
if (CMAKE_CXX_STANDARD EQUAL 20 AND CMAKE_VERSION VERSION_LESS 3.12.0)
message(FATAL_ERROR "C++ 2020 ISO Standard requires CMake version 3.12 or higher")
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Whether to use extensions of C++ ISO Standard version")
# workaround for cmake bug: CheckCXXSourceCompiles does not respect CXX_STANDARD
# see https://github.com/OPM/opm-common/blob/master/cmake/Modules/FindCXX11Features.cmake
add_options(CXX ALL_BUILDS ${CMAKE_CXX${CMAKE_CXX_STANDARD}_STANDARD_COMPILE_OPTION})
# Set install paths ============================================================
include(GNUInstallDirs)
set(MADNESS_INSTALL_BINDIR "${CMAKE_INSTALL_BINDIR}"
CACHE PATH "MADNESS BIN install directory")
set(MADNESS_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}"
CACHE PATH "MADNESS INCLUDE install directory")
set(MADNESS_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}"
CACHE PATH "MADNESS LIB install directory")
set(MADNESS_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}/madness/${MADNESS_VERSION}/data"
CACHE PATH "MADNESS DATA install directory")
set(MADNESS_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/madness/${MADNESS_VERSION}/doc"
CACHE PATH "MADNESS DOC install directory")
set(MADNESS_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/madness"
CACHE PATH "MADNESS CMAKE install directory")
# Build options ==============================================================
redefaultable_option(MADNESS_BUILD_LIBRARIES_ONLY "Build only MADNESS libraries" OFF)
if (NOT MADNESS_BUILD_LIBRARIES_ONLY)
redefaultable_option(MADNESS_BUILD_MADWORLD_ONLY "Build only MADWorld runtime (excluding BLAS/LAPACK interfaces)" OFF)
endif()
redefaultable_option(MADNESS_ENABLE_CEREAL "Support use of Cereal archives as backends for MADNESS serialization" OFF)
# Enable optional libraries ====================================================
# Preload versions/tags of all dependencies ====================================
include(external/versions.cmake)
# Always search for libraries that are 'ON' by default. If a library is not
# found, it is disabled without error. If the library is 'OFF' by default,
# failure to find the library is an error.
option(ENABLE_MPI "Enable Message Passing Interface (MPI) Library" ON)
#redefaultable_option(ENABLE_MKL "Search for Intel Math Kernel Library (MKL) for BLAS and LAPACK support" ON)
option(ENABLE_MKL "Search for Intel Math Kernel Library (MKL) for BLAS and LAPACK support" ON)
option(ENABLE_ACML "Search for AMD Core Math Library (ACML) for BLAS and LAPACK support" ON)
option(ENABLE_TCMALLOC_MINIMAL "Enable use of tcmalloc_minimal library from Google Performance Tools (gperftools)" OFF)
option(ENABLE_GPERFTOOLS "Enable use of full Google Performance Tools (gperftools)" OFF)
option(ENABLE_LIBUNWIND
"Forces detection (and possible use) of Libunwind (normally Libunwind will be sought automatically if needed)"
OFF)
option(ENABLE_PAPI "Enables use of PAPI" OFF)
option(ENABLE_LIBXC "Enables use of the libxc library of density functionals" ON)
option(ENABLE_PCM "Enables use of the polarizable continuum model library" ON)
option(ENABLE_INTEGRATORXX "Enables use of the IntegratorXX for building DFT quadrature grids" ON)
option(ENABLE_PYTHON "Enables Python bindings via pybind11" OFF)
set(CMAKE_REQUIRED_LIBRARIES ${LAPACK_LIBRARIES})
check_cxx_source_compiles(
"
namespace madness {
template <typename T>
void mTxmq(long dimi, long dimj, long dimk,
T* __restrict__ c, const T* a, const T* b, long ldb=-1);
template <>
void mTxmq(long dimi, long dimj, long dimk, double* __restrict__ c, const double* a, const double* b, long ldb);
}
int main() { double a[1], b[1], c[1]; madness::mTxmq(1,1,1,c,a,b,1); return 0; }
" HAVE_MTXMQ)
####### preferred task backend
set(MADNESS_TASK_VALID_BACKENDS Pthreads TBB PaRSEC)
set(MADNESS_TASK_BACKEND Pthreads CACHE STRING "The backend to use for dispatching tasks")
set_property(CACHE MADNESS_TASK_BACKEND PROPERTY STRINGS ${MADNESS_TASK_VALID_BACKENDS})
if (DEFINED MADNESS_TASK_BACKEND)
if(NOT MADNESS_TASK_BACKEND IN_LIST MADNESS_TASK_VALID_BACKENDS)
message(FATAL_ERROR "MADNESS_TASK_BACKEND must be one of ${MADNESS_TASK_VALID_BACKENDS}")
endif()
if (MADNESS_TASK_BACKEND STREQUAL TBB)
set(ENABLE_TBB ON)
else()
set(ENABLE_TBB OFF)
endif()
if (MADNESS_TASK_BACKEND STREQUAL PaRSEC)
set(ENABLE_PARSEC ON)
else()
set(ENABLE_PARSEC OFF)
endif()
else (DEFINED MADNESS_TASK_BACKEND)
redefaultable_option(ENABLE_TBB "Enables use of Intel Thread Building Blocks (TBB) as the task scheduler" OFF)
option(ENABLE_PARSEC "Enables use of PaRSEC as the task scheduler" OFF)
if(ENABLE_PARSEC AND ENABLE_TBB)
message(FATAL_ERROR "TBB and PaRSEC cannot be both enabled.")
endif()
endif(DEFINED MADNESS_TASK_BACKEND)
if (ENABLE_TBB)
redefaultable_option(MADNESS_EXPLOIT_TBB_PRIORITY "Enables use of Intel TBB task priorities" OFF)
endif(ENABLE_TBB)
option(ENABLE_ELEMENTAL "Enable Elemental library for distributed-memory linear algebra" OFF)
if (ENABLE_ELEMENTAL)
if (DEFINED ELEMENTAL_TAG)
if("${ELEMENTAL_TAG}" STREQUAL "")
message(FATAL_ERROR "Invalid value given for ELEMENTAL_TAG; specify a valid hash or tag.")
endif()
message(STATUS "Will compile Elemental source (tag=${ELEMENTAL_TAG}) in the build directory")
set(ENABLE_ELEMENTAL_EMBEDDED OFF)
set(MADNESS_HAS_ELEMENTAL_EMBEDDED 0)
else (DEFINED ELEMENTAL_TAG)
message(STATUS "Will use the embedded Elemental source(tag=v0.84)")
set(ENABLE_ELEMENTAL_EMBEDDED ON)
set(MADNESS_HAS_ELEMENTAL_EMBEDDED 1)
endif (DEFINED ELEMENTAL_TAG)
set(MADNESS_HAS_ELEMENTAL 1)
else (ENABLE_ELEMENTAL)
set(MADNESS_HAS_ELEMENTAL 0)
endif (ENABLE_ELEMENTAL)
add_feature_info(Elemental ENABLE_ELEMENTAL "compiles parallel linear-algebra library Elemental as part of MADNESS")
option(ENABLE_BOOST "Enable C++ Boost Libraries" OFF)
# Configure options ============================================================
option(ENABLE_GENTENSOR "Enable generic tensor support" OFF)
add_feature_info(GENTENSOR ENABLE_GENTENSOR "enables use of MRA Function compression that allows computing in 6 dimensions")
set(MADNESS_USE_GENTENSOR ${ENABLE_GENTENSOR} CACHE BOOL
"enables use of MRA Function compression that allows computing in 6 dimensions")
if(ENABLE_GENTENSOR)
add_definitions(-DUSE_GENTENSOR)
endif()
set(TENSOR_USE_GENTENSOR ${ENABLE_GENTENSOR} CACHE BOOL "enable generic tensors")
option(ENABLE_TASK_PROFILER
"Enable task profiler that collects per-task start and stop times." OFF)
add_feature_info(TASK_PROFILER ENABLE_TASK_PROFILER "supports task-level tracing of program execution")
set(MADNESS_TASK_PROFILING ${ENABLE_TASK_PROFILER} CACHE BOOL
"Enable task profiler that collects per-task start and stop times.")
option(ENABLE_WORLD_PROFILE "Enables profiling" OFF)
add_feature_info(WORLD_PROFILE ENABLE_WORLD_PROFILE "supports simple profiling of MADworld runtime")
set(WORLD_PROFILE_ENABLE ${ENABLE_WORLD_PROFILE} CACHE BOOL
"Enables world profiling")
option(ENABLE_MEM_STATS "Gather fine-grained memory statistics (expensive)" OFF)
add_feature_info(MEM_STATS ENABLE_MEM_STATS "gather fine-grained memory statistics (expensive)")
set(WORLD_GATHER_MEM_STATS ${ENABLE_MEM_STATS} CACHE BOOL "Gather fine-grained memory statistics (expensive)")
option(ENABLE_MEM_PROFILE "Turn on instrumented aggregate memory profiling (print_meminfo)" OFF)
add_feature_info(MEM_PROFILE ENABLE_MEM_PROFILE "instrumented aggregate memory profiling")
set(WORLD_MEM_PROFILE_ENABLE ${ENABLE_MEM_PROFILE} CACHE BOOL "Turn on instrumented aggregate memory profiling (print_meminfo)")
option(ENABLE_TENSOR_BOUNDS_CHECKING
"Enable checking of bounds in tensors ... slow but useful for debugging" OFF)
add_feature_info(TENSOR_BOUNDS_CHECKING ENABLE_TENSOR_BOUNDS_CHECKING
"Enable checking of bounds in tensors ... slow but useful for debugging")
set(TENSOR_BOUNDS_CHECKING ${ENABLE_TENSOR_BOUNDS_CHECKING} CACHE BOOL
"Enable checking of bounds in tensors ... slow but useful for debugging")
option(ENABLE_TENSOR_INSTANCE_COUNT
"Enable counting of allocated tensors for memory leak detection" OFF)
add_feature_info(TENSOR_INSTANCE_COUNT ENABLE_TENSOR_INSTANCE_COUNT
"Enable counting of allocated tensors for memory leak detection")
set(TENSOR_INSTANCE_COUNT CACHE BOOL
"Enable counting of allocated tensors for memory leak detection")
option(ENABLE_SPINLOCKS
"Enables use of spinlocks instead of mutexes (faster unless over subscribing processors)" ON)
add_feature_info(SPINLOCKS ENABLE_SPINLOCKS
"Enables use of spinlocks instead of mutexes (faster unless over subscribing processors)")
set(USE_SPINLOCKS ${ENABLE_SPINLOCKS} CACHE BOOL
"Enables use of spinlocks instead of mutexes (faster unless over subscribing processors)")
option(ENABLE_NEVER_SPIN
"Disables use of spinlocks (notably for use inside virtual machines)" OFF)
add_feature_info(NEVER_SPIN ENABLE_NEVER_SPIN
"Disables use of spinlocks (notably for use inside virtual machines)")
set(NEVER_SPIN ${ENABLE_NEVER_SPIN} CACHE BOOL
"Disables use of spinlocks (notably for use inside virtual machines)")
option(ENABLE_DQ_PREBUF
"Enables thread-local buffer for task aggregation to reduce lock contention" ON)
add_feature_info(DQ_PREBUF ENABLE_DQ_PREBUF
"Enables thread-local buffer for task aggregation to reduce lock contention")
set(MADNESS_DQ_USE_PREBUF ${ENABLE_DQ_PREBUF} CACHE BOOL
"Enables thread-local buffer for task aggregation to reduce lock contention")
set(MADNESS_DQ_PREBUF_SIZE 20 CACHE STRING "Number of entries in the thread-pool prebuffer for task aggregation to reduce lock contention")
option(ENABLE_BSEND_ACKS
"Use MPI Send instead of MPI Bsend for huge message acknowledgements" ON)
add_feature_info(BSEND_ACKS ENABLE_BSEND_ACKS
"Use MPI Send instead of MPI Bsend for huge message acknowledgements")
set(MADNESS_USE_BSEND_ACKS ${ENABLE_BSEND_ACKS} CACHE BOOL
"Use MPI Send instead of MPI Bsend for huge message acknowledgements")
option(DISABLE_WORLD_GET_DEFAULT "Disables World::get_default()" OFF)
add_feature_info(WORLD_GET_DEFAULT_DISABLE DISABLE_WORLD_GET_DEFAULT "Disables World::get_default()")
set(WORLD_GET_DEFAULT_DISABLED ${DISABLE_WORLD_GET_DEFAULT} CACHE BOOL
"Disables World::get_default()")
option(ENABLE_TASK_DEBUG_TRACE
"Enable task debug tracing." OFF)
add_feature_info(TASK_DEBUG_TRACE ENABLE_TASK_DEBUG_TRACE "supports debug trace of task engine")
set(MADNESS_TASK_DEBUG_TRACE ${ENABLE_TASK_DEBUG_TRACE} CACHE BOOL
"Enable task debug tracing.")
option(ENABLE_WORLDOBJECT_FUTURE_TRACE
"Enable tracing of futures assicuated with WorldObjects." OFF)
add_feature_info(WORLDOBJECT_FUTURE_TRACE ENABLE_WORLDOBJECT_FUTURE_TRACE "supports tracing of futures associated with WorldObjects")
set(MADNESS_WORLDOBJECT_FUTURE_TRACE ${ENABLE_WORLDOBJECT_FUTURE_TRACE} CACHE BOOL
"Enable tracing of futures assicuated with WorldObjects.")
set(FORTRAN_INTEGER_SIZE 4 CACHE STRING "The fortran integer size (4 or 8 bytes) used for BLAS and LAPACK function calls")
if(NOT (FORTRAN_INTEGER_SIZE EQUAL 4 OR FORTRAN_INTEGER_SIZE EQUAL 8))
message(FATAL_ERROR "Incorrect fortran integer size '${FORTRAN_INTEGER_SIZE}'\n"
"FORTRAN_INTEGER_SIZE must be equal to 4 or 8")
endif()
add_feature_info("FORTRAN_INTEGER_SIZE=${FORTRAN_INTEGER_SIZE}" TRUE "assumes Fortran integers to be ${FORTRAN_INTEGER_SIZE} bytes long")
if (CMAKE_BUILD_TYPE STREQUAL Release OR
CMAKE_BUILD_TYPE STREQUAL MinSizeRel)
set (DEFAULT_ASSERTION_TYPE "disable")
else ()
set (DEFAULT_ASSERTION_TYPE "assert")
endif()
set(ASSERTION_TYPE ${DEFAULT_ASSERTION_TYPE} CACHE STRING "Define MADNESS assertion behavior (abort|assert|disable|throw)")
if(ASSERTION_TYPE STREQUAL "abort")
set(MADNESS_ASSERTIONS_ABORT 1)
elseif(ASSERTION_TYPE STREQUAL "assert")
set(MADNESS_ASSERTIONS_ASSERT 1)
elseif(ASSERTION_TYPE STREQUAL "disable")
set(MADNESS_ASSERTIONS_DISABLE 1)
elseif(ASSERTION_TYPE STREQUAL "throw")
set(MADNESS_ASSERTIONS_THROW 1)
else()
message(WARNING "Unsupported ASSERTION_TYPE '${ASSERTION_TYPE}'")
set(ASSERTION_TYPE "throw")
set(MADNESS_ASSERTIONS_THROW 1)
endif()
message(STATUS "Assertion type: ${ASSERTION_TYPE}")
add_feature_info("ASSERTION_TYPE=${ASSERTION_TYPE}" TRUE "controls how MADNESS assertions (MADNESS_ASSERT) are handled")
set(MPI_THREAD "multiple" CACHE STRING "Thread level for MPI (multiple|serialized)")
if(MPI_THREAD STREQUAL "multiple")
set(MADNESS_MPI_THREAD_LEVEL "MPI_THREAD_MULTIPLE")
elseif(MPI_THREAD STREQUAL "serialized")
set(MADNESS_MPI_THREAD_LEVEL "MPI_THREAD_SERIALIZED")
if (ENABLE_ELEMENTAL)
message (FATAL_ERROR "Use of Elemental precludes MPI_THREAD=serialized, must use MPI_THREAD=multiple")
endif (ENABLE_ELEMENTAL)
else()
message(FATAL_ERROR "Invalid value for MPI_THREAD '${MPI_THREAD}'; valid values are 'multiple' or 'serialized'")
endif()
add_feature_info("MPI_THREAD=${MPI_THREAD}" TRUE "controls the level of thread-safety support in MPI")
# Enable support for shared libraries ==========================================
redefaultable_option(MADNESS_ASSUMES_ASLR_DISABLED "MADNESS runtime assumes the Address Space Layout Randomization (ASLR) to be disabled" OFF)
add_feature_info(ASSUMES_ASLR_DISABLED MADNESS_ASSUMES_ASLR_DISABLED
"MADNESS runtime assumes the Address Space Layout Randomization (ASLR) to be disabled")
get_property(SUPPORTS_SHARED GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
if (SUPPORTS_SHARED AND MADNESS_ASSUMES_ASLR_DISABLED)
set(default_BUILD_SHARED_LIBS ON)
else ()
set(default_BUILD_SHARED_LIBS OFF)
endif()
redefaultable_option(BUILD_SHARED_LIBS "Enable shared libraries" default_BUILD_SHARED_LIBS)
if (BUILD_SHARED_LIBS OR NOT MADNESS_ASSUMES_ASLR_DISABLED)
set(default_CMAKE_POSITION_INDEPENDENT_CODE ON)
else ()
set(default_CMAKE_POSITION_INDEPENDENT_CODE OFF)
endif()
redefaultable_option(CMAKE_POSITION_INDEPENDENT_CODE "Default value for POSITION_INDEPENDENT_CODE of targets" default_CMAKE_POSITION_INDEPENDENT_CODE)
if(BUILD_SHARED_LIBS)
set(BLA_STATIC_DEFAULT FALSE)
set(CMAKE_MACOSX_RPATH TRUE)
else(BUILD_SHARED_LIBS)
set(BLA_STATIC_DEFAULT TRUE)
set(CMAKE_MACOSX_RPATH FALSE)
endif(BUILD_SHARED_LIBS)
if (NOT DEFINED BLA_STATIC)
set(BLA_STATIC ${BLA_STATIC_DEFAULT})
endif()
set(CMAKE_SKIP_RPATH FALSE)
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_SKIP_INSTALL_RPATH FALSE)
# Get host and platform information ============================================
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
set(ON_A_MAC 1)
# look for frameworks and appbundles last
set(CMAKE_FIND_FRAMEWORK LAST)
set(CMAKE_FIND_APPBUNDLE LAST)
endif()
if (NOT DEFINED MADNESS_CONFIGURATION_USER)
if($ENV{USERNAME})
set(MADNESS_CONFIGURATION_USER "$ENV{USERNAME}" CACHE INTERNAL "")
elseif($ENV{USER})
set(MADNESS_CONFIGURATION_USER "$ENV{USER}" CACHE INTERNAL "")
else()
set(MADNESS_CONFIGURATION_USER "$ENV{USER}" CACHE INTERNAL "")
endif()
endif (NOT DEFINED MADNESS_CONFIGURATION_USER)
if (NOT DEFINED MADNESS_CONFIGURATION_HOST)
cmake_host_system_information(RESULT madness_configuration_host QUERY HOSTNAME)
set(MADNESS_CONFIGURATION_HOST "${madness_configuration_host}" CACHE INTERNAL "")
endif (NOT DEFINED MADNESS_CONFIGURATION_HOST)
if (NOT DEFINED MADNESS_CONFIGURATION_DATE)
string(TIMESTAMP madness_configuration_date)
set(MADNESS_CONFIGURATION_DATE "${madness_configuration_date}" CACHE INTERNAL "")
endif (NOT DEFINED MADNESS_CONFIGURATION_DATE)
set(MAD_BIND_DEFAULT "OFF" CACHE STRING "The default binding for threads")
# Check if the target platform is CRAY XE
check_cxx_source_compiles(
"
#ifndef __CRAYXE
#error choke me
#endif
int main() { return 0; }
" HAVE_CRAYXE)
# Check if the target platform is CRAY XE
check_cxx_source_compiles(
"
#ifndef __CRAYXT
#error choke me
#endif
int main() { return 0; }
" HAVE_CRAYXT)
if(HAVE_CRAYXE)
set(AMD_QUADCORE_TUNE ON CACHE BOOL "Target for tuning mtxmq kernels")
set(USE_SPINLOCKS ON CACHE BOOL
"Enables use of spinlocks instead of mutexs (faster unless over subscribing processors)" FORCE)
set(MAD_BIND_DEFAULT "1 0 2" CACHE STRING "The default binding for threads" FORCE)
set(MPI_C_COMPILER cc CACHE STRING "CRAY MPI C compiler")
set(MPI_CXX_COMPILER CC CACHE STRING "CRAY MPI C++ compiler")
endif()
# Check if the target platform is BG/P
check_cxx_source_compiles(
"
#ifndef __bgp__
#error choke me
#endif
int main() { return 0; }
" HAVE_IBMBGP)
# Check if the target platform is BG/Q
check_cxx_source_compiles(
"
#ifndef __bgq__
#error choke me
#endif
int main() { return 0; }
" HAVE_IBMBGQ)
if(HAVE_IBMBGQ OR HAVE_IBMBGP)
set(USE_SPINLOCKS ON CACHE BOOL
"Enables use of spinlocks instead of mutexs (faster unless over subscribing processors)" FORCE)
endif()
# Check if the target is x86_64
check_cxx_source_compiles(
"
#if !(defined(__x86_64__) || defined(_M_X64))
#error Not x86_64
#endif
int main() { return 0; }
" USE_X86_64_ASM)
if(NOT USE_X86_64_ASM)
# Check if the target is x86
check_cxx_source_compiles(
"
#if !(defined(__i386) || defined(_M_IX86))
#error Not x86
#endif
int main() { return 0; }
" USE_X86_32_ASM)
endif()
# (try to) determine C++ ABI
# ABI kinds are named as in https://clang.llvm.org/doxygen/classclang_1_1TargetCXXABI.html
# we only need ABI for serializing member pointers, hence all ARM-based ABIs are represented by same kind
set(MADNESS_CXX_ABI_GenericItanium 1)
set(MADNESS_CXX_ABI_GenericARM 2)
set(MADNESS_CXX_ABI_Microsoft 3)
if (NOT CMAKE_SYSTEM_PROCESSOR)
set(processor_name ${CMAKE_HOST_SYSTEM_PROCESSOR})
else(NOT CMAKE_SYSTEM_PROCESSOR)
set(processor_name ${CMAKE_SYSTEM_PROCESSOR})
endif(NOT CMAKE_SYSTEM_PROCESSOR)
if(processor_name MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*)" OR processor_name MATCHES "^(arm.*|ARM.*)" OR processor_name MATCHES "^(mips.*|MIPS.*)")
# on ARM everything, including Windows, targets ARM C++ ABI
set(MADNESS_CXX_ABI ${MADNESS_CXX_ABI_GenericARM})
elseif(processor_name MATCHES "amd64.*|x86_64.*|AMD64.*" OR processor_name MATCHES "i686.*|i386.*|x86.*" OR processor_name MATCHES "^(powerpc|ppc)64le" OR processor_name MATCHES "^(powerpc|ppc)64")
if (CMAKE_SYSTEM_NAME STREQUAL Windows) # on x86 Windows all compilers (clang, intel) target Windows C++ ABI
set(MADNESS_CXX_ABI ${MADNESS_CXX_ABI_Microsoft})
else (CMAKE_SYSTEM_NAME STREQUAL Windows) # everyone else uses Itanium C++ ABI
set(MADNESS_CXX_ABI ${MADNESS_CXX_ABI_GenericItanium})
endif (CMAKE_SYSTEM_NAME STREQUAL Windows)
else()
message(FATAL_ERROR "Cannot determine C++ ABI for CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}, please file an issue")
endif()
# Check compiler feature support ===============================================
# Check for system include files
check_include_file(sys/stat.h HAVE_SYS_STAT_H)
check_include_file(sys/types.h HAVE_SYS_TYPES_H)
check_include_file(unistd.h HAVE_UNISTD_H)
check_include_file(sys/resource.h HAVE_RESOURCE_H)
if(MADNESS_TASK_PROFILING)
check_include_file(execinfo.h HAVE_EXECINFO_H)
check_include_file(cxxabi.h HAVE_CXXABI_H)
if(NOT (HAVE_EXECINFO_H AND HAVE_CXXABI_H))
message(FATAL_ERROR "Unable to find required header files execinfo.h and/or cxxabi.h")
endif()
endif()
# Check type support
check_type_size("int64_t" HAVE_INT64_T)
check_type_size("long double" HAVE_LONG_DOUBLE)
check_type_size("long long" HAVE_LONG_LONG)
check_cxx_source_compiles(
"
#include <sys/types.h>
int main() { typedef pid_t test_t; return 0; }
" SYS_TYPES_H_HAS_PID_T)
# Check function support
check_function_exists(fork HAVE_FORK)
check_function_exists(memset HAVE_MEMSET)
check_function_exists(posix_memalign HAVE_POSIX_MEMALIGN)
if(HAVE_POSIX_MEMALIGN)
# look for both version of posix_memalign, with and without throw()
check_cxx_source_compiles(
"
#include <stddef.h>
#include <stdlib.h>
extern \"C\" int posix_memalign(void **memptr, size_t alignment, size_t size) throw();
int main() { void *m; posix_memalign(&m, 16, 1024); }
" CHECK_STDLIB_H_HAS_POSIX_MEMALIGN_THROW)
if(NOT CHECK_STDLIB_H_HAS_POSIX_MEMALIGN_THROW)
check_cxx_source_compiles(
"
#include <stddef.h>
#include <stdlib.h>
extern \"C\" int posix_memalign(void **memptr, size_t alignment, size_t size);
int main() { void *m; posix_memalign(&m, 16, 1024); }
" CHECK_STDLIB_H_HAS_POSIX_MEMALIGN)
endif()
if(NOT CHECK_STDLIB_H_HAS_POSIX_MEMALIGN_THROW AND NOT CHECK_STDLIB_H_HAS_POSIX_MEMALIGN)
set(MISSING_POSIX_MEMALIGN_PROTO 1)
endif()
else()
message(WARNING "posix_memalign NOT FOUND ... enabling override of new/delete ... THIS WILL BE SLOW")
endif()
check_function_exists(pow HAVE_POW)
check_function_exists(random HAVE_RANDOM)
check_function_exists(sleep HAVE_SLEEP)
check_function_exists(strchr HAVE_STRCHR)
# look for both version of posix_memalign, with and without throw()
check_cxx_source_compiles(
"
#include <cmath>
#include <cstdlib>
long (*absptr)(long) = &std::abs;
long a = -1;
long b = std::abs(a);
int main() { return 0; }
" HAVE_STD_ABS_LONG)
if(NOT HAVE_STD_ABS_LONG)
check_cxx_source_compiles(
"
#include <cmath>
#include <cstdlib>
long (*labsptr)(long) = &std::labs;
long a = -1l;
long b = labs(a);
int main() { return 0; }
" HAVE_LABS)
endif()
if(NOT CHECK_STDLIB_H_HAS_POSIX_MEMALIGN_THROW AND NOT CHECK_STDLIB_H_HAS_POSIX_MEMALIGN)
set(MISSING_POSIX_MEMALIGN_PROTO 1)
endif()
# Check for thread local storage keyword support.
# thread_local, __thread , __thread_local, or __declspec(thread)
if(NOT DEFINED THREAD_LOCAL_KEYWORD)
foreach(_thread_local_keyword thread_local __thread __thread_local)
check_cxx_source_compiles(
"
${_thread_local_keyword} int i = 0;
int main() { i = 1; return 0; }
" THREAD_LOCAL_SUPPORT)
if(THREAD_LOCAL_SUPPORT AND _thread_local_keyword STREQUAL "thread_local")
message(STATUS "Thread local keyword: thread_local")
unset(THREAD_LOCAL_KEYWORD CACHE)
break()
elseif(THREAD_LOCAL_SUPPORT)
message(STATUS "Thread local keyword: ${_thread_local_keyword}")
set(THREAD_LOCAL_KEYWORD "${_thread_local_keyword}"
CACHE STRING "thread local storage keyword, 'thread_local' in C++>11")
break()
else()
unset(THREAD_LOCAL_SUPPORT CACHE)
endif()
endforeach()
if(NOT DEFINED THREAD_LOCAL_SUPPORT)
message(FATAL_ERROR "Unable to detect mandatory support for thread-local storage")
endif()
endif()
# Check for restrict keyword support
# restrict, __restrict, __restrict__, or _Restrict
if(NOT DEFINED RESTRICT_KEYWORD)
foreach(_restrict_keyword restrict __restrict __restrict__ _Restrict)
check_cxx_source_compiles(
"
int* ${_restrict_keyword} i = nullptr;
int main() { *i = 1; return 0; }
" RESTRICT_SUPPORT)
if(RESTRICT_SUPPORT AND _restrict_keyword STREQUAL "restrict")
unset(RESTRICT_KEYWORD CACHE)
break()
elseif(RESTRICT_SUPPORT)
set(RESTRICT_KEYWORD "${_restrict_keyword}"
CACHE STRING "C++ equivialent of the C 'restrict' keyword")
break()
else()
unset(RESTRICT_SUPPORT CACHE)
endif()
endforeach()
if(NOT DEFINED RESTRICT_SUPPORT)
# Set the restrict keyword to nothing so that it is not used
set(RESTRICT_KEYWORD ""
CACHE STRING "C++ equivialent of the C 'restrict' keyword")
endif()
# Print restrict keyword search results
message(STATUS "Restrict keyword: ${RESTRICT_KEYWORD}")
endif()
check_cxx_source_compiles(
"
template <typename T>
static inline void f(T* a) {};
template <typename T> void g(T* a) { f(a); }
template void g(int* a);
int main() { return 0; }
" HAVE_UNQUALIFIED_STATIC_DECL)
# Check linker feature support ===============================================
include(CheckDisablePIESupport)
check_disablepie_support(LINKER_HAS_DISABLEPIE_SUPPORT DISABLEPIE_LINKER_FLAG)
# Check for applications =======================================================
find_package(Doxygen)
find_package(LATEX)
find_program(XTERM_EXECUTABLE xterm)
if(XTERM_EXECUTABLE)
set(HAVE_XTERM 1)
message(STATUS "Found xterm: ${XTERM_EXECUTABLE}")
endif()
find_program(GDB_EXECUTABLE gdb)
if(GDB_EXECUTABLE)
set(HAVE_GDB 1)
message(STATUS "Found gdb: ${GDB_EXECUTABLE}")
endif()
find_program(LLDB_EXECUTABLE lldb)
if(LLDB_EXECUTABLE)
set(HAVE_LLDB 1)
message(STATUS "Found lldb: ${LLDB_EXECUTABLE}")
endif()
# ccache for caching builds
find_program(CCACHE ccache)
if(CCACHE)
mark_as_advanced(CCACHE)
message (STATUS "Found ccache: ${CCACHE}")
set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE}" CACHE STRING "Compiler launcher to use for compiling C++")
set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE}" CACHE STRING "Compiler launcher to use for compiling C")
endif(CCACHE)
# Check for external dependencies ==============================================
include(external/pthread.cmake)
include(external/mpi.cmake)
include(external/papi.cmake)
include(external/libunwind.cmake)
include(external/gperftools.cmake)
include(external/tbb.cmake)
include(external/parsec.cmake)
include(external/boost.cmake)
if (NOT MADNESS_BUILD_MADWORLD_ONLY OR MADNESS_BUILD_LIBRARIES_ONLY)
include(external/lapack.cmake)
include(external/libxc.cmake)
include(external/pcm.cmake)
include(external/integratorxx.cmake)
endif ()
include(external/pybind11.cmake)
if (DEFINED ELEMENTAL_TAG)
include(external/elemental.cmake)
endif (DEFINED ELEMENTAL_TAG)
# Add project subdirectories ===================================================
# predefine targets
add_custom_target(everything)
add_dependencies(everything madness)
if(NOT (MADNESS_BUILD_MADWORLD_ONLY OR MADNESS_BUILD_LIBRARIES_ONLY) AND LAPACK_FOUND)
add_custom_target_subproject(madness numerical-examples)
add_custom_target_subproject(madness applications)
endif()
# Create build and install libraries libraries
add_custom_target(madness-libraries)
add_custom_target(install-madness-libraries)
add_dependencies(everything madness-libraries)
include_directories(${PROJECT_SOURCE_DIR}/src ${PROJECT_BINARY_DIR}/src)
set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE TRUE)
set(CMAKE_INCLUDE_CURRENT_DIR TRUE)
include(CTest)
if(BUILD_TESTING)
set(MADNESS_HAS_GOOGLE_TEST 1)
add_custom_target_subproject(madness unittests)
add_custom_target_subproject(madness scripted_tests)
add_custom_target_subproject(madness check COMMAND ${CMAKE_CTEST_COMMAND} -V -R "madness/test/" USES_TERMINAL) # to be GNU compatible
add_custom_target_subproject(madness check-short COMMAND ${CMAKE_CTEST_COMMAND} -L \"short|medium\" -V -R "madness/test/" USES_TERMINAL) # to be GNU compatible
add_dependencies(everything unittests)
endif()
add_subdirectory(src)
add_subdirectory(doc)
# Generate configure files =====================================================
configure_file(
${PROJECT_SOURCE_DIR}/cmake/config.h.in
${PROJECT_BINARY_DIR}/src/madness/config.h
)
configure_file(
${PROJECT_SOURCE_DIR}/cmake/doxygen.cfg.in
${PROJECT_BINARY_DIR}/doc/doxygen.cfg
@ONLY
)
CONFIGURE_FILE(
${PROJECT_SOURCE_DIR}/config/MADNESS.pc.in
${PROJECT_BINARY_DIR}/config/MADNESS.pc
)
CONFIGURE_FILE(
${PROJECT_SOURCE_DIR}/admin/conda/Makefile.in
${PROJECT_BINARY_DIR}/admin/conda/Makefile
@ONLY
)
CONFIGURE_FILE(
${PROJECT_SOURCE_DIR}/admin/conda/recipe/build.sh.in
${PROJECT_BINARY_DIR}/admin/conda/recipe/build.sh
@ONLY
)
CONFIGURE_FILE(
${PROJECT_SOURCE_DIR}/admin/conda/recipe/meta.yaml.in
${PROJECT_BINARY_DIR}/admin/conda/recipe/meta.yaml
@ONLY
)
# install config files
install(FILES ${PROJECT_BINARY_DIR}/config/MADNESS.pc
DESTINATION lib/pkgconfig)
# Install some CMake modules
install(FILES
"${PROJECT_SOURCE_DIR}/cmake/modules/FindTBB.cmake"
DESTINATION "${MADNESS_INSTALL_CMAKEDIR}/modules"
COMPONENT madness-config)
# Create the version file
write_basic_package_version_file(madness-config-version.cmake
VERSION ${MADNESS_VERSION} COMPATIBILITY AnyNewerVersion)
# Create the targets file for madness export set
# N.B. ALL targets end up in madness export set, even if building only madworld
export(EXPORT madness FILE "${PROJECT_BINARY_DIR}/madness-targets.cmake")
# Create the configure file
configure_package_config_file(cmake/madness-config.cmake.in
"${MADNESS_BINARY_DIR}/madness-config.cmake"
INSTALL_DESTINATION "${MADNESS_INSTALL_CMAKEDIR}"
PATH_VARS CMAKE_INSTALL_PREFIX MADNESS_INSTALL_BINDIR
MADNESS_INSTALL_INCLUDEDIR MADNESS_INSTALL_LIBDIR
MADNESS_INSTALL_DATADIR MADNESS_INSTALL_DOCDIR
MADNESS_INSTALL_CMAKEDIR)
# Install config, version, and target files
install(EXPORT madness
FILE "madness-targets.cmake"
DESTINATION "${MADNESS_INSTALL_CMAKEDIR}"
COMPONENT madness-config)
install(FILES
"${MADNESS_BINARY_DIR}/madness-config.cmake"
"${MADNESS_BINARY_DIR}/madness-config-version.cmake"
DESTINATION "${MADNESS_INSTALL_CMAKEDIR}"
COMPONENT madness-config)
add_custom_target(install-madness-config
COMMAND ${CMAKE_COMMAND} -DCOMPONENT=madness-config -P ${PROJECT_BINARY_DIR}/cmake_install.cmake
COMMENT "Installing MADNESS config components"
USES_TERMINAL)
# Add feature info for MPI tests
if(MADNESS_HAS_MPI_TESTS)
add_feature_info("MPI tests" MADNESS_HAS_MPI_TESTS "MPI tests with multiple processes are configured (use MADNESS_MPI_NODE_OPTIONS at runtime to control execution)")
endif()
feature_summary(WHAT ALL
DESCRIPTION "=== MADNESS Package/Feature Info ===")
================================================
FILE: INSTALL.md
================================================
## Introduction
Linux and MacOS are supported with x86, Arm64, and IBM Power processors. GPUs are not yet utilized.
MADNESS uses CMake to configure the build. Assuming that necessary prerequisites (below) are installed on your system in default locations and the source has been downloaded into the directory `/path/to/madness/source`, you can make a directory (outside the source tree) to build in and configure the build as follows
```
mkdir build
cd build
cmake /path/to/madness/source
make applications
```
The default make target builds only the numerical library and underlying runtime. To build applications (e.g., `moldft`, `nemo`) specify either `applications` (for all of them) or the name of the desired application on the make command. The target `everything` does what you expect. You can run executables and use libraries from the build directory, but to install into the default location (`/usr`) use `make install` (after first building the applications).
If required libraries are not in default locations or if you wish to override defaults, you may have to set CMake cache variables as described below. For instance, to build a debug version, without MPI, and with installation in `/home/me/madinstall`
```
cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_MPI=OFF -DCMAKE_INSTALL_PREFIX=/home/me/madinstall /path/to/madness/source
make applications
make install
```
Boolean values for cache variables (specified to CMake using the `-DVARIABLE_NAME` notation in the example above) are
considered true if the constant is 1, ON, YES, TRUE, Y, or a non-zero number; or false if the constant is 0, OFF, NO, FALSE, N, or IGNORE.
## Prerequisites
Fast BLAS and linear algebra libraries are essential. These must be sequential (single thread) implementations since MADNESS uses tasks/threads for parallelism and invokes the BLAS within a single-threaded task. On X86, we recommend the free [Intel MKL library](https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html#gs.8bsxug), which is auto detected on all platforms if the environment variable `MKLROOT` is set. On MacOS, the Apple [Accelerate](https://developer.apple.com/documentation/accelerate) framework (installed as part of [Xcode](https://developer.apple.com/xcode/)) is also autodetected. AMD ACML has not been tested in a while but can be enabled with the CMake variables below. Other libraries need to have their link (and possibly also header) paths and flags provided in the CMake variables for the compiler and linker. On ARM, we recommend the ARM performance library available with their optimized LLVM compiler and enabled with the `-armpl`` compiler+linker flag. The OpenBLAS libary for ARM (not on x86) had a major peformance problem when we last tested it in circa 2020 due to a mutex around a memory block shared by all threads (this issue was reported and might be fixed by now).
An MPI library is required by default, and should be autodected primarily by looking for the `mpicxx` command to compile C++ code with MPI. If you wish to overide this, use the appropriate cmake or environment variables (below). You can also disable use of MPI using `-DENABLE_MPI=OFF` --- in this case you can still use all cores within a shared memory computer.
MADNESS will autodetect the [Intel TBB library](https://www.intel.com/content/www/us/en/developer/tools/oneapi/onetbb.html#gs.8byhgg), which is available for free from Intel or via standard Linux package managers (even on ARM). TBB provides a fast task pool. If this is not detected, MADNESS will employ its own task pool. [PaRSEC](https://icl.utk.edu/parsec/) can also be used (see variables below) but is not recommended unless you are using MADNESS with the [Template Task Graph](https://github.com/TESSEorg/ttg).
### Minimal Ubuntu packages
If you are using a different distribution, just change the name of the command to install packages.
From a vanilla desktop install of Ubuntu (tested with 23.0.4)
```
sudo apt install build-essential cmake gcc g++ git intel-mkl mpich
```
If you want to build the documentation then also
```
sudo apt install doxygen graphviz texlive
```
### Minimal MacOS packages
To be written
The below summarizes some of the most useful CMake variables.
## Compiler variables
The following CMake cache variables are used to specify the compilers, compiler
flags, and linker flags.
* CMAKE_C_COMPILER --- C compiler [default=search]
* CMAKE_CXX_COMPILER --- C++ compiler [default=search]
* CMAKE_ASM_COMPILER --- Assembly compiler [default=search]
* MPI_CXX_COMPILER --- MPI C++ compiler wrapper [default=search]
* MPI_C_COMPILER --- MPI C compiler wrapper [default=search]
You can specify compile flags with the following variables. These cache variables
are optional, and it is typically not necessary to specify these variables.
* CMAKE_C_FLAGS --- Compile flags passed to the C compiler
* CMAKE_CXX_FLAGS --- Compile flags passed to the C++ compiler
* CMAKE_EXE_LINKER_FLAGS --- Linker flags to be used to create executables.
* CMAKE_STATIC_LINKER_FLAGS --- Linker flags to be used to create static
libraries.
* CMAKE_SHARED_LINKER_FLAGS --- Linker flags to be used to create shared
libraries.
## Build options
The following CMake cache variables turn features on and off.
* CMAKE_BUILD_TYPE --- Debug or Release
* ENABLE_GENTENSOR --- Enable generic tensors; only useful if need
compressed 6-d tensors, e.g. in MP2 [default=OFF]
* ENABLE_TASK_PROFILER - Enable task profiler that collects per-task start and
stop times. [default=OFF]
* ENABLE_WORLD_PROFILE --- Enables world profiling [default=OFF]
* ENABLE_MEM_STATS --- Gather memory statistics (expensive) (default=OFF)
* ENABLE_TENSOR_BOUNDS_CHECKING --- Enable checking of bounds in tensors ...
slow but useful for debugging [default=OFF]
* ENABLE_TENSOR_INSTANCE_COUNT --- Enable counting of allocated tensors for
memory leak detection [default=OFF]
* ENABLE_SPINLOCKS --- Enables use of spinlocks instead of mutexes (faster
unless over subscribing processors) [default=ON]
* ENABLE_NEVER_SPIN --- Disables use of spinlocks (notably for use inside
virtual machines [default=OFF]
* ENABLE_BSEND_ACKS --- Use MPI Send instead of MPI Bsend for huge message
acknowledgements [default=ON]
* BUILD_TESTING --- Enables unit tests targets [default=ON]
* FORTRAN_INTEGER_SIZE --- Set the fortran integer size (4 or 8 bytes) used for
BLAS and LAPACK function calls [default=4]
* ASSERTION_TYPE --- Define MADNESS assertion behavior
(abort|assert|disable|throw) [default=throw]
* MPI_THREAD --- Thread level for MPI (multiple|serialized)" [default=multiple]
* BUILD_SHARED_LIBS --- Enable shared libraries. This option is only available
if the platform supports shared libraries; if that's true and MADNESS_ASSUMES_ASLR_DISABLED is ON (see below) the default is ON,
otherwise the default is OFF.
* MADNESS_BUILD_MADWORLD_ONLY --- whether to build the MADNESS runtime only; if `ON`, discovery of BLAS/LAPACK
and building of numerical components and applications will be disabled [default=`OFF`]
* MADNESS_BUILD_LIBRARIES_ONLY --- whether to build the MADNESS libraries only; if `ON`,
building of numerical components and applications will be disabled and
the value of `MADNESS_BUILD_MADWORLD_ONLY` ignored [default=`OFF`]
## External libraries
The following CMake cache variables enable the use of external libraries with
MADNESS. If the WITH_* variable is set to "ON" by default, failure to find the
external library is not an error. If you explicitly set a WITH_* variable to
"ON" when the default is set to "OFF," an error will occur if the library is
not found.
* CMAKE_PREFIX_PATH - A semicolon seperated list of paths that are used when
searching for external libraries and dependencies. You may use this CMake
cache variable to specify the prefix for any of the dependencies, or you
may specify path for individual components below.
* ENABLE_MPI --- Enable use of MPI, should specify MPI_CXX_COMPILER or MPI_C_COMPILER
explicitly or have them in PATH; if not found will use StubMPI and
be limited to 1 process [default=ON]
In the following section, each optional library privides four variables that
the user can use to enable cmake to find the correct dependencies:
* ENABLE_<LIB> --- Enable the library feathres (ON|OFF)
* <LIB>_ROOT_DIR --- Prefix path used to search for the external library.
* <LIB>_INCLUDE_DIR --- The external library include path. By default the
include path is ${<LIB>_ROOT_DIR}/include, if <LIB>_ROOT_DIR is
specified in the configure command.
* <LIB>_LIBRARY --- The external library path. By default the
include path is ${<LIB>_ROOT_DIR}/(lib64|lib), if <LIB>_ROOT_DIR is
specified in the configure command.
If the <LIB>_ROOT_DIR, <LIB>_INCLUDE_DIR, and <LIB>_LIBRARY will be used to
search for specific dependencies. If the external library is not found in these
given paths, or if the paths are not given, CMake will search the paths in
CMAKE_PREFIX_PATH as well as other system paths.
### Library of Exchange-Correlation DFT functionals (LIBXC):
MADNESS can look for LibXC built/installed using CMake by default. You can help MADNESS find
LibXC by providing hints to `find_package()`, e.g., by adding the installation prefix of LibXC to `CMAKE_PREFIX_PATH`.
To disable search for LibXC configure with `ENABLE_LIBXC=OFF`.
E.g.,
```
cmake -DENABLE_LIBXC=ON -DCMAKE_PREFIX_PATH=/home/rjh/install ../madness
```
### Intel Threading Building Blocks (TBB):
* Define MADNESS_TASK_BACKEND=TBB --- this should auto detect TBB if it is installed in a standard location. If it is not, you'll have to also define
* TBB_ROOT_DIR --- The install prefix for TBB. If TBB_ROOT_DIR is not given, it will be set to the value of the TBBROOT environment variable if it is set. And if `cmake` still does not detect things you can set
* TBB_INCLUDE_DIR --- The path to the TBB include directory
* TBB_LIBRARY --- The path to the TBB library directory. By default, the library
search path is ${TBB_ROOT_DIR}/(lib/intel64/gcc4.4|lib) on Linux and
${TBB_ROOT_DIR}/(lib/libc++|lib) on OS X, if TBB_ROOT_DIR is specified in
the configure command.
* Optionally, MADNESS_EXPLOIT_TBB_PRIORITY --- If ON, MADNESS will try to use Intel TBB task priorities [default=OFF]
### Intel Math Kernel Library (MKL):
* ENABLE_MKL --- Search for Intel MKL for BLAS and LAPACK support [default=ON]
* MKL_ROOT_DIR --- The install prefix for MKL.
* MKL_LIBRARY --- The path to the MKL library directory.
If MKL_ROOT_DIR is not given, it will be set to the value of the MKLROOT environment variable if it is set.
### AMD Core Math Library (ACML):
*This is out of date since ACML is now AOCL.*
* ENABLE_ACML --- Search for AMD math library for BLAS and LAPACK support
[default=ON]
* ACML_ROOT_DIR --- The install prefix for ACML.
* ACML_LIBRARY --- The path to the ACML library directory.
### Google Performance Tools (Gperftools):
* ENABLE_GPERFTOOLS --- Enable use of gperftools, including tcmalloc.
[default=OFF]
* ENABLE_TCMALLOC_MINIMAL --- Enable use of the minimal tcmalloc library only.
[default=OFF]
* GPERFTOOLS_ROOT_DIR --- The install prefix for gperftools.
* GPERFTOOLS_INCLUDE_DIR --- The path to the gperftools include directory.
* GPERFTOOLS_LIBRARY --- The path to the gperftools library directory.
If GPERFTOOLS_ROOT_DIR is not given, it will be set to the value of the GPERFTOOLS_DIR environment variable if it is set.
### Libunwind:
* ENABLE_LIBUNWIND --- Force detection of gperftools [default=OFF, i.e. Libunwind will be searched for when needed]
* LIBUNWIND_DIR --- The install prefix for Libunwind.
If LIBUNWIND_DIR is not given, it will be set to the value of the LIBUNWIND_DIR environment variable if it is set.
### IntegratorXX for numerical integration via DFT grids
* ENABLE_INTEGRATORXX --- Enables use of IntegratorXX
* INTEGRATORXX_ROOT_DIR --- The install prefix for IntegratorXX
* INTEGRATORXX_INCLUDE_DIR --- The path to the IntegratorXX include directory (should be added automatically when the correct PCM_ROOT_DIR is given)
IntegratorXX is a library for numerical integration via DFT grids. It is used in the MP3 code of Madness for
generating low-rank representations of 6D functions.
If IntegratorXX absent, a Gaussian-distributed random grid will be used, leading to slightly varying results in
different MP3 runs.
### Polarizable Conitinuum Solver (PCM):
* ENABLE_PCM --- Enables use of PCM
* PCM_ROOT_DIR --- The install prefix for PCM
* PCM_INCLUDE_DIR --- The path to the PCM include directory (should be added automatically when the correct PCM_ROOT_DIR is given)
* PCM_LIBRARY --- The path to the PCM library (should be added automatically when the correct PCM_ROOT_DIR is given)
set either PCM_ROOT_DIR or manually set PCM_INCLUDE_DIR and PCM_LIBRARY
See also
madness/CMakeLists.txt
madness/external/pcm.cmake
madness/modules/FindPCM.cmake
madness/src/apps/chem/CMakeLists.txt
### Performance Application Programming Interface (PAPI):
* ENABLE_PAPI --- Enables use of PAPI [default=OFF]
* PAPI_ROOT_DIR --- The install prefix for PAPI.
* PAPI_INCLUDE_DIR --- The path to the PAPI include directory.
* PAPI_LIBRARY --- The path to the PAPI library directory.
### Elemental parallel linear algebra library:
*This has not been tested in some time.*
Elemental provides optional distributed-memory linear algebra for some MADNESS application codes.
MADNESS source includes (modified) Elemental v0.84, which has been validated to work with
the few MADNESS apps that can use Elemental. You can instruct MADNESS to download and compile
a more recent version of Elemental, if desired, but the apps will not use Elemental then.
Such bundling is currently necessary if your code uses the MADworld runtime AND Elemental because
madness::initialize will call El::initialize() .
* ENABLE_ELEMENTAL --- Enable Elemental [default=OFF].
* ELEMENTAL_TAG --- specifies the version of Elemental to be downloaded, compiled, and installed alongside
MADNESS (numerical codes of MADNESS will not use Elemental).
If not set, will use the included Elemental source.
### Parallel Runtime Scheduling and Execution Controller (PaRSEC):
Recommended only for TTG development.
* ENABLE_PARSEC --- Enables use of PaRSEC as the task scheduler [default=OFF]. The use of Intel TBB should be disabled
to use PaRSEC.
If ENABLE_PARSEC is set but PaRSEC is not found, it will be built from source.
## MADNESS Runtime and the Address Space Layout Randomization (ASLR)
If you can run with one process and are getting almost immediate segmentation violations with more processes, this might be the issue.
ASLR (Linux relevant documentation [here](https://linux-audit.com/linux-aslr-and-kernelrandomize_va_space-setting/))
is a standard technique for increasing platform security implemented by the OS kernel and/or
the dynamic linker. By randomizing both where the shared libraries are loaded as well as (when enabled) the absolute
position of the executable in memory (such executables are known as position-independent executables). Until recently
MADNESS could only be used with MPI on platforms with ASLR if built with static libraries (for MADNESS code; system and other libraries could still be shared). However, static libraries make it hard to integrate with Python and other frameworks that demand shared libraries.
If properly configured and built, MADNESS can now be used on ASLR platforms using either static (the default and easiest) or shared libraries. Use the following variables to control the ASLR-related aspects of MADNESS runtime.
* MADNESS_ASSUMES_ASLR_DISABLED --- MADNESS runtime will assume that the Address Space Layout Randomization (ASLR) is off.
By default MADNESS_ASSUMES_ASLR_DISABLED is set to OFF (i.e. MADNESS will assume that ASLR is enabled);
this will cause all libraries by default to be static (BUILD_SHARED_LIBS=OFF)
and compiled as position-independent code (CMAKE_POSITION_INDEPENDENT_CODE=ON).
This will also enable a runtime check for ASLR.
* CMAKE_POSITION_INDEPENDENT_CODE --- This standard CMake variable controls whether targets are compiled by default
as position-independent code or not. If BUILD_SHARED_LIBS=OFF need to set this to ON if want to use the MADNESS
libraries to build shared libraries or position-independent executables.
To make things more concrete, consider the following 2 scenarios:
* Platform with ASLR disabled --- set MADNESS_ASSUMES_ASLR_DISABLED=ON to set defaults correctly and enable the ASLR check.
BUILD_SHARED_LIBS can be set to ON (to produce shared libraries, e.g. to save space) or to OFF to
produce static libraries. If the static libraries will be linked into shared libraries set
CMAKE_POSITION_INDEPENDENT_CODE=ON, otherwise CMAKE_POSITION_INDEPENDENT_CODE will be set to OFF for maximum efficiency
of function calls.
* Platform with ASLR enabled --- this is the default. Setting BUILD_SHARED_LIBS=ON in this scenario will produce
executables that can only be safely used with 1 MPI rank, thus BUILD_SHARED_LIBS will be defaulted to OFF (i.e.
MADNESS libraries will be build as static libraries). CMAKE_POSITION_INDEPENDENT_CODE is by default set to ON,
thus MADNESS libraries can be linked into position-independent executables safely. MADNESS libraries can also be
linked into a shared library and used with more than 1 MPI rank, provided that *ALL* code using MADNESS is part of the *SAME* shared library.
E.g. to link MADNESS into a Python module compile MADNESS and all libraries using MADNESS as shared libraries
(with CMAKE_POSITION_INDEPENDENT_CODE=ON) and link them all together into a single module.
## Warning about fast memory allocators
Summary: Only use fast memory allocators if you are using just 1 MPI process or have configured without MPI.
Depending on the calculation and the number of threads being used, MADNESS can receive about a 10% or even more speedup from fast memory allocators such as tcmalloc, jemalloc, tbbmalloc, etc. However, these **do not work with MPI over InfiniBand** and probably most other transport layers. It can appear to work, and then fail with either wrong numbers or MPI errors. The reason is that IB requires that memory be pinned and hence MPI introduces its own memory allocator(s) to manage this. By overriding the allocator, you will break the guarantee that memory is pinned.
## Toolchain files
**Use of these files is now deprecated --- configuration should usually work without this.** However, they can be useful if all else fails or on "bleeding-edge" supercomputers with non-standard software environments.
MADNESS provides toolchain files for select systems. They contain the platform specific settings
neccessary to build on the given platform. The toolchain files are included with
the MADNESS source in the cmake/toolchains directory.
* CMAKE_TOOLCHAIN_FILE --- Specifies the path (including the file name) to the
toolchain file.
For example, to specify the toolchain file for Mira:
$ cmake -D CMAKE_TOOLCHAIN_FILE=/path/to/madness/source/cmake/toolchains/mira-gcc-essl.cmake \
/path/to/madness/source
================================================
FILE: LICENSE
================================================
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
================================================
FILE: README.md
================================================
MADNESS
=======
Multiresolution Adaptive Numerical Environment for Scientific Simulation
# Summary
MADNESS provides a high-level environment for the solution of integral and differential equations in many dimensions using adaptive, fast methods with guaranteed precision based on multi-resolution analysis and novel separated representations.
There are three main components to MADNESS. At the lowest level is a new petascale parallel programming environment that increases programmer productivity and code performance/scalability while maintaining backward compatibility with current programming tools such as MPI and Global Arrays. The numerical capabilities built upon the parallel tools provide a high-level environment for composing and solving numerical problems in many (1-6+) dimensions.
Finally, built upon the numerical tools are new applications with initial focus upon chemistry, atomic and molecular physics, material science, and nuclear structure.
User documentation can be found on [readthedocs](https://madness.readthedocs.io/en/latest/).
Developer documentation generated by doxygen can be found [here](https://m-a-d-n-e-s-s.github.io/madness/api-doc/).
## Python bindings
**[pymadness](src/pymadness/README.md)** provides Python bindings for MADNESS, exposing `Function<T,NDIM>` (1D–6D), integral operators, and derivatives to Python. Build with `cmake -DENABLE_PYTHON=ON`.
Here's a [video](http://www.youtube.com/watch?v=dBwWjmf5Tic) about MADNESS.
# Projects using MADNESS
A non-exhaustive list of downstream projects built on MADNESS:
* [TiledArray (TA)](https://github.com/ValeevGroup/tiledarray) — massively-parallel block-sparse tensor framework; consumes the MADNESS parallel runtime (MADWorld).
* [MPQC](https://github.com/ValeevGroup/mpqc) — Massively Parallel Quantum Chemistry program; uses the MRA layer (`Function<T,NDIM>`, operators) and MADWorld through TA.
* [Tequila](https://github.com/tequilahub/tequila) — quantum-algorithm development framework; uses MADNESS for classical chemistry back-ends.
* [FrayedEnds](https://github.com/FabianLangkabel/FrayedEnds) — correlated electronic-structure code built on MADNESS MRA.
# Funding
The developers gratefully acknowledge the support of:
* The Department of Energy, Office of Science, Office of Basic Energy Sciences "Numerically-Exact Relativistic ManyBody Electronic Structure of Heavy Elements" grant DE-SC0022327 ((Valeev, Virginia Tech, PI).
* The EPEXA project, currently supported by the National Science Foundation under grants 1931387 at Stony Brook University, 1931347 at Virginia Tech, and 1931384 at the University of Tennesse, Knoxville.
* The TESSE project, supported by the National Science Foundation under grants 1450344 at Stony Brook University, 1450262 at Virginia Tech, and 1450300 at the University of Tennesse, Knoxville.
* The Department of Energy, Office of Science, Office of Basic Energy Sciences and Office of Advanced Scientific Computing Research, under contract DE-AC05-00OR22725 with Oak Ridge National Laboratory.
* The National Science Foundation under grant 0509410 to the University of Tennessee in collaboration with The Ohio State University (P. Sadayappan). The MADNESS parallel runtime and parallel tree-algorithms include concepts and software developed under this project.
* The National Science Foundation under grant NSF OCI-0904972 to the University of Tennessee. The solid state physics and multiconfiguration SCF capabilities are being developed by this project.
* The National Science Foundation under grant NSF CHE-0625598 to the University of Tennessee, in collaboration with UIUC/NCSA. Some of the multi-threading and preliminary GPGPU ports were developed by this project.
* The Defense Advanced Research Projects Agency (DARPA) under subcontract from Argonne National Laboratory as part of the High-Productivity Computer Systems (HPCS) language evaluation project.
================================================
FILE: _config.yml
================================================
theme: jekyll-theme-slate
================================================
FILE: admin/conda/README.md
================================================
# Conda Packaging for MADNESS
Conda packages are built and uploaded to [anaconda.org/m-a-d-n-e-s-s](https://anaconda.org/m-a-d-n-e-s-s) automatically via GitHub Actions.
## Available Packages
| Package | MPI | Install command |
|---------|-----|-----------------|
| `madness` | no | `conda install -c m-a-d-n-e-s-s madness` |
| `madness-mpi` | Open MPI (from conda-forge) | `conda install -c m-a-d-n-e-s-s -c conda-forge madness-mpi` |
Both packages are built for Linux and macOS.
The **no-MPI** variant is the simplest option for single-node workstation use.
The **MPI variant** uses OpenMPI from conda-forge and is suitable for workstations and small clusters. Note that the conda-provided OpenMPI uses TCP networking and will not take advantage of high-performance interconnects (InfiniBand, Cray Aries, etc.).
**For HPC clusters**: expert users who need optimal performance should build MADNESS from source to take full advantage of their hardware (native MPI, vendor-tuned BLAS/LAPACK, InfiniBand, etc.). See the main project README for build instructions.
## Conda Recipe
The conda recipe lives in `/conda-recipe/` and consists of:
- **`meta.yaml`** — Package metadata, dependencies, and build configuration. Uses Jinja templating with `GIT_DESCRIBE_TAG` for versioning and `MPI_VARIANT` to control MPI support. Conditional selectors (`# [mpi == 'openmpi']`) toggle MPI dependencies.
- **`build.sh`** — Build script invoked by `conda build`. Runs the full CMake build inside the conda environment using conda-forge compilers and installs activation scripts that set `MRA_DATA_DIR` and `MRA_CHEMDATA_DIR`.
## Automated Workflow
The workflow is defined in `/.github/workflows/conda-deploy.yml`. It runs automatically when:
- The CI tests pass on `master` (triggered after the "Linux/MacOS Build" workflow succeeds)
- A version tag (`v*`) is pushed
- Manually via `workflow_dispatch`
For each trigger, four packages are built and uploaded (2 platforms x 2 MPI variants). Build artifacts are also saved as GitHub workflow artifacts.
Untagged builds on `master` produce development versions like `0.10.1.dev20260325+abcd1234`. Tagged releases produce clean version numbers (see below).
## Creating a Release with a Clean Version Number
1. Update the version in `CMakeLists.txt` if needed:
```cmake
set(MADNESS_MAJOR_VERSION 0)
set(MADNESS_MINOR_VERSION 10)
set(MADNESS_MICRO_VERSION 2)
```
2. Commit the version bump:
```
git commit -am "Bump version to 0.10.2"
```
3. Create and push a tag:
```
git tag v0.10.2
git push origin master --tags
```
The tag triggers the conda deploy workflow directly, producing packages with version `0.10.2`.
## Setup Requirements
The workflow requires an **Anaconda.org API token** stored as a GitHub repository secret:
1. Go to [anaconda.org](https://anaconda.org) and log in to the `m-a-d-n-e-s-s` organization
2. Navigate to Settings > Access and generate an API token with upload (write) permissions
3. In the GitHub repository, go to Settings > Secrets and variables > Actions
4. Add a new secret named `ANACONDA_TOKEN` with the token value
## Manual Build (Legacy)
The `Makefile.in` and `recipe/` directory contain the original manual workflow. To use it:
1. Configure MADNESS with CMake (this generates `admin/conda/Makefile` from `Makefile.in`)
2. In the build directory's `admin/conda/`, run `make`
3. Upload manually:
```
anaconda login
anaconda upload /path/to/madness-*.tar.bz2
```
================================================
FILE: admin/conda/recipe/meta.yaml.in
================================================
{% set name = "madness" %}
{% set version = "0.10.1" %}
package:
name: "{{ name|lower }}"
version: "{{ version }}"
source:
url: "@CMAKE_BINARY_DIR@/admin/conda/madness-conda.tar"
================================================
FILE: admin/docker/README.md
================================================
# What
This repo contains scripts for building MADNESS containers usable for running applications and for development.
# How
- Authenticate with Docker Hub: `docker login -u <docker.com username>`
- Build and push: `cd docker-images && make push/all`
================================================
FILE: admin/docker/images/Makefile
================================================
repo = rjharrison
latest ?= 22.04
ALL = ${repo}/ubuntu\:22.04
${repo}/ubuntu\:%: build = docker build --build-arg ubuntuImage=ubuntu:$* -f ../ubuntu/Dockerfile ../ubuntu/
${repo}/ubuntu: ${repo}/ubuntu\:${latest}
docker tag ${repo}/ubuntu:${latest} $@
${repo}/ubuntu\:%:
${build} -t $@
${repo}/ubuntu\:%.tar:
mkdir -p ${repo}
DOCKER_BUILDKIT=1 ${build} -o - > $@
all: ${ALL} ${repo}/ubuntu
all/tar: $(ALL:%=%.tar)
push/%: ${repo}/ubuntu\:%
docker push $?
push/all: push/22.04
================================================
FILE: admin/docker/ubuntu/Dockerfile
================================================
ARG ubuntuImage
FROM ${ubuntuImage}
RUN apt-get update && \
DEBIAN_FRONTEND=noninteractive apt-get install -y locales && \
locale-gen "en_US.UTF-8" && \
update-locale LANG=en_US.UTF-8
ENV LANGUAGE en_US:en
ENV LANG en_US.UTF-8
ENV LC_ALL en_US.UTF-8
# NB to enable nvidia docker runtime *with* --runtime nvidia
ENV NVIDIA_VISIBLE_DEVICES all
RUN mkdir -p /home/m-a-d-n-e-s-s/
COPY ./Makefile /home/m-a-d-n-e-s-s/
WORKDIR /home/m-a-d-n-e-s-s/
RUN DEBIAN_FRONTEND=noninteractive \
apt-get -yq update && \
apt-get -yq install make wget curl
# main, cmake, clang
RUN make install/main && \
make install/cmake && \
make install/clang && \
apt-get clean
# Add MKL repo, download
RUN make apt-add-repository/intel-mkl && \
make download/intel-mkl && \
make install/intel-mkl
# build MADNESS
RUN make build/madness
================================================
FILE: admin/docker/ubuntu/Makefile
================================================
ubuntu_codename ?= $(shell lsb_release -sc)
clang_version ?= 13
export DEBIAN_FRONTEND=noninteractive
ubuntu_release = $(shell lsb_release -sr)
intel_mkl_version ?= 2020.4-304
intel_mkl := intel-mkl-\*-${intel_mkl_version}
install/main:
apt-get update
apt-get -yq install \
lsb-release coreutils sudo bash-completion \
apt-transport-https software-properties-common ca-certificates gnupg \
linux-tools-common time pciutils \
build-essential wget curl \
git make ninja-build \
gcc g++ gfortran gdb valgrind \
libeigen3-dev \
libblas-dev liblapack-dev liblapacke-dev \
libunwind-dev libtbb-dev libomp-dev \
libopenmpi-dev openmpi-bin libscalapack-openmpi-dev \
libxc-dev \
python3 python3-pip python3-numpy python3-dev python3-pytest \
vim emacs-nox ccache
install/docker:
sudo apt-get install docker.io
install/g++-%:
apt-get -yq install gcc-$* g++-$* gfortran-$*
install/add-apt-repository:
apt-get update
apt-get -yq install software-properties-common
# CMake
install/cmake:
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc | apt-key add -
apt-add-repository "deb https://apt.kitware.com/ubuntu/ ${ubuntu_codename} main"
apt-get -yq update
apt-get -yq install cmake cmake-curses-gui
# LLVM
install/clang-%:
wget https://apt.llvm.org/llvm-snapshot.gpg.key -O - | apt-key add -
add-apt-repository "deb http://apt.llvm.org/${ubuntu_codename}/ llvm-toolchain-${ubuntu_codename}-$* main"
apt-get -yq update
apt-get -yq install clang-$* libomp-$*-dev
install/clang: install/clang-${clang_version}
# Intel
apt-add-repository/intel-mkl:
wget -O - https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB | apt-key add -
apt-add-repository "deb https://apt.repos.intel.com/mkl all main"
apt-get -yq update
download/intel-mkl:
apt-get install -yq --download-only ${intel_mkl}
install/intel-mkl:
apt-get -yq install ${intel_mkl}
rm -rf /opt/intel/mkl
ln -s /opt/intel/compilers_and_libraries_$(subst -,.,${intel_mkl_version})/linux/mkl /opt/intel/mkl
test -x /opt/intel/mkl/bin/mklvars.sh
# MADNESS
build/madness:
git clone https://github.com/m-a-d-n-e-s-s/madness /home/m-a-d-n-e-s-s/source
MKLROOT=/opt/intel/mkl cmake -S /home/m-a-d-n-e-s-s/source -B /home/m-a-d-n-e-s-s/build -GNinja -DCMAKE_INSTALL_PREFIX=/home/m-a-d-n-e-s-s/install
cmake --build /home/m-a-d-n-e-s-s/build --target applications-madness
cmake --build /home/m-a-d-n-e-s-s/build --target install
================================================
FILE: admin/docker/ubuntu/sudoers
================================================
#
# This file MUST be edited with the 'visudo' command as root.
#
# Please consider adding local content in /etc/sudoers.d/ instead of
# directly modifying this file.
#
# See the man page for details on how to write a sudoers file.
#
Defaults env_reset
Defaults mail_badpass
Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin"
# Host alias specification
# User alias specification
# Cmnd alias specification
# User privilege specification
root ALL=(ALL:ALL) ALL
# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL
# Allow members of group sudo to execute any command
%sudo ALL= (ALL:ALL) NOPASSWD: ALL
# See sudoers(5) for more information on "#include" directives:
#includedir /etc/sudoers.d
================================================
FILE: bin/latex2oo
================================================
#!/bin/csh
# This sed script partially automates the conversion
# from latex to openoffice focussing on the equations.
sed \
-e 's,\\begin{array}, matrix { ,g' \
-e 's,\\begin{eqnarray}, matrix { ,g' \
-e 's,\\begin{eqnarray\*}, matrix { ,g' \
-e 's,\\end{array}, } ,g' \
-e 's,\\end{eqnarray}, } ,g' \
-e 's,\\end{eqnarray\*}, } ,g' \
-e 's,\\left(, left ( ,g' \
-e 's,\\right), right ) ,g' \
-e 's,\\left\\lfloor, left lfloor ,g' \
-e 's,\\right\\rfloor, right rfloor,g' \
-e 's,\\left\\|, left ldline ,g' \
-e 's,\\right\\|, right rdline ,g' \
-e 's,\\left|, left lline ,g' \
-e 's,\\right|, right rline ,g' \
-e 's,\\left\., left none ,g' \
-e 's,\\right\., right none ,g' \
-e 's,& = &, # "=" # alignl ,g' \
-e 's,&=&, # "=" # alignl ,g' \
-e 's,\\asterisk, "*" ,g' \
-e 's,\\dagger, %dagger ,g' \
-e 's,\\ldots, dotslow ,g' \
-e 's,\\alpha, %alpha ,g' \
-e 's,\\beta, %beta ,g' \
-e 's,\\gamma, %gamma ,g' \
-e 's,\\delta, %delta ,g' \
-e 's,\\epsilon, %epsilon ,g' \
-e 's,\\mu, %mu ,g' \
-e 's,\\nu, %nu ,g' \
-e 's,\\omega, %omega ,g' \
-e 's,\\tau, %tau ,g' \
-e 's,\\phi, %phi ,g' \
-e 's,\\psi, %psi ,g' \
-e 's,\\sigma, %sigma ,g' \
-e 's,\\lambda, %lambda ,g' \
-e 's,\\approx, simeq ,g' \
-e 's,\\tmop, nitalic,g' \
-e 's,\\text, nitalic,g' \
-e 's,\\mathd, d,g' \
-e 's,\\sum_, sum from ,g' \
-e 's,\\int_, int from ,g' \
-e 's,\\infty, infinity ,g' \
-e 's,\\oplus, %oplus ,g' \
-e 's,\\\\, ## ,g' \
-e 's,\\nonumber,,g' \
-e 's,\\begin{equation},,g' \
-e 's,\\end{equation},,g' \
-e 's,\\\[,,g' \
-e 's,\\\],,g' \
-e 's,\\sqrt,sqrt,g' \
-e 's,\\leqslant,<=,g' \
-e 's,\\frac,frac,g' \
-e 's,\$,,g' \
-e 's,&, # ,g' \
-e 's,\\, ,g'
================================================
FILE: bin/taskprofile.pl
================================================
#!/usr/bin/perl
#
# This file is part of MADNESS.
#
# Copyright (C) 2012 Jinmei Zhang, Edward Valeev
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# For more information please contact:
#
# Robert J. Harrison
# Oak Ridge National Laboratory
# One Bethel Valley Road
# P.O. Box 2008, MS-6367
#
# email: harrisonrj@ornl.gov
# tel: 865-241-3937
# fax: 865-572-0680
#
# $Id$
#
&usage() if $#ARGV == -1;
my %func_counts = ();
my %func_tottime = ();
my %func_lattime = ();
my @funcs;
my $run_time = 0;
my $tot_tasktime = 0;
my %have_thread = {};
# to produce time-histograms set this to 1 and adjust the number of timeslices, if needed
my $make_histo = 1;
my $nslices = 100;
my $skip_shorter_than =
0.00; # skip if task shorter than this fraction of the timeslice
# use this search pattern to only include particular tasks in the running histogram
my %runninghisto_includes = (
"all" => ".*" # account all tasks
# add additional patterns below, e.g. for ta_dgemm these are useful
, "contract" => "contract"
, "bcasth" => "bcast_.*_handler"
, "bcastt" => "BcastTask"
);
foreach $file (@ARGV) {
# Open file
open( INFILE, "<$file" ) || die "cannot open file $file";
# Collect data for each task in the file
while (<INFILE>) {
s/\n//g;
my @line = split("\t");
# get task data
my $thread = $line[0]; # Thread that the task ran on
my $func_address = $line[1]; # Address of the task function
my $func_name = $line[2]; # Name of task function
my $func_nthreads = $line[3]; # Number of threads used by the task
my $func_submit = $line[4]; # Task submit time
my $func_start = $line[5]; # Task start time
my $func_finish = $line[6]; # Task finish time
# mark presence of this thread
$have_thread{$thread} = 1;
# Calculate task run time and delay time
my $func_time = ( $func_finish - $func_start ) * $func_nthreads;
my $func_delaytime = $func_start - $func_submit;
# Accumulate function statistics
if ( $func_counts{$func_name} == 0 ) {
push( @funcs, $func_name );
$func_counts{$func_name} = 1;
$func_tottime{$func_name} = $func_time;
$func_lattime{$func_name} = $func_delaytime;
}
else {
++$func_counts{$func_name};
$func_tottime{$func_name} += $func_time;
$func_lattime{$func_name} += $func_delaytime;
}
# Get the run time
if ( $run_time < $func_finish ) {
$run_time = $func_finish;
}
# Accumulate total function run time
$tot_functime += $func_time;
}
close INFILE;
}
printf "\nWall time: %10.6f (s)\n", $run_time;
printf "Total task time: %10.6f (s)\n\n", $tot_functime;
printf "%40s\n", "Time (s)";
printf "%-5s %7s %7s %10s %5s %10s\n", "name", "counts", "total", "average",
"%", "latency";
foreach $func ( sort by_time ( keys(%func_tottime) ) ) {
my $counts = $func_counts{$func};
my $tottime = $func_tottime{$func};
my $avgtime = $tottime / $counts;
my $lattime = $func_lattime{$func} / $counts;
my $perctime = $tottime / $run_time * 100;
printf "%s\n %10d %10.7f %10.7f %5d %10.7f\n", $func, $counts, $tottime,
$avgtime, $perctime, $lattime;
}
print "\n";
#
# time histograms
#
if ($make_histo) {
use POSIX;
my $timestep = $run_time / $nslices;
# time-weighted
my @pendinghisto = ();
foreach $ts ( 0 .. $nslices - 1 ) { push @pendinghisto, 0.0; }
my @inprogresshisto = ();
foreach $ts ( 0 .. $nslices - 1 ) { push @inprogresshisto, 0.0; }
my %runninghistos = {};
foreach my $key (keys %runninghisto_includes) {
my $values = [];
foreach $ts ( 0 .. $nslices - 1 ) { push @$values, 0.0; }
$runninghistos{$key} = $values;
}
# not time-weighted
my @spawnedhisto = ();
foreach $ts ( 0 .. $nslices - 1 ) { push @spawnedhisto, 0.0; }
my @startedhisto = ();
foreach $ts ( 0 .. $nslices - 1 ) { push @startedhisto, 0.0; }
my @retiredhisto = ();
foreach $ts ( 0 .. $nslices - 1 ) { push @retiredhisto, 0.0; }
# this is the list of tasks active for each time slice
# each entry is (ref to) an array of tasks active (not necessarily actively running, i.e. could be waiting for
# subtasks to finish)
my @inprogresstasks = ();
foreach my $slice (0 .. $nslices-1) {
$inprogresstasks[$slice] = [];
}
foreach $file (@ARGV) {
# Open file
open( INFILE, "<$file" ) || die "cannot open file $file";
# this will keep running tasks for each thread for deeper processing
my %runningtasks = {};
foreach my $threadid (keys %have_thread) {
$runningtasks{$threadid} = [];
}
# Collect data for each task in the file
while (<INFILE>) {
s/\n//g;
my @line = split("\t");
my $thread = $line[0]; # Thread that the task ran on
my $func_name = $line[2]; # Name of task function
my $func_nthreads = $line[3]; # Number of threads used by the task
# die("don't know how to handle a multithreaded task")
# if ( $func_nthreads != 1 );
my $time_submit = $line[4]; # Task submit time
my $time_start = $line[5]; # Task start time
my $time_finish = $line[6]; # Task finish time
my $tasklist = $runningtasks{$thread};
my $task = { "start" => $time_start, "finish" => $time_finish,
"name" => $func_name, "thread" => $thread };
push @$tasklist, $task;
if ( $time_start - $time_submit > $timestep * $skip_shorter_than ) {
my $submit_ts_0 = floor( $time_submit / $timestep );
my $submit_ts_1 = floor( $time_start / $timestep );
if ( $submit_ts_0 != $submit_ts_1 ) {
$pendinghisto[$submit_ts_0] +=
( $submit_ts_0 + 1 ) - ( $time_submit / $timestep );
foreach my $ts ( $submit_ts_0 + 1 .. $submit_ts_1 - 1 ) {
$pendinghisto[$ts] += 1;
}
$pendinghisto[$submit_ts_1] +=
( $time_start / $timestep ) - $submit_ts_1;
}
else {
$pendinghisto[$submit_ts_0] +=
( $time_start - $time_submit ) / $timestep;
}
}
if ( $time_finish - $time_start > $timestep * $skip_shorter_than ) {
my $start_ts_0 = floor( $time_start / $timestep );
my $start_ts_1 = floor( $time_finish / $timestep );
if ( $start_ts_0 != $start_ts_1 ) {
$inprogresshisto[$start_ts_0] +=
( $start_ts_0 + 1 ) - ( $time_start / $timestep );
push @{ $$inprogresstasks[$start_ts_0] }, $task;
foreach my $ts ( $start_ts_0 + 1 .. $start_ts_1 - 1 ) {
$inprogresshisto[$ts] += 1;
push @{ $$inprogresstasks[$ts] }, $task;
}
$inprogresshisto[$start_ts_1] +=
( $time_finish / $timestep ) - $start_ts_1;
push @{ $$inprogresstasks[$start_ts_1] }, $task;
}
else {
$inprogresshisto[$start_ts_0] +=
( $time_finish - $time_start ) / $timestep;
push @{ $$inprogresstasks[$start_ts_0] }, $task;
}
}
my $spawned_ts = floor( $time_submit / $timestep );
$spawnedhisto[$spawned_ts] += 1;
my $started_ts = floor( $time_start / $timestep );
$startedhisto[$started_ts] += 1;
my $stop_ts = floor( $time_finish / $timestep );
$retiredhisto[$stop_ts] += 1;
}
close INFILE;
# compute the time-averaged # of running
foreach my $threadid (keys %runningtasks) {
# printf STDOUT "threadid = %d\n", $threadid;
my $tasklistref = $runningtasks{$threadid};
my @tasklist = sort { $$a{"start"} <=> $$b{"start"} } @$tasklistref;
my $time_finish_last = 0.0;
foreach my $taskptr (@tasklist) {
my %task = %$taskptr;
my $time_start = $task{"start"};
my $time_finish = $task{"finish"};
my $func_name = $task{"name"};
# printf STDOUT "%lf %lf\n", $task{"start"}, $task{"finish"};
if ($time_finish > $time_finish_last) {
if ($time_start < $time_finish_last) {
$time_start = $time_finish_last;
}
my $start_ts_0 = floor( $time_start / $timestep );
my $start_ts_1 = floor( $time_finish / $timestep );
if ( $start_ts_0 != $start_ts_1 ) {
foreach my $key (keys %runninghisto_includes) {
my $func_name_pattern = $runninghisto_includes{$key};
if ($func_name =~ /$func_name_pattern/) {
${ $runninghistos{$key} }[$start_ts_0] +=
( $start_ts_0 + 1 ) - ( $time_start / $timestep );
foreach my $ts ( $start_ts_0 + 1 .. $start_ts_1 - 1 ) {
${ $runninghistos{$key} }[$ts] += 1;
}
${ $runninghistos{$key} }[$start_ts_1] +=
( $time_finish / $timestep ) - $start_ts_1;
}
}
}
else {
foreach my $key (keys %runninghisto_includes) {
my $func_name_pattern = $runninghisto_includes{$key};
if ($func_name =~ /$func_name_pattern/) {
${ $runninghistos{$key} }[$start_ts_0] +=
( $time_finish - $time_start ) / $timestep;
}
}
}
$time_finish_last = $time_finish;
}
}
}
# print out the histograms for this trace
printf STDOUT "file = %s\n", $file;
printf STDOUT "timestep = %lf\n", $timestep;
printf STDOUT "# ts nspawned nstarted nretired\n";
foreach my $ts ( 0 .. $nslices - 1 ) {
printf STDOUT "%d\t%lf\t%lf\t%lf\n", $ts, $spawnedhisto[$ts], $startedhisto[$ts], $retiredhisto[$ts];
}
# printf STDOUT "time-weighted # of waiting\n";
# foreach my $ts ( 0 .. $nslices - 1 ) {
# printf STDOUT "%d %lf\n", $ts, $pendinghisto[$ts];
# }
# printf STDOUT "time-weighted # of in-progress\n";
# foreach my $ts ( 0 .. $nslices - 1 ) {
# printf STDOUT "%d %lf\n", $ts, $inprogresshisto[$ts];
# }
# list keys in a reasonable order (keys returns keys in a weird order)
# "all" first, then the rest
my @running_keys = ("all");
foreach my $key (keys %runninghisto_includes) {
push @running_keys, $key if $key ne "all";
}
printf STDOUT "# ts, pend";
foreach my $key (@running_keys) {
printf STDOUT ", run_%s", $key;
}
printf STDOUT "\n";
foreach my $ts ( 0 .. $nslices - 1 ) {
printf STDOUT "%d", $ts;
printf STDOUT ", %lf", $pendinghisto[$ts];
foreach my $key (@running_keys) {
printf STDOUT ", %lf", ${ $runninghistos{$key} }[$ts];
}
printf STDOUT "\n";
}
my $active_tasks_fname = "$file.active_tasks.log";
open ATFILE, ">$active_tasks_fname" || die "could not open $active_tasks_fname";
foreach my $ts (0 .. $nslices-1) {
printf ATFILE "============================ ts %d: [%lf,%lf] =============================\n",
$ts, $ts*$timestep, ($ts+1)*$timestep;
foreach my $taskref (sort { $$a{"thread"} <=> $$b{"thread"} } @{ $$inprogresstasks[$ts] }) {
printf ATFILE "%d %s %lf %lf\n",
$$taskref{"thread"}, $$taskref{"name"},
$$taskref{"start"}, $$taskref{"finish"};
}
}
close ATFILE;
}
}
exit 0;
sub usage {
printf STDERR
"taskprofile.pl converts trace files info a summary profile. Usage:\n";
printf STDERR
" taskprofile.pl <trace file1> [<trace file2> <trace file3>... ]\n";
exit 0;
}
sub by_time {
$func_tottime{$b} <=> $func_tottime{$a};
}
================================================
FILE: bin/test_utilities.py
================================================
import json
import subprocess
class madjsoncompare:
# """takes two json output files and compares individual keys, accessed by a list of descending keys"""
def __init__(self, file1, file2):
"""Initialize with two json files, which are read and stored in data1 and data2"""
if not file1.endswith('.json'):
raise ValueError("File1 must be a JSON file")
if not file2.endswith('.json'):
raise ValueError("File2 must be a JSON file")
if not file1 or not file2:
raise ValueError("Both file1 and file2 must be provided")
if not isinstance(file1, str) or not isinstance(file2, str):
raise TypeError("file1 and file2 must be strings representing file paths")
# print out file names
print('comparing files:', file1, file2)
self.file1=file1
self.file2=file2
self.success=True
with open(file1, 'r') as f:
self.data1 = json.load(f)
with open(file2, 'r') as f:
self.data2 = json.load(f)
# print("json1",self.data1)
# print("json2",self.data2)
def exitcode(self):
if self.success:
return 0
else:
return 1
def compare(self, subsequentkeys, tolerance):
value1=self.data1
value2=self.data2
for i in subsequentkeys:
# print("key ", i, " in ", value1, value2)
value1=value1[i]
value2=value2[i]
# print("type of key/value",type(i),type(value1))
success=False
diff='is different'
if (type(value1)==float):
diff=abs(value1-value2)
success=diff<tolerance
elif (type(value1)==int):
diff=0
success=(value1==value2)
elif (type(value1)==str):
success=(value1==value2)
if success:
diff=''
else:
success=(value1==value2)
if success:
diff=''
if success:
print("key ", subsequentkeys, " agrees to ", tolerance,": ", value1, value2, diff)
else:
print("key ", subsequentkeys, " differs gt ", tolerance,": ", value1, value2, diff)
self.success=self.success and success
def cleanup(prefix):
"""Remove output files and directories created during the test."""
cmd = f'rm -r {prefix}.calc_info.json {prefix}'
print("Cleaning up with command:", cmd)
subprocess.run(cmd, shell=True)
def skip_on_small_machines():
"""Check the number of threads available and skip the test if too few."""
try:
num_threads=int(subprocess.check_output("echo $MAD_NUM_THREADS", shell=True).strip())
except subprocess.CalledProcessError as e:
print("Error retrieving number of threads:", e)
return True
print("Number of threads found to be:", num_threads)
return (num_threads < 20)
================================================
FILE: cmake/Makefile
================================================
CMAKE := cmake-3.5.1
URL := https://cmake.org/files/v3.5/$(CMAKE).tar.gz
PREFIX := $(PWD)
all: cmake
wget := $(shell wget 2>/dev/null)
curl := $(shell curl 2>/dev/null)
ifneq ($(wget), )
download := wget $(URL) -O $(CMAKE).tar.gz
else
download := curl $(URL) -o $(CMAKE).tar.gz
endif
$(CMAKE).tar.gz:
$(download)
.PHONY: cmake
cmake: $(CMAKE).tar.gz
tar -xzf $(CMAKE).tar.gz
cd ./$(CMAKE)
cd $(CMAKE) && ./configure --prefix=$(PREFIX) # --system-curl
cd $(CMAKE) && make install
================================================
FILE: cmake/config.h.in
================================================
/* Input file cmake/config.h.in. */
/* Define of package information */
#define MADNESS_PACKAGE_NAME "@PROJECT_NAME@"
#define MADNESS_PACKAGE_URL "https://github.com/m-a-d-n-e-s-s/madness"
#define MADNESS_PACKAGE_VERSION "@MADNESS_VERSION@"
#define MADNESS_VERSION "@MADNESS_VERSION@"
#define MADNESS_MAJOR_VERSION @MADNESS_MAJOR_VERSION@
#define MADNESS_MINOR_VERSION @MADNESS_MAJOR_VERSION@
#define MADNESS_MICRO_VERSION @MADNESS_MAJOR_VERSION@
/* Configured information */
#define MADNESS_CONFIGURATION_CXX "@CMAKE_CXX_COMPILER@"
#define MADNESS_CONFIGURATION_CXXFLAGS "@CMAKE_CXX_FLAGS@"
#define HOST_SYSTEM "@CMAKE_HOST_SYSTEM_NAME@"
#define MADNESS_CONFIGURATION_DATE "@MADNESS_CONFIGURATION_DATE@"
#define MADNESS_CONFIGURATION_HOST "@MADNESS_CONFIGURATION_HOST@"
#define MADNESS_CONFIGURATION_USER "@MADNESS_CONFIGURATION_USER@"
/* Target for tuning mtxmq kernels */
#cmakedefine AMD_QUADCORE_TUNE 1
/* Fortran-C linking convention type and integer size */
#cmakedefine FORTRAN_LINKAGE_LC 1
#cmakedefine FORTRAN_LINKAGE_LCU 1
#cmakedefine FORTRAN_LINKAGE_LCUU 1
#cmakedefine FORTRAN_LINKAGE_UC 1
#cmakedefine FORTRAN_LINKAGE_UCU 1
#define MADNESS_FORTRAN_DEFAULT_INTEGER_SIZE @FORTRAN_INTEGER_SIZE@
/* Defined system specific macros */
#cmakedefine HAVE_CRAYXE 1
#cmakedefine HAVE_CRAYXT 1
#cmakedefine HAVE_IBMBGP 1
#cmakedefine HAVE_IBMBGQ 1
#cmakedefine ON_A_MAC 1
#define MADNESS_CXX_ABI_GenericItanium @MADNESS_CXX_ABI_GenericItanium@
#define MADNESS_CXX_ABI_GenericARM @MADNESS_CXX_ABI_GenericARM@
#define MADNESS_CXX_ABI_Microsoft @MADNESS_CXX_ABI_Microsoft@
#define MADNESS_CXX_ABI @MADNESS_CXX_ABI@
/* Define type macros. */
#cmakedefine HAVE_INT64_T 1
#cmakedefine HAVE_LONG_LONG 1
/* Define to `int' if <sys/types.h> does not define. */
#cmakedefine SYS_TYPES_H_HAS_PID_T 1
#if !defined(SYS_TYPES_H_HAS_PID_T)
# define pid_t int
#endif
/* Define MADNESS has access to the library. */
#cmakedefine HAVE_MTXMQ 1
#cmakedefine HAVE_ACML 1
#cmakedefine HAVE_INTEL_TBB 1
#cmakedefine MADNESS_CAN_USE_TBB_PRIORITY 1
#cmakedefine HAVE_PARSEC 1
#cmakedefine HAVE_INTEL_MKL 1
#cmakedefine HAVE_PAPI 1
#cmakedefine MADNESS_HAS_PCM 1
#cmakedefine MADNESS_HAS_LIBXC 1
#cmakedefine MADNESS_HAS_INTEGRATORXX 1
#cmakedefine MADNESS_HAS_BOOST 1
#cmakedefine MADNESS_HAS_ELEMENTAL 1
#cmakedefine MADNESS_HAS_ELEMENTAL_EMBEDDED 1
#cmakedefine MADNESS_HAS_GOOGLE_PERF 1
#cmakedefine MADNESS_HAS_GOOGLE_PERF_PROFILER 1
#cmakedefine MADNESS_HAS_GOOGLE_PERF_TCMALLOC 1
#cmakedefine MADNESS_HAS_GOOGLE_PERF_TCMALLOC_MINIMAL 1
#cmakedefine MADNESS_HAS_GOOGLE_TEST 1
#cmakedefine MADNESS_HAS_LIBUNWIND 1
/* Define has access to function. */
#cmakedefine HAVE_FORK 1
#cmakedefine HAVE_MEMSET 1
#cmakedefine HAVE_POSIX_MEMALIGN 1
#cmakedefine MISSING_POSIX_MEMALIGN_PROTO 1
#cmakedefine HAVE_POW 1
#cmakedefine HAVE_RANDOM 1
#cmakedefine HAVE_SLEEP 1
#cmakedefine HAVE_STD_ABS_LONG 1
#cmakedefine HAVE_STRCHR 1
/* Define if header files are available. */
#ifndef HAVE_SYS_STAT_H
#cmakedefine HAVE_SYS_STAT_H 1
#endif
#ifndef HAVE_SYS_TYPES_H
#cmakedefine HAVE_SYS_TYPES_H
#endif
#ifndef HAVE_UNISTD_H
#cmakedefine HAVE_UNISTD_H 1
#endif
#ifndef HAVE_RESOURCE_H
#cmakedefine HAVE_RESOURCE_H 1
#endif
#cmakedefine HAVE_ELEMENTAL_H 1
#cmakedefine HAVE_EL_H 1
/* Set if compiler will instantiate static templates */
#cmakedefine HAVE_UNQUALIFIED_STATIC_DECL 1
/* Set MADNESS assertions behavior */
#cmakedefine MADNESS_ASSERTIONS_ABORT 1
#cmakedefine MADNESS_ASSERTIONS_ASSERT 1
#cmakedefine MADNESS_ASSERTIONS_DISABLE 1
#cmakedefine MADNESS_ASSERTIONS_THROW 1
/* The default binding for threads */
#define MADNESS_TASK_BACKEND "@MADNESS_TASK_BACKEND@"
/* Thread-safety level requested from MPI by MADNESS */
#define MADNESS_MPI_THREAD_LEVEL @MADNESS_MPI_THREAD_LEVEL@
#cmakedefine STUBOUTMPI 1
#ifndef MADNESS_MPI_HEADER
# cmakedefine MADNESS_MPI_HEADER "@MADNESS_MPI_HEADER@"
#endif
/* The default binding for threads */
#define MAD_BIND_DEFAULT "@MAD_BIND_DEFAULT@"
/* Define to enable MADNESS features */
#cmakedefine MADNESS_TASK_PROFILING 1
#cmakedefine MADNESS_USE_BSEND_ACKS 1
#cmakedefine ENABLE_GENTENSOR 1
#cmakedefine NEVER_SPIN 1
#cmakedefine TENSOR_BOUNDS_CHECKING 1
#cmakedefine TENSOR_INSTANCE_COUNT 1
#cmakedefine USE_SPINLOCKS 1
#cmakedefine WORLD_GATHER_MEM_STATS 1
#cmakedefine WORLD_MEM_PROFILE_ENABLE 1
#cmakedefine WORLD_PROFILE_ENABLE 1
#cmakedefine MADNESS_TASK_DEBUG_TRACE 1
#cmakedefine MADNESS_LINALG_USE_LAPACKE 1
#cmakedefine MADNESS_DQ_USE_PREBUF 1
#cmakedefine MADNESS_DQ_PREBUF_SIZE @MADNESS_DQ_PREBUF_SIZE@
#cmakedefine MADNESS_ASSUMES_ASLR_DISABLED 1
#cmakedefine MADNESS_WORLDOBJECT_FUTURE_TRACE 1
#cmakedefine MADNESS_WORLDOBJECT_FUTURE_TRACE_WORLD_ID @MADNESS_WORLDOBJECT_FUTURE_TRACE_WORLD_ID@
#cmakedefine MADNESS_WORLDOBJECT_FUTURE_TRACE_MAX_NOBJECTS @MADNESS_WORLDOBJECT_FUTURE_TRACE_MAX_NOBJECTS@
/* Define to the equivalent of the C99 'restrict' keyword, or to
nothing if this is not supported. Do not define if restrict is
supported directly. */
#define MADNESS_RESTRICT @RESTRICT_KEYWORD@
/* Work around a bug in Sun C++: it does not support _Restrict or
__restrict__, even though the corresponding Sun C compiler ends up with
"#define restrict _Restrict" or "#define restrict __restrict__" in the
previous line. Perhaps some future version of Sun C++ will work with
restrict; if so, hopefully it defines __RESTRICT like Sun C does. */
#if defined __SUNPRO_CC && !defined __RESTRICT
# define _Restrict
# define __restrict__
#endif
/* Define the thread_local key word. */
#cmakedefine THREAD_LOCAL_KEYWORD @THREAD_LOCAL_KEYWORD@
#if defined(THREAD_LOCAL_KEYWORD)
# define thread_local THREAD_LOCAL_KEYWORD
#endif
/* Define to the application path if available */
#cmakedefine HAVE_XTERM 1
#cmakedefine XTERM_EXECUTABLE "@XTERM_EXECUTABLE@"
#cmakedefine HAVE_GDB 1
#cmakedefine GDB_EXECUTABLE "@GDB_EXECUTABLE@"
#cmakedefine HAVE_LLDB 1
#cmakedefine LLDB_EXECUTABLE "@LLDB_EXECUTABLE@"
================================================
FILE: cmake/doxygen.cfg.in
================================================
# Doxyfile 1.8.9.1
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a double hash (##) is considered a comment and is placed in
# front of the TAG it is preceding.
#
# All text after a single hash (#) is considered a comment and will be ignored.
# The format is:
# TAG = value [value, ...]
# For lists, items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (\" \").
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all text
# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
# for the list of possible encodings.
# The default value is: UTF-8.
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
# double-quotes, unless you are using Doxywizard) that should identify the
# project for which the documentation is generated. This name is used in the
# title of most generated pages and in a few other places.
# The default value is: My Project.
PROJECT_NAME = @PROJECT_NAME@
# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
# could be handy for archiving the generated documentation or if some version
# control system is used.
PROJECT_NUMBER = "@MADNESS_VERSION@"
# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer a
# quick idea about the purpose of the project. Keep the description short.
PROJECT_BRIEF =
# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
# in the documentation. The maximum height of the logo should not exceed 55
# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
# the logo to the output directory.
PROJECT_LOGO =
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
# into which the generated documentation will be written. If a relative path is
# entered, it will be relative to the location where doxygen was started. If
# left blank the current directory will be used.
OUTPUT_DIRECTORY = ./
# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
# directories (in 2 levels) under the output directory of each output format and
# will distribute the generated files over these directories. Enabling this
# option can be useful when feeding doxygen a huge amount of source files, where
# putting all generated files in the same directory would otherwise causes
# performance problems for the file system.
# The default value is: NO.
CREATE_SUBDIRS = NO
# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
# characters to appear in the names of generated files. If set to NO, non-ASCII
# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
# U+3044.
# The default value is: NO.
ALLOW_UNICODE_NAMES = NO
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
# Ukrainian and Vietnamese.
# The default value is: English.
OUTPUT_LANGUAGE = English
# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
# descriptions after the members that are listed in the file and class
# documentation (similar to Javadoc). Set to NO to disable this.
# The default value is: YES.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
# description of a member or function before the detailed description
#
# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
# The default value is: YES.
REPEAT_BRIEF = YES
# This tag implements a quasi-intelligent brief description abbreviator that is
# used to form the text in various listings. Each string in this list, if found
# as the leading text of the brief description, will be stripped from the text
# and the result, after processing the whole list, is used as the annotated
# text. Otherwise, the brief description is used as-is. If left blank, the
# following values are used ($name is automatically replaced with the name of
# the entity):The $name class, The $name widget, The $name file, is, provides,
# specifies, contains, represents, a, an and the.
ABBREVIATE_BRIEF =
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# doxygen will generate a detailed section even if there is only a brief
# description.
# The default value is: NO.
ALWAYS_DETAILED_SEC = NO
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.
# The default value is: NO.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
# before files name in the file list and in the header files. If set to NO the
# shortest path that makes the file name unique will be used
# The default value is: YES.
FULL_PATH_NAMES = NO
# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
# Stripping is only done if one of the specified strings matches the left-hand
# part of the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the path to
# strip.
#
# Note that you can specify absolute paths here, but also relative paths, which
# will be relative from the directory where doxygen is started.
# This tag requires that the tag FULL_PATH_NAMES is set to YES.
STRIP_FROM_PATH = @PROJECT_SOURCE_DIR@/src
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
# path mentioned in the documentation of a class, which tells the reader which
# header file to include in order to use a class. If left blank only the name of
# the header file containing the class definition is used. Otherwise one should
# specify the list of include paths that are normally passed to the compiler
# using the -I flag.
STRIP_FROM_INC_PATH =
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
# less readable) file names. This can be useful is your file systems doesn't
# support long names like on DOS, Mac, or CD-ROM.
# The default value is: NO.
SHORT_NAMES = NO
# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
# first line (until the first dot) of a Javadoc-style comment as the brief
# description. If set to NO, the Javadoc-style will behave just like regular Qt-
# style comments (thus requiring an explicit @brief command for a brief
# description.)
# The default value is: NO.
JAVADOC_AUTOBRIEF = NO
# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
# line (until the first dot) of a Qt-style comment as the brief description. If
# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
# requiring an explicit \brief command for a brief description.)
# The default value is: NO.
QT_AUTOBRIEF = NO
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
# a brief description. This used to be the default behavior. The new default is
# to treat a multi-line C++ comment block as a detailed description. Set this
# tag to YES if you prefer the old behavior instead.
#
# Note that setting this tag to YES also means that rational rose comments are
# not recognized any more.
# The default value is: NO.
MULTILINE_CPP_IS_BRIEF = NO
# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
# documentation from any documented member that it re-implements.
# The default value is: YES.
INHERIT_DOCS = YES
# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
# page for each member. If set to NO, the documentation of a member will be part
# of the file/class/namespace that contains it.
# The default value is: NO.
SEPARATE_MEMBER_PAGES = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
# uses this value to replace tabs by spaces in code fragments.
# Minimum value: 1, maximum value: 16, default value: 4.
TAB_SIZE = 4
# This tag can be used to specify a number of aliases that act as commands in
# the documentation. An alias has the form:
# name=value
# For example adding
# "sideeffect=@par Side Effects:\n"
# will allow you to put the command \sideeffect (or @sideeffect) in the
# documentation, which will result in a user-defined paragraph with heading
# "Side Effects:". You can put \n's in the value part of an alias to insert
# newlines.
ALIASES = "website=https://github.com/m-a-d-n-e-s-s/madness"
# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding "class=itcl::class"
# will allow you to use the command class in the itcl::class meaning.
TCL_SUBST =
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
# only. Doxygen will then generate output that is more tailored for C. For
# instance, some of the names that are used will be different. The list of all
# members will be omitted, etc.
# The default value is: NO.
OPTIMIZE_OUTPUT_FOR_C = NO
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
# Python sources only. Doxygen will then generate output that is more tailored
# for that language. For instance, namespaces will be presented as packages,
# qualified scopes will look different, etc.
# The default value is: NO.
OPTIMIZE_OUTPUT_JAVA = NO
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources. Doxygen will then generate output that is tailored for Fortran.
# The default value is: NO.
OPTIMIZE_FOR_FORTRAN = NO
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for VHDL.
# The default value is: NO.
OPTIMIZE_OUTPUT_VHDL = NO
# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given
# extension. Doxygen has a built-in mapping, but you can override or extend it
# using this tag. The format is ext=language, where ext is a file extension, and
# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
# Fortran. In the later case the parser tries to guess whether the code is fixed
# or free formatted code, this is the default for Fortran type files), VHDL. For
# instance to make doxygen treat .inc files as Fortran files (default is PHP),
# and .f files as C (default is Fortran), use: inc=Fortran f=C.
#
# Note: For files without extension you can use no_extension as a placeholder.
#
# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
# the files are not read by doxygen.
EXTENSION_MAPPING =
# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
# according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you can
# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
# case of backward compatibilities issues.
# The default value is: YES.
MARKDOWN_SUPPORT = YES
# When enabled doxygen tries to link words that correspond to documented
# classes, or namespaces to their corresponding documentation. Such a link can
# be prevented in individual cases by putting a % sign in front of the word or
# globally by setting AUTOLINK_SUPPORT to NO.
# The default value is: YES.
AUTOLINK_SUPPORT = YES
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should set this
# tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string);
# versus func(std::string) {}). This also make the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
# The default value is: NO.
BUILTIN_STL_SUPPORT = NO
# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.
# The default value is: NO.
CPP_CLI_SUPPORT = NO
# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
# will parse them like normal C++ but will assume all classes use public instead
# of private inheritance when no explicit protection keyword is present.
# The default value is: NO.
SIP_SUPPORT = NO
# For Microsoft's IDL there are propget and propput attributes to indicate
# getter and setter methods for a property. Setting this option to YES will make
# doxygen to replace the get and set methods by a property in the documentation.
# This will only work if the methods are indeed getting or setting a simple
# type. If this is not the case, or you want to show the methods anyway, you
# should set this option to NO.
# The default value is: YES.
IDL_PROPERTY_SUPPORT = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
# The default value is: NO.
DISTRIBUTE_GROUP_DOC = NO
# Set the SUBGROUPING tag to YES to allow class member groups of the same type
# (for instance a group of public functions) to be put as a subgroup of that
# type (e.g. under the Public Functions section). Set it to NO to prevent
# subgrouping. Alternatively, this can be done per class using the
# \nosubgrouping command.
# The default value is: YES.
SUBGROUPING = YES
# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
# are shown inside the group in which they are included (e.g. using \ingroup)
# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
# and RTF).
#
# Note that this feature does not work in combination with
# SEPARATE_MEMBER_PAGES.
# The default value is: NO.
INLINE_GROUPED_CLASSES = NO
# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
# with only public data fields or simple typedef fields will be shown inline in
# the documentation of the scope in which they are defined (i.e. file,
# namespace, or group documentation), provided this scope is documented. If set
# to NO, structs, classes, and unions are shown on a separate page (for HTML and
# Man pages) or section (for LaTeX and RTF).
# The default value is: NO.
INLINE_SIMPLE_STRUCTS = NO
# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
# enum is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically be
# useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.
# The default value is: NO.
TYPEDEF_HIDES_STRUCT = NO
# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
# cache is used to resolve symbols given their name and scope. Since this can be
# an expensive process and often the same symbol appears multiple times in the
# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
# doxygen will become slower. If the cache is too large, memory is wasted. The
# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
# symbols. At the end of a run doxygen will report the cache usage and suggest
# the optimal cache size from a speed point of view.
# Minimum value: 0, maximum value: 9, default value: 0.
LOOKUP_CACHE_SIZE = 0
# The NUM_PROC_THREADS specifies the number of threads doxygen is allowed to use
# during processing. When set to 0 doxygen will based this on the number of
# cores available in the system. You can set it explicitly to a value larger
# than 0 to get more control over the balance between CPU load and processing
# speed. At this moment only the input processing can be done using multiple
# threads. Since this is still an experimental feature the default is set to 1,
# which effectively disables parallel processing. Please report any issues you
# encounter. Generating dot graphs in parallel is controlled by the
# DOT_NUM_THREADS setting.
# Minimum value: 0, maximum value: 32, default value: 1.
NUM_PROC_THREADS = 10
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
# documentation are documented, even if no documentation was available. Private
# class members and static file members will be hidden unless the
# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
# Note: This will also disable the warnings about undocumented members that are
# normally produced when WARNINGS is set to YES.
# The default value is: NO.
EXTRACT_ALL = YES
# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
# be included in the documentation.
# The default value is: NO.
EXTRACT_PRIVATE = YES
# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
# scope will be included in the documentation.
# The default value is: NO.
EXTRACT_PACKAGE = NO
# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
# included in the documentation.
# The default value is: NO.
EXTRACT_STATIC = YES
# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
# locally in source files will be included in the documentation. If set to NO,
# only classes defined in header files are included. Does not have any effect
# for Java sources.
# The default value is: YES.
EXTRACT_LOCAL_CLASSES = YES
# This flag is only useful for Objective-C code. If set to YES, local methods,
# which are defined in the implementation section but not in the interface are
# included in the documentation. If set to NO, only methods in the interface are
# included.
# The default value is: NO.
EXTRACT_LOCAL_METHODS = NO
# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base name of
# the file that contains the anonymous namespace. By default anonymous namespace
# are hidden.
# The default value is: NO.
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
# undocumented members inside documented classes or files. If set to NO these
# members will be included in the various overviews, but no documentation
# section is generated. This option has no effect if EXTRACT_ALL is enabled.
# The default value is: NO.
HIDE_UNDOC_MEMBERS = NO
# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy. If set
# to NO, these classes will be included in the various overviews. This option
# has no effect if EXTRACT_ALL is enabled.
# The default value is: NO.
HIDE_UNDOC_CLASSES = NO
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
# (class|struct|union) declarations. If set to NO, these declarations will be
# included in the documentation.
# The default value is: NO.
HIDE_FRIEND_COMPOUNDS = NO
# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
# documentation blocks found inside the body of a function. If set to NO, these
# blocks will be appended to the function's detailed documentation block.
# The default value is: NO.
HIDE_IN_BODY_DOCS = NO
# The INTERNAL_DOCS tag determines if documentation that is typed after a
# \internal command is included. If the tag is set to NO then the documentation
# will be excluded. Set it to YES to include the internal documentation.
# The default value is: NO.
INTERNAL_DOCS = NO
# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
# names in lower-case letters. If set to YES, upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.
# The default value is: system dependent.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
# their full class and namespace scopes in the documentation. If set to YES, the
# scope will be hidden.
# The default value is: NO.
HIDE_SCOPE_NAMES = NO
# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
# append additional text to a page's title, such as Class Reference. If set to
# YES the compound reference will be hidden.
# The default value is: NO.
HIDE_COMPOUND_REFERENCE= NO
# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
# the files that are included by a file in the documentation of that file.
# The default value is: YES.
SHOW_INCLUDE_FILES = YES
# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
# grouped member an include statement to the documentation, telling the reader
# which file to include in order to use the member.
# The default value is: NO.
SHOW_GROUPED_MEMB_INC = NO
# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
# files with double quotes in the documentation rather than with sharp brackets.
# The default value is: NO.
FORCE_LOCAL_INCLUDES = NO
# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
# documentation for inline members.
# The default value is: YES.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
# (detailed) documentation of file and class members alphabetically by member
# name. If set to NO, the members will appear in declaration order.
# The default value is: YES.
SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
# descriptions of file, namespace and class members alphabetically by member
# name. If set to NO, the members will appear in declaration order. Note that
# this will also influence the order of the classes in the class list.
# The default value is: NO.
SORT_BRIEF_DOCS = YES
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
# (brief and detailed) documentation of class members so that constructors and
# destructors are listed first. If set to NO the constructors will appear in the
# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
# member documentation.
# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
# detailed member documentation.
# The default value is: NO.
SORT_MEMBERS_CTORS_1ST = YES
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
# of group names into alphabetical order. If set to NO the group names will
# appear in their defined order.
# The default value is: NO.
SORT_GROUP_NAMES = NO
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
# fully-qualified names, including namespaces. If set to NO, the class list will
# be sorted only by class name, not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the alphabetical
# list.
# The default value is: NO.
SORT_BY_SCOPE_NAME = NO
# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
# type resolution of all parameters of a function it will reject a match between
# the prototype and the implementation of a member function even if there is
# only one candidate or it is obvious which candidate to choose by doing a
# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
# accept a match between prototype and implementation in such cases.
# The default value is: NO.
STRICT_PROTO_MATCHING = NO
# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
# list. This list is created by putting \todo commands in the documentation.
# The default value is: YES.
GENERATE_TODOLIST = YES
# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
# list. This list is created by putting \test commands in the documentation.
# The default value is: YES.
GENERATE_TESTLIST = YES
# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
# list. This list is created by putting \bug commands in the documentation.
# The default value is: YES.
GENERATE_BUGLIST = YES
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
# the deprecated list. This list is created by putting \deprecated commands in
# the documentation.
# The default value is: YES.
GENERATE_DEPRECATEDLIST= YES
# The ENABLED_SECTIONS tag can be used to enable conditional documentation
# sections, marked by \if <section_label> ... \endif and \cond <section_label>
# ... \endcond blocks.
ENABLED_SECTIONS =
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
# initial value of a variable or macro / define can have for it to appear in the
# documentation. If the initializer consists of more lines than specified here
# it will be hidden. Use a value of 0 to hide initializers completely. The
# appearance of the value of individual variables and macros / defines can be
# controlled using \showinitializer or \hideinitializer command in the
# documentation regardless of this setting.
# Minimum value: 0, maximum value: 10000, default value: 30.
MAX_INITIALIZER_LINES = 30
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
# the bottom of the documentation of classes and structs. If set to YES, the
# list will mention the files that were used to generate the documentation.
# The default value is: YES.
SHOW_USED_FILES = YES
# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
# will remove the Files entry from the Quick Index and from the Folder Tree View
# (if specified).
# The default value is: YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
# page. This will remove the Namespaces entry from the Quick Index and from the
# Folder Tree View (if specified).
# The default value is: YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command command input-file, where command is the value of the
# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
# by doxygen. Whatever the program writes to standard output is used as the file
# version. For an example see the documentation.
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option. You can
# optionally specify a file name after the option, if omitted DoxygenLayout.xml
# will be used as the name of the layout file.
#
# Note that if you run doxygen from a directory containing a file called
# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
# tag is left empty.
LAYOUT_FILE =
# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
# the reference definitions. This must be a list of .bib files. The .bib
# extension is automatically appended if omitted. This requires the bibtex tool
# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
# For LaTeX the style of the bibliography can be controlled using
# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
# search path. See also \cite for info how to create references.
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated to
# standard output by doxygen. If QUIET is set to YES this implies that the
# messages are off.
# The default value is: NO.
QUIET = NO
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
# this implies that the warnings are on.
#
# Tip: Turn warnings on while writing the documentation.
# The default value is: YES.
WARNINGS = YES
# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
# will automatically be disabled.
# The default value is: YES.
WARN_IF_UNDOCUMENTED = YES
# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some parameters
# in a documented function, or documenting parameters that don't exist or using
# markup commands wrongly.
# The default value is: YES.
WARN_IF_DOC_ERROR = YES
# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
# are documented, but have no documentation for their parameters or return
# value. If set to NO, doxygen will only warn about wrong or incomplete
# parameter documentation, but not about the absence of documentation.
# The default value is: NO.
WARN_NO_PARAMDOC = YES
# The WARN_FORMAT tag determines the format of the warning messages that doxygen
# can produce. The string should contain the $file, $line, and $text tags, which
# will be replaced by the file and line number from which the warning originated
# and the warning text. Optionally the format may contain $version, which will
# be replaced by the version of the file (if it could be obtained via
# FILE_VERSION_FILTER)
# The default value is: $file:$line: $text.
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning and error
# messages should be written. If left blank the output is written to standard
# error (stderr).
WARN_LOGFILE = doxygen-warnings.txt
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag is used to specify the files and/or directories that contain
# documented source files. You may enter file names like myfile.cpp or
# directories like /usr/src/myproject. Separate the files or directories with
# spaces.
# Note: If this tag is empty the current directory is searched.
INPUT = "@PROJECT_SOURCE_DIR@/doc" \
"@PROJECT_SOURCE_DIR@/src" \
"@PROJECT_SOURCE_DIR@/bin"
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
# documentation (see: http://www.gnu.org/software/libiconv) for the list of
# possible encodings.
# The default value is: UTF-8.
INPUT_ENCODING = UTF-8
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
# *.h) to filter out the source-files in the directories. If left blank the
# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
# *.qsf, *.as and *.js.
FILE_PATTERNS = *.dox \
*.h \
*.cpp \
*.cc \
*.c
# The RECURSIVE tag can be used to specify whether or not subdirectories should
# be searched for input files as well.
# The default value is: NO.
RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
#
# Note that relative paths are relative to the directory from which doxygen is
# run.
EXCLUDE = "@PROJECT_SOURCE_DIR@/src/madness/external" \
"@PROJECT_SOURCE_DIR@/src/apps/DFcode" \
"@PROJECT_SOURCE_DIR@/src/apps/ii" \
"@PROJECT_SOURCE_DIR@/src/apps/jacob" \
"@PROJECT_SOURCE_DIR@/src/apps/nick" \
"@PROJECT_SOURCE_DIR@/src/apps/polar"
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
# The default value is: NO.
EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories.
#
# Note that the wildcards are matched against the file with absolute path, so to
# exclude all test directories for example use the pattern */test/*
EXCLUDE_PATTERNS = LIBS.h \
mraX.cc \
mraX.h \
*.tex
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
#
# Note that the wildcards are matched against the file with absolute path, so to
# exclude all test directories use the pattern */test/*
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or directories
# that contain example code fragments that are included (see the \include
# command).
EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
# *.h) to filter out the source-files in the directories. If left blank all
# files are included.
EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude commands
# irrespective of the value of the RECURSIVE tag.
# The default value is: NO.
EXAMPLE_RECURSIVE = NO
# The IMAGE_PATH tag can be used to specify one or more files or directories
# that contain images that are to be included in the documentation (see the
# \image command).
IMAGE_PATH =
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command:
#
# <filter> <input-file>
#
# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
# name of an input file. Doxygen will then use the output that the filter
# program writes to standard output. If FILTER_PATTERNS is specified, this tag
# will be ignored.
#
# Note that the filter must not add or remove lines; it is applied before the
# code is scanned, but not when the output code is generated. If lines are added
# or removed, the anchors will not be placed correctly.
INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis. Doxygen will compare the file name with each pattern and apply the
# filter if there is a match. The filters are a list of the form: pattern=filter
# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
# patterns match the file name, INPUT_FILTER is applied.
FILTER_PATTERNS =
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will also be used to filter the input files that are used for
# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
# The default value is: NO.
FILTER_SOURCE_FILES = NO
# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
# it is also possible to disable source filtering for a specific pattern using
# *.ext= (so without naming a filter).
# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
FILTER_SOURCE_PATTERNS =
# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
# is part of the input, its contents will be placed on the main page
# (index.html). This can be useful if you have a project on for instance GitHub
# and want to reuse the introduction page also for the doxygen output.
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# Configuration options related to source browsing
#---------------------------------------------------------------------------
# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
# generated. Documented entities will be cross-referenced with these sources.
#
# Note: To get rid of all source code in the generated output, make sure that
# also VERBATIM_HEADERS is set to NO.
# The default value is: NO.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body of functions,
# classes and enums directly into the documentation.
# The default value is: NO.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
# special comment blocks from generated source code fragments. Normal C, C++ and
# Fortran comments will always remain visible.
# The default value is: YES.
STRIP_CODE_COMMENTS = NO
# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
# function all documented functions referencing it will be listed.
# The default value is: NO.
REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES then for each documented function
# all documented entities called/used by that function will be listed.
# The default value is: NO.
REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
# to YES then the hyperlinks from functions in REFERENCES_RELATION and
# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
# link to the documentation.
# The default value is: YES.
REFERENCES_LINK_SOURCE = YES
# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
# source code will show a tooltip with additional information such as prototype,
# brief description and links to the definition and documentation. Since this
# will make the HTML file larger and loading of large files a bit slower, you
# can opt to disable this feature.
# The default value is: YES.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
SOURCE_TOOLTIPS = YES
# If the USE_HTAGS tag is set to YES then the references to source code will
# point to the HTML generated by the htags(1) tool instead of doxygen built-in
# source browser. The htags tool is part of GNU's global source tagging system
# (see http://www.gnu.org/software/global/global.html). You will need version
# 4.8.6 or higher.
#
# To use it do the following:
# - Install the latest version of global
# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
# - Make sure the INPUT points to the root of the source tree
# - Run doxygen as normal
#
# Doxygen will invoke htags (and that will in turn invoke gtags), so these
# tools must be available from the command line (i.e. in the search path).
#
# The result: instead of the source browser generated by doxygen, the links to
# source code will now point to the output of htags.
# The default value is: NO.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
# verbatim copy of the header file for each class for which an include is
# specified. Set to NO to disable this.
# See also: Section \class.
# The default value is: YES.
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
# compounds will be generated. Enable this if the project contains a lot of
# classes, structs, unions or interfaces.
# The default value is: YES.
ALPHABETICAL_INDEX = NO
# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
# which the alphabetical index list will be split.
# Minimum value: 1, maximum value: 20, default value: 5.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all classes will
# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
# can be used to specify a prefix (or a list of prefixes) that should be ignored
# while generating the index headers.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
# The default value is: YES.
GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: html.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_OUTPUT = html
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
# generated HTML page (for example: .htm, .php, .asp).
# The default value is: .html.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
# each generated HTML page. If the tag is left blank doxygen will generate a
# standard header.
#
# To get valid HTML the header file that includes any scripts and style sheets
# that doxygen needs, which is dependent on the configuration options used (e.g.
# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
# default header using
# doxygen -w html new_header.html new_footer.html new_stylesheet.css
# YourConfigFile
# and then modify the file new_header.html. See also section "Doxygen usage"
# for information on how to generate the default header that doxygen normally
# uses.
# Note: The header is subject to change so you typically have to regenerate the
# default header when upgrading to a newer version of doxygen. For a description
# of the possible markers and block names see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
# generated HTML page. If the tag is left blank doxygen will generate a standard
# footer. See HTML_HEADER for more information on how to generate a default
# footer and what special commands can be used inside the footer. See also
# section "Doxygen usage" for information on how to generate the default footer
# that doxygen normally uses.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
# sheet that is used by each HTML page. It can be used to fine-tune the look of
# the HTML output. If left blank doxygen will generate a default style sheet.
# See also section "Doxygen usage" for information on how to generate the style
# sheet that doxygen normally uses.
# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
# it is more robust and this tag (HTML_STYLESHEET) will in the future become
# obsolete.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_STYLESHEET =
# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
# cascading style sheets that are included after the standard style sheets
# created by doxygen. Using this option one can overrule certain style aspects.
# This is preferred over using HTML_STYLESHEET since it does not replace the
# standard style sheet and is therefore more robust against future updates.
# Doxygen will copy the style sheet files to the output directory.
# Note: The order of the extra style sheet files is of importance (e.g. the last
# style sheet in the list overrules the setting of the previous ones in the
# list). For an example see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_STYLESHEET =
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
# files will be copied as-is; there are no commands or markers available.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_FILES =
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
# will adjust the colors in the style sheet and background images according to
# this color. Hue is specified as an angle on a colorwheel, see
# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
# purple, and 360 is red again.
# Minimum value: 0, maximum value: 359, default value: 220.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_HUE = 220
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
# in the HTML output. For a value of 0 the output will use grayscales only. A
# value of 255 will produce the most vivid colors.
# Minimum value: 0, maximum value: 255, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_SAT = 100
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
# luminance component of the colors in the HTML output. Values below 100
# gradually make the output lighter, whereas values above 100 make the output
# darker. The value divided by 100 is the actual gamma applied, so 80 represents
# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
# change the gamma.
# Minimum value: 40, maximum value: 240, default value: 80.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_GAMMA = 80
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting this
# to NO can help when comparing the output of multiple runs.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_TIMESTAMP = YES
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_DYNAMIC_SECTIONS = NO
# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
# shown in the various tree structured indices initially; the user can expand
# and collapse entries dynamically later on. Doxygen will expand the tree to
# such a level that at most the specified number of entries are visible (unless
# a fully collapsed tree already exceeds this amount). So setting the number of
# entries 1 will produce a full collapsed tree by default. 0 is a special value
# representing an infinite number of entries and will result in a full expanded
# tree by default.
# Minimum value: 0, maximum value: 9999, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_INDEX_NUM_ENTRIES = 100
# If the GENERATE_DOCSET tag is set to YES, additional index files will be
# generated that can be used as input for Apple's Xcode 3 integrated development
# environment (see: http://developer.apple.com/tools/xcode/), introduced with
# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
# Makefile in the HTML output directory. Running make will produce the docset in
# that directory and running make install will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_DOCSET = NO
# This tag determines the name of the docset feed. A documentation feed provides
# an umbrella under which multiple documentation sets from a single provider
# (such as a company or product suite) can be grouped.
# The default value is: Doxygen generated docs.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_FEEDNAME = "Doxygen generated docs"
# This tag specifies a string that should uniquely identify the documentation
# set bundle. This should be a reverse domain-name style string, e.g.
# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_BUNDLE_ID = org.doxygen.Project
# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
# the documentation publisher. This should be a reverse domain-name style
# string, e.g. com.mycompany.MyDocSet.documentation.
# The default value is: org.doxygen.Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
# The default value is: Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_NAME = Publisher
# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
# Windows.
#
# The HTML Help Workshop contains a compiler that can convert all HTML output
# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
# files are now used as the Windows 98 help format, and will replace the old
# Windows help format (.hlp) on all Windows platforms in the future. Compressed
# HTML files also contain an index, a table of contents, and you can search for
# words in the documentation. The HTML workshop also contains a viewer for
# compressed HTML files.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_HTMLHELP = NO
# The CHM_FILE tag can be used to specify the file name of the resulting .chm
# file. You can add a path in front of the file if the result should not be
# written to the html output directory.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_FILE =
# The HHC_LOCATION tag can be used to specify the location (absolute path
# including file name) of the HTML help compiler (hhc.exe). If non-empty,
# doxygen will try to run the HTML help compiler on the generated index.hhp.
# The file has to be specified with full path.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
HHC_LOCATION =
# The GENERATE_CHI flag controls if a separate .chi index file is generated
# (YES) or that it should be included in the master .chm file (NO).
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
GENERATE_CHI = NO
# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
# and project file content.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_INDEX_ENCODING =
# The BINARY_TOC flag controls whether a binary table of contents is generated
# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
# enables the Previous and Next buttons.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members to
# the table of contents of the HTML help documentation and to the tree view.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP
gitextract_z1ik1m5j/
├── .clang-tidy
├── .github/
│ └── workflows/
│ ├── cmake.yml
│ ├── conda-deploy.yml
│ └── make_doxygen.yml
├── .gitignore
├── .readthedocs.yaml
├── AGENTS.md
├── CMakeLists.txt
├── INSTALL.md
├── LICENSE
├── README.md
├── _config.yml
├── admin/
│ ├── conda/
│ │ ├── README.md
│ │ └── recipe/
│ │ └── meta.yaml.in
│ └── docker/
│ ├── README.md
│ ├── images/
│ │ └── Makefile
│ └── ubuntu/
│ ├── Dockerfile
│ ├── Makefile
│ └── sudoers
├── bin/
│ ├── latex2oo
│ ├── taskprofile.pl
│ └── test_utilities.py
├── cmake/
│ ├── Makefile
│ ├── config.h.in
│ ├── doxygen.cfg.in
│ ├── madness-config.cmake.in
│ ├── modules/
│ │ ├── AddCustomTargetSubproject.cmake
│ │ ├── AddMADExecutable.cmake
│ │ ├── AddMADLibrary.cmake
│ │ ├── AddMPITests.cmake
│ │ ├── AddOptions.cmake
│ │ ├── AddScriptedTests.cmake
│ │ ├── AddUnittests.cmake
│ │ ├── AppendFlags.cmake
│ │ ├── CheckCFortranFunctionExists.cmake
│ │ ├── CheckDisablePIESupport.cmake
│ │ ├── ConvertIncludesListToCompilerArgs.cmake
│ │ ├── ConvertLibrariesListToCompilerArgs.cmake
│ │ ├── CopyTargetProperties.cmake
│ │ ├── EchoTargetProperty.cmake
│ │ ├── FindACML.cmake
│ │ ├── FindFFTW.cmake
│ │ ├── FindGperftools.cmake
│ │ ├── FindIntegratorXX.cmake
│ │ ├── FindLibunwind.cmake
│ │ ├── FindMKL.cmake
│ │ ├── FindOrFetchCereal.cmake
│ │ ├── FindOrFetchPARSEC.cmake
│ │ ├── FindPCM.cmake
│ │ ├── FindPapi.cmake
│ │ ├── FindTBB.cmake
│ │ ├── GetGitMetadata.cmake
│ │ └── RedefaultableOption.cmake
│ └── toolchains/
│ ├── arm-gnu-tbb.cmake
│ ├── dancer_gcc.cmake
│ ├── generic-mkl-tbb.cmake
│ ├── mira-clang11-essl.cmake
│ ├── mira-gcc-essl.cmake
│ ├── osx-clang-accelerate-tbb.cmake
│ └── osx-clang-mkl-tbb.cmake
├── conda-recipe/
│ ├── .gitignore
│ ├── build.sh
│ └── meta.yaml
├── config/
│ └── MADNESS.pc.in
├── doc/
│ ├── CMakeLists.txt
│ ├── INSTALL.md
│ ├── Latex/
│ │ ├── api.tex
│ │ ├── apps/
│ │ │ ├── lrccs/
│ │ │ │ ├── LRCCS_Manual.tex
│ │ │ │ └── references.bib
│ │ │ ├── moldft/
│ │ │ │ └── manual.tex
│ │ │ └── nemo_mp2/
│ │ │ ├── aip.bst
│ │ │ ├── aip.sty
│ │ │ ├── manual.tex
│ │ │ └── references.bib
│ │ ├── implementation.tex
│ │ └── parallel-runtime.tex
│ ├── MADNESSeverything4.odp
│ ├── Makefile
│ ├── applications.dox
│ ├── conf.py
│ ├── configuration.dox
│ ├── contribution/
│ │ └── style.dox
│ ├── contribution.dox
│ ├── getting_started/
│ │ ├── gstart_basics.dox
│ │ ├── gstart_comp_run.dox
│ │ ├── gstart_env_var.dox
│ │ ├── gstart_functions.dox
│ │ ├── gstart_io.dox
│ │ ├── gstart_load_balance.dox
│ │ └── gstart_think_madness.dox
│ ├── getting_started.dox
│ ├── index.log
│ ├── index.rst
│ ├── libraries/
│ │ ├── chemistry.dox
│ │ ├── containers.dox
│ │ ├── parallel_runtime/
│ │ │ ├── futures.dox
│ │ │ ├── mpi.dox
│ │ │ ├── serialization.dox
│ │ │ ├── threading/
│ │ │ │ ├── atomics.dox
│ │ │ │ ├── taskq.dox
│ │ │ │ └── threads.dox
│ │ │ ├── threading.dox
│ │ │ ├── world.dox
│ │ │ └── world_object.dox
│ │ └── parallel_runtime.dox
│ ├── libraries.dox
│ ├── madness.bib
│ ├── mainpage.dox
│ ├── make.bat
│ ├── numerical_library.md
│ ├── quantum.md
│ ├── requirements.txt
│ ├── runtime.md
│ └── tutorial/
│ ├── API.md
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── TODO.md
│ ├── chemistry.md
│ ├── simple_hf.cpp
│ └── test_runtime.cpp
├── external/
│ ├── boost.cmake
│ ├── elemental.cmake
│ ├── gperftools.cmake
│ ├── integratorxx.cmake
│ ├── lapack.cmake
│ ├── libunwind.cmake
│ ├── libxc.cmake
│ ├── mpi.cmake
│ ├── papi.cmake
│ ├── parsec.cmake
│ ├── pcm.cmake
│ ├── pthread.cmake
│ ├── pybind11.cmake
│ ├── tbb.cmake
│ └── versions.cmake
└── src/
├── CMakeLists.txt
├── apps/
│ ├── CMakeLists.txt
│ ├── QCSchema_json.md
│ ├── cc2/
│ │ ├── CMakeLists.txt
│ │ └── cc2.cc
│ ├── cis/
│ │ ├── CMakeLists.txt
│ │ ├── cis.cpp
│ │ └── input
│ ├── dirac/
│ │ ├── CMakeLists.txt
│ │ ├── DF.cc
│ │ ├── DF.h
│ │ ├── DFParameters.h
│ │ ├── DFdriver.cc
│ │ ├── DFinput_sample
│ │ ├── DKops.h
│ │ ├── InitParameters.h
│ │ ├── README
│ │ ├── fcwf.cc
│ │ ├── fcwf.h
│ │ ├── relops.cc
│ │ └── rk.cc
│ ├── interior_bc/
│ │ ├── CMakeLists.txt
│ │ ├── embedded_dirichlet.cc
│ │ └── test_problems.h
│ ├── madqc_v2/
│ │ ├── CMakeLists.txt
│ │ ├── mad_madqc_test_cc2_callable.py.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_energy_he.py.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_symmetry_h2o.py_a2.calc_info.ref.json
│ │ ├── mad_madqc_test_cis_symmetry_h2o.py_b1.calc_info.ref.json
│ │ ├── mad_madqc_test_lrcc2_helium.py.calc_info.ref.json
│ │ ├── mad_madqc_test_moldft_energy.py.calc_info.ref.json
│ │ ├── mad_madqc_test_moldft_energy_mpi_parallel.py.calc_info.ref.json
│ │ ├── mad_madqc_test_mp2_helium.py.calc_info.ref.json
│ │ ├── mad_madqc_test_nemo_energy.py.calc_info.ref.json
│ │ ├── mad_madqc_test_nemo_localization.py.calc_info.ref.json
│ │ ├── mad_madqc_test_oep_energy.py.calc_info.ref.json
│ │ ├── madqc.cpp
│ │ ├── test_cc2_callable.py
│ │ ├── test_cis_energy_he.py
│ │ ├── test_cis_symmetry_h2o.py
│ │ ├── test_lrcc2_helium.py
│ │ ├── test_moldft_energy.py
│ │ ├── test_moldft_energy_mpi_parallel.py
│ │ ├── test_mp2_helium.py
│ │ ├── test_nemo_energy.py
│ │ ├── test_nemo_localization.py
│ │ └── test_oep_energy.py
│ ├── moldft/
│ │ ├── CMakeLists.txt
│ │ ├── calcguess.nw
│ │ ├── df_repo.tgz
│ │ ├── fci/
│ │ │ ├── GNUmakefile
│ │ │ ├── bitops.fh
│ │ │ ├── crayio.c
│ │ │ ├── daxpy.F
│ │ │ ├── dcopy.F
│ │ │ ├── ddot.F
│ │ │ ├── dgemm.F
│ │ │ ├── doc/
│ │ │ │ ├── GNUmakefile
│ │ │ │ ├── bibstuff.tex
│ │ │ │ ├── commands.tex
│ │ │ │ ├── matrixelements.ps
│ │ │ │ ├── matrixelements.tex
│ │ │ │ ├── matrixelements.toc
│ │ │ │ ├── mspingraph.eps
│ │ │ │ ├── mspingraph.fig
│ │ │ │ ├── orbitalarcs.eps
│ │ │ │ ├── orbitalarcs.fig
│ │ │ │ ├── orbitalgraph.eps
│ │ │ │ ├── orbitalgraph.fig
│ │ │ │ ├── psfig.sty
│ │ │ │ ├── spinarcs.eps
│ │ │ │ ├── spinarcs.fig
│ │ │ │ ├── spingraph.eps
│ │ │ │ └── spingraph.fig
│ │ │ ├── dscal.F
│ │ │ ├── fci.F
│ │ │ ├── fci_1pdm.F
│ │ │ ├── fci_2pdm.F
│ │ │ ├── fci_3pdm.F
│ │ │ ├── fci_axb.F
│ │ │ ├── fci_cntone.F
│ │ │ ├── fci_couple1.F
│ │ │ ├── fci_couple2.F
│ │ │ ├── fci_couple3.F
│ │ │ ├── fci_davids.F
│ │ │ ├── fci_detwalk.F
│ │ │ ├── fci_dfill.F
│ │ │ ├── fci_diags.F
│ │ │ ├── fci_err.F
│ │ │ ├── fci_hami.F
│ │ │ ├── fci_hmod.F
│ │ │ ├── fci_hsort.F
│ │ │ ├── fci_hv.F
│ │ │ ├── fci_ifill.F
│ │ │ ├── fci_intchk.F
│ │ │ ├── fci_load.F
│ │ │ ├── fci_make_eaj.F
│ │ │ ├── fci_mfndoc.F
│ │ │ ├── fci_mfndwt.F
│ │ │ ├── fci_mgraph.F
│ │ │ ├── fci_num.F
│ │ │ ├── fci_ofndoc.F
│ │ │ ├── fci_ofndwt.F
│ │ │ ├── fci_ograph.F
│ │ │ ├── fci_onelcc.F
│ │ │ ├── fci_onepdm.F
│ │ │ ├── fci_output.F
│ │ │ ├── fci_owalk_info.F
│ │ │ ├── fci_prntri.F
│ │ │ ├── fci_prspnad.F
│ │ │ ├── fci_prteop.F
│ │ │ ├── fci_prvec.F
│ │ │ ├── fci_setup.F
│ │ │ ├── fci_sigma.F
│ │ │ ├── fci_solve.F
│ │ │ ├── fci_spnad.F
│ │ │ ├── fci_spnfrc.F
│ │ │ ├── fci_srt1cc.F
│ │ │ ├── fci_tinit.F
│ │ │ ├── fciinfo.fh
│ │ │ ├── fciparam.fh
│ │ │ ├── fcitime.fh
│ │ │ ├── idamax.F
│ │ │ ├── ieor.c
│ │ │ ├── linux_cputime.c
│ │ │ ├── output
│ │ │ ├── renorm.F
│ │ │ ├── rsg.f
│ │ │ ├── screen.F
│ │ │ ├── timer.f
│ │ │ └── yacobi.F
│ │ ├── fitinput
│ │ ├── gth.xml
│ │ ├── gth_pbe.xml
│ │ ├── input
│ │ ├── lda.f
│ │ ├── mad_moldft_test_energy.py.calc_info.ref.json
│ │ ├── mad_moldft_test_energy_mpi_parallel.py.calc_info.ref.json
│ │ ├── mcpfit.cc
│ │ ├── moldft.cc
│ │ ├── moldx.py
│ │ ├── nwtoxml.py
│ │ ├── parsemad.py
│ │ ├── pointgroup.h
│ │ ├── preal.cc
│ │ ├── subspace.h
│ │ ├── testcosine.cc
│ │ ├── testmolbas.cc
│ │ ├── testperiodicdft.cc
│ │ ├── testpg.cc
│ │ ├── tests/
│ │ │ ├── be_lda.in
│ │ │ ├── c6h6_lda.in
│ │ │ ├── ca_lda.in
│ │ │ ├── h2o_1_lda.in
│ │ │ ├── h2o_2_lda.in
│ │ │ ├── h2o_5_lda.in
│ │ │ ├── h2o_9_lda.in
│ │ │ ├── h2o_hf.in
│ │ │ ├── h_hf.in
│ │ │ ├── h_lsda.in
│ │ │ ├── he_hf.in
│ │ │ ├── he_lda.in
│ │ │ ├── he_xpbe.in
│ │ │ ├── k_hf.in
│ │ │ ├── li_hf.in
│ │ │ ├── li_lsda.in
│ │ │ ├── mg_lda.in
│ │ │ ├── n2_hf.in
│ │ │ ├── n_lsda.in
│ │ │ ├── na_hf.in
│ │ │ ├── ne_lda.in
│ │ │ ├── nh3_planar_hf.in
│ │ │ ├── nh3_pyramidal_hf.in
│ │ │ ├── rb_hf.in
│ │ │ └── sr_lda.in
│ │ ├── vizit.cfg
│ │ ├── vizit.net
│ │ ├── wst_functional.h
│ │ └── xmlguess.py
│ ├── molresponse/
│ │ ├── CMakeLists.txt
│ │ ├── ExcitedResponse.cpp
│ │ ├── ExcitedResponse.hpp
│ │ ├── FrequencyResponse.cpp
│ │ ├── FrequencyResponse.hpp
│ │ ├── Plot_VTK.cc
│ │ ├── Plot_VTK.h
│ │ ├── ResponseBase.cpp
│ │ ├── ResponseBase.hpp
│ │ ├── ResponseExceptions.hpp
│ │ ├── basic_operators.cc
│ │ ├── basic_operators.h
│ │ ├── calc_runner.cc
│ │ ├── details.md
│ │ ├── global_functions.cc
│ │ ├── global_functions.h
│ │ ├── ground_parameters.h
│ │ ├── molresponse.cc
│ │ ├── molresponse_tutorial.md
│ │ ├── property.cc
│ │ ├── property.h
│ │ ├── response_functions.h
│ │ ├── response_macrotask.hpp
│ │ ├── response_parameters.cpp
│ │ ├── response_parameters.h
│ │ ├── timer.cc
│ │ ├── timer.h
│ │ ├── x_space.cc
│ │ └── x_space.h
│ ├── molresponse_v2/
│ │ ├── CMakeLists.txt
│ │ ├── FrequencyLoop.hpp
│ │ ├── GroundStateData.cpp
│ │ ├── GroundStateData.hpp
│ │ ├── InnerContributions.hpp
│ │ ├── MolecularProperty.hpp
│ │ ├── Perturbation.hpp
│ │ ├── PropertyManager.hpp
│ │ ├── ResponseDebugLogger.hpp
│ │ ├── ResponseDebugLoggerMacros.hpp
│ │ ├── ResponseIO.hpp
│ │ ├── ResponseInitializer.hpp
│ │ ├── ResponseManager.cpp
│ │ ├── ResponseManager.hpp
│ │ ├── ResponseMetaData.hpp
│ │ ├── ResponseSolver.cpp
│ │ ├── ResponseSolver.hpp
│ │ ├── ResponseSolverUtils.hpp
│ │ ├── ResponseState.cpp
│ │ ├── ResponseState.hpp
│ │ ├── ResponseVector.hpp
│ │ ├── StateGenerator.hpp
│ │ ├── VBCMacrotask.hpp
│ │ ├── broadcast_json.hpp
│ │ ├── molresponse2.cpp
│ │ ├── test_parameter_manager.cpp
│ │ ├── test_preliminaries.cpp
│ │ └── usage.rst
│ ├── mp2/
│ │ ├── CMakeLists.txt
│ │ └── mp2.cc
│ ├── nemo/
│ │ ├── CMakeLists.txt
│ │ ├── madtestboys.calc_info.ref.json
│ │ ├── madtestcanon.calc_info.ref.json
│ │ ├── madtestnew.calc_info.ref.json
│ │ └── nemo.cc
│ ├── oep/
│ │ ├── CMakeLists.txt
│ │ ├── madtest1.oep_calc_info.ref.json
│ │ └── oep.cc
│ ├── periodic_old/
│ │ ├── CMakeLists.txt
│ │ ├── complexfun.h
│ │ ├── dft.cc
│ │ ├── dft.h
│ │ ├── eigsolver.cc
│ │ ├── eigsolver.h
│ │ ├── electronicstructureapp.h
│ │ ├── electronicstructureparams.h
│ │ ├── esolver.h
│ │ ├── ewald.cc
│ │ ├── hartreefock.cc
│ │ ├── hartreefock.h
│ │ ├── input
│ │ ├── lda.h
│ │ ├── libxc.h
│ │ ├── matlab/
│ │ │ └── cosine_potential/
│ │ │ ├── fd_coulomb_conv.m
│ │ │ ├── test_coulomb.m
│ │ │ ├── test_coulomb1D.m
│ │ │ ├── test_coulomb1D_pw.m
│ │ │ ├── test_coulomb1D_sincos.m
│ │ │ ├── test_coulomb3D.m
│ │ │ ├── test_coulomb3D_pw.m
│ │ │ └── test_coulomb3D_sep.m
│ │ ├── mentity.cc
│ │ ├── mentity.h
│ │ ├── molecularbasis.h
│ │ ├── outputwriter.h
│ │ ├── poperator.h
│ │ ├── solver.h
│ │ ├── solver_driver.cc
│ │ ├── sto-3g
│ │ ├── test_be.cc
│ │ ├── test_comm.cc
│ │ ├── test_coulomb.cc
│ │ ├── test_he.cc
│ │ ├── test_hf.cc
│ │ ├── test_hydro.cc
│ │ ├── test_lattice.cc
│ │ ├── test_xc.cc
│ │ ├── testconv.cc
│ │ ├── util.cc
│ │ └── util.h
│ ├── plot/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── plot2cube.cpp
│ │ └── plot2plane.cpp
│ ├── pno/
│ │ ├── CMakeLists.txt
│ │ ├── auxbas
│ │ ├── input
│ │ ├── input_hylleraas_file
│ │ ├── input_hylleraas_internal
│ │ └── pno.cpp
│ ├── tdse/
│ │ ├── CMakeLists.txt
│ │ ├── graveyard
│ │ ├── hatom.job
│ │ ├── input
│ │ ├── input4
│ │ ├── restart
│ │ ├── tdse.cc
│ │ ├── tdse.confused.cc
│ │ └── tdse4.cc
│ ├── zcis/
│ │ ├── CMakeLists.txt
│ │ └── zcis.cc
│ └── znemo/
│ ├── CMakeLists.txt
│ ├── madtest1.calc_info.ref.json
│ ├── test_energy.py
│ └── znemo.cc
├── examples/
│ ├── 3dharmonic.cc
│ ├── CMakeLists.txt
│ ├── RUNALL
│ ├── ac_corr.cc
│ ├── array_worldobject.cc
│ ├── binaryop.cc
│ ├── colloid.cc
│ ├── compiler/
│ │ ├── Makefile
│ │ ├── Makefile-prog.am
│ │ ├── README
│ │ ├── eqn.tex
│ │ ├── hatom
│ │ ├── hatompolar
│ │ ├── he2el
│ │ ├── hehf
│ │ ├── hehf2
│ │ ├── mra-driver.cc
│ │ ├── mra-driver.hh
│ │ ├── mra.cc
│ │ ├── mra.ll
│ │ ├── mra.yy
│ │ └── qa
│ ├── csqrt.cc
│ ├── dataloadbal.cc
│ ├── density_smoothing.cc
│ ├── derivatives.cc
│ ├── dielectric.cc
│ ├── dielectric_external_field.cc
│ ├── dirac-hatom.cc
│ ├── functionio.cc
│ ├── gaussian.cc
│ ├── graveyard
│ ├── gygi_soltion.cc
│ ├── h2.cc
│ ├── h2dft.cc
│ ├── h2dynamic.cc
│ ├── hatom.cc
│ ├── hatom_1d.cc
│ ├── hatom_energy.cc
│ ├── hatom_sf_dirac.cc
│ ├── he.cc
│ ├── heat.cc
│ ├── heat2.cc
│ ├── hedft.cc
│ ├── hefxc.cc
│ ├── hehf.cc
│ ├── helium_exact.cc
│ ├── helium_mp2.cc
│ ├── hello.cc
│ ├── input_tdhf_virtuals
│ ├── madinfo.cc
│ ├── molecularmask.h
│ ├── molecularsurface.cc
│ ├── navstokes_cosines.cc
│ ├── newsolver.cc
│ ├── newsolver_lda.cc
│ ├── nonlinschro.cc
│ ├── pcr.cc
│ ├── periodic/
│ │ ├── CMakeLists.txt
│ │ ├── erfcr.cc
│ │ ├── test.cc
│ │ ├── testfilter.cc
│ │ ├── testfuns.cc
│ │ ├── testpc.h
│ │ └── testpercoul.cc
│ ├── ploterr.cc
│ ├── sdf_shape_tester.cc
│ ├── siam_example.cc
│ ├── sininteg.cc
│ ├── smooth
│ ├── smooth.h
│ ├── spectralprop.h
│ ├── svpe.cc
│ ├── tdhf_input
│ ├── tdse1d.cc
│ ├── tdse_example.cc
│ ├── test_derivative.cc
│ ├── test_gmres.cc
│ ├── testcomplexfunctionsolver.cc
│ ├── testspectralprop.cc
│ ├── testttg.cc
│ ├── tiny.cc
│ ├── vnucso.cc
│ ├── vtk.cc
│ ├── writecoeff.cc
│ ├── writecoeff2.cc
│ └── writecoeffs/
│ ├── CMakeLists.txt
│ ├── FunctionIO.h
│ ├── FunctionIO2.h
│ ├── FunctionIOHDF5.h
│ ├── app.cpp
│ ├── core.cpp
│ ├── core.hpp
│ ├── h2_write.cc
│ ├── h2_write_json.cc
│ ├── h2_write_json_2.cc
│ ├── h5cpp_test.cc
│ ├── writecoeff.cc
│ ├── writecoeff2.cc
│ ├── writecoeff3.cc
│ ├── writecoeff_hdf5.cc
│ └── writecoeff_json.cc
├── madchem.h
├── madness/
│ ├── CMakeLists.txt
│ ├── chem/
│ │ ├── 3-21g
│ │ ├── 6-31g
│ │ ├── 6-31gss
│ │ ├── AC.cc
│ │ ├── AC.h
│ │ ├── Applications.hpp
│ │ ├── BSHApply.h
│ │ ├── CC2.cc
│ │ ├── CC2.h
│ │ ├── CCLib.hpp
│ │ ├── CCParameters.h
│ │ ├── CCPotentials.cc
│ │ ├── CCPotentials.h
│ │ ├── CCStructures.cc
│ │ ├── CCStructures.h
│ │ ├── CMakeLists.txt
│ │ ├── CalculationParameters.h
│ │ ├── Drivers.hpp
│ │ ├── ESInterface.h
│ │ ├── GuessFactory.cc
│ │ ├── GuessFactory.h
│ │ ├── InputWriter.cpp
│ │ ├── InputWriter.hpp
│ │ ├── IntegratorXX.h
│ │ ├── MoldftLib.hpp
│ │ ├── MolecularOrbitals.cc
│ │ ├── MolecularOrbitals.h
│ │ ├── MolresponseLib.hpp
│ │ ├── NWChem.cc
│ │ ├── NWChem.h
│ │ ├── PNO.cpp
│ │ ├── PNO.h
│ │ ├── PNOF12Potentials.cpp
│ │ ├── PNOF12Potentials.h
│ │ ├── PNOGuessFunctions.cpp
│ │ ├── PNOGuessFunctions.h
│ │ ├── PNOParameters.cpp
│ │ ├── PNOParameters.h
│ │ ├── PNOStructures.cpp
│ │ ├── PNOStructures.h
│ │ ├── PNOTensors.h
│ │ ├── ParameterManager.hpp
│ │ ├── PathManager.hpp
│ │ ├── QCPropertyInterface.h
│ │ ├── ResponseParameters.hpp
│ │ ├── Results.h
│ │ ├── SAP.cc
│ │ ├── SAP.h
│ │ ├── SCF.cc
│ │ ├── SCF.h
│ │ ├── SCFOperators.cc
│ │ ├── SCFOperators.h
│ │ ├── SCFProtocol.h
│ │ ├── SCFTargetAdapter.hpp
│ │ ├── TDHF.cc
│ │ ├── TDHF.h
│ │ ├── atomutil.cc
│ │ ├── atomutil.h
│ │ ├── aug-cc-pvdz
│ │ ├── basis.h
│ │ ├── benchmark_exchange_operator.cc
│ │ ├── ccpairfunction.cc
│ │ ├── ccpairfunction.h
│ │ ├── cis_example_input
│ │ ├── coredata/
│ │ │ ├── mcp
│ │ │ ├── mcp2
│ │ │ ├── mcp2_guess
│ │ │ └── mcp_guess
│ │ ├── corepotential.cc
│ │ ├── corepotential.h
│ │ ├── correlationfactor.cc
│ │ ├── correlationfactor.h
│ │ ├── def2-SVP
│ │ ├── diamagneticpotentialfactor.cc
│ │ ├── diamagneticpotentialfactor.h
│ │ ├── distpm.cc
│ │ ├── distpm.h
│ │ ├── electronic_correlation_factor.h
│ │ ├── exchangeoperator.cc
│ │ ├── exchangeoperator.h
│ │ ├── gaussian.cc
│ │ ├── gaussian.h
│ │ ├── gth_pseudopotential.cc
│ │ ├── gth_pseudopotential.h
│ │ ├── lda.cc
│ │ ├── localizer.cc
│ │ ├── localizer.h
│ │ ├── lowrankfunction.h
│ │ ├── masks_and_boxes.h
│ │ ├── molecular_functors.h
│ │ ├── molecular_optimizer.h
│ │ ├── molecularbasis.cc
│ │ ├── molecularbasis.h
│ │ ├── molecule.cc
│ │ ├── molecule.h
│ │ ├── molopt.h
│ │ ├── mp2.cc
│ │ ├── mp2.h
│ │ ├── mp3.cc
│ │ ├── mp3.h
│ │ ├── nemo.cc
│ │ ├── nemo.h
│ │ ├── oep.cc
│ │ ├── oep.h
│ │ ├── pcm.cc
│ │ ├── pcm.h
│ │ ├── plotxc.cc
│ │ ├── pointgroupoperator.h
│ │ ├── pointgroupsymmetry.cc
│ │ ├── pointgroupsymmetry.h
│ │ ├── polynomial.cc
│ │ ├── polynomial.h
│ │ ├── potentialmanager.cc
│ │ ├── potentialmanager.h
│ │ ├── projector.h
│ │ ├── sto-3g
│ │ ├── sto-6g
│ │ ├── structure_library
│ │ ├── test_BSHApply.cc
│ │ ├── test_IntegratorXX.cc
│ │ ├── test_MolecularOrbitals.cc
│ │ ├── test_SCFOperators.cc
│ │ ├── test_ccpairfunction.cc
│ │ ├── test_dft.cc
│ │ ├── test_exchangeoperator.cc
│ │ ├── test_localizer.cc
│ │ ├── test_low_rank_function.cc
│ │ ├── test_masks_and_boxes.cc
│ │ ├── test_pointgroupsymmetry.cc
│ │ ├── test_projector.cc
│ │ ├── test_qc.cc
│ │ ├── testlda.cc
│ │ ├── testxc.cc
│ │ ├── vibanal.cc
│ │ ├── vibanal.h
│ │ ├── write_test_input.h
│ │ ├── xcfunctional.h
│ │ ├── xcfunctional_ldaonly.cc
│ │ ├── xcfunctional_libxc.cc
│ │ ├── zcis.cc
│ │ ├── zcis.h
│ │ ├── znemo.cc
│ │ └── znemo.h
│ ├── constants.h
│ ├── external/
│ │ ├── CMakeLists.txt
│ │ ├── catch/
│ │ │ └── catch.hpp
│ │ ├── elemental/
│ │ │ ├── AUTHORS
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE
│ │ │ ├── PUBLICATIONS.bib
│ │ │ ├── README.md
│ │ │ ├── REFERENCES.bib
│ │ │ ├── TODO
│ │ │ ├── cmake/
│ │ │ │ ├── ElemSub.cmake
│ │ │ │ ├── ElemVars.cmake
│ │ │ │ ├── README.md
│ │ │ │ ├── config.h.cmake
│ │ │ │ ├── tests/
│ │ │ │ │ ├── CXX.cmake
│ │ │ │ │ ├── Fortran.cmake
│ │ │ │ │ ├── MPI.cmake
│ │ │ │ │ ├── Math.cmake
│ │ │ │ │ ├── OpenMP.cmake
│ │ │ │ │ └── Qt5.cmake
│ │ │ │ └── toolchains/
│ │ │ │ ├── BGQ-Mira-clang-essl.cmake
│ │ │ │ ├── BGQ-Vesta-clang-essl.cmake
│ │ │ │ ├── BGQ-Vesta-clang-netlib.cmake
│ │ │ │ ├── BGQ-Vesta-gnu-essl.cmake
│ │ │ │ ├── BGQ-Vesta-gnu-netlib.cmake
│ │ │ │ ├── Edison-gnu-mpich-libsci.cmake
│ │ │ │ ├── Hopper-gnu-mpich2-libsci.cmake
│ │ │ │ ├── Lonestar-intel-mvapich2-mkl.cmake
│ │ │ │ ├── Longhorn-intel-mvapich2-mkl.cmake
│ │ │ │ ├── README.md
│ │ │ │ ├── Ranger-gnu-mvapich-mkl.cmake
│ │ │ │ ├── Ranger-gnu-mvapich2-mkl.cmake
│ │ │ │ ├── Ranger-intel-mvapich-mkl.cmake
│ │ │ │ ├── Ranger-intel-mvapich2-mkl.cmake
│ │ │ │ ├── Stampede-gnu-mvapich2-mkl.cmake
│ │ │ │ └── Stampede-intel-mvapich2-mkl.cmake
│ │ │ ├── examples/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── Cannon.cpp
│ │ │ │ │ ├── Gemm.cpp
│ │ │ │ │ ├── Gemv.cpp
│ │ │ │ │ └── README.md
│ │ │ │ ├── convex/
│ │ │ │ │ ├── BasisPursuit.cpp
│ │ │ │ │ ├── LinearProgram.cpp
│ │ │ │ │ ├── LogDetDiv.cpp
│ │ │ │ │ ├── QuadraticProgram.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── RPCA.cpp
│ │ │ │ │ └── SparseInvCov.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── Arbitrary.cpp
│ │ │ │ │ ├── Constructors.cpp
│ │ │ │ │ ├── LogicError.cpp
│ │ │ │ │ └── README.md
│ │ │ │ ├── io/
│ │ │ │ │ ├── Read.cpp
│ │ │ │ │ └── Write.cpp
│ │ │ │ ├── lapack-like/
│ │ │ │ │ ├── BunchKaufman.cpp
│ │ │ │ │ ├── BusingerGolub.cpp
│ │ │ │ │ ├── ChunkedPseudospectrum.cpp
│ │ │ │ │ ├── ChunkedTriangularPseudospectrum.cpp
│ │ │ │ │ ├── ComplexHermitianFunction.cpp
│ │ │ │ │ ├── GLM.cpp
│ │ │ │ │ ├── GaussianElimination.cpp
│ │ │ │ │ ├── HPDInverse.cpp
│ │ │ │ │ ├── HPSDCholesky.cpp
│ │ │ │ │ ├── HPSDSquareRoot.cpp
│ │ │ │ │ ├── HermitianEig.cpp
│ │ │ │ │ ├── HermitianEigFromSequential.cpp
│ │ │ │ │ ├── HermitianPseudoinverse.cpp
│ │ │ │ │ ├── HermitianQDWH.cpp
│ │ │ │ │ ├── HermitianSDC.cpp
│ │ │ │ │ ├── HermitianSVD.cpp
│ │ │ │ │ ├── ID.cpp
│ │ │ │ │ ├── KyFanAndSchatten.cpp
│ │ │ │ │ ├── LDL.cpp
│ │ │ │ │ ├── LDLInverse.cpp
│ │ │ │ │ ├── LSE.cpp
│ │ │ │ │ ├── LeastSquares.cpp
│ │ │ │ │ ├── Polar.cpp
│ │ │ │ │ ├── Pseudoinverse.cpp
│ │ │ │ │ ├── Pseudospectrum.cpp
│ │ │ │ │ ├── QDWH.cpp
│ │ │ │ │ ├── QR.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── RealHermitianFunction.cpp
│ │ │ │ │ ├── RealSchur.cpp
│ │ │ │ │ ├── RealSymmetricFunction.cpp
│ │ │ │ │ ├── SVD.cpp
│ │ │ │ │ ├── Schur.cpp
│ │ │ │ │ ├── SequentialBunchKaufman.cpp
│ │ │ │ │ ├── SequentialQR.cpp
│ │ │ │ │ ├── SequentialSVD.cpp
│ │ │ │ │ ├── Sign.cpp
│ │ │ │ │ ├── SimpleSVD.cpp
│ │ │ │ │ ├── Skeleton.cpp
│ │ │ │ │ ├── SkewHermitianEig.cpp
│ │ │ │ │ └── TriangularPseudospectrum.cpp
│ │ │ │ └── matrices/
│ │ │ │ ├── Cauchy.cpp
│ │ │ │ ├── CauchyLike.cpp
│ │ │ │ ├── Circulant.cpp
│ │ │ │ ├── Diagonal.cpp
│ │ │ │ ├── Egorov.cpp
│ │ │ │ ├── Fourier.cpp
│ │ │ │ ├── Hankel.cpp
│ │ │ │ ├── Helmholtz1D.cpp
│ │ │ │ ├── Helmholtz2D.cpp
│ │ │ │ ├── Helmholtz3D.cpp
│ │ │ │ ├── HermitianUniformSpectrum.cpp
│ │ │ │ ├── Hilbert.cpp
│ │ │ │ ├── Identity.cpp
│ │ │ │ ├── Kahan.cpp
│ │ │ │ ├── Legendre.cpp
│ │ │ │ ├── LehmerParterRis.cpp
│ │ │ │ ├── NormalUniformSpectrum.cpp
│ │ │ │ ├── OneTwoOne.cpp
│ │ │ │ ├── Ones.cpp
│ │ │ │ ├── PSFW.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── RiemannRedhefferGCD.cpp
│ │ │ │ ├── Toeplitz.cpp
│ │ │ │ ├── Uniform.cpp
│ │ │ │ ├── Walsh.cpp
│ │ │ │ ├── Wilkinson.cpp
│ │ │ │ └── Zeros.cpp
│ │ │ ├── experimental/
│ │ │ │ └── g3d/
│ │ │ │ └── G3DGemm.cpp
│ │ │ ├── external/
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── FindCXXFeatures/
│ │ │ │ │ │ ├── cxx11-auto.cxx
│ │ │ │ │ │ ├── cxx11-auto_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-class_override_final.cxx
│ │ │ │ │ │ ├── cxx11-class_override_final_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-constexpr.cxx
│ │ │ │ │ │ ├── cxx11-cstdint_header.cxx
│ │ │ │ │ │ ├── cxx11-decltype.cxx
│ │ │ │ │ │ ├── cxx11-defaulted_functions.cxx
│ │ │ │ │ │ ├── cxx11-delegating_constructors.cxx
│ │ │ │ │ │ ├── cxx11-deleted_functions.cxx
│ │ │ │ │ │ ├── cxx11-deleted_functions_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-func_identifier.cxx
│ │ │ │ │ │ ├── cxx11-initializer_list.cxx
│ │ │ │ │ │ ├── cxx11-lambda.cxx
│ │ │ │ │ │ ├── cxx11-long_long.cxx
│ │ │ │ │ │ ├── cxx11-nullptr.cxx
│ │ │ │ │ │ ├── cxx11-nullptr_fail_compile.cxx
│ │ │ │ │ │ ├── cxx11-rvalue_references.cxx
│ │ │ │ │ │ ├── cxx11-sizeof_member.cxx
│ │ │ │ │ │ ├── cxx11-static_assert.cxx
│ │ │ │ │ │ ├── cxx11-static_assert_fail_compile.cxx
│ │ │ │ │ │ └── cxx11-variadic_templates.cxx
│ │ │ │ │ ├── FindCXXFeatures.cmake
│ │ │ │ │ ├── FindNumPy.cmake
│ │ │ │ │ ├── FindValgrind.cmake
│ │ │ │ │ ├── GetGitRevisionDescription.cmake
│ │ │ │ │ ├── GetGitRevisionDescription.cmake.in
│ │ │ │ │ └── language_support_v2.cmake
│ │ │ │ └── pmrrr/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README
│ │ │ │ ├── include/
│ │ │ │ │ ├── counter.h
│ │ │ │ │ ├── global.h
│ │ │ │ │ ├── plarre.h
│ │ │ │ │ ├── plarrv.h
│ │ │ │ │ ├── pmrrr.h
│ │ │ │ │ ├── process_task.h
│ │ │ │ │ ├── queue.h
│ │ │ │ │ ├── rrr.h
│ │ │ │ │ ├── structs.h
│ │ │ │ │ └── tasks.h
│ │ │ │ └── src/
│ │ │ │ ├── blas/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── odcpy.c
│ │ │ │ │ ├── odscal.c
│ │ │ │ │ └── odswap.c
│ │ │ │ ├── counter.c
│ │ │ │ ├── lapack/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── ode2.c
│ │ │ │ │ ├── odebz.c
│ │ │ │ │ ├── odev2.c
│ │ │ │ │ ├── odnan.c
│ │ │ │ │ ├── odneg.c
│ │ │ │ │ ├── odnst.c
│ │ │ │ │ ├── odr1v.c
│ │ │ │ │ ├── odrnv.c
│ │ │ │ │ ├── odrra.c
│ │ │ │ │ ├── odrrb.c
│ │ │ │ │ ├── odrrc.c
│ │ │ │ │ ├── odrrd.c
│ │ │ │ │ ├── odrre.c
│ │ │ │ │ ├── odrrf.c
│ │ │ │ │ ├── odrrj.c
│ │ │ │ │ ├── odrrk.c
│ │ │ │ │ ├── odrrr.c
│ │ │ │ │ ├── odrrv.c
│ │ │ │ │ ├── odruv.c
│ │ │ │ │ ├── odset.c
│ │ │ │ │ ├── odsnan.c
│ │ │ │ │ ├── odsq2.c
│ │ │ │ │ ├── odsq3.c
│ │ │ │ │ ├── odsq4.c
│ │ │ │ │ ├── odsq5.c
│ │ │ │ │ ├── odsq6.c
│ │ │ │ │ ├── odsrt.c
│ │ │ │ │ ├── odssq.c
│ │ │ │ │ ├── odstmr.c
│ │ │ │ │ ├── oerbla.c
│ │ │ │ │ └── olsame.c
│ │ │ │ ├── plarre.c
│ │ │ │ ├── plarrv.c
│ │ │ │ ├── pmrrr.c
│ │ │ │ ├── pmrrr_dscal.c
│ │ │ │ ├── process_c_task.c
│ │ │ │ ├── process_r_task.c
│ │ │ │ ├── process_s_task.c
│ │ │ │ ├── queue.c
│ │ │ │ ├── rrr.c
│ │ │ │ └── tasks.c
│ │ │ ├── include/
│ │ │ │ ├── README.md
│ │ │ │ ├── elemental/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── blas-like/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── impl.hpp
│ │ │ │ │ │ ├── level1/
│ │ │ │ │ │ │ ├── Adjoint.hpp
│ │ │ │ │ │ │ ├── Axpy.hpp
│ │ │ │ │ │ │ ├── AxpyTriangle.hpp
│ │ │ │ │ │ │ ├── Conjugate.hpp
│ │ │ │ │ │ │ ├── Copy.hpp
│ │ │ │ │ │ │ ├── DiagonalScale.hpp
│ │ │ │ │ │ │ ├── DiagonalScaleTrapezoid.hpp
│ │ │ │ │ │ │ ├── DiagonalSolve.hpp
│ │ │ │ │ │ │ ├── Dot.hpp
│ │ │ │ │ │ │ ├── Dotu.hpp
│ │ │ │ │ │ │ ├── EntrywiseMap.hpp
│ │ │ │ │ │ │ ├── Hadamard.hpp
│ │ │ │ │ │ │ ├── HilbertSchmidt.hpp
│ │ │ │ │ │ │ ├── MakeHermitian.hpp
│ │ │ │ │ │ │ ├── MakeReal.hpp
│ │ │ │ │ │ │ ├── MakeSymmetric.hpp
│ │ │ │ │ │ │ ├── MakeTrapezoidal.hpp
│ │ │ │ │ │ │ ├── MakeTriangular.hpp
│ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ ├── MaxAbs.hpp
│ │ │ │ │ │ │ ├── Min.hpp
│ │ │ │ │ │ │ ├── MinAbs.hpp
│ │ │ │ │ │ │ ├── Nrm2.hpp
│ │ │ │ │ │ │ ├── QuasiDiagonalScale.hpp
│ │ │ │ │ │ │ ├── QuasiDiagonalSolve.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Scale.hpp
│ │ │ │ │ │ │ ├── ScaleTrapezoid.hpp
│ │ │ │ │ │ │ ├── SetDiagonal.hpp
│ │ │ │ │ │ │ ├── Swap.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Inv.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Scale.hpp
│ │ │ │ │ │ │ ├── Symmetric2x2Solve.hpp
│ │ │ │ │ │ │ ├── Transpose.hpp
│ │ │ │ │ │ │ ├── UpdateDiagonal.hpp
│ │ │ │ │ │ │ └── Zero.hpp
│ │ │ │ │ │ ├── level1.hpp
│ │ │ │ │ │ ├── level2/
│ │ │ │ │ │ │ ├── Gemv/
│ │ │ │ │ │ │ │ ├── N.hpp
│ │ │ │ │ │ │ │ └── T.hpp
│ │ │ │ │ │ │ ├── Gemv.hpp
│ │ │ │ │ │ │ ├── Ger.hpp
│ │ │ │ │ │ │ ├── Geru.hpp
│ │ │ │ │ │ │ ├── Hemv.hpp
│ │ │ │ │ │ │ ├── Her.hpp
│ │ │ │ │ │ │ ├── Her2.hpp
│ │ │ │ │ │ │ ├── QuasiTrsv/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── QuasiTrsv.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Symv/
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ └── U.hpp
│ │ │ │ │ │ │ ├── Symv.hpp
│ │ │ │ │ │ │ ├── Syr.hpp
│ │ │ │ │ │ │ ├── Syr2.hpp
│ │ │ │ │ │ │ ├── Trmv.hpp
│ │ │ │ │ │ │ ├── Trr.hpp
│ │ │ │ │ │ │ ├── Trr2.hpp
│ │ │ │ │ │ │ ├── Trsv/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ └── Trsv.hpp
│ │ │ │ │ │ ├── level2.hpp
│ │ │ │ │ │ ├── level3/
│ │ │ │ │ │ │ ├── Gemm/
│ │ │ │ │ │ │ │ ├── NN.hpp
│ │ │ │ │ │ │ │ ├── NT.hpp
│ │ │ │ │ │ │ │ ├── TN.hpp
│ │ │ │ │ │ │ │ └── TT.hpp
│ │ │ │ │ │ │ ├── Gemm.hpp
│ │ │ │ │ │ │ ├── Hemm.hpp
│ │ │ │ │ │ │ ├── Her2k.hpp
│ │ │ │ │ │ │ ├── Herk.hpp
│ │ │ │ │ │ │ ├── MultiShiftQuasiTrsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── MultiShiftQuasiTrsm.hpp
│ │ │ │ │ │ │ ├── MultiShiftTrsm/
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── MultiShiftTrsm.hpp
│ │ │ │ │ │ │ ├── QuasiTrsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ └── LUT.hpp
│ │ │ │ │ │ │ ├── QuasiTrsm.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Symm/
│ │ │ │ │ │ │ │ ├── LL.hpp
│ │ │ │ │ │ │ │ ├── LU.hpp
│ │ │ │ │ │ │ │ ├── RL.hpp
│ │ │ │ │ │ │ │ └── RU.hpp
│ │ │ │ │ │ │ ├── Symm.hpp
│ │ │ │ │ │ │ ├── Syr2k/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── Syr2k.hpp
│ │ │ │ │ │ │ ├── Syrk/
│ │ │ │ │ │ │ │ ├── LN.hpp
│ │ │ │ │ │ │ │ ├── LT.hpp
│ │ │ │ │ │ │ │ ├── UN.hpp
│ │ │ │ │ │ │ │ └── UT.hpp
│ │ │ │ │ │ │ ├── Syrk.hpp
│ │ │ │ │ │ │ ├── Trdtrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ └── Unblocked.hpp
│ │ │ │ │ │ │ ├── Trdtrmm.hpp
│ │ │ │ │ │ │ ├── Trmm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ ├── LUT.hpp
│ │ │ │ │ │ │ │ ├── RLN.hpp
│ │ │ │ │ │ │ │ ├── RLT.hpp
│ │ │ │ │ │ │ │ ├── RUN.hpp
│ │ │ │ │ │ │ │ └── RUT.hpp
│ │ │ │ │ │ │ ├── Trmm.hpp
│ │ │ │ │ │ │ ├── Trsm/
│ │ │ │ │ │ │ │ ├── LLN.hpp
│ │ │ │ │ │ │ │ ├── LLT.hpp
│ │ │ │ │ │ │ │ ├── LUN.hpp
│ │ │ │ │ │ │ │ ├── LUT.hpp
│ │ │ │ │ │ │ │ ├── RLN.hpp
│ │ │ │ │ │ │ │ ├── RLT.hpp
│ │ │ │ │ │ │ │ ├── RUN.hpp
│ │ │ │ │ │ │ │ └── RUT.hpp
│ │ │ │ │ │ │ ├── Trsm.hpp
│ │ │ │ │ │ │ ├── Trstrm/
│ │ │ │ │ │ │ │ └── LLN.hpp
│ │ │ │ │ │ │ ├── Trstrm.hpp
│ │ │ │ │ │ │ ├── Trtrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ └── Unblocked.hpp
│ │ │ │ │ │ │ ├── Trtrmm.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrmm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar4.hpp
│ │ │ │ │ │ │ │ ├── LVar5.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar4.hpp
│ │ │ │ │ │ │ │ └── UVar5.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrmm.hpp
│ │ │ │ │ │ │ ├── TwoSidedTrsm/
│ │ │ │ │ │ │ │ ├── LVar1.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ ├── LVar4.hpp
│ │ │ │ │ │ │ │ ├── LVar5.hpp
│ │ │ │ │ │ │ │ ├── UVar1.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar3.hpp
│ │ │ │ │ │ │ │ ├── UVar4.hpp
│ │ │ │ │ │ │ │ └── UVar5.hpp
│ │ │ │ │ │ │ └── TwoSidedTrsm.hpp
│ │ │ │ │ │ └── level3.hpp
│ │ │ │ │ ├── blas-like.hpp
│ │ │ │ │ ├── config-internal.h
│ │ │ │ │ ├── control/
│ │ │ │ │ │ ├── Lyapunov.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Ricatti.hpp
│ │ │ │ │ │ ├── Sylvester.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── control.hpp
│ │ │ │ │ ├── convex/
│ │ │ │ │ │ ├── BasisPursuit.hpp
│ │ │ │ │ │ ├── Clip.hpp
│ │ │ │ │ │ ├── Covariance.hpp
│ │ │ │ │ │ ├── LinearProgram.hpp
│ │ │ │ │ │ ├── LogBarrier.hpp
│ │ │ │ │ │ ├── LogDetDiv.hpp
│ │ │ │ │ │ ├── QuadraticProgram.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── SVT/
│ │ │ │ │ │ │ ├── Cross.hpp
│ │ │ │ │ │ │ ├── Normal.hpp
│ │ │ │ │ │ │ ├── PivotedQR.hpp
│ │ │ │ │ │ │ └── TSQR.hpp
│ │ │ │ │ │ ├── SVT.hpp
│ │ │ │ │ │ ├── SoftThreshold.hpp
│ │ │ │ │ │ ├── SparseInvCov.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── convex.hpp
│ │ │ │ │ ├── core/
│ │ │ │ │ │ ├── AxpyInterface/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── AxpyInterface.hpp
│ │ │ │ │ │ ├── BlockDistMatrix/
│ │ │ │ │ │ │ ├── Abstract.hpp
│ │ │ │ │ │ │ ├── CIRC_CIRC.hpp
│ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ ├── MC_MR.hpp
│ │ │ │ │ │ │ ├── MC_STAR.hpp
│ │ │ │ │ │ │ ├── MD_STAR.hpp
│ │ │ │ │ │ │ ├── MR_MC.hpp
│ │ │ │ │ │ │ ├── MR_STAR.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── STAR_MC.hpp
│ │ │ │ │ │ │ ├── STAR_MD.hpp
│ │ │ │ │ │ │ ├── STAR_MR.hpp
│ │ │ │ │ │ │ ├── STAR_STAR.hpp
│ │ │ │ │ │ │ ├── STAR_VC.hpp
│ │ │ │ │ │ │ ├── STAR_VR.hpp
│ │ │ │ │ │ │ ├── VC_STAR.hpp
│ │ │ │ │ │ │ ├── VR_STAR.hpp
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── BlockDistMatrix.hpp
│ │ │ │ │ │ ├── Complex/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── Complex.hpp
│ │ │ │ │ │ ├── DistMatrix/
│ │ │ │ │ │ │ ├── Abstract.hpp
│ │ │ │ │ │ │ ├── CIRC_CIRC.hpp
│ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ ├── MC_MR.hpp
│ │ │ │ │ │ │ ├── MC_STAR.hpp
│ │ │ │ │ │ │ ├── MD_STAR.hpp
│ │ │ │ │ │ │ ├── MR_MC.hpp
│ │ │ │ │ │ │ ├── MR_STAR.hpp
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── STAR_MC.hpp
│ │ │ │ │ │ │ ├── STAR_MD.hpp
│ │ │ │ │ │ │ ├── STAR_MR.hpp
│ │ │ │ │ │ │ ├── STAR_STAR.hpp
│ │ │ │ │ │ │ ├── STAR_VC.hpp
│ │ │ │ │ │ │ ├── STAR_VR.hpp
│ │ │ │ │ │ │ ├── VC_STAR.hpp
│ │ │ │ │ │ │ ├── VR_STAR.hpp
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── DistMatrix.hpp
│ │ │ │ │ │ ├── Grid/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── Matrix/
│ │ │ │ │ │ │ └── forward_decl.hpp
│ │ │ │ │ │ ├── Matrix.hpp
│ │ │ │ │ │ ├── Memory.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Timer/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── environment/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── imports/
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── blas.hpp
│ │ │ │ │ │ │ ├── choice.hpp
│ │ │ │ │ │ │ ├── flame.hpp
│ │ │ │ │ │ │ ├── lapack.hpp
│ │ │ │ │ │ │ ├── mpi.hpp
│ │ │ │ │ │ │ ├── mpi_choice.hpp
│ │ │ │ │ │ │ ├── pmrrr.hpp
│ │ │ │ │ │ │ └── scalapack.hpp
│ │ │ │ │ │ ├── indexing/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── random/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── types/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ └── views/
│ │ │ │ │ │ ├── Partition.hpp
│ │ │ │ │ │ ├── Repartition.hpp
│ │ │ │ │ │ ├── SlidePartition.hpp
│ │ │ │ │ │ └── View.hpp
│ │ │ │ │ ├── core.hpp
│ │ │ │ │ ├── include-paths.hpp
│ │ │ │ │ ├── io/
│ │ │ │ │ │ ├── ComplexDisplayWindow-premoc.hpp
│ │ │ │ │ │ ├── Display.hpp
│ │ │ │ │ │ ├── DisplayWidget/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── DisplayWindow-premoc.hpp
│ │ │ │ │ │ ├── Print.hpp
│ │ │ │ │ │ ├── Read/
│ │ │ │ │ │ │ ├── Ascii.hpp
│ │ │ │ │ │ │ ├── AsciiMatlab.hpp
│ │ │ │ │ │ │ ├── Binary.hpp
│ │ │ │ │ │ │ ├── BinaryFlat.hpp
│ │ │ │ │ │ │ └── MatrixMarket.hpp
│ │ │ │ │ │ ├── Read.hpp
│ │ │ │ │ │ ├── Spy.hpp
│ │ │ │ │ │ ├── SpyWidget/
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── SpyWindow/
│ │ │ │ │ │ │ └── decl.hpp
│ │ │ │ │ │ ├── Write/
│ │ │ │ │ │ │ ├── Ascii.hpp
│ │ │ │ │ │ │ ├── AsciiMatlab.hpp
│ │ │ │ │ │ │ ├── Binary.hpp
│ │ │ │ │ │ │ ├── BinaryFlat.hpp
│ │ │ │ │ │ │ ├── Image.hpp
│ │ │ │ │ │ │ └── MatrixMarket.hpp
│ │ │ │ │ │ ├── Write.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── lapack-like/
│ │ │ │ │ │ ├── condense/
│ │ │ │ │ │ │ ├── Bidiag/
│ │ │ │ │ │ │ │ ├── Apply.hpp
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ │ │ │ ├── LUnb.hpp
│ │ │ │ │ │ │ │ ├── U.hpp
│ │ │ │ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ │ │ │ └── UUnb.hpp
│ │ │ │ │ │ │ ├── Bidiag.hpp
│ │ │ │ │ │ │ ├── HermitianTridiag/
│ │ │ │ │ │ │ │ └── ApplyQ.hpp
│ │ │ │ │ │ │ ├── HermitianTridiag.hpp
│ │ │ │ │ │ │ ├── Hessenberg/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── L.hpp
│ │ │ │ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ │ │ │ ├── LUnb.hpp
│ │ │ │ │ │ │ │ ├── U.hpp
│ │ │ │ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ │ │ │ └── UUnb.hpp
│ │ │ │ │ │ │ ├── Hessenberg.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── condense.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── decomp/
│ │ │ │ │ │ │ ├── HermitianEig/
│ │ │ │ │ │ │ │ └── SDC.hpp
│ │ │ │ │ │ │ ├── HermitianEig.hpp
│ │ │ │ │ │ │ ├── HermitianGenDefiniteEig.hpp
│ │ │ │ │ │ │ ├── HermitianTridiagEig/
│ │ │ │ │ │ │ │ └── Sort.hpp
│ │ │ │ │ │ │ ├── HermitianTridiagEig.hpp
│ │ │ │ │ │ │ ├── Polar/
│ │ │ │ │ │ │ │ ├── QDWH.hpp
│ │ │ │ │ │ │ │ └── SVD.hpp
│ │ │ │ │ │ │ ├── Polar.hpp
│ │ │ │ │ │ │ ├── SVD/
│ │ │ │ │ │ │ │ ├── Chan.hpp
│ │ │ │ │ │ │ │ ├── GolubReinsch.hpp
│ │ │ │ │ │ │ │ ├── Thresholded.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── SVD.hpp
│ │ │ │ │ │ │ ├── Schur/
│ │ │ │ │ │ │ │ ├── CheckReal.hpp
│ │ │ │ │ │ │ │ ├── InverseFreeSDC.hpp
│ │ │ │ │ │ │ │ ├── QR.hpp
│ │ │ │ │ │ │ │ ├── QuasiTriangEig.hpp
│ │ │ │ │ │ │ │ ├── RealToComplex.hpp
│ │ │ │ │ │ │ │ └── SDC.hpp
│ │ │ │ │ │ │ ├── Schur.hpp
│ │ │ │ │ │ │ ├── SkewHermitianEig.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── decomp.hpp
│ │ │ │ │ │ ├── factor/
│ │ │ │ │ │ │ ├── Cholesky/
│ │ │ │ │ │ │ │ ├── LMod.hpp
│ │ │ │ │ │ │ │ ├── LVar2.hpp
│ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ ├── LVar3Pivoted.hpp
│ │ │ │ │ │ │ │ ├── LVar3Square.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ ├── UMod.hpp
│ │ │ │ │ │ │ │ ├── UVar2.hpp
│ │ │ │ │ │ │ │ ├── UVar3.hpp
│ │ │ │ │ │ │ │ ├── UVar3Pivoted.hpp
│ │ │ │ │ │ │ │ └── UVar3Square.hpp
│ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ ├── GQR.hpp
│ │ │ │ │ │ │ ├── GRQ.hpp
│ │ │ │ │ │ │ ├── ID.hpp
│ │ │ │ │ │ │ ├── LDL/
│ │ │ │ │ │ │ │ ├── Inertia.hpp
│ │ │ │ │ │ │ │ ├── MultiplyAfter.hpp
│ │ │ │ │ │ │ │ ├── Pivoted.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ └── Var3.hpp
│ │ │ │ │ │ │ ├── LDL.hpp
│ │ │ │ │ │ │ ├── LQ/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── Explicit.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── LQ.hpp
│ │ │ │ │ │ │ ├── LU/
│ │ │ │ │ │ │ │ ├── Full.hpp
│ │ │ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ │ │ ├── Mod.hpp
│ │ │ │ │ │ │ │ ├── Panel.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── LU.hpp
│ │ │ │ │ │ │ ├── QR/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── BusingerGolub.hpp
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ ├── Explicit.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ ├── SolveAfter.hpp
│ │ │ │ │ │ │ │ └── TS.hpp
│ │ │ │ │ │ │ ├── QR.hpp
│ │ │ │ │ │ │ ├── RQ/
│ │ │ │ │ │ │ │ ├── ApplyQ.hpp
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ ├── Householder.hpp
│ │ │ │ │ │ │ │ ├── PanelHouseholder.hpp
│ │ │ │ │ │ │ │ └── SolveAfter.hpp
│ │ │ │ │ │ │ ├── RQ.hpp
│ │ │ │ │ │ │ ├── Skeleton.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── factor.hpp
│ │ │ │ │ │ ├── funcs/
│ │ │ │ │ │ │ ├── HermitianFunction.hpp
│ │ │ │ │ │ │ ├── Inverse/
│ │ │ │ │ │ │ │ ├── General/
│ │ │ │ │ │ │ │ │ └── LUPartialPiv.hpp
│ │ │ │ │ │ │ │ ├── General.hpp
│ │ │ │ │ │ │ │ ├── HPD/
│ │ │ │ │ │ │ │ │ ├── CholeskyLVar2.hpp
│ │ │ │ │ │ │ │ │ └── CholeskyUVar2.hpp
│ │ │ │ │ │ │ │ ├── HPD.hpp
│ │ │ │ │ │ │ │ ├── Hermitian.hpp
│ │ │ │ │ │ │ │ ├── Symmetric.hpp
│ │ │ │ │ │ │ │ ├── Triangular/
│ │ │ │ │ │ │ │ │ ├── LVar3.hpp
│ │ │ │ │ │ │ │ │ └── UVar3.hpp
│ │ │ │ │ │ │ │ ├── Triangular.hpp
│ │ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ │ ├── Inverse.hpp
│ │ │ │ │ │ │ ├── Pseudoinverse.hpp
│ │ │ │ │ │ │ ├── Sign.hpp
│ │ │ │ │ │ │ ├── SquareRoot.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── funcs.hpp
│ │ │ │ │ │ ├── impl.hpp
│ │ │ │ │ │ ├── perm/
│ │ │ │ │ │ │ ├── ApplyColPivots.hpp
│ │ │ │ │ │ │ ├── ApplyRowPivots.hpp
│ │ │ │ │ │ │ ├── ApplySymmetricPivots.hpp
│ │ │ │ │ │ │ ├── ExplicitPermutation.hpp
│ │ │ │ │ │ │ ├── InvertPermutation.hpp
│ │ │ │ │ │ │ ├── PermutationMeta.hpp
│ │ │ │ │ │ │ ├── PermuteCols.hpp
│ │ │ │ │ │ │ ├── PermuteRows.hpp
│ │ │ │ │ │ │ ├── PivotsToPartialPermutation.hpp
│ │ │ │ │ │ │ ├── PivotsToPermutation.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── perm.hpp
│ │ │ │ │ │ ├── props/
│ │ │ │ │ │ │ ├── Condition/
│ │ │ │ │ │ │ │ ├── Frobenius.hpp
│ │ │ │ │ │ │ │ ├── Infinity.hpp
│ │ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ │ ├── One.hpp
│ │ │ │ │ │ │ │ └── Two.hpp
│ │ │ │ │ │ │ ├── Condition.hpp
│ │ │ │ │ │ │ ├── Determinant/
│ │ │ │ │ │ │ │ ├── Cholesky.hpp
│ │ │ │ │ │ │ │ └── LUPartialPiv.hpp
│ │ │ │ │ │ │ ├── Determinant.hpp
│ │ │ │ │ │ │ ├── Inertia.hpp
│ │ │ │ │ │ │ ├── Norm/
│ │ │ │ │ │ │ │ ├── Entrywise.hpp
│ │ │ │ │ │ │ │ ├── EntrywiseOne.hpp
│ │ │ │ │ │ │ │ ├── Frobenius.hpp
│ │ │ │ │ │ │ │ ├── Infinity.hpp
│ │ │ │ │ │ │ │ ├── KyFan.hpp
│ │ │ │ │ │ │ │ ├── Max.hpp
│ │ │ │ │ │ │ │ ├── Nuclear.hpp
│ │ │ │ │ │ │ │ ├── One.hpp
│ │ │ │ │ │ │ │ ├── Schatten.hpp
│ │ │ │ │ │ │ │ ├── Two.hpp
│ │ │ │ │ │ │ │ ├── TwoEstimate.hpp
│ │ │ │ │ │ │ │ └── Zero.hpp
│ │ │ │ │ │ │ ├── Norm.hpp
│ │ │ │ │ │ │ ├── Pseudospectrum/
│ │ │ │ │ │ │ │ ├── Analytic.hpp
│ │ │ │ │ │ │ │ ├── IRA.hpp
│ │ │ │ │ │ │ │ ├── IRL.hpp
│ │ │ │ │ │ │ │ ├── Lanczos.hpp
│ │ │ │ │ │ │ │ ├── Power.hpp
│ │ │ │ │ │ │ │ ├── Util/
│ │ │ │ │ │ │ │ │ ├── BasicMath.hpp
│ │ │ │ │ │ │ │ │ ├── Rearrange.hpp
│ │ │ │ │ │ │ │ │ └── Snapshot.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── Pseudospectrum.hpp
│ │ │ │ │ │ │ ├── Trace.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── props.hpp
│ │ │ │ │ │ ├── solve/
│ │ │ │ │ │ │ ├── GLM.hpp
│ │ │ │ │ │ │ ├── GaussianElimination.hpp
│ │ │ │ │ │ │ ├── HPDSolve.hpp
│ │ │ │ │ │ │ ├── HermitianSolve.hpp
│ │ │ │ │ │ │ ├── LSE.hpp
│ │ │ │ │ │ │ ├── LeastSquares.hpp
│ │ │ │ │ │ │ ├── MultiShiftHessSolve.hpp
│ │ │ │ │ │ │ ├── SymmetricSolve.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ ├── solve.hpp
│ │ │ │ │ │ ├── util/
│ │ │ │ │ │ │ ├── ApplyPackedReflectors/
│ │ │ │ │ │ │ │ ├── LLHB.hpp
│ │ │ │ │ │ │ │ ├── LLHF.hpp
│ │ │ │ │ │ │ │ ├── LLVB.hpp
│ │ │ │ │ │ │ │ ├── LLVF.hpp
│ │ │ │ │ │ │ │ ├── LUHB.hpp
│ │ │ │ │ │ │ │ ├── LUHF.hpp
│ │ │ │ │ │ │ │ ├── LUVB.hpp
│ │ │ │ │ │ │ │ ├── LUVF.hpp
│ │ │ │ │ │ │ │ ├── RLHB.hpp
│ │ │ │ │ │ │ │ ├── RLHF.hpp
│ │ │ │ │ │ │ │ ├── RLVB.hpp
│ │ │ │ │ │ │ │ ├── RLVF.hpp
│ │ │ │ │ │ │ │ ├── RUHB.hpp
│ │ │ │ │ │ │ │ ├── RUHF.hpp
│ │ │ │ │ │ │ │ ├── RUVB.hpp
│ │ │ │ │ │ │ │ ├── RUVF.hpp
│ │ │ │ │ │ │ │ └── Util.hpp
│ │ │ │ │ │ │ ├── ApplyPackedReflectors.hpp
│ │ │ │ │ │ │ ├── ExpandPackedReflectors/
│ │ │ │ │ │ │ │ └── LV.hpp
│ │ │ │ │ │ │ ├── ExpandPackedReflectors.hpp
│ │ │ │ │ │ │ ├── HyperbolicReflector/
│ │ │ │ │ │ │ │ ├── Col.hpp
│ │ │ │ │ │ │ │ └── Row.hpp
│ │ │ │ │ │ │ ├── HyperbolicReflector.hpp
│ │ │ │ │ │ │ ├── Median.hpp
│ │ │ │ │ │ │ ├── PermutationParity.hpp
│ │ │ │ │ │ │ ├── PivotParity.hpp
│ │ │ │ │ │ │ ├── Reflector/
│ │ │ │ │ │ │ │ ├── Col.hpp
│ │ │ │ │ │ │ │ └── Row.hpp
│ │ │ │ │ │ │ ├── Reflector.hpp
│ │ │ │ │ │ │ ├── Sort.hpp
│ │ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ │ └── util.hpp
│ │ │ │ │ ├── lapack-like.hpp
│ │ │ │ │ ├── matrices/
│ │ │ │ │ │ ├── BullsHead.hpp
│ │ │ │ │ │ ├── Cauchy.hpp
│ │ │ │ │ │ ├── CauchyLike.hpp
│ │ │ │ │ │ ├── Circulant.hpp
│ │ │ │ │ │ ├── Demmel.hpp
│ │ │ │ │ │ ├── Diagonal.hpp
│ │ │ │ │ │ ├── Egorov.hpp
│ │ │ │ │ │ ├── ExtendedKahan.hpp
│ │ │ │ │ │ ├── Fiedler.hpp
│ │ │ │ │ │ ├── Forsythe.hpp
│ │ │ │ │ │ ├── Fourier.hpp
│ │ │ │ │ │ ├── FoxLi.hpp
│ │ │ │ │ │ ├── GCDMatrix.hpp
│ │ │ │ │ │ ├── GKS.hpp
│ │ │ │ │ │ ├── Gaussian.hpp
│ │ │ │ │ │ ├── Gear.hpp
│ │ │ │ │ │ ├── Grcar.hpp
│ │ │ │ │ │ ├── Haar.hpp
│ │ │ │ │ │ ├── Hankel.hpp
│ │ │ │ │ │ ├── Hanowa.hpp
│ │ │ │ │ │ ├── HatanoNelson.hpp
│ │ │ │ │ │ ├── Helmholtz.hpp
│ │ │ │ │ │ ├── HelmholtzPML.hpp
│ │ │ │ │ │ ├── HermitianFromEVD.hpp
│ │ │ │ │ │ ├── HermitianUniformSpectrum.hpp
│ │ │ │ │ │ ├── Hilbert.hpp
│ │ │ │ │ │ ├── Identity.hpp
│ │ │ │ │ │ ├── Jordan.hpp
│ │ │ │ │ │ ├── KMS.hpp
│ │ │ │ │ │ ├── Kahan.hpp
│ │ │ │ │ │ ├── Laplacian.hpp
│ │ │ │ │ │ ├── Lauchli.hpp
│ │ │ │ │ │ ├── Legendre.hpp
│ │ │ │ │ │ ├── Lehmer.hpp
│ │ │ │ │ │ ├── Lotkin.hpp
│ │ │ │ │ │ ├── MinIJ.hpp
│ │ │ │ │ │ ├── NormalFromEVD.hpp
│ │ │ │ │ │ ├── NormalUniformSpectrum.hpp
│ │ │ │ │ │ ├── OneTwoOne.hpp
│ │ │ │ │ │ ├── Ones.hpp
│ │ │ │ │ │ ├── Parter.hpp
│ │ │ │ │ │ ├── Pei.hpp
│ │ │ │ │ │ ├── Redheffer.hpp
│ │ │ │ │ │ ├── Riemann.hpp
│ │ │ │ │ │ ├── Ris.hpp
│ │ │ │ │ │ ├── Toeplitz.hpp
│ │ │ │ │ │ ├── Trefethen.hpp
│ │ │ │ │ │ ├── TriW.hpp
│ │ │ │ │ │ ├── Triangle.hpp
│ │ │ │ │ │ ├── Uniform.hpp
│ │ │ │ │ │ ├── UniformHelmholtzGreens.hpp
│ │ │ │ │ │ ├── Walsh.hpp
│ │ │ │ │ │ ├── Whale.hpp
│ │ │ │ │ │ ├── Wigner.hpp
│ │ │ │ │ │ ├── Wilkinson.hpp
│ │ │ │ │ │ ├── Zeros.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ └── impl.hpp
│ │ │ │ │ └── matrices.hpp
│ │ │ │ ├── elemental-lite.hpp
│ │ │ │ └── elemental.hpp
│ │ │ ├── octave/
│ │ │ │ ├── LUMod.m
│ │ │ │ ├── LUModDriver.m
│ │ │ │ ├── LUModSimple.m
│ │ │ │ └── LUModSimpleDriver.m
│ │ │ ├── src/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── Trr2k/
│ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ ├── NNNN.hpp
│ │ │ │ │ │ ├── NNNT.hpp
│ │ │ │ │ │ ├── NNTN.hpp
│ │ │ │ │ │ ├── NNTT.hpp
│ │ │ │ │ │ ├── NTNN.hpp
│ │ │ │ │ │ ├── NTNT.hpp
│ │ │ │ │ │ ├── NTTN.hpp
│ │ │ │ │ │ ├── NTTT.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── TNNN.hpp
│ │ │ │ │ │ ├── TNNT.hpp
│ │ │ │ │ │ ├── TNTN.hpp
│ │ │ │ │ │ ├── TNTT.hpp
│ │ │ │ │ │ ├── TTNN.hpp
│ │ │ │ │ │ ├── TTNT.hpp
│ │ │ │ │ │ ├── TTTN.hpp
│ │ │ │ │ │ └── TTTT.hpp
│ │ │ │ │ ├── Trr2k.cpp
│ │ │ │ │ ├── Trrk/
│ │ │ │ │ │ ├── Local.hpp
│ │ │ │ │ │ ├── NN.hpp
│ │ │ │ │ │ ├── NT.hpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── TN.hpp
│ │ │ │ │ │ └── TT.hpp
│ │ │ │ │ └── Trrk.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── BlockDistMatrix/
│ │ │ │ │ │ ├── Abstract.cpp
│ │ │ │ │ │ ├── CIRC_CIRC.cpp
│ │ │ │ │ │ ├── General.cpp
│ │ │ │ │ │ ├── MC_MR.cpp
│ │ │ │ │ │ ├── MC_STAR.cpp
│ │ │ │ │ │ ├── MD_STAR.cpp
│ │ │ │ │ │ ├── MR_MC.cpp
│ │ │ │ │ │ ├── MR_STAR.cpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── STAR_MC.cpp
│ │ │ │ │ │ ├── STAR_MD.cpp
│ │ │ │ │ │ ├── STAR_MR.cpp
│ │ │ │ │ │ ├── STAR_STAR.cpp
│ │ │ │ │ │ ├── STAR_VC.cpp
│ │ │ │ │ │ ├── STAR_VR.cpp
│ │ │ │ │ │ ├── VC_STAR.cpp
│ │ │ │ │ │ ├── VR_STAR.cpp
│ │ │ │ │ │ └── setup.hpp
│ │ │ │ │ ├── DistMatrix/
│ │ │ │ │ │ ├── Abstract.cpp
│ │ │ │ │ │ ├── CIRC_CIRC.cpp
│ │ │ │ │ │ ├── General.cpp
│ │ │ │ │ │ ├── MC_MR.cpp
│ │ │ │ │ │ ├── MC_STAR.cpp
│ │ │ │ │ │ ├── MD_STAR.cpp
│ │ │ │ │ │ ├── MR_MC.cpp
│ │ │ │ │ │ ├── MR_STAR.cpp
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── STAR_MC.cpp
│ │ │ │ │ │ ├── STAR_MD.cpp
│ │ │ │ │ │ ├── STAR_MR.cpp
│ │ │ │ │ │ ├── STAR_STAR.cpp
│ │ │ │ │ │ ├── STAR_VC.cpp
│ │ │ │ │ │ ├── STAR_VR.cpp
│ │ │ │ │ │ ├── VC_STAR.cpp
│ │ │ │ │ │ ├── VR_STAR.cpp
│ │ │ │ │ │ └── setup.hpp
│ │ │ │ │ ├── Matrix.cpp
│ │ │ │ │ ├── Memory.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── global.cpp
│ │ │ │ │ ├── imports/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── blas.cpp
│ │ │ │ │ │ ├── flame.cpp
│ │ │ │ │ │ ├── lapack.cpp
│ │ │ │ │ │ ├── mpi.cpp
│ │ │ │ │ │ ├── pmrrr.cpp
│ │ │ │ │ │ └── scalapack.cpp
│ │ │ │ │ └── mpi_register.cpp
│ │ │ │ ├── io/
│ │ │ │ │ ├── ColorMap.cpp
│ │ │ │ │ ├── ComplexDisplayWindow.cpp
│ │ │ │ │ ├── DisplayWindow.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── SpyWindow.cpp
│ │ │ │ └── lapack-like/
│ │ │ │ ├── HermitianEig.cpp
│ │ │ │ ├── HermitianTridiag/
│ │ │ │ │ ├── L.hpp
│ │ │ │ │ ├── LPan.hpp
│ │ │ │ │ ├── LPanSquare.hpp
│ │ │ │ │ ├── LSquare.hpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── U.hpp
│ │ │ │ │ ├── UPan.hpp
│ │ │ │ │ ├── UPanSquare.hpp
│ │ │ │ │ └── USquare.hpp
│ │ │ │ ├── HermitianTridiag.cpp
│ │ │ │ └── README.md
│ │ │ ├── tests/
│ │ │ │ ├── README.md
│ │ │ │ ├── blas-like/
│ │ │ │ │ ├── Gemm.cpp
│ │ │ │ │ ├── Hemm.cpp
│ │ │ │ │ ├── Her2k.cpp
│ │ │ │ │ ├── Herk.cpp
│ │ │ │ │ ├── MultiShiftQuasiTrsm.cpp
│ │ │ │ │ ├── QuasiTrsm.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── Symm.cpp
│ │ │ │ │ ├── Symv.cpp
│ │ │ │ │ ├── Syr2k.cpp
│ │ │ │ │ ├── Syrk.cpp
│ │ │ │ │ ├── Trmm.cpp
│ │ │ │ │ ├── Trsm.cpp
│ │ │ │ │ ├── Trsv.cpp
│ │ │ │ │ ├── TwoSidedTrmm.cpp
│ │ │ │ │ └── TwoSidedTrsm.cpp
│ │ │ │ ├── convex/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── TSSVT.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── AxpyInterface.cpp
│ │ │ │ │ ├── BasicBlockDistMatrix.cpp
│ │ │ │ │ ├── BlockDistMatrix.cpp
│ │ │ │ │ ├── Constants.cpp
│ │ │ │ │ ├── DifferentGrids.cpp
│ │ │ │ │ ├── DistMatrix.cpp
│ │ │ │ │ ├── Matrix.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── Version.cpp
│ │ │ │ └── lapack-like/
│ │ │ │ ├── ApplyPackedReflectors.cpp
│ │ │ │ ├── Bidiag.cpp
│ │ │ │ ├── Cholesky.cpp
│ │ │ │ ├── CholeskyMod.cpp
│ │ │ │ ├── CholeskyQR.cpp
│ │ │ │ ├── HermitianEig.cpp
│ │ │ │ ├── HermitianGenDefiniteEig.cpp
│ │ │ │ ├── HermitianTridiag.cpp
│ │ │ │ ├── Hessenberg.cpp
│ │ │ │ ├── LDL.cpp
│ │ │ │ ├── LQ.cpp
│ │ │ │ ├── LU.cpp
│ │ │ │ ├── LUMod.cpp
│ │ │ │ ├── MultiShiftHessSolve.cpp
│ │ │ │ ├── QR.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── RQ.cpp
│ │ │ │ ├── SequentialBidiag.cpp
│ │ │ │ ├── SequentialCholeskyMod.cpp
│ │ │ │ ├── SequentialHessenberg.cpp
│ │ │ │ ├── SequentialLU.cpp
│ │ │ │ ├── SequentialMultiShiftHessSolve.cpp
│ │ │ │ ├── TSQR.cpp
│ │ │ │ └── TriangularInverse.cpp
│ │ │ └── vagrant/
│ │ │ ├── README.md
│ │ │ ├── saucy32/
│ │ │ │ ├── Vagrantfile
│ │ │ │ └── bootstrap.sh
│ │ │ └── saucy64/
│ │ │ ├── Vagrantfile
│ │ │ └── bootstrap.sh
│ │ ├── gtest/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── gtest-all.cc
│ │ │ ├── include/
│ │ │ │ └── gtest/
│ │ │ │ ├── gtest-death-test.h
│ │ │ │ ├── gtest-message.h
│ │ │ │ ├── gtest-param-test.h
│ │ │ │ ├── gtest-param-test.h.pump
│ │ │ │ ├── gtest-printers.h
│ │ │ │ ├── gtest-spi.h
│ │ │ │ ├── gtest-test-part.h
│ │ │ │ ├── gtest-typed-test.h
│ │ │ │ ├── gtest.h
│ │ │ │ ├── gtest_pred_impl.h
│ │ │ │ ├── gtest_prod.h
│ │ │ │ └── internal/
│ │ │ │ ├── gtest-death-test-internal.h
│ │ │ │ ├── gtest-filepath.h
│ │ │ │ ├── gtest-internal.h
│ │ │ │ ├── gtest-linked_ptr.h
│ │ │ │ ├── gtest-param-util-generated.h
│ │ │ │ ├── gtest-param-util-generated.h.pump
│ │ │ │ ├── gtest-param-util.h
│ │ │ │ ├── gtest-port.h
│ │ │ │ ├── gtest-string.h
│ │ │ │ ├── gtest-tuple.h
│ │ │ │ ├── gtest-tuple.h.pump
│ │ │ │ ├── gtest-type-util.h
│ │ │ │ └── gtest-type-util.h.pump
│ │ │ └── src/
│ │ │ ├── gtest-all.cc
│ │ │ ├── gtest-death-test.cc
│ │ │ ├── gtest-filepath.cc
│ │ │ ├── gtest-internal-inl.h
│ │ │ ├── gtest-port.cc
│ │ │ ├── gtest-printers.cc
│ │ │ ├── gtest-test-part.cc
│ │ │ ├── gtest-typed-test.cc
│ │ │ ├── gtest.cc
│ │ │ └── gtest_main.cc
│ │ ├── muParser/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── muParser.cpp
│ │ │ ├── muParser.h
│ │ │ ├── muParserBase.cpp
│ │ │ ├── muParserBase.h
│ │ │ ├── muParserBytecode.cpp
│ │ │ ├── muParserBytecode.h
│ │ │ ├── muParserCallback.cpp
│ │ │ ├── muParserCallback.h
│ │ │ ├── muParserComplex.h
│ │ │ ├── muParserDLL.h
│ │ │ ├── muParserDef.h
│ │ │ ├── muParserError.cpp
│ │ │ ├── muParserError.h
│ │ │ ├── muParserFixes.h
│ │ │ ├── muParserInt.h
│ │ │ ├── muParserStack.h
│ │ │ ├── muParserTest.h
│ │ │ ├── muParserToken.h
│ │ │ ├── muParserTokenReader.cpp
│ │ │ └── muParserTokenReader.h
│ │ ├── nlohmann_json/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── json.cc
│ │ │ └── json.hpp
│ │ └── tinyxml/
│ │ ├── CMakeLists.txt
│ │ ├── README
│ │ ├── readme.txt
│ │ ├── tinystr.cc
│ │ ├── tinystr.h
│ │ ├── tinyxml.cc
│ │ ├── tinyxml.h
│ │ ├── tinyxmlerror.cc
│ │ └── tinyxmlparser.cc
│ ├── fortran_ctypes.h
│ ├── madness.cc
│ ├── madness_config.h
│ ├── misc/
│ │ ├── CMakeLists.txt
│ │ ├── array_of_bools.h
│ │ ├── cfft.cc
│ │ ├── cfft.h
│ │ ├── checksum_file.cc
│ │ ├── gnuplot.h
│ │ ├── gprofexit.cc
│ │ ├── info.cc
│ │ ├── info.h
│ │ ├── interp3.cc
│ │ ├── interpolation_1d.h
│ │ ├── kahan_accumulator.h
│ │ ├── misc.h
│ │ ├── numerics.cc
│ │ ├── phandler.h
│ │ ├── position_stream.cc
│ │ ├── ran.cc
│ │ ├── ran.h
│ │ ├── test_gnuplot.cc
│ │ └── unique_filename.cc
│ ├── mra/
│ │ ├── CMakeLists.txt
│ │ ├── QCCalculationParametersBase.cc
│ │ ├── QCCalculationParametersBase.h
│ │ ├── adquad.h
│ │ ├── autocorr
│ │ ├── b-spline-deriv1.txt
│ │ ├── b-spline-deriv2.txt
│ │ ├── b-spline-deriv3.txt
│ │ ├── bc.h
│ │ ├── ble-first.txt
│ │ ├── ble-second.txt
│ │ ├── coeffs
│ │ ├── commandlineparser.h
│ │ ├── convolution1d.h
│ │ ├── derivative.h
│ │ ├── displacements.h
│ │ ├── funcdefaults.h
│ │ ├── funcimpl.h
│ │ ├── funcplot.h
│ │ ├── function_common_data.h
│ │ ├── function_factory.h
│ │ ├── function_interface.h
│ │ ├── functypedefs.h
│ │ ├── gaussleg
│ │ ├── gfit.h
│ │ ├── graveyard
│ │ ├── indexit.h
│ │ ├── kernelrange.h
│ │ ├── key.h
│ │ ├── lbdeux.h
│ │ ├── leafop.h
│ │ ├── legendre.cc
│ │ ├── legendre.h
│ │ ├── macrotaskpartitioner.h
│ │ ├── macrotaskq.h
│ │ ├── memory_measurement.h
│ │ ├── minmax/
│ │ │ ├── Makefile
│ │ │ ├── y.cc
│ │ │ ├── y1.cc
│ │ │ ├── y_signed.cc
│ │ │ └── y_varx.cc
│ │ ├── mra.h
│ │ ├── mra1.cc
│ │ ├── mra2.cc
│ │ ├── mra3.cc
│ │ ├── mra4.cc
│ │ ├── mra5.cc
│ │ ├── mra6.cc
│ │ ├── mraimpl.h
│ │ ├── mraplot.cc
│ │ ├── mw.h
│ │ ├── mypmap.h
│ │ ├── nonlinsol.h
│ │ ├── operator.h
│ │ ├── operatorinfo.h
│ │ ├── power.h
│ │ ├── qmprop.cc
│ │ ├── qmprop.h
│ │ ├── sdf_domainmask.h
│ │ ├── sdf_shape_2D.h
│ │ ├── sdf_shape_3D.h
│ │ ├── simplecache.h
│ │ ├── startup.cc
│ │ ├── test6.cc
│ │ ├── test_QCCalculationParametersBase.cc
│ │ ├── test_cloud.cc
│ │ ├── test_keybox.cc
│ │ ├── test_macrotaskpartitioner.cc
│ │ ├── test_memory_measurement.cc
│ │ ├── test_mra6.cc
│ │ ├── test_sepop.cc
│ │ ├── test_tree_state.cc
│ │ ├── test_vectormacrotask.cc
│ │ ├── testbc.cc
│ │ ├── testbsh.cc
│ │ ├── testdiff1D.cc
│ │ ├── testdiff1Db.cc
│ │ ├── testdiff2D.cc
│ │ ├── testdiff3D.cc
│ │ ├── testgaxpyext.cc
│ │ ├── testgconv.cc
│ │ ├── testinnerext.cc
│ │ ├── testopdir.cc
│ │ ├── testpdiff.cc
│ │ ├── testper.cc
│ │ ├── testperiodic.cc
│ │ ├── testproj.cc
│ │ ├── testqm.cc
│ │ ├── testsolver.cc
│ │ ├── testsuite.cc
│ │ ├── testunaryop.cc
│ │ ├── testvmra.cc
│ │ ├── tools/
│ │ │ ├── MRAMeshOrbitalPlot3D.wl
│ │ │ ├── README.md
│ │ │ ├── autocorr.mw
│ │ │ ├── dump2.py
│ │ │ ├── h2-no1.cube
│ │ │ ├── h2-no1.tree.json
│ │ │ ├── h2-no1.wsl
│ │ │ ├── longfloat.py
│ │ │ ├── mathutil.py
│ │ │ ├── quadrature.py
│ │ │ └── twoscalecoeffs.py
│ │ ├── twoscale.cc
│ │ ├── twoscale.h
│ │ ├── vmra.h
│ │ └── vmra1.h
│ ├── tensor/
│ │ ├── CMakeLists.txt
│ │ ├── RandomizedMatrixDecomposition.cc
│ │ ├── RandomizedMatrixDecomposition.h
│ │ ├── SVDTensor.cc
│ │ ├── SVDTensor.h
│ │ ├── aligned.h
│ │ ├── basetensor.cc
│ │ ├── basetensor.h
│ │ ├── cblas.h
│ │ ├── cblas_types.h
│ │ ├── clapack.h
│ │ ├── clapack_fortran.h
│ │ ├── distributed_matrix.h
│ │ ├── dummy_main.c
│ │ ├── elem.cc
│ │ ├── elem.h
│ │ ├── fred.cc
│ │ ├── genmtxm.py
│ │ ├── gentensor.h
│ │ ├── gfit.cc
│ │ ├── gmres.h
│ │ ├── jacobi.h
│ │ ├── jimkernel.cc
│ │ ├── kain.cc
│ │ ├── lapack.cc
│ │ ├── lapacke_types.h
│ │ ├── linalg_wrappers.cc
│ │ ├── linalg_wrappers.h
│ │ ├── lowranktensor.h
│ │ ├── miketest.cc
│ │ ├── mtxmq_bg/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── bgp_cc.cc
│ │ │ ├── bgp_cr.cc
│ │ │ ├── bgp_rc.cc
│ │ │ ├── bgp_rr.cc
│ │ │ └── bgq_mtxm.cc
│ │ ├── mtxmq_graveyard/
│ │ │ ├── bgp_tuning/
│ │ │ │ ├── Makefile
│ │ │ │ ├── mTxm_tune.cc
│ │ │ │ ├── mtxmq.cc
│ │ │ │ ├── original_performance_data.145618.output
│ │ │ │ ├── submit
│ │ │ │ ├── test_Zmtxmq.cc
│ │ │ │ └── test_mtxmq.cc
│ │ │ ├── mtxm_gen.h
│ │ │ ├── mtxmq.cc
│ │ │ ├── mtxmq.h
│ │ │ ├── mtxmq_asm.S
│ │ │ ├── mtxmq_avx_rjh.cc
│ │ │ ├── new_mtxmq/
│ │ │ │ ├── README
│ │ │ │ ├── __main__.py
│ │ │ │ ├── bests/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── avx2_cc.cc
│ │ │ │ │ ├── avx2_cr.cc
│ │ │ │ │ ├── avx2_rc.cc
│ │ │ │ │ ├── avx2_rr.cc
│ │ │ │ │ ├── avx_cc.cc
│ │ │ │ │ ├── avx_cr.cc
│ │ │ │ │ ├── avx_rc.cc
│ │ │ │ │ ├── avx_rr.cc
│ │ │ │ │ ├── sse_cc.cc
│ │ │ │ │ ├── sse_cr.cc
│ │ │ │ │ ├── sse_rc.cc
│ │ │ │ │ └── sse_rr.cc
│ │ │ │ ├── bgq_results_parse.py
│ │ │ │ ├── codegen/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── bgqdriver.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ └── mtxm.py
│ │ │ │ ├── main.py
│ │ │ │ ├── results_parse.py
│ │ │ │ └── tests/
│ │ │ │ ├── __init__.py
│ │ │ │ └── testDocStrings.py
│ │ │ └── test_scott.cc
│ │ ├── mxm.h
│ │ ├── oldtest.cc
│ │ ├── slice.h
│ │ ├── solvers.cc
│ │ ├── solvers.h
│ │ ├── srconf.h
│ │ ├── systolic.h
│ │ ├── tempspec.py
│ │ ├── tensor.cc
│ │ ├── tensor.h
│ │ ├── tensor_json.hpp
│ │ ├── tensor_lapack.h
│ │ ├── tensor_macros.h
│ │ ├── tensorexcept.h
│ │ ├── tensoriter.cc
│ │ ├── tensoriter.h
│ │ ├── tensortrain.h
│ │ ├── test_RandomizedMatrixDecomposition.cc
│ │ ├── test_Zmtxmq.cc
│ │ ├── test_distributed_matrix.cc
│ │ ├── test_elemental.cc
│ │ ├── test_gentensor.cc
│ │ ├── test_jacobi.cc
│ │ ├── test_linalg.cc
│ │ ├── test_lowranktensor.cc
│ │ ├── test_mtxmq.cc
│ │ ├── test_solvers.cc
│ │ ├── test_systolic.cc
│ │ ├── test_tensor.cc
│ │ ├── testseprep.cc
│ │ ├── transform3d.cc
│ │ ├── type_data.h
│ │ ├── vector_factory.h
│ │ ├── vmath.cc
│ │ └── vmath.h
│ └── world/
│ ├── CMakeLists.txt
│ ├── MADworld.h
│ ├── README.test_renaming
│ ├── archive.cc
│ ├── archive.h
│ ├── archive_type_names.cc
│ ├── array_addons.h
│ ├── atomicint.h
│ ├── bgq_atomics.h
│ ├── binary_fstream_archive.cc
│ ├── binary_fstream_archive.h
│ ├── binsorter.h
│ ├── buffer_archive.h
│ ├── cereal_archive.h
│ ├── cloud.h
│ ├── debug.cc
│ ├── deferred_cleanup.cc
│ ├── deferred_cleanup.h
│ ├── dependency_interface.h
│ ├── dist_cache.h
│ ├── distributed_id.h
│ ├── dqueue.h
│ ├── function_traits.h
│ ├── future.cc
│ ├── future.h
│ ├── graveyard
│ ├── group.cc
│ ├── group.h
│ ├── hello_world.cu
│ ├── lookup3.c
│ ├── madness_exception.cc
│ ├── madness_exception.h
│ ├── mem_func_wrapper.h
│ ├── meta.h
│ ├── mpi_archive.h
│ ├── nodefaults.h
│ ├── parallel_archive.h
│ ├── parallel_dc_archive.h
│ ├── parsec.cc
│ ├── parsec.h
│ ├── posixmem.h
│ ├── print.cc
│ ├── print.h
│ ├── print_seq.h
│ ├── range.h
│ ├── ranks_and_hosts.cpp
│ ├── ranks_and_hosts.h
│ ├── redirectio.cc
│ ├── safempi.cc
│ ├── safempi.h
│ ├── stack.h
│ ├── stubmpi.h
│ ├── taskfn.h
│ ├── test_ar.cc
│ ├── test_atomicint.cc
│ ├── test_binsorter.cc
│ ├── test_dc.cc
│ ├── test_future.cc
│ ├── test_future2.cc
│ ├── test_future3.cc
│ ├── test_googletest.cc
│ ├── test_hashdc.cc
│ ├── test_hashthreaded.cc
│ ├── test_hello.cc
│ ├── test_list.cc
│ ├── test_mpihang.cc
│ ├── test_papi.cc
│ ├── test_prof.cc
│ ├── test_queue.cc
│ ├── test_sig.cc
│ ├── test_stack.cc
│ ├── test_sysctl.c
│ ├── test_tree.cc
│ ├── test_utilities.h
│ ├── test_vec.cc
│ ├── test_vector.cc
│ ├── test_world.cc
│ ├── test_worldprofile.cc
│ ├── test_worldptr.cc
│ ├── test_worldref.cc
│ ├── text_fstream_archive.cc
│ ├── text_fstream_archive.h
│ ├── thread.cc
│ ├── thread.h
│ ├── thread_info.h
│ ├── threadbind
│ ├── timers.cc
│ ├── timers.h
│ ├── timing_utilities.h
│ ├── type_traits.h
│ ├── uniqueid.h
│ ├── units.cc
│ ├── units.h
│ ├── vector.h
│ ├── vector_archive.h
│ ├── world.cc
│ ├── world.h
│ ├── world_object.h
│ ├── world_task_queue.cc
│ ├── world_task_queue.h
│ ├── worldam.cc
│ ├── worldam.h
│ ├── worlddc.h
│ ├── worldgop.cc
│ ├── worldgop.h
│ ├── worldhash.h
│ ├── worldhashmap.h
│ ├── worldinit.h
│ ├── worldmem.cc
│ ├── worldmem.h
│ ├── worldmpi.cc
│ ├── worldmpi.h
│ ├── worldmutex.cc
│ ├── worldmutex.h
│ ├── worldpapi.cc
│ ├── worldpapi.h
│ ├── worldprofile.cc
│ ├── worldprofile.h
│ ├── worldptr.h
│ ├── worldref.cc
│ ├── worldref.h
│ ├── worldrmi.cc
│ ├── worldrmi.h
│ └── worldtypes.h
├── madness.h
└── pymadness/
├── CMakeLists.txt
├── README.md
├── examples/
│ ├── derivatives.py
│ ├── harmonic_oscillator_1d.py
│ └── hydrogen_atom.py
├── pyproject.toml
├── src/
│ ├── _pymadness/
│ │ ├── bind_defaults.cpp
│ │ ├── bind_function.cpp
│ │ ├── bind_operators.cpp
│ │ ├── bind_tensor.cpp
│ │ ├── bind_world.cpp
│ │ ├── module.cpp
│ │ └── py_functor.h
│ └── pymadness/
│ ├── __init__.py
│ └── plotting.py
└── tests/
├── conftest.py
└── test_function.py
Copy disabled (too large)
Download .txt
Showing preview only (433,499K chars total). Download the full file to get everything.
SYMBOL INDEX (14309 symbols across 1497 files)
FILE: bin/test_utilities.py
class madjsoncompare (line 4) | class madjsoncompare:
method __init__ (line 6) | def __init__(self, file1, file2):
method exitcode (line 32) | def exitcode(self):
method compare (line 38) | def compare(self, subsequentkeys, tolerance):
function cleanup (line 72) | def cleanup(prefix):
function skip_on_small_machines (line 80) | def skip_on_small_machines():
FILE: doc/tutorial/simple_hf.cpp
function main (line 6) | int main(int argc, char* argv[]) {
FILE: doc/tutorial/test_runtime.cpp
function task (line 4) | int task (int i) { return i + 1; }
function main (line 6) | int main(int argc, char* argv[]) {
FILE: src/apps/cc2/cc2.cc
function main (line 47) | int main(int argc, char **argv) {
function main (line 110) | int main(int argc, char** argv) {
FILE: src/apps/cis/cis.cpp
function main (line 16) | int main(int argc, char **argv) {
FILE: src/apps/dirac/DF.cc
function myxfunc (line 21) | double myxfunc(const madness::coord_3d& r){
function myyfunc (line 26) | double myyfunc(const madness::coord_3d& r){
type lbcost (line 32) | struct lbcost {
method lbcost (line 35) | lbcost(double leaf_value=1.0, double parent_value=0.0) : leaf_value(le...
type function_real2complex_op (line 84) | struct function_real2complex_op
method serialize (line 94) | void serialize(Archive& ar) {}
function function_real2complex (line 97) | Function<std::complex<double>,3> function_real2complex(const Function<do...
function GradBSHOperator_Joel (line 106) | static
function Q2 (line 188) | Tensor<std::complex<double>> Q2(const Tensor<std::complex<double>>& s) {
function myr (line 195) | double myr(const coord_3d& r){
function Fcwf (line 326) | Fcwf apply_T(World& world, Fcwf& psi){
function apply_BSH (line 888) | void apply_BSH(World& world, Fcwf& Vpsi, double& eps, double& small, dou...
function apply_BSH_new (line 958) | void apply_BSH_new(World& world, Fcwf& Vpsi, double& eps, double& small,...
FILE: src/apps/dirac/DF.h
function class (line 25) | class DF {
FILE: src/apps/dirac/DFParameters.h
function namespace (line 10) | namespace madness {
FILE: src/apps/dirac/DFdriver.cc
function main (line 24) | int main(int argc, char **argv) {
FILE: src/apps/dirac/DKops.h
function q (line 18) | double q(double t){
function w (line 22) | double w(double t, double eps){
function Ebark (line 28) | double Ebark(double t, double eps){
function real_convolution_3d (line 33) | real_convolution_3d Ebar(World& world, double eps){
function real_convolution_3d (line 111) | real_convolution_3d Pbar(World& world){
function real_convolution_3d (line 170) | real_convolution_3d Tbar(World& world){
function real_convolution_3d (line 230) | real_convolution_3d A(World& world){
function real_convolution_3d (line 286) | real_convolution_3d A2(World& world){
function real_convolution_3d (line 342) | real_convolution_3d PbarA(World& world){
FILE: src/apps/dirac/InitParameters.h
function namespace (line 16) | namespace madness{
function readnw (line 279) | void readnw(World& world, const std::string& filename, bool Krestricted){
FILE: src/apps/dirac/fcwf.cc
function complex_function_3d (line 38) | complex_function_3d& Fcwf::operator[](const int i){
function complex_function_3d (line 44) | const complex_function_3d& Fcwf::operator[](const int i) const {
function Fcwf (line 92) | Fcwf Fcwf::operator=(const Fcwf& phi){
function Fcwf (line 99) | Fcwf Fcwf::operator-(const Fcwf& phi) const {
function Fcwf (line 117) | Fcwf Fcwf::operator+(const Fcwf& phi){
function Fcwf (line 134) | Fcwf Fcwf::operator*(std::complex<double> a) const {
function Fcwf (line 152) | Fcwf Fcwf::operator+=(const Fcwf& phi){
function Fcwf (line 169) | Fcwf Fcwf::operator-=(const Fcwf& phi){
function Fcwf (line 213) | Fcwf Fcwf::operator*(madness::complex_function_3d& phi){
function Fcwf (line 222) | Fcwf Fcwf::operator*(madness::real_function_3d& phi){
function Fcwf (line 266) | Fcwf Fcwf::KramersPair(){
function inner (line 275) | std::complex<double> inner(const Fcwf& psi, const Fcwf& phi){
function Fcwf (line 281) | Fcwf apply(World& world, real_convolution_3d& op, const Fcwf& psi){
function Fcwf (line 288) | Fcwf apply(World& world, complex_derivative_3d& D, const Fcwf& psi){
function real_function_3d (line 295) | real_function_3d squaremod(Fcwf& psi){
function real_function_3d (line 303) | real_function_3d squaremod_small(Fcwf& psi){
function real_function_3d (line 311) | real_function_3d squaremod_large(Fcwf& psi){
function complex_function_3d (line 318) | complex_function_3d inner_func(World& world, Fcwf& psi, Fcwf& phi){
function Fcwf (line 338) | Fcwf copy(Fcwf psi){
function inner (line 344) | std::complex<double> inner(std::vector<Fcwf>& a, std::vector<Fcwf>& b){
function Fcwf_vector_allocator (line 421) | Fcwf_vector_allocator Fcwf_vector_allocator::operator=(const Fcwf_vector...
function matrix_inner (line 431) | Tensor<std::complex<double>> matrix_inner(World& world, std::vector<Fcwf...
function transform (line 477) | std::vector<Fcwf> transform(World& world, std::vector<Fcwf>& a, Tensor<s...
FILE: src/apps/dirac/fcwf.h
function getinitialize (line 35) | bool getinitialize() const ;
FILE: src/apps/dirac/relops.cc
function q (line 15) | double q(double t) {
function Q (line 20) | double Q(double a) {
function C (line 25) | double C(double a) {
function fastsum_oscillating (line 37) | double fastsum_oscillating(const T& C, int nmax) {
class Tbar_omega (line 54) | class Tbar_omega {
method Tbar_omega (line 57) | Tbar_omega(double t) : t(t) {}
class A_omega (line 66) | class A_omega {
method A_omega (line 69) | A_omega(double t) : t(t) {}
class APbar_omega (line 78) | class APbar_omega {
method APbar_omega (line 81) | APbar_omega(double t) : t(t) {}
class Pbar_omega (line 92) | class Pbar_omega {
method Pbar_omega (line 95) | Pbar_omega(double t) : t(t) {}
function tbar_OMEGA (line 104) | double tbar_OMEGA(double t) {
function a_OMEGA (line 119) | double a_OMEGA(double t) {
function pbar_OMEGA (line 131) | double pbar_OMEGA(double t) {
function apbar_OMEGA (line 143) | double apbar_OMEGA(double t) {
function munge_quadrature_points (line 154) | void munge_quadrature_points(int& npt, double& tlo, double& thi, double...
function relops_h (line 168) | double relops_h(const double quadacc) {
function tbar_fit (line 173) | void tbar_fit(const double dx, const double thresh, const double quadacc...
function pbar_fit (line 224) | void pbar_fit(const double dx, const double thresh, const double quadacc...
function apbar_fit (line 275) | void apbar_fit(const double dx, const double thresh, const double quadac...
function a_fit (line 325) | void a_fit(const double dx, const double thresh, const double quadacc, s...
function bshrel_omega (line 374) | double bshrel_omega(double t, int k, double epsilon) {
function bshrel_OMEGA (line 432) | double bshrel_OMEGA(double t, double epsilon) {
function bshrel_fit (line 440) | void bshrel_fit(double epsilon, const double dx, const double thresh, do...
function check (line 495) | bool check(double value, double correct, double thresh, const char* msg) {
FILE: src/apps/dirac/rk.cc
type lbcost (line 18) | struct lbcost {
method lbcost (line 21) | lbcost(double leaf_value=1.0, double parent_value=0.0) : leaf_value(le...
class FiniteNucleusPotential (line 55) | class FiniteNucleusPotential : public FunctionFunctorInterface<double,3> {
method expnt (line 58) | static double expnt(int Z) {
method FiniteNucleusPotential (line 67) | FiniteNucleusPotential(int Z) : xi(expnt(Z)) {}
function real_convolution_3d (line 80) | real_convolution_3d make_operator(World& world,
function make_grad_operator (line 101) | static
function rk_v (line 192) | double rk_v(double Z) {
class Guess (line 206) | class Guess : public FunctionFunctorInterface<double,3> {
method Guess (line 213) | Guess(double Z)
method special_points (line 227) | std::vector<coord_3d> special_points() const final {return specialpt;}
method Level (line 229) | Level special_level() const final {return 5;}
function real_function_3d (line 237) | real_function_3d apply_potential(const real_function_3d& Vnuc, const rea...
function compute_energy (line 302) | double compute_energy(World& world, const real_function_3d& psi, const r...
function compute_energy_simple (line 336) | double compute_energy_simple(World& world, const real_function_3d& psi, ...
function real_function_3d (line 370) | real_function_3d apply_laplacian(World& world, const real_function_3d& p...
function real_convolution_3d (line 381) | real_convolution_3d make_bsh_operator(World& world, double eps, double& ...
function real_function_3d (line 392) | real_function_3d iterate(World& world, const real_function_3d& V, const ...
function logplot (line 424) | void logplot(double Z, const real_function_3d& psi, double lo=1e-7, doub...
function main (line 446) | int main(int argc, char** argv) {
FILE: src/apps/interior_bc/embedded_dirichlet.cc
function main (line 79) | int main(int argc, char **argv) {
FILE: src/apps/interior_bc/test_problems.h
type Mask (line 74) | enum Mask { LLRV, Gaussian }
type FunctorOutput (line 76) | enum FunctorOutput { SURFACE, DIRICHLET_RHS, EXACT, DOMAIN_MASK }
function else (line 92) | else if(node.is_leaf()) {
function virtual (line 161) | virtual ~EmbeddedDirichlet() {
function load_balance (line 169) | void load_balance(World &world, const Function<double, 3> &f)
function const (line 191) | double operator() (const Vector<double, 3> &x) const {
function virtual (line 225) | virtual double SurfaceIntegral() const = 0;
function DirichletCond (line 260) | double DirichletCond(const Vector<double, 3> &x) const {
function ExactSol (line 264) | double ExactSol(const Vector<double, 3> &x) const {
function Inhomogeneity (line 273) | double Inhomogeneity(const Vector<double, 3> &x) const {
function class (line 304) | class InhomoConstantSphere : public EmbeddedDirichlet {
function DirichletCond (line 326) | double DirichletCond(const Vector<double, 3> &x) const {
function ExactSol (line 330) | double ExactSol(const Vector<double, 3> &x) const {
function Inhomogeneity (line 339) | double Inhomogeneity(const Vector<double, 3> &x) const {
function class (line 370) | class CosineSphere : public EmbeddedDirichlet {
function DirichletCond (line 392) | double DirichletCond(const Vector<double, 3> &x) const {
function ExactSol (line 401) | double ExactSol(const Vector<double, 3> &x) const {
function Inhomogeneity (line 410) | double Inhomogeneity(const Vector<double, 3> &x) const {
function class (line 441) | class Y20Sphere : public EmbeddedDirichlet {
function DirichletCond (line 463) | double DirichletCond(const Vector<double, 3> &x) const {
function ExactSol (line 472) | double ExactSol(const Vector<double, 3> &x) const {
function Inhomogeneity (line 482) | double Inhomogeneity(const Vector<double, 3> &x) const {
function action (line 526) | void action(const Function<double, 3> &invec,
FILE: src/apps/madqc_v2/madqc.cpp
function help (line 66) | void help(std::string wf) {
function print_parameters (line 110) | void print_parameters(World& world, const commandlineparser& parser,
function main (line 155) | int main(int argc, char** argv) {
FILE: src/apps/madqc_v2/test_nemo_localization.py
function localizer_run (line 9) | def localizer_run(localizer):
FILE: src/apps/moldft/fci/crayio.c
type integer (line 25) | typedef int integer;
type w_file (line 40) | struct w_file {
function walltm_ (line 56) | void walltm_(double *ai)
function CheckUnit (line 67) | static int CheckUnit(integer unit)
function CheckAddr (line 78) | static int CheckAddr(integer addr)
function CheckCount (line 86) | static int CheckCount(integer count)
function InitFileStats (line 94) | void InitFileStats(struct w_file *file)
function PrintFileStats (line 107) | void PrintFileStats(struct w_file *unit, struct w_file *file)
function InitFileData (line 141) | void InitFileData(struct w_file *file)
function FirstCall (line 149) | void FirstCall()
function wclose_ (line 164) | void wclose_(integer* unit, integer* ierr)
function wopen_ (line 187) | void wopen_(integer* unit, char* name, integer* blocks, integer* stats, ...
function getwa_ (line 226) | void getwa_(integer* unit, double* result, integer* addr, integer* count...
function putwa_ (line 282) | void putwa_(integer* unit, double* source, integer* addr, integer* count...
FILE: src/apps/moldft/fci/ieor.c
function ieor_ (line 5) | int ieor_(int *i, int *j)
FILE: src/apps/moldft/fci/linux_cputime.c
function linux_cputime_ (line 7) | double linux_cputime_(void)
FILE: src/apps/moldft/mcpfit.cc
function START_TIMER (line 58) | void START_TIMER(World& world) {
function END_TIMER (line 62) | void END_TIMER(World& world, const char* msg) {
function mask1 (line 67) | inline double mask1(double x) {
function mask3 (line 81) | double mask3(const coordT& ruser) {
function tensorT (line 105) | tensorT Q3(const tensorT& s) {
function tensorT (line 122) | static tensorT vec2tensor (const vector<double> & v) {
function tensor2vec (line 131) | static vector<double> tensor2vec (const tensorT & t) {
function print (line 140) | void print (const tensorT & t) {
class CorePotentialFunctor (line 148) | class CorePotentialFunctor : public FunctionFunctorInterface<double,3> {
method CorePotentialFunctor (line 152) | CorePotentialFunctor(const CorePotential& pot) : pot(pot) {}
function radius_function (line 159) | inline static double radius_function (double rsq) {
class RadiusFunctor (line 164) | class RadiusFunctor : public FunctionFunctorInterface<double,3> {
method RadiusFunctor (line 166) | RadiusFunctor () {}
class RadiusSquareFunctor (line 172) | class RadiusSquareFunctor : public FunctionFunctorInterface<double,3> {
method RadiusSquareFunctor (line 174) | RadiusSquareFunctor () {}
class GaussianFunctor (line 180) | class GaussianFunctor : public FunctionFunctorInterface<double,3> {
method GaussianFunctor (line 183) | GaussianFunctor (double alpha) : alpha(alpha) {}
class PotentialBasisFunctor (line 190) | class PotentialBasisFunctor : public FunctionFunctorInterface<double,3> {
method PotentialBasisFunctor (line 196) | PotentialBasisFunctor (int n, double alpha, double rcut) : n(n), alpha...
class NcOverR (line 214) | class NcOverR : public FunctionFunctorInterface<double,3> {
method NcOverR (line 218) | NcOverR (int Nc, double c) : Nc(Nc), c(c) {}
class CoreOrbitalFunctor (line 224) | class CoreOrbitalFunctor : public FunctionFunctorInterface<double,3> {
method CoreOrbitalFunctor (line 230) | CoreOrbitalFunctor (CorePotentialManager & cpm, unsigned int atn, unsi...
type CalculationParameters (line 241) | struct CalculationParameters {
method CalculationParameters (line 254) | CalculationParameters()
method print_info (line 268) | void print_info () {
method read_file (line 283) | void read_file (const std::string filename) {
method serialize (line 322) | void serialize(Archive& ar) {
type Calculation (line 327) | struct Calculation {
method Calculation (line 343) | Calculation (World & world)
method print_info (line 380) | void print_info () {
method set_protocol (line 393) | void set_protocol (World & world, double thresh)
method load_mos (line 425) | void load_mos (World& world, std::string atom)
method vecfuncT (line 507) | vecfuncT make_reference (World & world, vecfuncT & mo, tensorT & occ)
method functionT (line 610) | functionT project_potential_basis (World & world, CorePotential & cp, ...
method vecfuncT (line 630) | vecfuncT make_Upsi (World & world, CorePotential & cp, vecfuncT & mo)
method plot_z (line 644) | void plot_z (const char* filename, const functionT & f)
method plot_p (line 653) | void plot_p (const char* filename, const vecfuncT& f)
method CorePotential (line 684) | CorePotential calc_optimal_coeffs (World & world, CorePotential & cp)
method compute_residuals (line 750) | double compute_residuals (World & world, CorePotential & cp, vecfuncT ...
method tensorT (line 795) | tensorT calc_deriv (World & world, CorePotential & cp, double r)
method CorePotential (line 813) | CorePotential update (World & world, CorePotential & cp, tensorT & der...
type CoreFittingTarget (line 858) | struct CoreFittingTarget : public OptimizationTargetInterface {
method CoreFittingTarget (line 866) | CoreFittingTarget (World & world, Calculation & calc, CorePotential & cp)
method provides_gradient (line 870) | bool provides_gradient() const {return true;}
method value (line 872) | double value (const tensorT & x) {
method tensorT (line 892) | tensorT gradient(const tensorT& x) {
class MySteepestDescent (line 903) | class MySteepestDescent : public OptimizerInterface {
method MySteepestDescent (line 910) | MySteepestDescent(const std::shared_ptr<OptimizationTargetInterface>& ...
method check_positive (line 921) | bool check_positive (tensorT & x)
method optimize (line 930) | bool optimize(Tensor<double>& x)
method converged (line 961) | bool converged() const
method gradient_norm (line 966) | double gradient_norm() const
method value (line 971) | double value() const
function main (line 979) | int main (int argc, char **argv) {
FILE: src/apps/moldft/moldft.cc
function START_TIMER (line 65) | static void START_TIMER(World &world) {
function END_TIMER (line 71) | static void END_TIMER(World &world, const char *msg) {
function main (line 77) | int main(int argc, char **argv) {
FILE: src/apps/moldft/moldx.py
class Element (line 46) | class Element:
method __init__ (line 47) | def __init__(self,symbol,covrad,vdwrad,col,name,atno):
method __str__ (line 55) | def __str__(self):
function scale_coords (line 172) | def scale_coords(coords, fac):
function dist (line 178) | def dist(i,j):
function make_bonds (line 183) | def make_bonds(coords, z, radii):
function moldx (line 193) | def moldx(coords,z,bonds=None,units="angstrom",fname="mol.dx",
function symtoatn (line 313) | def symtoatn(sym):
FILE: src/apps/moldft/parsemad.py
function parsemad (line 5) | def parsemad(filename):
FILE: src/apps/moldft/pointgroup.h
function class (line 50) | class PointGroup {
function virtual (line 159) | virtual ~PointGroup() {}
function irmul (line 162) | int irmul(int ir1, int ir2) const {
function coordT (line 167) | coordT apply(int op, const coordT& r) const {
function coordT (line 172) | static coordT apply(const std::string& op, const coordT& r) {
function cart_ir (line 206) | int cart_ir(int axis) const {
function coordT (line 232) | coordT ircell() const {
function test (line 259) | static bool test() {
function std (line 279) | const std::string& get_ir_name(int ir) const {
function std (line 283) | const std::string& get_op_name(int op) const {
function ctable (line 287) | int ctable(int ir, int op) const {
FILE: src/apps/moldft/preal.cc
function drot3 (line 23) | void drot3(long n, double* MADNESS_RESTRICT a, double* MADNESS_RESTRICT ...
class MolecularGuessDensityFunctor (line 62) | class MolecularGuessDensityFunctor : public FunctionFunctorInterface<dou...
method MolecularGuessDensityFunctor (line 67) | MolecularGuessDensityFunctor(const Molecule& molecule, const AtomicBas...
class AtomicBasisFunctor (line 77) | class AtomicBasisFunctor : public FunctionFunctorInterface<Q,3> {
method AtomicBasisFunctor (line 82) | AtomicBasisFunctor(const AtomicBasisFunction& aofunc)
method Q (line 86) | Q operator()(const coord_3d& x) const {
method special_points (line 90) | std::vector<coord_3d> special_points() const final {
method Level (line 94) | Level special_level() const final {
class MolecularPotentialFunctor (line 100) | class MolecularPotentialFunctor : public FunctionFunctorInterface<double...
method MolecularPotentialFunctor (line 104) | MolecularPotentialFunctor(const Molecule& molecule)
method special_points (line 111) | std::vector<coord_3d> special_points() const {return molecule.get_all_...
class DipoleFunctor (line 115) | class DipoleFunctor : public FunctionFunctorInterface<double,3> {
method DipoleFunctor (line 119) | DipoleFunctor(int axis) : axis(axis) {}
type BoysLocalization (line 125) | struct BoysLocalization {
method BoysLocalization (line 129) | BoysLocalization() {}
method BoysLocalization (line 131) | BoysLocalization(unsigned int norbs) {
method set_size (line 135) | void set_size(unsigned int norbs) {
method DIP (line 139) | inline double DIP(const real_tensor& dip, int i, int j, int k, int l)
method real_tensor (line 144) | real_tensor operator ()(World& world,
class MiniDFT (line 278) | class MiniDFT {
method MiniDFT (line 287) | MiniDFT(double thresh,
method vector_real_function_3d (line 307) | vector_real_function_3d makeao(World& world, const Molecule& molecule) {
method real_tensor (line 324) | real_tensor kinetic_energy_matrix(World& world, const vector_real_func...
method vector_real_function_3d (line 339) | vector_real_function_3d apply_potential(World& world, const real_funct...
method real_function_3d (line 345) | real_function_3d make_lda_potential(World& world, const real_function_...
method real_function_3d (line 354) | real_function_3d make_coulomb_potential(World& world, const real_funct...
method make_bsh_operators (line 362) | vector<poperatorT> make_bsh_operators(World& world, const real_tensor&...
method orthogonalize (line 376) | void orthogonalize(World& world, std::vector<Function<Q,3> >& psi) {
method vector_real_function_3d (line 392) | vector_real_function_3d update(World& world,
method real_function_3d (line 441) | real_function_3d make_density(World& world, const vector_real_function...
method doit (line 457) | void doit(World& world) {
function main (line 621) | int main(int argc, char** argv) {
FILE: src/apps/moldft/subspace.h
function class (line 16) | class Subspace
FILE: src/apps/moldft/testcosine.cc
class ExpFunctor (line 24) | class ExpFunctor: public FunctionFunctorInterface<Q,3> {
method ExpFunctor (line 30) | ExpFunctor(Q qx, Q qy, Q qz) : qx(qx), qy(qy), qz(qz) {}
method Q (line 31) | Q operator()(const coord_3d& x) const {
class ExpFunctor3d (line 37) | class ExpFunctor3d: public FunctionFunctorInterface<Q,3> {
method ExpFunctor3d (line 43) | ExpFunctor3d(Q q0, Q q1, Q q2) : q0(q0), q1(q1), q2(q2) {}
method Q (line 44) | Q operator()(const coord_3d& x) const {
class PWFunctor (line 49) | class PWFunctor: public FunctionFunctorInterface<double_complex,3> {
method PWFunctor (line 56) | PWFunctor(const std::vector<coord_3d>& gvecs, const real_tensor& coeff...
method double_complex (line 58) | double_complex operator()(const coord_3d& x) const {
class CosPotentialFunctor (line 70) | class CosPotentialFunctor : public FunctionFunctorInterface<double,3> {
function get_coeffs_pw (line 77) | std::vector<coord_3d> get_coeffs_pw(double maxKlen) {
function real_tensor (line 96) | real_tensor make_pw_matrix(const std::vector<coord_3d>& gvecs) {
function vector_complex_function_3d (line 124) | vector_complex_function_3d make_basis(World& world, double maxKlen) {
function tensor_complex (line 143) | tensor_complex make_kinetic_matrix(World& world, const vector_complex_fu...
function vector_complex_function_3d (line 169) | vector_complex_function_3d apply_potential(const real_function_3d& poten...
function orthogonalize (line 178) | void orthogonalize(World& world, vector_complex_function_3d& psi) {
function complex_function_3d (line 196) | complex_function_3d apply_periodic_bsh(World& world, const complex_funct...
function vector_complex_function_3d (line 210) | vector_complex_function_3d update(World& world,
function main (line 263) | int main(int argc, char** argv) {
FILE: src/apps/moldft/testmolbas.cc
function main (line 37) | int main() {
FILE: src/apps/moldft/testperiodicdft.cc
function START_TIMER (line 50) | static void START_TIMER(World& world) {
function END_TIMER (line 54) | static void END_TIMER(World& world, const char* msg) {
class SplitterFunctor (line 58) | class SplitterFunctor: public FunctionFunctorInterface<double,3> {
class ExpFunctor (line 66) | class ExpFunctor: public FunctionFunctorInterface<Q,3> {
method ExpFunctor (line 72) | ExpFunctor(Q qx, Q qy, Q qz) : qx(qx), qy(qy), qz(qz) {}
method Q (line 73) | Q operator()(const coord_3d& x) const {
class ExpFunctor3d (line 79) | class ExpFunctor3d: public FunctionFunctorInterface<Q,3> {
method ExpFunctor3d (line 85) | ExpFunctor3d(Q q0, Q q1, Q q2) : q0(q0), q1(q1), q2(q2) {}
method Q (line 86) | Q operator()(const coord_3d& x) const {
class MolecularGuessDensityFunctor (line 91) | class MolecularGuessDensityFunctor : public FunctionFunctorInterface<dou...
method MolecularGuessDensityFunctor (line 97) | MolecularGuessDensityFunctor(const Molecule& molecule, const AtomicBas...
class AtomicBasisFunctor (line 113) | class AtomicBasisFunctor : public FunctionFunctorInterface<double_comple...
method AtomicBasisFunctor (line 119) | AtomicBasisFunctor(const AtomicBasisFunction& aofunc, double kx, doubl...
method double_complex (line 129) | double_complex operator()(const coord_3d& x) const {
method special_points (line 153) | std::vector<coord_3d> special_points() const {return specialpt;}
class AtomicOrbitalFunctor (line 156) | class AtomicOrbitalFunctor: public FunctionFunctorInterface<double,3> {
method AtomicOrbitalFunctor (line 164) | AtomicOrbitalFunctor(const AtomicBasisFunction& aofunc, double R, int ...
method special_points (line 179) | std::vector<coord_3d> special_points() const {return specialpt;}
class KPeriodicBSHOperator (line 182) | class KPeriodicBSHOperator {
method KPeriodicBSHOperator (line 190) | KPeriodicBSHOperator(World& world, const double& kx, const double& ky,...
method KPeriodicBSHOperator (line 198) | KPeriodicBSHOperator(World& world, const Vector<double,3>& kpt, const ...
method vector_complex_function_3d (line 206) | vector_complex_function_3d apply(World& world, const vector_complex_fu...
function vector_complex_function_3d (line 225) | vector_complex_function_3d makeao_slow(World& world, const std::vector<V...
function vector_complex_function_3d (line 246) | vector_complex_function_3d makeao(World& world, const std::vector<Vector...
function tensor_complex (line 330) | tensor_complex make_kinetic_matrix(World& world, const vector_complex_fu...
function vector_complex_function_3d (line 359) | vector_complex_function_3d apply_potential(World& world, const real_func...
function vector_complex_function_3d (line 368) | vector_complex_function_3d orth(World& world, const vector_complex_funct...
function diag_and_transform (line 398) | std::pair<vector_complex_function_3d, tensor_real> diag_and_transform(Wo...
function real_function_3d (line 436) | real_function_3d make_lda_potential(World& world, const real_function_3d...
function real_function_3d (line 446) | real_function_3d make_coulomb_potential(World& world, const real_functio...
function make_bsh_operators (line 454) | vector<poperatorT> make_bsh_operators(World & world, const tensor_real& ...
function orthogonalize (line 465) | void orthogonalize(World& world, vector_complex_function_3d& psi) {
function complex_function_3d (line 487) | complex_function_3d apply_periodic_bsh(World& world, const complex_funct...
function complex_function_3d (line 500) | complex_function_3d apply_periodic_bsh(World& world, const complex_funct...
function vcpairT (line 508) | vcpairT update(World& world,
function real_function_3d (line 549) | real_function_3d make_density(World& world, const vector_complex_functio...
function vector_complex_function_3d (line 563) | vector_complex_function_3d initial_guess(World& world, const real_functi...
function tensor_complex (line 622) | tensor_complex matrix_exponential(const tensor_complex& A) {
function fixphases (line 660) | void fixphases(World& world, tensor_real& e, tensor_complex& U) {
function fixphases (line 740) | void fixphases(World& world, tensor_real& e, tensor_complex& U, vector_c...
function main (line 840) | int main(int argc, char** argv) {
FILE: src/apps/moldft/testpg.cc
function main (line 37) | int main(int argc, char** argv) {
FILE: src/apps/moldft/wst_functional.h
function class (line 4) | class WSTFunctional
FILE: src/apps/moldft/xmlguess.py
function find_string (line 6) | def find_string(s):
function read_geometry (line 16) | def read_geometry():
function read_numao (line 25) | def read_numao():
function read_energy (line 30) | def read_energy():
function read_occn (line 36) | def read_occn(n, ab):
function matrix (line 54) | def matrix(n,m):
function read_matrix (line 60) | def read_matrix(n,m):
function read_orbitals (line 74) | def read_orbitals(n):
function make_density (line 79) | def make_density(n, aocc, amo, bocc, bmo):
function print_matrix (line 89) | def print_matrix(n, m, a):
function print_vector (line 95) | def print_vector(n, a):
FILE: src/apps/molresponse/ExcitedResponse.cpp
class GaussianGuess (line 123) | class GaussianGuess : public FunctionFunctorInterface<double, NDIM>
method GaussianGuess (line 133) | GaussianGuess(const coordT &origin, const double alpha,
function X_space (line 154) | X_space ExcitedResponse::make_random_trial(World &world, size_t m) const
function X_space (line 187) | X_space ExcitedResponse::make_nwchem_trial(World &world, size_t m) const
function X_space (line 316) | X_space ExcitedResponse::create_trial_functions(World &world, size_t k) ...
function X_space (line 386) | X_space ExcitedResponse::create_trial_functions2(World &world) const
function response_space (line 1942) | response_space ExcitedResponse::apply_shift(World &world, const Tensor<d...
function X_space (line 2832) | X_space ExcitedResponse::create_virtual_ao_guess(World &world) const
function X_space (line 2991) | X_space ExcitedResponse::create_response_guess(World &world) const
function X_space (line 3243) | X_space ExcitedTester::test_ao_guess(World &world, ExcitedResponse &calc)
FILE: src/apps/molresponse/ExcitedResponse.hpp
type ExcitedSpace (line 9) | struct ExcitedSpace {
class ExcitedResponse (line 16) | class ExcitedResponse : public ResponseBase {
method ExcitedResponse (line 19) | ExcitedResponse(World& world, const CalcParams& params) : ResponseBase...
class ExcitedTester (line 145) | class ExcitedTester {
method ExcitedTester (line 148) | ExcitedTester(World& world, ExcitedResponse& calc, double thresh) {
FILE: src/apps/molresponse/FrequencyResponse.cpp
function nuclear_generator (line 425) | auto nuclear_generator(World &world, ResponseBase &calc) -> X_space {
function dipole_generator (line 447) | auto dipole_generator(World &world, ResponseBase &calc) -> X_space {
function vector_to_PQ (line 464) | auto vector_to_PQ(World &world, const vector_real_function_3d &rhs_opera...
function response_xy_pair (line 535) | response_xy_pair QuadraticResponse::compute_vbc(
function X_space (line 1241) | X_space QuadraticResponse::compute_second_order_perturbation_terms_v2(
function X_space (line 1382) | X_space QuadraticResponse::compute_second_order_perturbation_terms_v3(
function X_space (line 1567) | X_space QuadraticResponse::compute_second_order_perturbation_terms(
function X_space (line 1773) | X_space QuadraticResponse::compute_g1_term(World &world, const X_space &...
function X_space (line 1783) | X_space QuadraticResponse::compute_coulomb_term(World &world, const X_sp...
function X_space (line 1814) | X_space QuadraticResponse::compute_exchange_term(World &world, const X_s...
FILE: src/apps/molresponse/FrequencyResponse.hpp
class FrequencyResponse (line 12) | class FrequencyResponse
method FrequencyResponse (line 564) | FrequencyResponse(World &world, const CalcParams ¶ms, RHS_Generato...
method check_k (line 590) | void check_k(World &world, double thresh, int k) override {
method get_response_data (line 599) | std::pair<double, Tensor<double>> get_response_data() {
type response_lr_pair (line 14) | struct response_lr_pair {
type response_density (line 19) | struct response_density {
type response_xy_pair (line 24) | struct response_xy_pair {
class QuadraticResponse (line 40) | class QuadraticResponse : public ResponseBase {
method QuadraticResponse (line 51) | QuadraticResponse(World &world, const CalcParams ¶ms,
method set_x_data (line 205) | void set_x_data(World &world, const std::array<double, 3> &freqABC,
class PODResponse (line 342) | class PODResponse : public ResponseBase {
method PODResponse (line 353) | PODResponse(World &world, const CalcParams ¶ms,
method set_x_data (line 506) | void set_x_data(World &world, const std::vector<double> &freqABC,
class FrequencyResponse (line 561) | class FrequencyResponse : public ResponseBase {
method FrequencyResponse (line 564) | FrequencyResponse(World &world, const CalcParams ¶ms, RHS_Generato...
method check_k (line 590) | void check_k(World &world, double thresh, int k) override {
method get_response_data (line 599) | std::pair<double, Tensor<double>> get_response_data() {
FILE: src/apps/molresponse/Plot_VTK.cc
type madness (line 31) | namespace madness {
function write_molecules_to_file (line 32) | void write_molecules_to_file(const Molecule& molecule, const std::stri...
function do_response_orbital_vtk_plots (line 57) | void do_response_orbital_vtk_plots(World& world, int npt_plot, double ...
function do_response_density_vtk_plots (line 114) | void do_response_density_vtk_plots(World& world, int npt_plot, double ...
function do_response_density_vtk_plots_new (line 151) | void do_response_density_vtk_plots_new(World& world, int npt_plot, dou...
function do_vtk_plots (line 187) | void do_vtk_plots(World& world, int npt_plot, double L, int lowest_orb...
function do_vtk_plots (line 244) | void do_vtk_plots(World& world, int npt_plot, double L, Molecule molec...
FILE: src/apps/molresponse/Plot_VTK.h
function namespace (line 39) | namespace madness {
FILE: src/apps/molresponse/ResponseBase.cpp
function protocol_to_json (line 1672) | void protocol_to_json(json &j, const double proto) {
function check_k (line 1782) | void check_k(World &world, X_space &Chi,
function add_randomness (line 1809) | auto add_randomness(World &world, const response_space &f,
function normalize (line 1844) | void normalize(World &world, response_space &f) {
function normalize (line 1858) | void normalize(World &world, X_space &Chi) {
function solid_harmonics (line 1876) | auto solid_harmonics(World &world,
function vector_real_function_3d (line 1942) | vector_real_function_3d
function Molecule (line 2149) | Molecule ResponseBase::get_molecule() const { return molecule; }
function transition_densityTDA (line 2153) | auto transition_densityTDA(World &world,
function response_space (line 2180) | response_space transform(World &world, const response_space &f,
function transform (line 2205) | auto transform(World &world, const X_space &x,
function expectation (line 2216) | auto expectation(World &world, const response_space &A,
function print_norms (line 2250) | void print_norms(World &world, const response_space &f) {
function response_space (line 2267) | response_space select_functions(World &world, response_space f,
function sort (line 2302) | void sort(World &world, Tensor<double> &vals, response_space &f) {
function sort (line 2334) | void sort(World &world, Tensor<double> &vals, X_space &f) {
function gram_schmidt (line 2366) | auto gram_schmidt(World &world, const response_space &f) -> response_spa...
function make_xyz_functions (line 2398) | auto make_xyz_functions(World &world) -> vector_real_function_3d {
function inner_to_json (line 2552) | void inner_to_json(World &world, const std::string &name,
FILE: src/apps/molresponse/ResponseBase.hpp
class LoadXSpaceStrategy (line 36) | class LoadXSpaceStrategy {
class LoadFrequencyXSpace (line 43) | class LoadFrequencyXSpace : public LoadXSpaceStrategy {
method XData (line 45) | XData load_x_space(World &world, const std::string &filename,
class LoadExcitedXSpace (line 83) | class LoadExcitedXSpace : public LoadXSpaceStrategy {
method XData (line 85) | XData load_x_space(World &world, const std::string &filename,
class ComputeDensityStrategy (line 131) | class ComputeDensityStrategy {
class StaticDensityStrategy (line 140) | class StaticDensityStrategy : public ComputeDensityStrategy {
method vector_real_function_3d (line 142) | vector_real_function_3d compute_density(World &world, const X_space &x,
class FullDensityStrategy (line 187) | class FullDensityStrategy : public ComputeDensityStrategy {
method vector_real_function_3d (line 189) | vector_real_function_3d compute_density(World &world, const X_space &x,
class VXC1Strategy (line 235) | class VXC1Strategy {
class VXC1StrategyStandard (line 244) | class VXC1StrategyStandard : public VXC1Strategy {
method X_space (line 247) | X_space compute_VXC1(
class J1Strategy (line 269) | class J1Strategy {
class J1StrategyFull (line 278) | class J1StrategyFull : public J1Strategy {
method X_space (line 280) | X_space compute_J1(
class J1StrategyStable (line 297) | class J1StrategyStable : public J1Strategy {
method X_space (line 299) | X_space compute_J1(
class K1Strategy (line 323) | class K1Strategy {
method make_k (line 333) | [[nodiscard]] auto make_k(const vecfuncT &ket, const vecfuncT &bra) co...
class K1StrategyFull (line 352) | class K1StrategyFull : public K1Strategy {
method X_space (line 354) | X_space compute_K1(
method set_algorithm (line 390) | void set_algorithm(const std::string &algo) override { algorithm_ = al...
class K1StrategyStatic (line 393) | class K1StrategyStatic : public K1Strategy {
method X_space (line 395) | X_space compute_K1(
method set_algorithm (line 418) | void set_algorithm(const std::string &algo) override { algorithm_ = al...
class inner_strategy (line 421) | class inner_strategy {
class Context (line 429) | class Context {
method Context (line 440) | explicit Context(
method set_strategy (line 453) | void set_strategy(std::unique_ptr<inner_strategy> &&strategy,
method inner (line 470) | [[nodiscard]] Tensor<double> inner(const X_space &x, const X_space &y)...
method X_space (line 480) | X_space compute_j1(World &world, const X_space &x,
method X_space (line 493) | X_space compute_k1(World &world, const X_space &x,
method X_space (line 504) | X_space compute_VXC1(World &world, const X_space &x,
method vector_real_function_3d (line 517) | vector_real_function_3d compute_density(World &world, const X_space &x,
method XData (line 529) | XData load_x_space(World &world, const std::string &filename,
class full_inner_product (line 543) | class full_inner_product : public inner_strategy {
method compute_inner (line 545) | [[nodiscard]] Tensor<double> compute_inner(const X_space &x,
class static_inner_product (line 551) | class static_inner_product : public inner_strategy {
method compute_inner (line 553) | [[nodiscard]] Tensor<double> compute_inner(const X_space &x,
class response_timing (line 565) | class response_timing {
class response_data (line 579) | class response_data {
class ResponseTester (line 593) | class ResponseTester
method load_calc (line 1037) | static void load_calc(World &world, ResponseBase *p, double thresh) {
method X_space (line 1043) | static X_space compute_gamma_full(World &world, ResponseBase *p,
method X_space (line 1049) | X_space compute_lambda_X(World &world, ResponseBase *p, double thresh) {
method compute_VFOX (line 1056) | std::pair<X_space, X_space> compute_VFOX(World &world, ResponseBase *p,
type residuals (line 595) | struct residuals {
class ResponseBase (line 603) | class ResponseBase {
method get_parameter (line 616) | auto get_parameter() const -> CalcParams {
method get_orbitals (line 621) | auto get_orbitals() const -> vector_real_function_3d {
method get_chi (line 625) | auto get_chi() const -> X_space { return Chi.copy(); }
method help (line 636) | static void help() {
method print_parameters (line 655) | static void print_parameters() {
method set_protocol (line 722) | void set_protocol(World &world, double thresh) {
method save_x_space (line 785) | void save_x_space(World &world, const std::string &name, const X_space...
method X_space (line 801) | X_space load_x_space(World &world, const std::string &name) {
method exchangeHF (line 903) | auto exchangeHF(const vecfuncT &ket, const vecfuncT &bra,
function kronecker (line 969) | static auto kronecker(size_t l, size_t n) -> double {
class ResponseTester (line 1034) | class ResponseTester {
method load_calc (line 1037) | static void load_calc(World &world, ResponseBase *p, double thresh) {
method X_space (line 1043) | static X_space compute_gamma_full(World &world, ResponseBase *p,
method X_space (line 1049) | X_space compute_lambda_X(World &world, ResponseBase *p, double thresh) {
method compute_VFOX (line 1056) | std::pair<X_space, X_space> compute_VFOX(World &world, ResponseBase *p,
FILE: src/apps/molresponse/ResponseExceptions.hpp
class Input_Error (line 18) | class Input_Error : public MadException {
method Input_Error (line 20) | explicit Input_Error()
class Response_Input_Error (line 23) | class Response_Input_Error : public MadException {
method Response_Input_Error (line 25) | explicit Response_Input_Error()
class Response_Convergence_Error (line 30) | class Response_Convergence_Error : public MadException {
method Response_Convergence_Error (line 32) | explicit Response_Convergence_Error()
class Quad_Response_Error (line 37) | class Quad_Response_Error : public MadException {
method Quad_Response_Error (line 39) | explicit Quad_Response_Error()
FILE: src/apps/molresponse/basic_operators.cc
type madness (line 7) | namespace madness {
function response_space (line 10) | response_space transpose(response_space &f) {
function truncate (line 31) | void truncate(World &world, response_space &v, double tol, bool fence) {
function response_space (line 42) | response_space
function response_space (line 61) | response_space apply(World &world,
function response_space (line 79) | response_space apply(World &world, real_derivative_3d &op, response_sp...
FILE: src/apps/molresponse/basic_operators.h
function namespace (line 15) | namespace madness {
FILE: src/apps/molresponse/calc_runner.cc
function X_space (line 202) | X_space TDDFT::create_random_guess(
function X_space (line 286) | X_space TDDFT::create_nwchem_guess(World& world, size_t m) {
FILE: src/apps/molresponse/global_functions.cc
function set_poisson (line 9) | static auto set_poisson(World &world, const double lo, const double econ...
function initialize_calc_params (line 14) | auto initialize_calc_params(World &world, const std::string &input_file)...
function T (line 28) | auto T(World &world, response_space &f) -> response_space
function ground_exchange (line 59) | auto ground_exchange(const vecfuncT &phi0, const X_space &x, const bool ...
function response_exchange (line 127) | auto response_exchange(const vecfuncT &phi0, const X_space &x, const boo...
function newK (line 228) | auto newK(const vecfuncT &ket, const vecfuncT &bra, const vecfuncT &vf) ...
function molresponseExchange (line 240) | auto molresponseExchange(World &world, const vecfuncT &ket_i, const vecf...
function make_k (line 340) | auto make_k(const vecfuncT &ket, const vecfuncT &bra, const ResponsePara...
function response_exchange (line 375) | auto response_exchange(const vecfuncT &phi0, const X_space &chi, const b...
function ground_exchange (line 432) | auto ground_exchange(const vecfuncT &phi0, const X_space &chi, const boo...
FILE: src/apps/molresponse/global_functions.h
type CalcParams (line 14) | struct CalcParams {
function class (line 20) | class plotCoords {
function rsquared (line 63) | static double rsquared(const coord_3d &r) { return r[0] * r[0] + r[1] * ...
FILE: src/apps/molresponse/ground_parameters.h
function spinrestricted (line 28) | bool spinrestricted{true};///< Indicates if ground state calc. was open ...
function explicit (line 44) | explicit GroundStateCalculation(World& world, std::string input_file)
FILE: src/apps/molresponse/molresponse.cc
function file_exists (line 50) | static inline int file_exists(const char *inpname) {
function main (line 60) | int main(int argc, char **argv) {
FILE: src/apps/molresponse/property.h
function class (line 23) | class PropertyBase {
function class (line 32) | class DipoleVector : public PropertyBase {
function class (line 37) | class NuclearVector : public PropertyBase {
FILE: src/apps/molresponse/response_functions.h
function namespace (line 17) | namespace madness
function vector_real_function_3d (line 167) | const vector_real_function_3d &operator[](size_t i) const { return x.at(...
function friend (line 169) | friend auto inplace_unary_apply(
function push_back (line 408) | void push_back(const vector_real_function_3d &f)
function pop_back (line 423) | void pop_back()
function clear (line 436) | void clear()
function size (line 449) | [[nodiscard]] const auto end() const { return x.end(); }
function compress_rf (line 465) | void compress_rf() const
function inner (line 639) | inline double inner(response_space &a, response_space &b)
FILE: src/apps/molresponse/response_macrotask.hpp
type madness (line 19) | namespace madness {
class VBC_task_one_i (line 696) | class VBC_task_one_i : public MacroTaskOperationBase {
class Partitioner (line 698) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 700) | Partitioner() {
method VBC_task_one_i (line 708) | VBC_task_one_i() { partitioner.reset(new Partitioner()); }
method resultT (line 719) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 724) | resultT operator()(const std::vector<int> &b, const std::vector<int>...
class VBC_task_two_i_copy (line 811) | class VBC_task_two_i_copy : public MacroTaskOperationBase {
class Partitioner (line 813) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 815) | Partitioner() {
method VBC_task_two_i_copy (line 823) | VBC_task_two_i_copy() { partitioner.reset(new Partitioner()); }
method resultT (line 832) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 844) | resultT operator()(const std::vector<int> &state_index,
class VBC_task_two_i (line 930) | class VBC_task_two_i : public MacroTaskOperationBase {
class Partitioner (line 932) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 934) | Partitioner() {
method VBC_task_two_i (line 942) | VBC_task_two_i() { partitioner.reset(new Partitioner()); }
method resultT (line 954) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 959) | resultT operator()(const std::vector<int> &b, const std::vector<int>...
class VBC_task_three_i (line 1050) | class VBC_task_three_i : public MacroTaskOperationBase {
class Partitioner (line 1052) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 1054) | Partitioner() {
method VBC_task_three_i (line 1062) | VBC_task_three_i() { partitioner.reset(new Partitioner()); }
method resultT (line 1073) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 1085) | resultT
class VBC_task_i (line 1221) | class VBC_task_i : public MacroTaskOperationBase {
class Partitioner (line 1223) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 1225) | Partitioner() {
method VBC_task_i (line 1233) | VBC_task_i() { partitioner.reset(new Partitioner()); }
method resultT (line 1246) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 1258) | resultT
class ResponseComputeGammaX (line 1601) | class ResponseComputeGammaX : public MacroTaskOperationBase {
class Partitioner (line 1603) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 1605) | Partitioner() {
method ResponseComputeGammaX (line 1613) | ResponseComputeGammaX() { partitioner.reset(new Partitioner()); }
method resultT (line 1625) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 1633) | resultT operator()(const std::vector<int> &orb_index,
class ResponseComputeGroundExchange (line 1735) | class ResponseComputeGroundExchange : public MacroTaskOperationBase {
class Partitioner (line 1737) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 1739) | Partitioner() {
method ResponseComputeGroundExchange (line 1747) | ResponseComputeGroundExchange() { partitioner.reset(new Partitioner(...
method resultT (line 1759) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 1767) | resultT operator()(const std::vector<int> &orb_index,
class ResponseApplyBSH (line 1855) | class ResponseApplyBSH : public MacroTaskOperationBase {
class Partitioner (line 1857) | class Partitioner : public MacroTaskPartitioner {
method Partitioner (line 1859) | Partitioner() {
method ResponseApplyBSH (line 1867) | ResponseApplyBSH() { partitioner.reset(new Partitioner()); }
method resultT (line 1879) | resultT allocator(World &world, const argtupleT &args) const {
method resultT (line 1887) | resultT operator()(const vector_real_function_3d &x,
FILE: src/apps/molresponse/response_parameters.h
function namespace (line 22) | namespace madness {
function set_ground_state_calculation_data (line 161) | void set_ground_state_calculation_data(const GroundStateCalculation &g_p...
function set_derived_values (line 170) | void set_derived_values(World &world, const Molecule &molecule) {
FILE: src/apps/molresponse/timer.cc
type molresponse (line 10) | namespace molresponse {
function pop (line 11) | double pop(std::vector<double> &v) {
function start_timer (line 17) | void start_timer(madness::World &world) {
function end_timer (line 23) | void end_timer(madness::World &world, const char *msg) {
function end_timer (line 33) | void end_timer(madness::World &world, const char *msg, const std::stri...
FILE: src/apps/molresponse/timer.h
function namespace (line 9) | namespace molresponse {
FILE: src/apps/molresponse/x_space.cc
type madness (line 7) | namespace madness
function to_response_vector (line 15) | auto to_response_vector(const vector_real_function_3d &vec)
function create_response_matrix (line 40) | auto create_response_matrix(const size_t &num_states,
function to_response_matrix (line 56) | auto to_response_matrix(const X_space &x) -> response_matrix
function to_conjugate_response_matrix (line 71) | auto to_conjugate_response_matrix(const X_space &x) -> response_matrix
function to_flattened_vector (line 92) | auto to_flattened_vector(const X_space &x) -> vector_real_function_3d
function to_X_space (line 108) | auto to_X_space(const response_matrix &x) -> X_space
function to_conjugate_X_space (line 133) | auto to_conjugate_X_space(const response_matrix &x) -> X_space
function transposeResponseMatrix (line 157) | auto transposeResponseMatrix(const response_matrix &x) -> response_matrix
function inner (line 185) | auto inner(const X_space &A, const X_space &B) -> Tensor<double>
function vector_real_function_3d (line 212) | vector_real_function_3d copyToVector(const X_space &chi)
function copyToXspace (line 233) | void copyToXspace(const vector_real_function_3d &rf, X_space &chi)
function vector_real_function_3d (line 252) | vector_real_function_3d copyToVector(const response_space &chi)
function copyToResponseSpace (line 271) | void copyToResponseSpace(const vector_real_function_3d &rf,
FILE: src/apps/molresponse/x_space.h
function namespace (line 17) | namespace madness {
function scale_a (line 304) | auto scale_a = [&](vector_real_function_3d &vec_ai) {
function transform_ai (line 358) | auto transform_ai = [&](auto &ai) { return transform(world, ai, b, true); }
function friend (line 367) | friend auto inner(const X_space &A, const X_space &B) -> Tensor<double>;
function truncate (line 389) | void truncate(double thresh) {
type response_function_allocator (line 549) | struct response_function_allocator {
function class (line 572) | class x_space_indexer {
function class (line 601) | class response_space_index {
FILE: src/apps/molresponse_v2/FrequencyLoop.hpp
function iterate (line 18) | inline bool iterate(World &world, const ResponseManager &rm,
function solve_response_vector (line 118) | inline bool solve_response_vector(
function promote_response_vector (line 150) | inline void promote_response_vector(World &world,
function computeFrequencyLoop (line 207) | inline void computeFrequencyLoop(World &world, const ResponseManager &rm,
FILE: src/apps/molresponse_v2/GroundStateData.cpp
function real_function_3d (line 210) | real_function_3d GroundStateData::computeDensity(World &world) const {
function real_function_3d (line 219) | real_function_3d GroundStateData::computeNuclearPotential(double vtol) c...
function real_function_3d (line 225) | [[nodiscard]] real_function_3d
function real_function_3d (line 233) | real_function_3d GroundStateData::computeXCPotential(World &world) const {
function vector_real_function_3d (line 240) | vector_real_function_3d
FILE: src/apps/molresponse_v2/GroundStateData.hpp
class GroundStateData (line 17) | class GroundStateData {
method isFockLoadedFromFile (line 39) | [[nodiscard]] bool isFockLoadedFromFile() const {
method getNumOrbitals (line 48) | [[nodiscard]] long getNumOrbitals() const { return num_orbitals; }
method getL (line 49) | [[nodiscard]] double getL() const { return L; }
method getK (line 50) | [[nodiscard]] int getK() const { return k; }
method isSpinRestricted (line 51) | [[nodiscard]] bool isSpinRestricted() const { return spinrestricted; }
method Molecule (line 52) | [[nodiscard]] const Molecule &getMolecule() const { return molecule; }
FILE: src/apps/molresponse_v2/InnerContributions.hpp
function json (line 7) | inline json &global_inner_contributions() {
FILE: src/apps/molresponse_v2/MolecularProperty.hpp
type MolecularPropertyType (line 7) | enum class MolecularPropertyType { Polarizability, Raman, Hyperpolarizab...
type MolecularProperty (line 11) | struct MolecularProperty {
method MolecularProperty (line 16) | MolecularProperty(MolecularPropertyType t, std::vector<double> freqs,
function property_type_to_string (line 25) | std::string property_type_to_string(MolecularPropertyType type) {
function print_requested_properties (line 39) | void print_requested_properties(const std::vector<MolecularProperty> &pr...
FILE: src/apps/molresponse_v2/Perturbation.hpp
type overloaded (line 5) | struct overloaded : Ts... {
type PerturbationType (line 10) | enum class PerturbationType {
type DipolePerturbation (line 16) | struct DipolePerturbation {
type NuclearDisplacementPerturbation (line 20) | struct NuclearDisplacementPerturbation {
type MagneticPerturbation (line 25) | struct MagneticPerturbation {
function describe_perturbation (line 34) | inline std::string describe_perturbation(const Perturbation &p) {
FILE: src/apps/molresponse_v2/PropertyManager.hpp
function iso_timestamp (line 26) | inline std::string iso_timestamp() {
function compute_response_inner_product_tensor (line 35) | inline madness::Tensor<double> compute_response_inner_product_tensor(
type PropRow (line 112) | struct PropRow {
type PropKey (line 121) | struct PropKey {
function to_json (line 139) | inline void to_json(json &j, PropRow const &r) {
function from_json (line 152) | inline void from_json(json const &j, PropRow &r) {
class PropertyManager (line 164) | class PropertyManager {
method PropertyManager (line 166) | explicit PropertyManager(World &world, const std::string &filename)
method json (line 186) | json to_json() const {
method save (line 195) | void save() const {
method has_alpha (line 201) | [[nodiscard]] bool has_alpha(double omega, std::string comp) const {
method has_beta (line 207) | [[nodiscard]] bool has_beta(double w1, double w2, std::string comp) co...
method set_alpha (line 214) | void set_alpha(double omega, const madness::Tensor<double> &tensor,
method set_beta (line 234) | void set_beta(double w1, double w2, const std::string &comp, double va...
method print_table (line 249) | void print_table() const {
method freq_str (line 284) | static std::string freq_str(double freq) {
method parse_old_format (line 291) | void parse_old_format(json const &old) {
function compute_alpha (line 390) | void compute_alpha(World &world,
function compute_beta (line 473) | void compute_beta(
function compute_hyperpolarizability (line 635) | void compute_hyperpolarizability(
function compute_Raman (line 670) | void compute_Raman(
FILE: src/apps/molresponse_v2/ResponseDebugLogger.hpp
class ResponseDebugLogger (line 16) | class ResponseDebugLogger {
method ResponseDebugLogger (line 20) | explicit ResponseDebugLogger(const std::string &filename,
method json (line 30) | [[nodiscard]] json to_json() const { return log_data_; }
method enabled (line 32) | [[nodiscard]] bool enabled() const { return enabled_; }
method set_enabled (line 33) | void set_enabled(bool on) { enabled_ = on; }
method start_state (line 36) | void start_state(const LinearResponseDescriptor &state) {
method begin_iteration (line 52) | void begin_iteration(size_t iter_index) {
method log_value (line 60) | void log_value(const std::string &step_name, const T &value) {
method log_timing (line 66) | void log_timing(const std::string &step_name, double wall_time,
method log_value_and_time (line 76) | void log_value_and_time(const std::string &step_name, const T &value,
method end_iteration (line 83) | void end_iteration() {
method finalize_state (line 90) | void finalize_state() {
method write_to_disk (line 96) | void write_to_disk() const {
method print_timing_table (line 106) | void print_timing_table(const std::string &description) const {
method print_values_table (line 142) | void print_values_table(const std::string &description) const {
class TimedValueLogger (line 185) | class TimedValueLogger {
method TimedValueLogger (line 187) | TimedValueLogger(madness::World &world, const std::string &key,
method log (line 195) | void log() {
method log (line 212) | void log(const T &value) {
method log (line 230) | void log(const std::vector<T> &values) {
method log_value (line 255) | void log_value(const T &value) {
FILE: src/apps/molresponse_v2/ResponseIO.hpp
function save_response_vector (line 13) | void save_response_vector(World &world, const Desc &desc,
function load_response_vector (line 38) | inline bool load_response_vector(World &world, const int &num_orbitals,
FILE: src/apps/molresponse_v2/ResponseInitializer.hpp
function ResponseVector (line 7) | inline ResponseVector initialize_guess_vector(
FILE: src/apps/molresponse_v2/ResponseManager.hpp
class ResponseManager (line 10) | class ResponseManager {
method getVtol (line 17) | [[nodiscard]] double getVtol() const { return vtol; }
method poperatorT (line 18) | [[nodiscard]] poperatorT getCoulombOp() const { return coulop; }
method getGradOp (line 19) | [[nodiscard]] std::vector<std::shared_ptr<real_derivative_3d>> getGrad...
method CalculationParameters (line 25) | [[nodiscard]] CalculationParameters params() const { return calc_param...
FILE: src/apps/molresponse_v2/ResponseMetaData.hpp
class ResponseMetadata (line 15) | class ResponseMetadata {
method ResponseMetadata (line 17) | explicit ResponseMetadata(World &world, const std::string &filepath)
method initialize_states (line 40) | void initialize_states(const std::vector<LinearResponseDescriptor> &st...
method print_summary (line 70) | void print_summary() const {
method is_saved (line 84) | [[nodiscard]] bool is_saved(const std::string &state_id, double protocol,
method is_converged (line 89) | [[nodiscard]] bool is_converged(const std::string &state_id, double pr...
method mark_saved (line 94) | void mark_saved(const std::string &state_id, double protocol, double f...
method mark_converged (line 99) | void mark_converged(const std::string &state_id, double protocol, doub...
method mark_final_converged (line 105) | void mark_final_converged(const std::string &state_id, bool flag = tru...
method mark_final_saved (line 110) | void mark_final_saved(const std::string &state_id, bool flag = true) {
method final_converged (line 115) | [[nodiscard]] bool final_converged(const std::string &state_id) const {
method final_saved (line 119) | [[nodiscard]] bool final_saved(const std::string &state_id) const {
method write (line 123) | void write() const {
method json (line 127) | json to_json() const { return data_; }
method to_string (line 133) | static std::string to_string(double val) {
method get_flag (line 139) | [[nodiscard]] bool get_flag(const std::string &state_id, double protocol,
method set_flag (line 153) | void set_flag(const std::string &state_id, double protocol, double freq,
method frequency_to_string (line 161) | static std::string frequency_to_string(double frequency) {
method protocol_to_string (line 167) | static std::string protocol_to_string(double protocol) {
FILE: src/apps/molresponse_v2/ResponseSolver.cpp
function vector_real_function_3d (line 48) | vector_real_function_3d
function vector_real_function_3d (line 97) | vector_real_function_3d
FILE: src/apps/molresponse_v2/ResponseSolver.hpp
type response_vector_allocator (line 8) | struct response_vector_allocator {
method response_vector_allocator (line 11) | response_vector_allocator(World &world, size_t n_orbtials)
method vector_real_function_3d (line 13) | vector_real_function_3d operator()() {
class ResponseSolverPolicy (line 22) | class ResponseSolverPolicy
class ResponseSolverPolicy (line 25) | class ResponseSolverPolicy {
class ResponseSolverPolicy<StaticRestrictedResponse> (line 29) | class ResponseSolverPolicy<StaticRestrictedResponse> {
method real_function_3d (line 33) | static real_function_3d compute_density(World &world,
class ResponseSolverPolicy<DynamicRestrictedResponse> (line 53) | class ResponseSolverPolicy<DynamicRestrictedResponse> {
method real_function_3d (line 60) | static real_function_3d compute_density(World &world,
class ResponseSolverPolicy<StaticUnrestrictedResponse> (line 78) | class ResponseSolverPolicy<StaticUnrestrictedResponse> {
method real_function_3d (line 85) | static real_function_3d
class ResponseSolverPolicy<DynamicUnrestrictedResponse> (line 101) | class ResponseSolverPolicy<DynamicUnrestrictedResponse> {
method real_function_3d (line 108) | static real_function_3d
FILE: src/apps/molresponse_v2/ResponseSolverUtils.hpp
type ResponseSolverUtils (line 9) | namespace ResponseSolverUtils {
function print_iteration_line (line 13) | inline void print_iteration_line(int iter, double residual, double del...
function make_bsh_operators_response (line 34) | inline std::vector<poperatorT> make_bsh_operators_response(World &worl...
function inner (line 50) | inline double inner(World &world, const vector_real_function_3d &x, co...
function do_step_restriction (line 58) | inline void do_step_restriction(World &world, const vecfuncT &x, vecfu...
FILE: src/apps/molresponse_v2/ResponseState.hpp
type AbstractResponseDescriptor (line 21) | struct AbstractResponseDescriptor {
type LinearResponseDescriptor (line 30) | struct LinearResponseDescriptor : public AbstractResponseDescriptor {
method LinearResponseDescriptor (line 43) | LinearResponseDescriptor() = default;
method LinearResponseDescriptor (line 45) | LinearResponseDescriptor(Perturbation pert, PerturbationType ptype,
method current_threshold (line 62) | [[nodiscard]] double current_threshold() const {
method current_frequency (line 65) | [[nodiscard]] double current_frequency() const {
method at_final_frequency (line 68) | [[nodiscard]] bool at_final_frequency() const {
method at_final_threshold (line 71) | [[nodiscard]] bool at_final_threshold() const {
method set_frequency_index (line 75) | void set_frequency_index(size_t index) {
method advance_threshold (line 83) | void advance_threshold() {
method advance_frequency (line 89) | void advance_frequency() {
method is_static (line 94) | [[nodiscard]] bool is_static() const override {
method is_static (line 97) | [[nodiscard]] bool is_static(size_t freq_index) const {
method is_spin_restricted (line 100) | [[nodiscard]] bool is_spin_restricted() const override {
method make_key (line 105) | [[nodiscard]] std::string make_key(double thresh, double freq) const {
method make_key (line 120) | [[nodiscard]] std::string make_key(size_t ti, size_t fi) const {
method response_filename (line 124) | [[nodiscard]] std::string response_filename() const override {
method response_filename (line 127) | [[nodiscard]] std::string response_filename(
method perturbationDescription (line 132) | [[nodiscard]] std::string perturbationDescription() const {
method description (line 135) | [[nodiscard]] std::string description() const {
method ResponseVector (line 144) | [[nodiscard]] ResponseVector make_vector(int num_orbitals, size_t fi) ...
type SecondOrderResponseDescriptor (line 151) | struct SecondOrderResponseDescriptor : public AbstractResponseDescriptor {
method SecondOrderResponseDescriptor (line 159) | SecondOrderResponseDescriptor(PerturbationType t1, PerturbationType t2,
method LinearResponseDescriptor (line 168) | [[nodiscard]] LinearResponseDescriptor B_state() const {
method LinearResponseDescriptor (line 173) | [[nodiscard]] LinearResponseDescriptor C_state() const {
method get_states (line 179) | [[nodiscard]] std::pair<LinearResponseDescriptor, LinearResponseDescri...
method current_threshold (line 184) | [[nodiscard]] double current_threshold() const { return thresh; }
method current_frequency (line 186) | [[nodiscard]] double current_frequency() const {
method perturbationDescription (line 192) | [[nodiscard]] std::string perturbationDescription() const {
method is_spin_restricted (line 197) | [[nodiscard]] bool is_spin_restricted() const override {
method is_static (line 201) | [[nodiscard]] bool is_static() const override {
method make_key (line 207) | [[nodiscard]] std::string make_key(double f1, double f2,
method response_filename (line 233) | [[nodiscard]] std::string response_filename() const override {
method response_filename (line 237) | [[nodiscard]] std::string response_filename(
method ResponseVector (line 242) | [[nodiscard]] ResponseVector make_vector(int num_orbitals, size_t fi) ...
type VBCResponseState (line 253) | struct VBCResponseState : public SecondOrderResponseDescriptor {
type XBCResponseState (line 258) | struct XBCResponseState : public SecondOrderResponseDescriptor {
function real_function_3d (line 268) | inline real_function_3d raw_perturbation_operator(
function vector_real_function_3d (line 307) | inline vector_real_function_3d project_perturbation_onto_orbitals(
function perturbation_vector (line 316) | inline madness::vector_real_function_3d perturbation_vector(
function perturbation_vector (line 329) | inline madness::vector_real_function_3d perturbation_vector(
FILE: src/apps/molresponse_v2/ResponseVector.hpp
type StaticRestrictedResponse (line 8) | struct StaticRestrictedResponse
method StaticRestrictedResponse (line 48) | StaticRestrictedResponse() = default;
method StaticRestrictedResponse (line 49) | explicit StaticRestrictedResponse(const size_t &num_orbitals)
method sync (line 55) | void sync() {
method flatten (line 61) | void flatten() { flat = x_alpha; }
type DynamicRestrictedResponse (line 9) | struct DynamicRestrictedResponse
method DynamicRestrictedResponse (line 68) | DynamicRestrictedResponse() = default;
method DynamicRestrictedResponse (line 69) | explicit DynamicRestrictedResponse(const size_t &num_orbitals)
method sync (line 75) | void sync() {
method flatten (line 82) | void flatten() {
type StaticUnrestrictedResponse (line 10) | struct StaticUnrestrictedResponse
method StaticUnrestrictedResponse (line 92) | StaticUnrestrictedResponse() = default;
method StaticUnrestrictedResponse (line 93) | explicit StaticUnrestrictedResponse(const size_t &num_orbitals)
method sync (line 97) | void sync() {
method flatten (line 103) | void flatten() {
type DynamicUnrestrictedResponse (line 11) | struct DynamicUnrestrictedResponse
method DynamicUnrestrictedResponse (line 115) | DynamicUnrestrictedResponse() = default;
method DynamicUnrestrictedResponse (line 117) | explicit DynamicUnrestrictedResponse(const size_t &num_orbitals)
method flatten (line 123) | void flatten() {
method sync (line 129) | void sync() {
type StaticRestrictedResponse (line 44) | struct StaticRestrictedResponse {
method StaticRestrictedResponse (line 48) | StaticRestrictedResponse() = default;
method StaticRestrictedResponse (line 49) | explicit StaticRestrictedResponse(const size_t &num_orbitals)
method sync (line 55) | void sync() {
method flatten (line 61) | void flatten() { flat = x_alpha; }
type DynamicRestrictedResponse (line 64) | struct DynamicRestrictedResponse {
method DynamicRestrictedResponse (line 68) | DynamicRestrictedResponse() = default;
method DynamicRestrictedResponse (line 69) | explicit DynamicRestrictedResponse(const size_t &num_orbitals)
method sync (line 75) | void sync() {
method flatten (line 82) | void flatten() {
type StaticUnrestrictedResponse (line 88) | struct StaticUnrestrictedResponse {
method StaticUnrestrictedResponse (line 92) | StaticUnrestrictedResponse() = default;
method StaticUnrestrictedResponse (line 93) | explicit StaticUnrestrictedResponse(const size_t &num_orbitals)
method sync (line 97) | void sync() {
method flatten (line 103) | void flatten() {
type DynamicUnrestrictedResponse (line 109) | struct DynamicUnrestrictedResponse {
method DynamicUnrestrictedResponse (line 115) | DynamicUnrestrictedResponse() = default;
method DynamicUnrestrictedResponse (line 117) | explicit DynamicUnrestrictedResponse(const size_t &num_orbitals)
method flatten (line 123) | void flatten() {
method sync (line 129) | void sync() {
function ResponseVector (line 150) | inline ResponseVector make_response_vector(size_t num_orbitals, bool is_...
function vector_real_function_3d (line 169) | inline const vector_real_function_3d &get_flat(const ResponseVector &vec) {
FILE: src/apps/molresponse_v2/StateGenerator.hpp
type GeneratedStateData (line 13) | struct GeneratedStateData {
method print_generated_state_map (line 17) | static void print_generated_state_map(
class StateGenerator (line 40) | class StateGenerator {
method StateGenerator (line 42) | StateGenerator(const Molecule &mol, const std::vector<double> &thresho...
method GeneratedStateData (line 52) | [[nodiscard]] GeneratedStateData generateStates() const {
type PropertyTensorType (line 154) | enum class PropertyTensorType { Alpha, Beta }
type PropertyComponentPlan (line 156) | struct PropertyComponentPlan {
FILE: src/apps/molresponse_v2/VBCMacrotask.hpp
type madness (line 13) | namespace madness {
class SimpleVBCComputer (line 15) | class SimpleVBCComputer {
method SimpleVBCComputer (line 17) | SimpleVBCComputer(World &world, const GroundStateData &gs)
method get_BC_vecs (line 21) | std::pair<ResponseVector, ResponseVector>
method vector_real_function_3d (line 40) | static vector_real_function_3d
method K (line 48) | static auto K(const vector_real_function_3d &bra,
method compute_g (line 56) | static auto compute_g(World &world, const vector_real_function_3d &A...
method compute_vbc_i (line 94) | static auto compute_vbc_i(World &world, const vector_real_function_3...
method ResponseVector (line 136) | ResponseVector compute_vbc_response(World &world, const GroundStateD...
method ResponseVector (line 166) | ResponseVector compute_and_save(const VBCResponseState &vbc_state) {
FILE: src/apps/molresponse_v2/broadcast_json.hpp
function json (line 11) | inline json broadcast_json_file(World &world, const std::string &filepat...
FILE: src/apps/molresponse_v2/molresponse2.cpp
function main (line 17) | int main(int argc, char **argv) {
FILE: src/apps/molresponse_v2/test_parameter_manager.cpp
function main (line 15) | int main(int argc, char **argv) {
FILE: src/apps/molresponse_v2/test_preliminaries.cpp
function get_fock_from_json (line 13) | std::pair<Tensor<double>, Tensor<double>>
function approximately_equal (line 39) | bool approximately_equal(double computed, double reference, double tol =...
function tensor_approx_equal (line 44) | bool tensor_approx_equal(World &world, const Tensor<double> &computed,
function main (line 90) | int main(int argc, char **argv) {
FILE: src/apps/mp2/mp2.cc
function main (line 48) | int main(int argc, char** argv) {
function main (line 108) | int main(int argc, char** argv) {
FILE: src/apps/nemo/nemo.cc
function main (line 54) | int main(int argc, char** argv) {
FILE: src/apps/oep/oep.cc
function write_test_input (line 44) | void write_test_input() {
function main (line 84) | int main(int argc, char** argv) {
FILE: src/apps/periodic_old/complexfun.h
function namespace (line 45) | namespace madness {
type typename (line 107) | typedef typename TensorTypeData<Q>::scalar_type resultT;
type typename (line 131) | typedef typename TensorTypeData<Q>::scalar_type resultT;
type typename (line 155) | typedef typename TensorTypeData<Q>::scalar_type resultT;
type typename (line 179) | typedef typename TensorTypeData<Q>::scalar_type resultT;
type Q (line 203) | typedef Q resultT;
type std (line 227) | typedef std::complex<Q> resultT;
FILE: src/apps/periodic_old/dft.cc
type madness (line 42) | namespace madness
class DFT<double, 3> (line 397) | class DFT<double, 3>
type madness (line 192) | namespace madness
class DFT<double, 3> (line 397) | class DFT<double, 3>
FILE: src/apps/periodic_old/dft.h
function namespace (line 45) | namespace madness
function virtual (line 146) | virtual bool is_od() {return false;}
function virtual (line 151) | virtual bool is_rd() {return true;}
function virtual (line 197) | virtual bool is_od() {return false;}
function virtual (line 202) | virtual bool is_rd() {return true;}
function virtual (line 231) | virtual bool is_od() {return false;}
function virtual (line 236) | virtual bool is_rd() {return true;}
function prepare_op (line 240) | void prepare_op(Function<double,NDIM> rho) {}
type Vector (line 264) | typedef Vector<double,NDIM> kvecT;
function T (line 310) | T matrix_element(const funcT& phii, const funcT& phij)
function print_matrix_elements (line 317) | void print_matrix_elements(const funcT& phii, const funcT& phij)
function get_eig (line 330) | double get_eig(int indx)
function funcT (line 337) | funcT get_phi(int indx)
function std (line 344) | const std::vector<double>& eigs()
function std (line 351) | const std::vector<funcT>& phis()
FILE: src/apps/periodic_old/eigsolver.cc
type madness (line 51) | namespace madness
function T (line 143) | T EigSolver<T,NDIM>::matrix_element(const funcT& phii, const funcT& phij)
class EigSolver<double,1> (line 524) | class EigSolver<double,1>
class EigSolver<double,2> (line 525) | class EigSolver<double,2>
class EigSolver<double,3> (line 526) | class EigSolver<double,3>
FILE: src/apps/periodic_old/eigsolver.h
function namespace (line 39) | namespace madness
type Function (line 101) | typedef Function<T,NDIM> funcT;
function virtual (line 111) | virtual ~EigSolverOp() {}
function virtual (line 126) | virtual void prepare_op(funcT rho) {}
function virtual (line 131) | virtual funcT op_o(const std::vector<funcT>& phis, const funcT& psi)
function virtual (line 140) | virtual funcT op_r(const funcT& rho, const funcT& psi)
function virtual (line 149) | virtual std::vector<funcT> multi_op_o(const std::vector<funcT>& phis)
function virtual (line 164) | virtual std::vector<funcT> multi_op_r(const funcT& rho, const std::vecto...
function coeff (line 177) | double coeff() {return _coeff;}
function messageME (line 197) | void messageME(std::string messageME)
type Vector (line 232) | typedef Vector<double,NDIM> kvecT;
type SeparatedConvolution (line 233) | typedef SeparatedConvolution<double,NDIM> operatorT;
type std (line 234) | typedef std::shared_ptr<operatorT> poperatorT;
function get_eig (line 268) | double get_eig(int indx)
function funcT (line 275) | funcT get_phi(int indx)
function std (line 282) | const std::vector<funcT>& phis()
function std (line 289) | const std::vector<double>& eigs()
function addObserver (line 296) | void addObserver(IEigSolverObserver<T,NDIM>* obs)
FILE: src/apps/periodic_old/electronicstructureapp.h
function class (line 51) | class LevelPmap : public WorldDCPmapInterface< Key<3> > {
function const (line 79) | double operator()(const coordT& x) const
function virtual (line 102) | virtual Level special_level()
function const (line 107) | double operator()(const coordT& x) const
function rsquared (line 269) | double rsquared(const coordT& r) {
FILE: src/apps/periodic_old/electronicstructureparams.h
function namespace (line 43) | namespace madness {
FILE: src/apps/periodic_old/esolver.h
type std (line 43) | typedef std::shared_ptr< WorldDCPmapInterface< Key<3> > > pmapT;
type Vector (line 44) | typedef Vector<double,3> coordT;
type std (line 45) | typedef std::shared_ptr< FunctionFunctorInterface<std::complex<double>,3...
type std (line 46) | typedef std::shared_ptr< FunctionFunctorInterface<double,3> > rfunctorT;
type Function (line 47) | typedef Function<std::complex<double>,3> functionT;
type Function (line 48) | typedef Function<std::complex<double>,3> cfunctionT;
type Function (line 49) | typedef Function<double,3> rfunctionT;
type std (line 50) | typedef std::vector<functionT> vecfuncT;
type std (line 51) | typedef std::vector<rfunctionT> rvecfuncT;
type std (line 52) | typedef std::vector<cfunctionT> cvecfuncT;
type Tensor (line 53) | typedef Tensor< std::complex<double> > ctensorT;
type Tensor (line 54) | typedef Tensor<double> rtensorT;
type FunctionFactory (line 55) | typedef FunctionFactory<std::complex<double>,3> factoryT;
type FunctionFactory (line 56) | typedef FunctionFactory<double,3> rfactoryT;
type SeparatedConvolution (line 57) | typedef SeparatedConvolution<double,3> operatorT;
type std (line 58) | typedef std::shared_ptr<operatorT> poperatorT;
function print_cube (line 60) | void print_cube(World& world, const Function<double,3>& f, int npts)
function print_cube (line 84) | void print_cube(World& world, const Function<double,3>& f1, const Functi...
function print_cube (line 109) | void print_cube(World& world, const Function<double,3>& f1, const Functi...
type KPoint (line 136) | struct KPoint
function is_orb_in_kpoint (line 166) | bool is_orb_in_kpoint(unsigned int idx)
function is_equal (line 190) | bool is_equal(double val1, double val2, double eps)
FILE: src/apps/periodic_old/ewald.cc
function compute_volume (line 16) | double compute_volume()
type vectorLengthFunctor (line 23) | struct vectorLengthFunctor : public std::binary_function<Vector<double,3...
class GaussianFunctor (line 35) | class GaussianFunctor : public FunctionFunctorInterface<double,3> {
method GaussianFunctor (line 42) | GaussianFunctor(double coeff, double expnt)
method special_points (line 48) | virtual std::vector<coordT> special_points() const
method Level (line 53) | virtual Level special_level()
function gen_ce (line 65) | void gen_ce(double mu, double xlo, double eps, Tensor<double>& c, Tensor...
function generate_R_vectors (line 102) | std::vector< Vector<double,3> > generate_R_vectors(World& world, double ...
function generate_G_vectors (line 167) | std::vector< Vector<double,3> > generate_G_vectors(World& world, double ...
class OnesFunctor (line 212) | class OnesFunctor : public FunctionFunctorInterface<double,3> {
method OnesFunctor (line 217) | OnesFunctor(double val=1.0) : val(val) {}
class EwaldNuclearPotentialFunctor (line 228) | class EwaldNuclearPotentialFunctor : public FunctionFunctorInterface<dou...
method EwaldNuclearPotentialFunctor (line 237) | EwaldNuclearPotentialFunctor(World& world, MolecularEntity* mentity, d...
method double_complex (line 334) | double_complex do_G_sum_v1(const coordT& r) const
method double_complex (line 356) | double_complex do_G_sum_v2(const coordT& r) const
method double_complex (line 390) | double_complex do_R_sum_v1(const coordT& r) const
function nuclear_potential (line 502) | double nuclear_potential(const Tensor<double>& c, const Tensor<double>& ...
class MolecularNuclearPotentialFunctor2 (line 514) | class MolecularNuclearPotentialFunctor2 : public FunctionFunctorInterfac...
method MolecularNuclearPotentialFunctor2 (line 524) | MolecularNuclearPotentialFunctor2(World& world, const MolecularEntity&...
method get_coeff (line 617) | Tensor<double> get_coeff() {return coeff;}
method get_expnt (line 618) | Tensor<double> get_expnt() {return expnt;}
class MolecularNuclearChargeDensityFunctor (line 623) | class MolecularNuclearChargeDensityFunctor : public FunctionFunctorInter...
method MolecularNuclearChargeDensityFunctor (line 632) | MolecularNuclearChargeDensityFunctor(const MolecularEntity& mentity, c...
method special_points (line 639) | virtual std::vector<coordT> special_points() const
method Level (line 644) | virtual Level special_level()
function rfunctionT (line 698) | rfunctionT make_nuclear_charge_density(World& world,
function rvecfuncT (line 721) | rvecfuncT make_nuclear_charge_density_individual(World& world,
function test_gaussian_num_coeffs (line 749) | void test_gaussian_num_coeffs(int argc, char** argv)
function compute_madelung_energy_PWSCF (line 816) | void compute_madelung_energy_PWSCF(World& world, MolecularEntity mentity,
function compute_madelung_energy (line 916) | void compute_madelung_energy(World& world, MolecularEntity mentity,
function test_gence (line 1023) | void test_gence(int argc, char** argv)
function test_gence2 (line 1045) | void test_gence2(int argc, char** argv)
function test_nuclear_potential2 (line 1081) | void test_nuclear_potential2(int argc, char** argv)
function test_nuclear_potential (line 1148) | void test_nuclear_potential(int argc, char** argv)
function test_nuclear_potential3 (line 1261) | void test_nuclear_potential3(int argc, char** argv)
function test_nuclear_potential_big_unit_cell (line 1354) | void test_nuclear_potential_big_unit_cell(int argc, char** argv)
function test_G_R_vectors (line 1432) | void test_G_R_vectors(int argc, char** argv)
function test_nuclear_energy (line 1487) | void test_nuclear_energy(int argc, char** argv)
function main (line 1577) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/hartreefock.cc
type madness (line 35) | namespace madness
FILE: src/apps/periodic_old/hartreefock.h
function namespace (line 41) | namespace madness
FILE: src/apps/periodic_old/lda.h
type doublereal (line 47) | typedef double doublereal;
type MADNESS_FORINT (line 48) | typedef MADNESS_FORINT integer;
type logical (line 49) | typedef int logical;
function pow (line 74) | static inline double pow(const double* a, const double* b) {
function x_rks_s__ (line 84) | inline /* Subroutine */ int x_rks_s__(const double *r__, double *f, doub...
function x_uks_s__ (line 125) | inline /* Subroutine */ int x_uks_s__(double *ra, double *rb, double *f,
function c_rks_vwn5__ (line 166) | inline /* Subroutine */ int c_rks_vwn5__(const double *r__, double *f, d...
function c_uks_vwn5__ (line 246) | inline /* Subroutine */ int c_uks_vwn5__(double *ra, double *rb, double *
function rks_c_vwn5__ (line 431) | inline /* Subroutine */ int rks_c_vwn5__(integer *ideriv, integer *npt, ...
function rks_x_lda__ (line 712) | inline /* Subroutine */ int rks_x_lda__(integer *ideriv, integer *npt, d...
function wst_munge_grho (line 833) | inline void wst_munge_grho(int npoint, double *rho, double *grho) {
function wst_munge_rho (line 841) | inline void wst_munge_rho(int npoint, double *rho) {
function xc_rks_generic_lda (line 848) | inline void xc_rks_generic_lda(Tensor<double> rho_alpha, ///< ...
function dft_xc_lda_V (line 900) | void dft_xc_lda_V(const Key<NDIM>& key, Tensor<double>& t)
function dft_xc_lda_ene (line 911) | void dft_xc_lda_ene(const Key<NDIM>& key, Tensor<double>& t)
FILE: src/apps/periodic_old/libxc.h
function munge (line 48) | static double munge(double r) {
function ldaop (line 56) | static void ldaop(const Key<3>& key, Tensor<T>& t) {
function ldaeop (line 63) | static void ldaeop(const Key<3>& key, Tensor<T>& t) {
FILE: src/apps/periodic_old/mentity.cc
function distance (line 48) | static inline double distance(double x1, double y1, double z1, double x2...
function distance_sq (line 55) | static inline double distance_sq(double x1, double y1, double z1, double...
function AtomicData (line 175) | const AtomicData& get_atomic_data(unsigned int atomic_number) {
function symbol_to_atomic_number (line 181) | unsigned int symbol_to_atomic_number(const std::string& symbol) {
function smoothing_parameter (line 192) | static double smoothing_parameter(double Z, double eprec) {
function smoothed_potential (line 206) | static double smoothed_potential(double r) {
function dsmoothed_potential (line 223) | static double dsmoothed_potential(double r)
function smoothed_density (line 254) | static double smoothed_density(double r)
function Atom (line 369) | const Atom& MolecularEntity::get_atom(unsigned int i) const {
FILE: src/apps/periodic_old/mentity.h
type AtomicData (line 45) | struct AtomicData {
function class (line 71) | class Atom {
function class (line 95) | class MolecularEntity {
FILE: src/apps/periodic_old/molecularbasis.h
function class (line 49) | class ContractedGaussianShell {
function class (line 227) | class AtomicBasis {
function set_guess_info (line 246) | void set_guess_info(const Tensor<double>& dmat,
function eval_guess_density (line 290) | double eval_guess_density(double x, double y, double z) const {
function ContractedGaussianShell (line 309) | const ContractedGaussianShell& get_shell_from_basis_function(int ibf, in...
function class (line 361) | class AtomicBasisFunction {
function print_me (line 392) | void print_me(std::ostream& s) const {
function get_coords (line 408) | void get_coords(double& x, double& y, double& z) const {
function class (line 424) | class AtomicBasisSet {
FILE: src/apps/periodic_old/outputwriter.h
function class (line 38) | class OutputWriter
FILE: src/apps/periodic_old/poperator.h
function namespace (line 42) | namespace madness
FILE: src/apps/periodic_old/solver.h
function namespace (line 67) | namespace madness
function double_complex (line 140) | double_complex operator()(const coord_3d& x) const {
function const (line 170) | double operator()(const coordT& x) const {
function virtual (line 173) | virtual ~DipoleFunctor() {}
type std (line 195) | typedef std::complex<T> valueT;
type Function (line 196) | typedef Function<valueT,NDIM> functionT;
type std (line 197) | typedef std::vector<functionT> vecfuncT;
type std (line 198) | typedef std::pair<vecfuncT,vecfuncT> pairvecfuncT;
type std (line 199) | typedef std::vector<pairvecfuncT> subspaceT;
type Tensor (line 200) | typedef Tensor<valueT> tensorT;
type std (line 201) | typedef std::vector<tensorT> vectensorT;
type std (line 202) | typedef std::vector<subspaceT> vecsubspaceT;
function update_subspace (line 245) | void update_subspace(vecfuncT& awfs_new,
type std (line 411) | typedef std::complex<T> valueT;
type Function (line 412) | typedef Function<valueT,NDIM> functionT;
type std (line 413) | typedef std::vector<functionT> vecfuncT;
type std (line 414) | typedef std::pair<vecfuncT,vecfuncT> pairvecfuncT;
type std (line 415) | typedef std::vector<pairvecfuncT> subspaceT;
type Tensor (line 416) | typedef Tensor<valueT> tensorT;
function update_subspace (line 448) | void update_subspace(vecfuncT& awfs_new,
function reproject (line 556) | void reproject()
type std (line 621) | typedef std::complex<T> valueT;
type Function (line 622) | typedef Function<T,NDIM> rfunctionT;
type FunctionFactory (line 623) | typedef FunctionFactory<T,NDIM> rfactoryT;
type Function (line 624) | typedef Function<valueT,NDIM> functionT;
type std (line 625) | typedef std::vector<functionT> vecfuncT;
type FunctionFactory (line 626) | typedef FunctionFactory<valueT,NDIM> factoryT;
type Vector (line 627) | typedef Vector<double,NDIM> kvecT;
type SeparatedConvolution (line 628) | typedef SeparatedConvolution<T,3> operatorT;
type std (line 629) | typedef std::shared_ptr<operatorT> poperatorT;
type Tensor (line 630) | typedef Tensor<double> rtensorT;
type Tensor (line 631) | typedef Tensor<std::complex<double> > ctensorT;
type Tensor (line 632) | typedef Tensor<valueT> tensorT;
type std (line 633) | typedef std::pair<vecfuncT,vecfuncT> pairvecfuncT;
type std (line 634) | typedef std::vector<pairvecfuncT> subspaceT;
type std (line 635) | typedef std::vector<tensorT> vectensorT;
type std (line 636) | typedef std::vector<subspaceT> vecsubspaceT;
function START_TIMER (line 761) | void START_TIMER(World& world) {
function END_TIMER (line 765) | void END_TIMER(World& world, const char* msg) {
function _world (line 771) | _world(world)
function init (line 789) | void init(const std::string& filename)
function rfunctionT (line 1229) | rfunctionT
function vecfuncT (line 1243) | vecfuncT project_ao_basis(World& world, KPoint kpt) {
function initial_guess (line 1316) | void initial_guess()
function virtual (line 1882) | virtual ~Solver()
function set_occs2 (line 1893) | void set_occs2(const std::vector<KPoint>& kpoints,
function rfunctionT (line 2010) | rfunctionT compute_rho_slow(const vecfuncT& phis, std::vector<KPoint> kp...
function rfunctionT (line 2042) | rfunctionT compute_rho(const vecfuncT& phis, std::vector<KPoint> kpoints,
function calculate_kinetic_energy (line 2135) | double calculate_kinetic_energy()
function apply_potential (line 2177) | void apply_potential(vecfuncT& pfuncsa,
function apply_hf_exchange3 (line 2318) | void apply_hf_exchange3(vecfuncT& phisa, vecfuncT& phisb,
function KPoint (line 2353) | KPoint find_kpt_from_orb(unsigned int idx)
function apply_hf_exchange4 (line 2366) | void apply_hf_exchange4(vecfuncT& phisa, vecfuncT& phisb,
function orthonormalize (line 3660) | void orthonormalize(vecfuncT& wf, KPoint kpoint)
function vecfuncT (line 3683) | vecfuncT compute_residual(const vecfuncT& awfs,
function update_orbitals (line 3716) | void update_orbitals(vecfuncT& awfs,
function step_restriction (line 3778) | void step_restriction(vecfuncT& owfs,
function fix_occupations (line 3810) | void fix_occupations(const std::vector<T>& eps,
FILE: src/apps/periodic_old/solver_driver.cc
function main (line 38) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_be.cc
function smoothing_parameter (line 50) | static double smoothing_parameter(double Z, double eprec) {
function smoothed_potential (line 66) | static double smoothed_potential(double r) {
function psi_func_be1 (line 82) | static double psi_func_be1(const coordT& rr)
function psi_func_be2 (line 91) | static double psi_func_be2(const coordT& rr)
function V_func_be (line 101) | static double V_func_be(const coordT& r)
function rho_func_be (line 111) | static double rho_func_be(const coordT& rr)
function test_hf_be (line 126) | void test_hf_be(World& world)
function main (line 206) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_comm.cc
class Array (line 37) | class Array : public WorldObject<Array> {
method Array (line 41) | Array(World& world, size_t size)
method ProcessID (line 48) | ProcessID owner(size_t i) const {return i/v.size();}
method read (line 51) | Future<double> read(size_t i) const {
method write (line 59) | void write(size_t i, double value) {
function main (line 68) | int main(int argc, char** argv) {
FILE: src/apps/periodic_old/test_coulomb.cc
function smoothing_parameter (line 58) | static double smoothing_parameter(double Z, double eprec) {
function smoothed_potential (line 73) | static double smoothed_potential(double r) {
function V_cosine1D (line 89) | static double V_cosine1D(const coordT1d& r)
function V_cosine3D (line 98) | static double V_cosine3D(const coordT3d& r)
function V_cosine3D_sep (line 107) | static double V_cosine3D_sep(const coordT3d& r)
function gaussian_func (line 117) | static double gaussian_func(const Vector<double, NDIM> r)
function phi_initial_guess1D (line 127) | static double phi_initial_guess1D(const coordT1d& r)
function phi_initial_guess3D (line 134) | static double phi_initial_guess3D(const coordT3d& r)
function psi_func_he (line 179) | static double psi_func_he(const coordT3d& r)
function V_func_he (line 187) | static double V_func_he(const coordT3d& r)
function test_he (line 302) | void test_he(int argc, char** argv)
function main (line 347) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_he.cc
function smoothing_parameter (line 55) | static double smoothing_parameter(double Z, double eprec) {
function printfunc (line 65) | void printfunc(const World& world, Function<double,3> f, int npts)
function smoothed_potential (line 84) | static double smoothed_potential(double r) {
function multiply_op (line 99) | void multiply_op(const Key<3>& key, Tensor<double> tcube,
function psi_func_he (line 107) | static double psi_func_he(const coordT& r)
function V_func_he (line 115) | static double V_func_he(const coordT& r)
function rho_func_he (line 125) | static double rho_func_he(const coordT& rr)
class HeElectronicChargeDensityIGuess (line 141) | class HeElectronicChargeDensityIGuess : public FunctionFunctorInterface<...
method HeElectronicChargeDensityIGuess (line 147) | HeElectronicChargeDensityIGuess(const coordT& center)
method T (line 150) | T operator()(const coordT& rr) const
class HeNuclearChargeDensityIGuess (line 165) | class HeNuclearChargeDensityIGuess : public FunctionFunctorInterface<T,N...
method HeNuclearChargeDensityIGuess (line 171) | HeNuclearChargeDensityIGuess(const coordT& center)
method T (line 174) | T operator()(const coordT& rr) const
function test_xc (line 192) | void test_xc(World& world)
function he_munge (line 209) | double he_munge(double r) {
function he_ldaop (line 216) | static void he_ldaop(const Key<3>& key, Tensor<double>& t) {
type myunaryop_square (line 227) | struct myunaryop_square
method serialize (line 242) | void serialize(Archive& ar) {}
function test_hf_he (line 247) | void test_hf_he(World& world)
function test_he_potential (line 356) | void test_he_potential(World& world)
function main (line 442) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_hf.cc
function smoothing_parameter (line 50) | static double smoothing_parameter(double Z, double eprec) {
function smoothed_potential (line 66) | static double smoothed_potential(double r) {
function psi_func_be1 (line 82) | static double psi_func_be1(const coordT& rr)
function psi_func_be2 (line 91) | static double psi_func_be2(const coordT& rr)
function psi_func_he (line 100) | static double psi_func_he(const coordT& r)
function V_func_he (line 108) | static double V_func_he(const coordT& r)
function rho_func_he (line 118) | static double rho_func_he(const coordT& rr)
function V_func_be (line 133) | static double V_func_be(const coordT& r)
function V_func_h2 (line 143) | double V_func_h2(const Vector<double,3>& r)
function psi_func_h2 (line 154) | double psi_func_h2(const Vector<double,3>& r)
class H2Potential (line 167) | class H2Potential :
method H2Potential (line 173) | H2Potential() {}
function test_hf_h2 (line 187) | void test_hf_h2(World& world)
function test_hf_he (line 240) | void test_hf_he(World& world)
function test_hf_be (line 319) | void test_hf_be(World& world)
function main (line 388) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_hydro.cc
class NuclearChargeDensityOp (line 50) | class NuclearChargeDensityOp : public EigSolverOp<T,NDIM>
method NuclearChargeDensityOp (line 56) | NuclearChargeDensityOp(World& world, funcT rhon, double coeff, double ...
method is_od (line 77) | virtual bool is_od() {return false;}
method is_rd (line 82) | virtual bool is_rd() {return true;}
method prepare_op (line 86) | void prepare_op(Function<double,NDIM> rho) {}
method funcT (line 90) | virtual funcT op_r(const funcT& rho, const funcT& psi)
function rho_func_hydro (line 112) | static double rho_func_hydro(const coordT& rr)
function psi_func_hydro (line 127) | double psi_func_hydro(const Vector<double,3>& r)
function test_hydro (line 137) | void test_hydro(World& world)
function main (line 189) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/test_lattice.cc
function rho_bsh_func3d (line 46) | static double rho_bsh_func3d(const coordT3d& r)
function func_ones (line 55) | static double func_ones(const coordT3d& r)
function double_complex (line 63) | static double_complex rho_coulomb_func3d(const coordT3d& r)
function complex_exp_1d (line 73) | static std::complex<double> complex_exp_1d(const coordT1d r)
function rho_gaussian_func3d (line 84) | static double rho_gaussian_func3d(const coordT3d& r)
function double_complex (line 101) | static double_complex phi_coulomb_func3d(const coordT3d& r)
function phi_bsh_func3d (line 122) | static double phi_bsh_func3d(const coordT3d& r)
function Q (line 133) | Q laplacian(const Q& f, bool periodic = false)
class wstFunctor (line 159) | class wstFunctor
method wstFunctor (line 164) | wstFunctor(int kmax, double coeff, double expnt) :
method Q (line 168) | Q operator()(double x) const
function testPeriodicCoulomb3d (line 483) | void testPeriodicCoulomb3d(int argc, char**argv)
function main (line 776) | int main(int argc, char**argv)
FILE: src/apps/periodic_old/test_xc.cc
function gauss_func3 (line 390) | static double gauss_func3(const coordT& r)
function gauss_func1 (line 398) | static double gauss_func1(const coordT& r)
function test_xc1 (line 406) | void test_xc1(World& world)
function da_ldaop (line 447) | static void da_ldaop(const Key<3>& key, Tensor<double>& t) {
function multiply_op (line 463) | void multiply_op(const Key<3>& key, Tensor<double> tcube,
function add_op (line 472) | void add_op(const Key<3>& key, Tensor<double> tcube,
function test_xc2 (line 481) | void test_xc2(World& world)
function main (line 522) | int main(int argc, char** argv)
FILE: src/apps/periodic_old/testconv.cc
class Array (line 39) | class Array : public WorldObject<Array> {
method Array (line 43) | Array(World& world, size_t size)
method ProcessID (line 50) | ProcessID owner(size_t i) const {return i/v.size();}
method read (line 53) | Future<double> read(size_t i) const {
method write (line 61) | void write(size_t i, double value) {
function main (line 70) | int main(int argc, char** argv) {
FILE: src/apps/periodic_old/util.h
function namespace (line 38) | namespace madness {
FILE: src/apps/plot/plot2cube.cpp
function main (line 9) | int main(int argc, char** argv) {
FILE: src/apps/plot/plot2plane.cpp
function do_plot (line 10) | void do_plot (World& world, const std::vector<std::string>& filenames, c...
function main (line 37) | int main(int argc, char** argv) {
FILE: src/apps/pno/pno.cpp
function main (line 16) | int main(int argc, char** argv) {
FILE: src/apps/tdse/tdse.cc
type InputParameters (line 49) | struct InputParameters {
method read (line 80) | void read(const char* filename) {
method serialize (line 187) | void serialize(Archive & ar) {
type refop (line 223) | struct refop {
method serialize (line 230) | void serialize(Archive& ar) {}
function complex_functionT (line 233) | complex_functionT APPLY(const complex_operatorT* q1d, const complex_func...
function d_smoothed_potential (line 257) | static double d_smoothed_potential(double r) {
function smoothed_potential (line 274) | static double smoothed_potential(double r) {
function V (line 288) | static double V(const coordT& r) {
function dVdx (line 303) | static double dVdx(const coordT& r) {
function dVdy (line 319) | static double dVdy(const coordT& r) {
function dVdz (line 335) | static double dVdz(const coordT& r) {
function guess1s (line 351) | static double guess1s(const coordT& r) {
function guess2s (line 366) | static double guess2s(const coordT& r) {
function xdipole (line 381) | double xdipole(const coordT& r) {
function ydipole (line 386) | double ydipole(const coordT& r) {
function zdipole (line 391) | double zdipole(const coordT& r) {
function laser (line 396) | double laser(double t) {
function myreal (line 406) | double myreal(double t) {return t;}
function myreal (line 408) | double myreal(const double_complex& t) {return real(t);}
function energy (line 412) | double energy(World& world, const Function<T,3>& psi, const functionT& p...
function converge (line 441) | void converge(World& world, functionT& potn, functionT& psi, double& eps) {
function converge2s (line 465) | void converge2s(World& world, functionT& potn, functionT& psi, double& e...
function complex_functionT (line 489) | complex_functionT chin_chen(const complex_functionT& expV_0,
function complex_functionT (line 520) | complex_functionT trotter(World& world,
type unaryexp (line 541) | struct unaryexp {
type unaryexp<double_complex,NDIM> (line 551) | struct unaryexp<double_complex,NDIM> {
method serialize (line 557) | void serialize(Archive& ar) {}
function complex_functionT (line 562) | complex_functionT make_exp(double t, const functionT& v) {
function print_stats_header (line 570) | void print_stats_header(World& world) {
function print_stats (line 577) | void print_stats(World& world, int step, double t, const functionT& v,
function complex_functionT (line 611) | complex_functionT wave_function_load(World& world, int step) {
function wave_function_store (line 618) | void wave_function_store(World& world, int step, const complex_functionT...
function wave_function_exists (line 623) | bool wave_function_exists(World& world, int step) {
function doplot (line 627) | void doplot(World& world, int step, const complex_functionT& psi, double...
function line_plot (line 638) | void line_plot(World& world, int step, complex_functionT& psi) {
type lbcost (line 666) | struct lbcost {
method lbcost (line 669) | lbcost(double leaf_value=1.0, double parent_value=1.0) : leaf_value(le...
function preloadbal (line 686) | void preloadbal(World& world,
function loadbal (line 700) | void loadbal(World& world,
function propagate (line 728) | void propagate(World& world, int step0) {
function doit (line 921) | void doit(World& world) {
function main (line 1025) | int main(int argc, char** argv) {
FILE: src/apps/tdse/tdse.confused.cc
type InputParameters (line 47) | struct InputParameters {
method read (line 79) | void read(const char* filename) {
method serialize (line 181) | void serialize(Archive & ar) {
function ostream (line 189) | ostream& operator<<(ostream& s, const InputParameters& p) {
class LevelPmap (line 215) | class LevelPmap : public WorldDCPmapInterface< Key<3> > {
method LevelPmap (line 219) | LevelPmap() : nproc(0) {}
method LevelPmap (line 221) | LevelPmap(World& world) : nproc(world.nproc()) {}
method ProcessID (line 224) | ProcessID owner(const Key<3>& key) const {
function d_smoothed_potential (line 251) | static double d_smoothed_potential(double r) {
function smoothed_potential (line 268) | static double smoothed_potential(double r) {
function V (line 282) | static double V(const coordT& r) {
function dVdx (line 297) | static double dVdx(const coordT& r) {
function dVdy (line 313) | static double dVdy(const coordT& r) {
function dVdz (line 329) | static double dVdz(const coordT& r) {
function guess (line 345) | static double guess(const coordT& r) {
function xdipole (line 359) | double xdipole(const coordT& r) {
function ydipole (line 364) | double ydipole(const coordT& r) {
function zdipole (line 369) | double zdipole(const coordT& r) {
function laser (line 374) | double laser(double t) {
function myreal (line 384) | double myreal(double t) {return t;}
function myreal (line 386) | double myreal(const double_complex& t) {return real(t);}
function energy (line 390) | double energy(World& world, const Function<T,3>& psi, const functionT& p...
function converge (line 418) | void converge(World& world, functionT& potn, functionT& psi, double& eps) {
function complex_functionT (line 442) | complex_functionT chin_chen(const complex_functionT& expV_0,
function complex_functionT (line 471) | complex_functionT trotter(World& world,
type unaryexp (line 492) | struct unaryexp {
type unaryexp<double_complex,NDIM> (line 502) | struct unaryexp<double_complex,NDIM> {
method serialize (line 508) | void serialize(Archive& ar) {}
function complex_functionT (line 513) | complex_functionT make_exp(double t, const functionT& v) {
function print_stats_header (line 520) | void print_stats_header(World& world) {
function print_stats (line 527) | void print_stats(World& world, int step, double t, const functionT& v,
function complex_functionT (line 561) | complex_functionT wave_function_load(World& world, int step) {
function wave_function_store (line 568) | void wave_function_store(World& world, int step, const complex_functionT...
function wave_function_exists (line 573) | bool wave_function_exists(World& world, int step) {
function doplot (line 577) | void doplot(World& world, int step, const complex_functionT& psi, double...
function line_plot (line 588) | void line_plot(World& world, int step, complex_functionT& psi) {
type lbcost (line 616) | struct lbcost {
method lbcost (line 619) | lbcost(double leaf_value=1.0, double parent_value=1.0) : leaf_value(le...
function loadbal (line 632) | void loadbal(World& world,
function propagate (line 665) | void propagate(World& world, int step0) {
function doit (line 846) | void doit(World& world) {
function main (line 909) | int main(int argc, char** argv) {
FILE: src/apps/tdse/tdse4.cc
type lbcost (line 50) | struct lbcost {
method lbcost (line 53) | lbcost(double leaf_value=1.0, double parent_value=1.0) : leaf_value(le...
function real (line 78) | double real(double a) {return a;}
type InputParameters (line 86) | struct InputParameters {
method read (line 112) | void read(const char* filename) {
method serialize (line 198) | void serialize(Archive & ar) {
function smoothed_potential (line 220) | static double smoothed_potential(double r) {
function Vn (line 234) | static double Vn(const coordT& r) {
function Ve (line 244) | static double Ve(const coordT& r) {
function guess (line 261) | static double guess(const coordT& r) {
function xdipole (line 293) | double xdipole(const coordT& r) {
function ydipole (line 298) | double ydipole(const coordT& r) {
function zdipole (line 303) | double zdipole(const coordT& r) {
function bond_length (line 307) | double bond_length(const coordT& r) {
function laser (line 312) | double laser(double t) {
function myreal (line 322) | double myreal(double t) {return t;}
function myreal (line 324) | double myreal(const double_complex& t) {return real(t);}
function energy (line 328) | double energy(World& world, const Function<T,4>& psi, const functionT& p...
function fred (line 368) | double fred(const coordT& r) {
function delsqfred (line 374) | double delsqfred(const coordT& r) {
function testbsh (line 381) | void testbsh(World& world) {
function converge (line 401) | void converge(World& world, functionT& potn, functionT& pote, functionT&...
function complex_functionT (line 437) | complex_functionT APPLY(const complex_operatorT* Ge, const complex_opera...
function complex_functionT (line 454) | complex_functionT trotter(World& world,
type unaryexp (line 486) | struct unaryexp {}
type unaryexp<double_complex,NDIM> (line 490) | struct unaryexp<double_complex,NDIM> {
method serialize (line 496) | void serialize(Archive& ar) {}
function complex_functionT (line 501) | complex_functionT make_exp(double t, const functionT& v) {
function print_stats_header (line 508) | void print_stats_header(World& world) {
function print_stats (line 515) | void print_stats(World& world, int step, double t, const functionT& pote...
function complex_functionT (line 550) | complex_functionT wave_function_load(World& world, int step) {
function wave_function_store (line 557) | void wave_function_store(World& world, int step, const complex_functionT...
function wave_function_exists (line 562) | bool wave_function_exists(World& world, int step) {
function loadbal (line 567) | void loadbal(World& world,
function initial_loadbal (line 581) | void initial_loadbal(World& world,
function propagate (line 596) | void propagate(World& world, functionT& pote, functionT& potn, functionT...
function doit (line 690) | void doit(World& world) {
function main (line 783) | int main(int argc, char** argv) {
FILE: src/apps/zcis/zcis.cc
function main (line 49) | int main(int argc, char** argv) {
FILE: src/apps/znemo/znemo.cc
function main (line 49) | int main(int argc, char** argv) {
function main (line 135) | int main() {
FILE: src/examples/3dharmonic.cc
function guess (line 127) | double guess(const coord_3d& r) {
function potential (line 132) | double potential(const coord_3d& r) {
function plot (line 137) | void plot(const char* filename, const real_function_3d& f) {
function energy (line 143) | double energy(World& world, const real_function_3d& phi, const real_func...
function main (line 156) | int main(int argc, char** argv) {
FILE: src/examples/ac_corr.cc
class xc_functor (line 33) | class xc_functor : public FunctionFunctorInterface<double,NDIM>{
method xc_functor (line 36) | xc_functor(){}
method xc_functor (line 37) | xc_functor(std::vector<atom_information<NDIM> > atoms): atoms(atoms){}
method get_distance (line 46) | double get_distance(Vector<double,NDIM> elec, Vector<double,NDIM> nuc)...
method density (line 57) | double density (const Vector<double, NDIM> &r) const{
method xc_potential (line 72) | double xc_potential(const Vector<double, NDIM> &r) const{
function main (line 83) | int main(int argc, char** argv){
FILE: src/examples/array_worldobject.cc
class Array (line 8) | class Array : public WorldObject<Array> {
method Array (line 12) | Array(World& world, size_t size)
method ProcessID (line 19) | ProcessID owner(size_t i) const {return i/v.size();}
method read (line 21) | Future<double> read(size_t i) const {
method write (line 28) | void write(size_t i, double value) {
function main (line 36) | int main(int argc, char** argv) {
FILE: src/examples/binaryop.cc
function delta (line 119) | double delta(const coord_3d& r) {
function uexact (line 124) | double uexact(const coord_3d& r) {
type Uop (line 129) | struct Uop {
method serialize (line 145) | void serialize(Archive& ar) {}
function main (line 148) | int main(int argc, char** argv) {
FILE: src/examples/colloid.cc
function distance1 (line 53) | inline double distance1(const coord_3d& r, const coord_3d& center){
function nuclear_charge_function (line 62) | double nuclear_charge_function(const coord_3d& r) {
function electronic_charge_function (line 68) | double electronic_charge_function(const coord_3d& r) {
function charge_function (line 73) | double charge_function(const coord_3d& r) {
class SurfaceMoleculeInteraction (line 78) | class SurfaceMoleculeInteraction {
type Reciprocal (line 89) | struct Reciprocal {
method serialize (line 93) | void serialize(Archive& ar) {}
type Bop (line 97) | struct Bop {
method serialize (line 110) | void serialize(Archive& ar) {}
method colloid_coords (line 114) | std::vector< madness::Vector<double,3> > colloid_coords()const{
method colloid_radii (line 129) | std::vector<double> colloid_radii()const {
method realfunc (line 138) | realfunc make_surfcharge(const realfunc& u,const realfunc& surface,con...
method realfunc (line 155) | realfunc perturbed_molecular_pot(const realfunc& surface,const realfun...
method SurfaceMoleculeInteraction (line 200) | SurfaceMoleculeInteraction(const double& d, const double& R,const
function main (line 210) | int main(int argc, char **argv) {
FILE: src/examples/compiler/mra-driver.hh
class Exp (line 18) | class Exp
type Type (line 26) | enum Type {
method Exp (line 60) | Exp(const std::string& s, Type t=UNKNOWN)
method Exp (line 65) | Exp(const std::string& s, Exp* left, Type t=UNKNOWN)
method Exp (line 73) | Exp(const std::string& s, Exp* left, Exp*right, Type t=UNKNOWN)
method Exp (line 82) | Exp(const std::string& s, Exp* left, Exp* middle, Exp* right, Type t=U...
method Exp (line 91) | Exp(const std::string& s, Exp* left, Exp* middle, Exp* right, Exp* far...
method Exp (line 100) | Exp* add(Exp* child)
method Exp (line 106) | Exp* add(const std::string& str, Type t=UNKNOWN)
method print_tree (line 111) | void print_tree(std::ostream& file, int depth=0) const {
method match_sub_tree (line 120) | bool match_sub_tree(const Exp* t) const {
method regenerate (line 138) | void regenerate(std::ostream& file) const {
method generate_tex (line 324) | void generate_tex(std::ostream& file) const {
method Exp (line 561) | const Exp* strip_paren() const {
method generate_cxx (line 566) | void generate_cxx(std::ostream& file) const {
method Type (line 916) | Type type() const {
method iterator (line 920) | iterator begin() {
method iterator (line 924) | iterator end() {
method const_iterator (line 928) | const_iterator begin() const {
method const_iterator (line 932) | const_iterator end() const {
method Type (line 937) | static Type funtype(Type t) {
method Type (line 947) | static Type subscrtype(Type t) {
method Type (line 954) | static Type brakettype(Type f, Type g) {
method is_real (line 966) | static bool is_real(Type t) {
method is_complex (line 970) | static bool is_complex(Type t) {
method is_string (line 974) | static bool is_string(Type t) {
method is_tensor (line 978) | static bool is_tensor(Type t) {
method is_integer (line 982) | static bool is_integer(Type t) {
method is_number (line 986) | static bool is_number(Type t) {
method is_unknown (line 990) | static bool is_unknown(Type t) {
method is_pod (line 994) | static bool is_pod(Type t) {
method is_mrafun (line 998) | static bool is_mrafun(Type t) {
method Type (line 1003) | static Type unaryoptype(const std::string& op, Type t) {
method Type (line 1009) | static Type binaryoptype(const std::string& op, Type l, Type r) {
method set_type (line 1033) | void set_type(Type t) {
method Exp (line 1043) | Exp* operator[](int i) const {
class Exp (line 24) | class Exp {
type Type (line 26) | enum Type {
method Exp (line 60) | Exp(const std::string& s, Type t=UNKNOWN)
method Exp (line 65) | Exp(const std::string& s, Exp* left, Type t=UNKNOWN)
method Exp (line 73) | Exp(const std::string& s, Exp* left, Exp*right, Type t=UNKNOWN)
method Exp (line 82) | Exp(const std::string& s, Exp* left, Exp* middle, Exp* right, Type t=U...
method Exp (line 91) | Exp(const std::string& s, Exp* left, Exp* middle, Exp* right, Exp* far...
method Exp (line 100) | Exp* add(Exp* child)
method Exp (line 106) | Exp* add(const std::string& str, Type t=UNKNOWN)
method print_tree (line 111) | void print_tree(std::ostream& file, int depth=0) const {
method match_sub_tree (line 120) | bool match_sub_tree(const Exp* t) const {
method regenerate (line 138) | void regenerate(std::ostream& file) const {
method generate_tex (line 324) | void generate_tex(std::ostream& file) const {
method Exp (line 561) | const Exp* strip_paren() const {
method generate_cxx (line 566) | void generate_cxx(std::ostream& file) const {
method Type (line 916) | Type type() const {
method iterator (line 920) | iterator begin() {
method iterator (line 924) | iterator end() {
method const_iterator (line 928) | const_iterator begin() const {
method const_iterator (line 932) | const_iterator end() const {
method Type (line 937) | static Type funtype(Type t) {
method Type (line 947) | static Type subscrtype(Type t) {
method Type (line 954) | static Type brakettype(Type f, Type g) {
method is_real (line 966) | static bool is_real(Type t) {
method is_complex (line 970) | static bool is_complex(Type t) {
method is_string (line 974) | static bool is_string(Type t) {
method is_tensor (line 978) | static bool is_tensor(Type t) {
method is_integer (line 982) | static bool is_integer(Type t) {
method is_number (line 986) | static bool is_number(Type t) {
method is_unknown (line 990) | static bool is_unknown(Type t) {
method is_pod (line 994) | static bool is_pod(Type t) {
method is_mrafun (line 998) | static bool is_mrafun(Type t) {
method Type (line 1003) | static Type unaryoptype(const std::string& op, Type t) {
method Type (line 1009) | static Type binaryoptype(const std::string& op, Type l, Type r) {
method set_type (line 1033) | void set_type(Type t) {
method Exp (line 1043) | Exp* operator[](int i) const {
class mra_driver (line 1055) | class mra_driver {
method tmpvar (line 1076) | std::string tmpvar() {
method Exp (line 1092) | Exp* add(Exp* statement) {
method insert_before (line 1098) | void insert_before(Exp* e) {
method insert_after (line 1104) | void insert_after(Exp* e) {
method rewrite_sum (line 1110) | void rewrite_sum(Exp* ee) {
method lookup_type (line 1142) | Exp::Type lookup_type(const std::string& s) {
method lookup_type (line 1157) | Exp::Type lookup_type(const Exp* e) {
method insert_sym (line 1161) | void insert_sym(const std::string& how, const std::string& s, Exp::Typ...
method insert_sym (line 1172) | void insert_sym(const std::string& how, const Exp* e) {
method addsyms (line 1181) | void addsyms(const Exp* e, const std::string& type) {
method print_tree (line 1207) | void print_tree(std::ostream& file) const {
method regenerate (line 1212) | void regenerate(std::ostream& file) const {
method generate_tex (line 1241) | void generate_tex(std::ostream& file) const {
method generate_cxx (line 1271) | void generate_cxx(std::ostream& file) {
FILE: src/examples/compiler/mra.cc
function main (line 7) | int
FILE: src/examples/csqrt.cc
function f (line 51) | static std::complex<double> f(const coordT& r)
function csqrt_op (line 57) | inline static void csqrt_op(const Key<1>& key, Tensor< T >& t) {
function main (line 63) | int main(int argc, char** argv)
FILE: src/examples/dataloadbal.cc
class Gaussian (line 141) | class Gaussian : public FunctionFunctorInterface<double,3> {
method Gaussian (line 148) | Gaussian(const coord_3d& center, double exponent, double coefficient)
method special_points (line 172) | std::vector<coord_3d> special_points() const {
function real_functor_3d (line 178) | real_functor_3d random_gaussian() {
type LBCost (line 203) | struct LBCost {
method LBCost (line 206) | LBCost(double leaf_value=1.0, double parent_value=1.0)
function test (line 224) | void test(World& world, bool doloadbal=false) {
function main (line 275) | int main(int argc, char** argv) {
FILE: src/examples/density_smoothing.cc
function main (line 50) | int main(int argc, char** argv) {
FILE: src/examples/derivatives.cc
function gaussian (line 19) | double gaussian(const coord_3d& r) {
function gaussian1 (line 26) | double gaussian1(const coord_3d& r) {
function gaussian2 (line 33) | double gaussian2(const coord_3d& r) {
function gaussian3 (line 40) | double gaussian3(const coord_3d& r) {
function gaussian_energy (line 47) | double gaussian_energy() {
class F (line 60) | class F : public FunctionFunctorInterface<double,3> {
method F (line 65) | F(double(*f)(const coord_3d&), const coord_3d& pt) : f(f), pts(1,pt) {}
method special_points (line 69) | std::vector<coord_3d> special_points() const {return pts;}
function tabulate (line 78) | Tensor<double> tabulate(funcT& f, const std::vector<coord_3d>& pts) {
function make_pts (line 87) | std::vector<coord_3d> make_pts(size_t n, double lo, double hi) {
function plotter1 (line 97) | void plotter1(const std::string& fname, const std::vector<coord_3d>& pts...
function plotter2 (line 116) | void plotter2(const std::string& fname, const std::vector<coord_3d>& pts...
function plotter3 (line 131) | void plotter3(const std::string& fname, const std::vector<coord_3d>& pts...
function test (line 146) | void test(World& world, int k, int initial_level, double thresh, int tru...
function main (line 271) | int main(int argc, char** argv) {
FILE: src/examples/dielectric.cc
function reciprocal (line 198) | double reciprocal(double x) {
function charge_function (line 202) | double charge_function(const coord_3d& r) {
function exact_function (line 208) | double exact_function(const coord_3d& x) {
function main (line 221) | int main(int argc, char **argv) {
FILE: src/examples/dielectric_external_field.cc
function exact_function (line 121) | double exact_function(const coord_3d& x) {
function main (line 133) | int main(int argc, char **argv) {
FILE: src/examples/dirac-hatom.cc
type Uplo (line 15) | enum Uplo {upper, lower}
class DiracParameters (line 29) | class DiracParameters : public QCCalculationParametersBase {
method get_tag (line 31) | std::string get_tag() const override {
method DiracParameters (line 36) | DiracParameters() {
method DiracParameters (line 47) | DiracParameters(World& world, const commandlineparser& parser) : Dirac...
method shift (line 52) | double shift() const {return get<double>("shift");}
method nucrad (line 53) | double nucrad() const {return get<double>("nucrad");}
method charge (line 54) | double charge() const {return get<double>("charge");}
method lo (line 55) | double lo() const {return get<double>("lo");}
method use_ble (line 56) | bool use_ble() const {return get<bool>("use_ble");}
method use_bsp (line 57) | bool use_bsp() const {return get<bool>("use_bsp");}
method nstates (line 58) | long nstates() const {return get<long>("nstates");}
method ansatz (line 59) | long ansatz() const {return get<long>("ansatz");}
function compute_gamma (line 64) | double compute_gamma(const double nuclear_charge) {
type stepfunction (line 68) | struct stepfunction : public FunctionFunctorInterface<double,3> {
method stepfunction (line 70) | stepfunction(const int axis) : axis(axis) {
method Level (line 74) | Level special_level() const final {return 20;}
method special_points (line 75) | std::vector<Vector<double, 3UL>> special_points() const override {
type ncf_cusp (line 81) | struct ncf_cusp {
method ncf_cusp (line 84) | ncf_cusp(double a, double Z) :a(a),Z(Z) {}
type Sigma_ncf_cusp (line 91) | struct Sigma_ncf_cusp {
method Sigma_ncf_cusp (line 94) | Sigma_ncf_cusp(double a, double Z) :a(a),Z(Z) {}
type ncf_singularity (line 103) | struct ncf_singularity {
method ncf_singularity (line 105) | ncf_singularity(double gamma) : gamma(gamma) {}
type ncf (line 112) | struct ncf : public FunctionFunctorInterface<double,3> {
method ncf (line 116) | ncf(double gamma, double a, double Z) : ncfs(gamma), ncfc(a,Z) {}
method Level (line 122) | Level special_level() const final {return 20;}
method special_points (line 123) | std::vector<Vector<double, 3UL>> special_points() const final {
function generalized_laguerre (line 129) | double generalized_laguerre(const double alpha, const long n, const doub...
type SphericalHarmonics (line 140) | struct SphericalHarmonics{
method SphericalHarmonics (line 143) | SphericalHarmonics(const long l, const long m) : l(l), m(m) {
method double_complex (line 148) | double_complex operator()(const coord_3d& xyz) const {
type sgl_guess (line 190) | struct sgl_guess {
method sgl_guess (line 193) | sgl_guess(const long n, const long l, const long m, const double Z) : ...
method double_complex (line 195) | double_complex operator()(const coord_3d& coord) const {
method energy (line 204) | double energy() const {
method complex_function_3d (line 208) | complex_function_3d get_wf(World& world) const {
type Xi (line 222) | struct Xi {
method Xi (line 225) | Xi(const long k, const double m, const double component, const double ...
method compute_a (line 231) | static long compute_a(const double j, const long l) {
method double_complex (line 237) | double_complex operator()(const coord_3d& xyz) const {
type Omega (line 253) | struct Omega {
method Omega (line 256) | Omega(const long k, const double m, const double component) : k(k), co...
method double_complex (line 259) | double_complex operator()(const coord_3d& xyz) const {
function compute_electronic_energy (line 276) | double compute_electronic_energy(const double energy) {
function mask1d (line 282) | double mask1d(double x) {
function mask3d (line 296) | double mask3d(const Vector<double,3>& ruser) {
class MyDerivativeOperator (line 320) | class MyDerivativeOperator : public SCFOperatorBase<T,NDIM> {
method MyDerivativeOperator (line 327) | MyDerivativeOperator(World& world, const int axis1) : world(world), ax...
method set_ble1 (line 328) | void set_ble1() {ble=true;}
method set_bspline1 (line 329) | void set_bspline1() {bsp=true;}
method info (line 331) | std::string info() const {return "D"+std::to_string(axis);}
method functionT (line 333) | functionT operator()(const functionT& ket) const {
method vecfuncT (line 338) | vecfuncT operator()(const vecfuncT& vket) const {
method T (line 347) | T operator()(const functionT& bra, const functionT& ket) const {
method tensorT (line 353) | tensorT operator()(const vecfuncT& vbra, const vecfuncT& vket) const {
class Spinor (line 368) | class Spinor {
method World (line 371) | World& world() const {return components.front().world();}
method Spinor (line 372) | Spinor() {
method Spinor (line 376) | Spinor(World& world) {
method Spinor (line 380) | Spinor(const vector_complex_function_3d& components) : components(comp...
method Spinor (line 382) | Spinor& operator+=(const Spinor& other) {
method Spinor (line 387) | Spinor& operator-=(const Spinor& other) {
method Spinor (line 392) | Spinor operator+(const Spinor& other) const {
method Spinor (line 399) | Spinor operator-(const Spinor& other) const {
method Spinor (line 406) | Spinor& truncate() {
method print_norms (line 415) | void print_norms(std::string text) {
method plot (line 432) | void plot(const std::string filename) const {
method double_complex (line 437) | double_complex inner(const Spinor& bra, const Spinor& ket) {
function Spinor (line 443) | Spinor operator*(const T fac, const Spinor& arg) {
method World (line 371) | World& world() const {return components.front().world();}
method Spinor (line 372) | Spinor() {
method Spinor (line 376) | Spinor(World& world) {
method Spinor (line 380) | Spinor(const vector_complex_function_3d& components) : components(comp...
method Spinor (line 382) | Spinor& operator+=(const Spinor& other) {
method Spinor (line 387) | Spinor& operator-=(const Spinor& other) {
method Spinor (line 392) | Spinor operator+(const Spinor& other) const {
method Spinor (line 399) | Spinor operator-(const Spinor& other) const {
method Spinor (line 406) | Spinor& truncate() {
method print_norms (line 415) | void print_norms(std::string text) {
method plot (line 432) | void plot(const std::string filename) const {
method double_complex (line 437) | double_complex inner(const Spinor& bra, const Spinor& ket) {
function Spinor (line 448) | Spinor operator*(const Spinor& arg, const T fac) {
method World (line 371) | World& world() const {return components.front().world();}
method Spinor (line 372) | Spinor() {
method Spinor (line 376) | Spinor(World& world) {
method Spinor (line 380) | Spinor(const vector_complex_function_3d& components) : components(comp...
method Spinor (line 382) | Spinor& operator+=(const Spinor& other) {
method Spinor (line 387) | Spinor& operator-=(const Spinor& other) {
method Spinor (line 392) | Spinor operator+(const Spinor& other) const {
method Spinor (line 399) | Spinor operator-(const Spinor& other) const {
method Spinor (line 406) | Spinor& truncate() {
method print_norms (line 415) | void print_norms(std::string text) {
method plot (line 432) | void plot(const std::string filename) const {
method double_complex (line 437) | double_complex inner(const Spinor& bra, const Spinor& ket) {
function Spinor (line 453) | Spinor copy(const Spinor& other) {
method World (line 371) | World& world() const {return components.front().world();}
method Spinor (line 372) | Spinor() {
method Spinor (line 376) | Spinor(World& world) {
method Spinor (line 380) | Spinor(const vector_complex_function_3d& components) : components(comp...
method Spinor (line 382) | Spinor& operator+=(const Spinor& other) {
method Spinor (line 387) | Spinor& operator-=(const Spinor& other) {
method Spinor (line 392) | Spinor operator+(const Spinor& other) const {
method Spinor (line 399) | Spinor operator-(const Spinor& other) const {
method Spinor (line 406) | Spinor& truncate() {
method print_norms (line 415) | void print_norms(std::string text) {
method plot (line 432) | void plot(const std::string filename) const {
method double_complex (line 437) | double_complex inner(const Spinor& bra, const Spinor& ket) {
function copy (line 457) | std::vector<Spinor> copy(const std::vector<Spinor>& other) {
function double_complex (line 470) | double_complex inner(const std::vector<Spinor>& bra, const std::vector<S...
function matrix_inner (line 476) | Tensor<double_complex> matrix_inner(const std::vector<Spinor>& bra, cons...
function truncate (line 503) | std::vector<Spinor> truncate(std::vector<Spinor> arg) {
type LProjector (line 508) | struct LProjector {
method LProjector (line 512) | LProjector(World& world) : world(world) {
method analyze (line 523) | void analyze(const Spinor& f, const std::string text="") const {
type spinorallocator (line 550) | struct spinorallocator {
method spinorallocator (line 556) | spinorallocator(World& world, const int n) : world(world), n(n) {
class MatrixOperator (line 568) | class MatrixOperator {
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
class Metric (line 669) | class Metric : public MatrixOperator{
method Spinor (line 672) | virtual Spinor operator()(const Spinor& arg) const {
method print (line 681) | void print() const {
function show_norms (line 687) | void show_norms(const Spinor& bra, const Spinor& ket, const std::string&...
function MatrixOperator (line 693) | MatrixOperator make_Hdiag(World& world, const LocalPotentialOperator<dou...
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
function potn (line 703) | double potn(double r) {
function MatrixOperator (line 710) | MatrixOperator make_Hv(World& world, const double nuclear_charge) {
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
function MatrixOperator (line 721) | MatrixOperator make_sp(World& world) {
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
function MatrixOperator (line 753) | MatrixOperator make_alpha_p(World& world) {
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
function MatrixOperator (line 765) | MatrixOperator make_Hd(World& world, const std::pair<double_complex,std:...
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
function schrodinger2dirac (line 785) | std::vector<Spinor> schrodinger2dirac(const std::vector<complex_function...
function get_fock_transformation (line 809) | Tensor<double_complex> get_fock_transformation(World& world, const std::...
function transform (line 831) | std::vector<Spinor>
function orthonormalize_fock (line 854) | std::vector<Spinor> orthonormalize_fock(const std::vector<Spinor>& arg,
type AnsatzBase (line 876) | struct AnsatzBase {
method filename (line 878) | [[nodiscard]] virtual std::string filename() const {return "ansatz"+th...
method AnsatzBase (line 881) | AnsatzBase(const double Z, const double a) : nuclear_charge(Z), a(a) {}
method normalize (line 886) | virtual void normalize(Spinor& bra, Spinor& ket) const {
method normalize (line 894) | virtual void normalize(Spinor& ket) const {
method normalize (line 899) | virtual void normalize(std::vector<Spinor>& ket) const {
method normalize (line 904) | virtual void normalize(std::vector<Spinor>& bra, std::vector<Spinor>& ...
method MatrixOperator (line 911) | virtual MatrixOperator R(World& world) const {
method MatrixOperator (line 914) | virtual MatrixOperator Rinv(World& world) const {
method make_vbra (line 918) | virtual std::vector<Spinor> make_vbra(const std::vector<Spinor>& ket) ...
method mu (line 925) | [[nodiscard]] virtual double mu(const double energy) const {
method get_cusp_a (line 928) | [[nodiscard]] double get_cusp_a() const {return a;}
type Ansatz0 (line 931) | struct Ansatz0 : public AnsatzBase {
method Ansatz0 (line 934) | Ansatz0(const double nuclear_charge) : AnsatzBase(nuclear_charge,1.0) {
method name (line 939) | [[nodiscard]] std::string name() const {
method Spinor (line 942) | Spinor make_guess(World& world) const {
method MatrixOperator (line 966) | MatrixOperator make_Hv(World& world) const {
method Spinor (line 970) | Spinor make_bra(const Spinor& ket) const {
method MatrixOperator (line 973) | MatrixOperator make_Hd(World& world) const {
method energy (line 981) | double energy() const {
method MatrixOperator (line 985) | MatrixOperator R(World& world) const {
method MatrixOperator (line 990) | MatrixOperator Rinv(World& world) const {
function MatrixOperator (line 998) | MatrixOperator moments(World& world, int axis, int order) {
method MatrixOperator (line 572) | explicit MatrixOperator(const int i=4, const int j=4) {
method nrow (line 577) | std::size_t nrow() const {return elements.size();}
method ncol (line 578) | std::size_t ncol() const {
method Spinor (line 583) | virtual Spinor operator()(const Spinor& arg) const {
method add_submatrix (line 616) | void add_submatrix(int istart, int jstart, const MatrixOperator& subma...
method MatrixOperator (line 626) | MatrixOperator& operator+=(const MatrixOperator& other) {
method MatrixOperator (line 635) | MatrixOperator operator+(const MatrixOperator& other) const {
method add_operator (line 646) | void add_operator(const int i, const int j, const double_complex& fac,...
method print (line 650) | void print(std::string name="") const {
type ExactSpinor (line 1012) | struct ExactSpinor : public FunctionFunctorInterface<double_complex,3> {
method ExactSpinor (line 1019) | ExactSpinor(const int n, const char lc, const double j, const int Z, c...
method ExactSpinor (line 1021) | ExactSpinor(const int n, const int l, const double j, const int Z,cons...
method l_to_string (line 1032) | std::string l_to_string(const long l) const {
method filename (line 1039) | std::string filename() const {
method set_ansatz (line 1044) | void set_ansatz(const AnsatzBase& ansatz) {
method l_char_to_int (line 1050) | static int l_char_to_int(const char lc) {
method Level (line 1061) | Level special_level() const final {return 20;}
method special_points (line 1062) | std::vector<Vector<double, 3UL>> special_points() const final {
method compute_energy (line 1067) | double compute_energy() const {
method compute_C (line 1073) | double compute_C() const {
method compute_en (line 1079) | double compute_en() const {
method get_energy (line 1084) | double get_energy() const {
method print (line 1088) | void print() const {
method double_complex (line 1102) | double_complex operator()(const coord_3d& c) const override {
method double_complex (line 1107) | double_complex Fvalue(const coord_3d& coord) const {
method double_complex (line 1139) | double_complex psivalue(const coord_3d& coord) const {
method double_complex (line 1197) | double_complex angular(const coord_3d& c, const double g, const double...
method Spinor (line 1224) | Spinor get_spinor(World& world) const {
function orthonormalize (line 1242) | void orthonormalize(std::vector<Spinor>& arg, const AnsatzT ansatz) {
function Spinor (line 1265) | Spinor apply_bsh(ansatzT& ansatz, const MatrixOperator& Hd, const Matrix...
method World (line 371) | World& world() const {return components.front().world();}
method Spinor (line 372) | Spinor() {
method Spinor (line 376) | Spinor(World& world) {
method Spinor (line 380) | Spinor(const vector_complex_function_3d& components) : components(comp...
method Spinor (line 382) | Spinor& operator+=(const Spinor& other) {
method Spinor (line 387) | Spinor& operator-=(const Spinor& other) {
method Spinor (line 392) | Spinor operator+(const Spinor& other) const {
method Spinor (line 399) | Spinor operator-(const Spinor& other) const {
method Spinor (line 406) | Spinor& truncate() {
method print_norms (line 415) | void print_norms(std::string text) {
method plot (line 432) | void plot(const std::string filename) const {
method double_complex (line 437) | double_complex inner(const Spinor& bra, const Spinor& ket) {
function apply_mask (line 1313) | void apply_mask(std::vector<Spinor>& v) {
function iterate (line 1322) | std::vector<Spinor> iterate(const std::vector<Spinor>& input, const std:...
function run (line 1392) | void run(World& world, ansatzT ansatz, const int nuclear_charge, const c...
function eigenvector_test (line 1490) | void eigenvector_test(World& world, const ansatzT ansatz, ExactSpinor es) {
function main (line 1547) | int main(int argc, char* argv[]) {
FILE: src/examples/functionio.cc
function function (line 100) | static double function(const coord_3d& r) {
function main (line 107) | int main(int argc, char** argv) {
FILE: src/examples/gaussian.cc
function gaussian (line 59) | double gaussian(const coord_3d& r) {
function main (line 69) | int main(int argc, char** argv) {
FILE: src/examples/gygi_soltion.cc
function nuc_func (line 76) | double nuc_func(const coord_3d& r) {
function rho_func (line 82) | double rho_func(const coord_3d& r){
class GygiPot (line 88) | class GygiPot {
type Reciprocal (line 102) | struct Reciprocal {
method serialize (line 106) | void serialize(Archive& ar) {}
type Pow (line 110) | struct Pow {
method serialize (line 119) | void serialize(Archive& ar) {}
type Pow_beta_one (line 123) | struct Pow_beta_one {
method serialize (line 132) | void serialize(Archive& ar) {}
method realfunc (line 135) | realfunc ratio_rho()const {
method realfunc (line 142) | realfunc rho_beta_one() const {
method realfunc (line 149) | realfunc re_one_plus_ratio_rho() const{
method realfunc (line 155) | realfunc grad_rho(const realfunc& dens) const {
method realfunc (line 162) | realfunc re_grad_rho(const realfunc& dens) const{
method realfunc (line 170) | realfunc epsilon_rho()const {
method realfunc (line 175) | realfunc re_epsilon_rho() const{
method realfunc (line 181) | realfunc depsilon_drho() const {
method cavitation_energy (line 190) | double cavitation_energy() const {
method realfunc (line 197) | realfunc dfree_drho() const {
method realfunc (line 219) | realfunc GuessPotential(World& world) const {
method realfunc (line 226) | realfunc MolecularPotential()const {
method realfunc (line 230) | realfunc depsilon_dr() const {
method realfunc (line 234) | realfunc make_surfcharge(const realfunc& u) const {
method realfunc (line 242) | realfunc ESP(World& world)const {
method realfunc (line 281) | realfunc V_epsilon(const realfunc& u) const {
method realfunc (line 287) | realfunc dESP_drho(const realfunc u) const {
method GygiPot (line 291) | GygiPot(const realfunc& rho,
function main (line 306) | int main(int argc, char **argv){
FILE: src/examples/h2.cc
function guess (line 60) | static double guess(const coord_3d& r) {
function V (line 66) | static double V(const coord_3d& r) {
function iterate (line 72) | void iterate(World& world, real_function_3d& V, real_function_3d& psi, d...
function main (line 88) | int main(int argc, char** argv) {
FILE: src/examples/h2dft.cc
function guess (line 65) | static double guess(const coord_3d& r) {
function V (line 71) | static double V(const coord_3d& r) {
function iterate_ground (line 78) | double iterate_ground(World& world, NonlinearSolver& solver,
function main (line 98) | int main(int argc, char** argv) {
FILE: src/examples/h2dynamic.cc
function guess (line 12) | static double guess(const coord_3d& r) {
function V (line 18) | static double V(const coord_3d& r) {
function rifunction (line 24) | double rifunction(const coord_3d& r) {
function iterate_ground (line 28) | double iterate_ground(World& world, NonlinearSolver& solver, real_functi...
function iterate_excite (line 47) | double iterate_excite(World& world, NonlinearSolver& solver, real_functi...
function iterate_xy (line 63) | double iterate_xy(World& world, real_function_3d& V, real_function_3d& p...
function main (line 94) | int main(int argc, char** argv) {
FILE: src/examples/hatom.cc
function guess (line 13) | static double guess(const coord_3d& r) {
function V (line 22) | static double V(const coord_3d& r) {
function mask1 (line 27) | inline double mask1(double x) {
function mask3 (line 41) | static double mask3(const coord_3d& ruser) {
function iterate (line 64) | void iterate(World& world, real_function_3d& V, real_function_3d& mask, ...
function compute_energy (line 91) | std::tuple<double,double,double> compute_energy(World& world, real_funct...
function run (line 104) | void run(World& world) {
function main (line 140) | int main(int argc, char** argv) {
FILE: src/examples/hatom_1d.cc
function guess (line 53) | static double guess(const coord_1d& r) {
function V (line 59) | static double V(const coord_1d& r) {
function iterate (line 64) | void iterate(World& world, real_function_1d& V, real_function_1d& psi, d...
function main (line 81) | int main(int argc, char** argv) {
FILE: src/examples/hatom_energy.cc
function psi (line 78) | double psi(const Vector<double,3>& r) {
function V (line 82) | double V(const Vector<double,3>& r) {
function main (line 86) | int main(int argc, char**argv) {
FILE: src/examples/hatom_sf_dirac.cc
function mask1 (line 22) | inline double mask1(double x) {
function mask3 (line 27) | static double mask3(const coord_3d& ruser) {
type LBCost (line 51) | struct LBCost {
method LBCost (line 54) | LBCost(double leaf_value=1.0, double parent_value=1.0)
type F (line 66) | struct F {
method F (line 69) | F(const real_function_3d& psi, const real_function_3d& phi)
method F (line 73) | F operator-(const F& b) const {
method F (line 77) | F operator+=(const F& b) { // Operator+= necessarphi
method F (line 82) | F operator*(double a) const { // Scale bphi a constant necessarphi
function inner (line 87) | double inner(const F& a, const F& b) {
type allocator (line 91) | struct allocator {
method allocator (line 94) | allocator(World& world) : world(world) {}
method F (line 96) | F operator()() {
function exact_energy (line 101) | double exact_energy(double Z) {
function psi_guess (line 114) | static double psi_guess(const coord_3d& r) {
function phi_guess (line 122) | static double phi_guess(const coord_3d& r) {
function V (line 130) | static double V(const coord_3d& r) {
class Vderiv (line 136) | class Vderiv : public FunctionFunctorInterface<double,3> {
method Vderiv (line 139) | Vderiv(int axis) : axis(axis) {}
function real_function_3d (line 149) | real_function_3d pVp(World& world, const real_function_3d& V, const real...
function real_function_3d (line 168) | real_function_3d pVp(World& world, const real_function_3d& V, const real...
function compute_energy (line 180) | std::tuple<double,double,double,double> compute_energy(World& world,
function iterate (line 204) | std::tuple<real_function_3d, real_function_3d, double> iterate(World& wo...
function run (line 263) | void run(World& world) {
function main (line 345) | int main(int argc, char** argv) {
FILE: src/examples/he.cc
function u (line 20) | static double u(double r, double c) {
function distances (line 34) | void distances(const coord_6d& r, double& r1, double& r2, double& r12) {
function V (line 45) | static double V(const coord_6d& r) {
type LBCost (line 63) | struct LBCost {
method LBCost (line 66) | LBCost(double leaf_value=1.0, double parent_value=1.0)
type true_op (line 85) | struct true_op {
method serialize (line 90) | void serialize (Archive& ar) {}
function f6d (line 93) | static double f6d(const coord_6d& r) {
class YetAnotherWrapperClass (line 123) | class YetAnotherWrapperClass {
method YetAnotherWrapperClass (line 129) | YetAnotherWrapperClass(const real_function_6d& f)
function real_function_6d (line 153) | real_function_6d multiply_by_V(const real_function_6d& psi) {
function energy (line 159) | double energy(World& world, const real_function_6d& psi) {
function main (line 198) | int main(int argc, char** argv) {
FILE: src/examples/heat.cc
function uinitial (line 80) | static double uinitial(const coordT& r) {
class uexact (line 87) | class uexact : public FunctionFunctorInterface<double,3> {
method uexact (line 90) | uexact(double t) : t(t) {}
function main (line 101) | int main(int argc, char** argv) {
FILE: src/examples/heat2.cc
function uinitial (line 82) | static double uinitial(const coord_3d& r) {
function Vp (line 88) | static double Vp(const coord_3d& r) {
class uexact (line 94) | class uexact : public FunctionFunctorInterface<double,3> {
method uexact (line 97) | uexact(double t) : t(t) {}
type unaryexp (line 110) | struct unaryexp {
method serialize (line 115) | void serialize(Archive& ar) {}
function main (line 118) | int main(int argc, char** argv) {
FILE: src/examples/hedft.cc
function guess (line 67) | static double guess(const coord_3d& r) {
function V (line 72) | static double V(const coord_3d& r) {
function iterate_ground (line 94) | double iterate_ground(World& world, NonlinearSolver& solver,
function main (line 114) | int main(int argc, char** argv) {
FILE: src/examples/hefxc.cc
function guess (line 74) | static double guess(const coord_3d& r) {
function main (line 102) | int main(int argc, char** argv) {
FILE: src/examples/hehf.cc
function guess (line 104) | static double guess(const coord_3d& r) {
function V (line 109) | static double V(const coord_3d& r) {
function iterate (line 114) | void iterate(World& world, real_function_3d& V, real_function_3d& psi, d...
function main (line 130) | int main(int argc, char** argv) {
FILE: src/examples/helium_exact.cc
function real_function_6d (line 69) | real_function_6d apply_U_mix(World& world, const real_function_6d& psi,
function real_function_6d (line 109) | real_function_6d apply_U_ncf(World& world, const real_function_6d& psi,
function real_function_6d (line 155) | real_function_6d apply_V(World& world, const real_function_6d& psi, cons...
function real_function_6d (line 174) | real_function_6d apply_U_ecf(World& world, const real_function_6d& psi,
function real_function_6d (line 184) | real_function_6d reconstruct_psi(World& world, const real_function_6d& psi,
function real_function_6d (line 217) | real_function_6d compute_R2f2_psi(World& world, const real_function_6d& ...
function compute_energy_with_U (line 251) | double compute_energy_with_U(World& world, const real_function_6d& psi,
function compute_energy (line 284) | double compute_energy(World& world, const real_function_6d& psi,
function save (line 364) | void save(World& world, const real_function_6d& f, std::string filename) {
function load (line 369) | void load(World& world, real_function_6d& f, std::string filename) {
function test_U_el (line 375) | void test_U_el(World& world, const real_function_6d& psi,
function main (line 436) | int main(int argc, char** argv) {
FILE: src/examples/helium_mp2.cc
function guess (line 70) | static double guess(const coord_3d& r) {
function V (line 75) | static double V(const coord_3d& r) {
function HO_3d (line 80) | static double HO_3d(const coord_3d& r) {
function HO_6d (line 85) | static double HO_6d(const coord_6d& r) {
function gauss_3d (line 97) | static double gauss_3d(const coord_3d& r) {
function gauss_6d (line 104) | static double gauss_6d(const coord_6d& r) {
function HO_vphi_3d (line 117) | static double HO_vphi_3d(const coord_3d& r) {
function Z2 (line 124) | static double Z2(const coord_3d& r) {
function Z1 (line 129) | static double Z1(const coord_3d& r) {
function V_1 (line 135) | static double V_1(const coord_6d& r) {
function u (line 153) | static double u(double r, double c) {
function distances (line 167) | void distances(const coord_6d& r, double& r1, double& r2, double& r12) {
function V (line 176) | static double V(const coord_6d& r) {
function coul (line 183) | static double coul(const coord_6d& r) {
function helium_pot (line 204) | static double helium_pot(const coord_6d& r) {
function V_times_phi (line 223) | static double V_times_phi(const coord_6d& r) {
function h_orbital (line 245) | static double h_orbital(const coord_3d& r) {
function he_plus_orbital (line 251) | static double he_plus_orbital(const coord_3d& r) {
function he_orbital_3d (line 256) | static double he_orbital_3d(const coord_3d& r) {
function he_orbital_McQuarrie (line 273) | static double he_orbital_McQuarrie(const coord_3d& r) {
function he_orbitals (line 289) | static double he_orbitals(const coord_6d& r) {
function hylleraas_3term (line 308) | static double hylleraas_3term(const coord_6d& r) {
function he_correlation (line 331) | static double he_correlation(const coord_6d& r) {
class YetAnotherWrapperClass (line 337) | class YetAnotherWrapperClass {
method YetAnotherWrapperClass (line 347) | YetAnotherWrapperClass(const real_function_6d& f)
function real_function_6d (line 393) | real_function_6d multiply_by_V(const real_function_6d& psi) {
function save_function (line 400) | void save_function(World& world, const Function<double,NDIM>& pair, cons...
function load_function (line 407) | void load_function(World& world, Function<double,NDIM>& pair, const std:...
type LBCost (line 415) | struct LBCost {
method LBCost (line 418) | LBCost(double leaf_value=1.0, double parent_value=1.0)
type true_op (line 447) | struct true_op {
method serialize (line 452) | void serialize (Archive& ar) {}
type true_if_n_gt_op (line 456) | struct true_if_n_gt_op {
method true_if_n_gt_op (line 458) | true_if_n_gt_op() : _l(100) {}
method true_if_n_gt_op (line 459) | true_if_n_gt_op(const int level) : _l(level) {}
method serialize (line 464) | void serialize (Archive& ar) {}
function simpt2key (line 468) | Key<6> simpt2key(const Vector<double,6>& pt, Level n) {
function iterate (line 501) | void iterate(World& world, real_function_6d& Vpsi, real_function_6d& psi...
function iterate (line 534) | void iterate(World& world, const real_function_3d& V, real_function_3d& ...
function compute_energy (line 584) | void compute_energy(World& world, const real_function_3d& psi, const rea...
function compute_energy (line 606) | void compute_energy(World& world, const real_function_6d& pair,
function solve (line 663) | void solve(World& world, real_function_6d& pair, double& energy, long ma...
function test_modified (line 777) | void test_modified(World& world) {
function test_recursive_application (line 826) | void test_recursive_application(World& world) {
function test_adaptive_tree (line 908) | void test_adaptive_tree(World& world, const bool restart, const std::str...
function test_truncation (line 1013) | void test_truncation(World& world) {
function test_compress (line 1042) | void test_compress(World& world) {
function main (line 1087) | int main(int argc, char** argv) {
FILE: src/examples/hello.cc
function main (line 48) | int main(int argc, char** argv) {
FILE: src/examples/madinfo.cc
function main (line 13) | int main() {
FILE: src/examples/molecularmask.h
function distance (line 10) | inline double distance(const madness::coord_3d& a, const madness::coord_...
function class (line 18) | class MolecularMaskBase {
FILE: src/examples/molecularsurface.cc
function area_two_spheres (line 18) | double area_two_spheres(double r1, double r2, double d) {
function volume_two_spheres (line 24) | double volume_two_spheres(double r1, double r2, double d) {
function main (line 31) | int main(int argc, char **argv) {
FILE: src/examples/navstokes_cosines.cc
type FunctorInterfaceWrapper (line 110) | struct FunctorInterfaceWrapper : public FunctionFunctorInterface<double,...
method FunctorInterfaceWrapper (line 113) | FunctorInterfaceWrapper(double (*f)(const coordT&)) : f(f) {}
function diff (line 119) | static Function<T,NDIM> diff(const Function<T,NDIM>& f, int axis) {
function init_zero (line 126) | static double init_zero(const coordT3d& r) {
function uxexact (line 132) | static double uxexact(const coordT3d& r) {
function uyexact (line 142) | static double uyexact(const coordT3d& r) {
function uzexact (line 151) | static double uzexact(const coordT3d& r) {
function fxexact (line 160) | static double fxexact(const coordT3d& r)
function fyexact (line 169) | static double fyexact(const coordT3d& r)
function fzexact (line 179) | static double fzexact(const coordT3d& r)
function pexact (line 190) | static double pexact(const coordT3d& r) {
function functionT (line 202) | inline functionT div(const functT& uint) {
function functionT (line 207) | inline functionT lap(const functionT& uint) {
function adv (line 215) | void adv(const myfun& uu, myfun& advu) {
function myfun (line 219) | inline myfun operator-(const myfun& l, const myfun& r) { return sub(*pwo...
function testNavierStokes (line 221) | void testNavierStokes(int argc, char**argv) {
function main (line 368) | int main(int argc, char**argv) {
FILE: src/examples/newsolver.cc
function guess (line 12) | static double guess(const coord_3d& r) {
function V (line 18) | static double V(const coord_3d& r) {
function rifunction (line 24) | double rifunction(const coord_3d& r) {
function iterate_ground (line 28) | double iterate_ground(World& world, NonlinearSolver& solver,
function iterate_excite (line 48) | double iterate_excite(World& world, NonlinearSolver& solver,
type F (line 70) | struct F {
method F (line 73) | F(const real_function_3d& x, const real_function_3d& y)
method F (line 77) | F operator-(const F& b) const {
method F (line 81) | F operator+=(const F& b) { // Operator+= necessary
method F (line 86) | F operator*(double a) const { // Scale by a constant necessary
function inner (line 91) | double inner(const F& a, const F& b) {
type allocator (line 98) | struct allocator {
method allocator (line 101) | allocator(World& world) : world(world) {}
method F (line 103) | F operator()() {
function iterate_xy (line 122) | double iterate_xy(World& world, solverT& solver, const real_function_3d& V,
function main (line 154) | int main(int argc, char** argv) {
FILE: src/examples/newsolver_lda.cc
function make_dft_energy (line 119) | double make_dft_energy(World & world, const vecfuncT& vf, int ispin)
function functionT (line 125) | functionT make_dft_potential(World & world, const vecfuncT& vf, int ispi...
function functionT (line 130) | functionT make_dft_kernel(World & world, const vecfuncT& vf, int ispin, ...
function guess (line 147) | static double guess(const coord_3d& r) {
function V (line 155) | static double V(const coord_3d& r) {
function rifunction (line 160) | double rifunction(const coord_3d& r) {
function iterate_ground (line 164) | double iterate_ground(World& world, NonlinearSolver& solver,
function iterate_excite (line 184) | double iterate_excite(World& world, NonlinearSolver& solver,
function main (line 305) | int main(int argc, char** argv) {
FILE: src/examples/nonlinschro.cc
function munge (line 130) | double munge(double x, double xmin, double xmax) {
function Vdynamic (line 153) | static void Vdynamic(const Key<1> & key, Tensor<T>& t)
function Vstatic (line 163) | static double Vstatic(const coord_1d& r) {
function guess (line 168) | static double guess(const coord_1d& r) {
function real_function_1d (line 173) | real_function_1d make_potential(World& world, const real_function_1d& rh...
function iterate (line 180) | void iterate(World& world, real_function_1d& psi) {
function main (line 209) | int main(int argc, char** argv) {
FILE: src/examples/pcr.cc
class Gaussian (line 67) | class Gaussian : public FunctionFunctorInterface<double, 3> {
method Gaussian (line 74) | Gaussian(const coord_3d ¢er, double exponent, double coefficient)
method special_points (line 98) | std::vector<coord_3d> special_points() const { return specialpt; }
function real_functor_3d (line 103) | real_functor_3d random_gaussian() {
function random_gaussians (line 121) | std::vector<real_function_3d> random_gaussians(size_t n, World &world) {
function test (line 129) | void test(World &world) {
function main (line 156) | int main(int argc, char **argv) {
FILE: src/examples/periodic/erfcr.cc
function make_fit (line 10) | std::pair<std::vector<double>,std::vector<double>>
function main (line 64) | int main() {
FILE: src/examples/periodic/test.cc
function main (line 24) | int main() {
FILE: src/examples/periodic/testfilter.cc
function gaussian_3d (line 6) | static double gaussian_3d(const madness::coord_3d& r, const double expnt) {
function rho_electronic_3d (line 12) | static double rho_electronic_3d(const madness::coord_3d& r) { return gau...
function rho_nuclear_3d (line 13) | static double rho_nuclear_3d(const madness::coord_3d& r) { return -gauss...
function rho_gaussian_func_3d (line 15) | static double rho_gaussian_func_3d(const madness::coord_3d& r) {
function filter_moments_inplace (line 21) | void filter_moments_inplace(madness::Function<T,NDIM>& f, const int k, c...
function main (line 67) | int main(int argc, char**argv) {
FILE: src/examples/periodic/testfuns.cc
function erfaroverr (line 9) | double erfaroverr(double a, double r) {
function solve (line 22) | std::vector<double> solve(size_t m, size_t n, const std::vector<double>&...
function fit (line 36) | std::vector<double> fit(size_t m, size_t n, const std::vector<double> N,...
function tabulate (line 51) | std::vector<double> tabulate(double(*f)(double, double, double), std::ve...
function periodic_sum (line 67) | double periodic_sum(double x, double y, double z, double(*f)(double, dou...
function periodic_sum_partial (line 81) | std::vector<double> periodic_sum_partial(double x, double y, double z, d...
function periodic_sum_accelerated (line 104) | double periodic_sum_accelerated(double x, double y, double z, double(*f)...
function distancesq (line 116) | double distancesq(double x, double y, double z, double x0, double y0, do...
function f_spheropole (line 126) | double f_spheropole(double x, double y, double z) {
function exact_spheropole (line 134) | double exact_spheropole(double x, double y, double z) {
function f_dipole (line 144) | double f_dipole(double x, double y, double z) {
function exact_dipoleX (line 152) | double exact_dipoleX(double x, double y, double z) {
function opposing_field_potential (line 163) | double opposing_field_potential(double x, double y, double z) {
function exact_dipole (line 170) | double exact_dipole(double x, double y, double z) {
function f_quadrupole (line 176) | double f_quadrupole(double x, double y, double z) {
function exact_quadrupoleX (line 186) | double exact_quadrupoleX(double x, double y, double z) {
function exact_quadrupole (line 201) | double exact_quadrupole(double x, double y, double z) {
function f_cosine (line 212) | double f_cosine(double x, double y, double z) {
function exact_cosine (line 216) | double exact_cosine(double x, double y, double z) {
function linspace (line 221) | std::vector<double> linspace(double a, double b, size_t n, bool include_...
function set_test_case (line 230) | void set_test_case(int test_case) {
FILE: src/examples/periodic/testpercoul.cc
function unit_func3d (line 14) | static double unit_func3d(const madness::coord_3d& r)
function gdiffuse_000_func3d (line 20) | static double gdiffuse_000_func3d(const madness::coord_3d& r)
function gtight_000_func3d (line 30) | static double gtight_000_func3d(const madness::coord_3d& r)
function gdiffuse_001_func3d (line 40) | static double gdiffuse_001_func3d(const madness::coord_3d& r)
function gdiffuse_00m1_func3d (line 50) | static double gdiffuse_00m1_func3d(const madness::coord_3d& r)
function gtight_00m1_func3d (line 60) | static double gtight_00m1_func3d(const madness::coord_3d& r)
function kth_moment_func3d (line 71) | static double kth_moment_func3d(const madness::coord_3d& r) {
function r2_func3d (line 79) | static double r2_func3d(const madness::coord_3d& r) {
function filter_moments_inplace (line 92) | void filter_moments_inplace(madness::Function<T,NDIM>& f, const int k, c...
function main (line 141) | int main(int argc, char**argv) {
FILE: src/examples/ploterr.cc
function myf (line 5) | double myf(const coord_1d& r) {
function main (line 9) | int main(int argc, char** argv) {
FILE: src/examples/sdf_shape_tester.cc
function main (line 61) | int main(int argc, char **argv) {
FILE: src/examples/siam_example.cc
class DSphere (line 68) | class DSphere : public FunctionFunctorInterface<double, 3> {
method dmask (line 78) | double dmask(double s) const {
method DSphere (line 89) | DSphere(double Vint, double Vext, int axis)
function rho_function (line 107) | double rho_function(const coord_3d &r) {
function main (line 117) | int main(int argc, char **argv) {
FILE: src/examples/sininteg.cc
function myf (line 53) | double myf(const coord_1d& r) {
function main (line 57) | int main(int argc, char** argv) {
FILE: src/examples/smooth.h
function namespace (line 21) | namespace madness {
type asymptotic_density (line 98) | struct asymptotic_density {
type asymptotic_slater_kernel (line 118) | struct asymptotic_slater_kernel {
type slater_kernel (line 135) | struct slater_kernel {
type slater_kernel_apply (line 246) | struct slater_kernel_apply {
function else (line 262) | struct density_mask_operator {
function else (line 286) | struct merging_operator {
function make_radius (line 307) | static double make_radius(const Vector<double, NDIM>& x) {
type inv_mask_functor (line 365) | struct inv_mask_functor {
function get_density_thresh (line 496) | double get_density_thresh() const {
function gauss_norm (line 622) | double gauss_norm(const double& exponent) const {
function output (line 626) | void output(const std::string& msg) const {
FILE: src/examples/spectralprop.h
function namespace (line 92) | namespace madness {
function class (line 259) | class SpectralPropagatorGaussLobatto {
FILE: src/examples/svpe.cc
function reciprocal (line 61) | double reciprocal(double x) {
function nuclear_charge_function (line 65) | double nuclear_charge_function(const coord_3d& r) {
function electronic_charge_function (line 71) | double electronic_charge_function(const coord_3d& r) {
function charge_function (line 76) | double charge_function(const coord_3d& r) {
class SVPESolver (line 80) | class SVPESolver {
method SVPESolver (line 121) | SVPESolver(World& world,
method real_function_3d (line 152) | real_function_3d make_surface_charge(const real_function_3d& u) const {
method real_function_3d (line 160) | real_function_3d solve(const real_function_3d& rho,
function main (line 198) | int main(int argc, char **argv) {
FILE: src/examples/tdse1d.cc
function complex_function_1d (line 121) | complex_function_1d APPLY(complex_operatorT* q1d, const complex_function...
type refop (line 172) | struct refop {
method serialize (line 179) | void serialize(Archive& ar) {}
function atom_position (line 184) | double atom_position() {
function double_complex (line 189) | double_complex psi_exact(const coord_1d& r) {
function V (line 206) | double V(const coord_1d& r) {
function dVsq (line 214) | double dVsq(const coord_1d& r) {
type unaryexp (line 224) | struct unaryexp {
method serialize (line 229) | void serialize(Archive& ar) {}
function complex_function_1d (line 233) | complex_function_1d expV(World& world, double vcoeff, double dcoeff) {
function complex_function_1d (line 251) | complex_function_1d sympgrad4(World& world,
function complex_function_1d (line 278) | complex_function_1d sympgrad6(World& world,
function complex_function_1d (line 322) | complex_function_1d trotter(World& world, const complex_function_1d& psi...
function print_info (line 340) | void print_info(World& world, const complex_function_1d& psi, int step) {
function readin (line 362) | static void readin(int np) {
function icoeff (line 369) | double icoeff(const int np, const int j, const double t) {
function T (line 377) | T myp(const std::vector<T>& ps, const double t) {
function complex_function_1d (line 385) | complex_function_1d q_c(World& world, const int np, const complex_functi...
function main (line 467) | int main(int argc, char** argv) {
FILE: src/examples/tdse_example.cc
function smoothed_potential (line 69) | static double smoothed_potential(double r) {
function V (line 85) | static double V(const coordT& r) {
function guess (line 92) | static double guess(const coordT& r) {
function zdipole (line 98) | double zdipole(const coordT& r) {
function laser (line 103) | double laser(double t) {
function energy (line 111) | double energy(World& world, const Function<T,3>& psi, const functionT& p...
type unaryexp (line 132) | struct unaryexp {
method serialize (line 137) | void serialize(Archive& ar) {}
function lbcost (line 141) | double lbcost(const Key<NDIM>& key, const FunctionNode<T,NDIM>& node) {
function load_balance (line 147) | void load_balance(World& world, const madness::Function<T,NDIM>& psi) {
function converge (line 155) | void converge(World& world, functionT& potn, functionT& psi, double& eps) {
function propagate (line 207) | void propagate(World& world, functionT& potn, functionT& psi0, double& e...
function main (line 286) | int main(int argc, char** argv) {
FILE: src/examples/test_derivative.cc
class F (line 7) | class F : public FunctionFunctorInterface<double,1>
method F (line 13) | F(int n) : n(n) {}
class G (line 23) | class G : public FunctionFunctorInterface<double,1>
method G (line 30) | G(int n, double p) : n(n), p(p) {}
function main (line 39) | int main(int argc,char** argv)
FILE: src/examples/test_gmres.cc
class RealVecIdentOp (line 55) | class RealVecIdentOp : public Operator<Vector<double, 3> > {
method action (line 57) | void action(const Vector<double, 3> &invec, Vector<double, 3> &outvec)
class RealVecLinearOp (line 67) | class RealVecLinearOp : public Operator<Vector<double, 3> > {
method action (line 69) | void action(const Vector<double, 3> &invec, Vector<double, 3> &outvec)
class ComplexVecIdentOp (line 79) | class ComplexVecIdentOp : public Operator<Vector<std::complex<double>, 3...
method action (line 81) | void action(const Vector<std::complex<double>, 3> &invec,
class ComplexVecLinearOp (line 89) | class ComplexVecLinearOp : public Operator<Vector<std::complex<double>, ...
method action (line 91) | void action(const Vector<std::complex<double>, 3> &invec,
class RealFuncIdentOp (line 107) | class RealFuncIdentOp : public Operator<Function<double, 3> > {
method action (line 109) | void action(const Function<double, 3> &invec,
class RealFuncLinearOp (line 118) | class RealFuncLinearOp : public Operator<Function<double, 3> > {
method action (line 122) | void action(const Function<double, 3> &invec,
method RealFuncLinearOp (line 131) | RealFuncLinearOp(const Function<double, 3> &_b) : b(_b) {}
class ComplexFuncIdentOp (line 135) | class ComplexFuncIdentOp : public Operator<Function<std::complex<double>...
method action (line 137) | void action(const Function<std::complex<double>, 3> &invec,
class ComplexFuncLinearOp (line 146) | class ComplexFuncLinearOp : public Operator<Function<std::complex<double...
method action (line 150) | void action(const Function<std::complex<double>, 3> &invec,
method ComplexFuncLinearOp (line 159) | ComplexFuncLinearOp(const Function<std::complex<double>, 3> &_b) : b(_...
function main (line 185) | int main(int argc, char **argv) {
function realvec0 (line 246) | bool realvec0() {
function realvec1 (line 265) | bool realvec1() {
function realvec2 (line 284) | bool realvec2() {
function cplxvec0 (line 304) | bool cplxvec0() {
function cplxvec1 (line 323) | bool cplxvec1() {
function cplxvec2 (line 342) | bool cplxvec2() {
function magfunc (line 364) | static double magfunc(const Vector<double, 3> &pt) {
function zmagfunc (line 368) | static std::complex<double> zmagfunc(const Vector<double, 3> &pt) {
function invert (line 374) | inline static void invert(const Key<3> &key, Tensor<T> &t) {
function realfunc0 (line 380) | bool realfunc0() {
function realfunc1 (line 397) | bool realfunc1() {
function realfunc2 (line 415) | bool realfunc2() {
function cplxfunc0 (line 442) | bool cplxfunc0() {
function cplxfunc1 (line 459) | bool cplxfunc1() {
function cplxfunc2 (line 477) | bool cplxfunc2() {
FILE: src/examples/testcomplexfunctionsolver.cc
class F (line 14) | class F
method F (line 21) | F(const functionT& x) : x(copy(x)) {}
method F (line 23) | F() : x(allocator().x) {}
method F (line 25) | F(const F& a) : x(copy(a.x)) {}
method F (line 27) | F operator=(const F& f) { // Assignment required for storage in vector
method F (line 34) | F operator-(const F& b) const { // Operator- necessary
method F (line 38) | F& operator+=(const F& b) { // Operator+= necessary
method F (line 43) | F operator*(const dataT& a) const { // Scale by a constant necessary
method functionT (line 47) | const functionT& get() const {return x;}
class F (line 17) | class F {
method F (line 21) | F(const functionT& x) : x(copy(x)) {}
method F (line 23) | F() : x(allocator().x) {}
method F (line 25) | F(const F& a) : x(copy(a.x)) {}
method F (line 27) | F operator=(const F& f) { // Assignment required for storage in vector
method F (line 34) | F operator-(const F& b) const { // Operator- necessary
method F (line 38) | F& operator+=(const F& b) { // Operator+= necessary
method F (line 43) | F operator*(const dataT& a) const { // Scale by a constant necessary
method functionT (line 47) | const functionT& get() const {return x;}
function F (line 52) | F allocator() {
method F (line 21) | F(const functionT& x) : x(copy(x)) {}
method F (line 23) | F() : x(allocator().x) {}
method F (line 25) | F(const F& a) : x(copy(a.x)) {}
method F (line 27) | F operator=(const F& f) { // Assignment required for storage in vector
method F (line 34) | F operator-(const F& b) const { // Operator- necessary
method F (line 38) | F& operator+=(const F& b) { // Operator+= necessary
method F (line 43) | F operator*(const dataT& a) const { // Scale by a constant necessary
method functionT (line 47) | const functionT& get() const {return x;}
function dataT (line 57) | dataT inner(const F& a, const F& b) {
function residualx (line 65) | void residualx(const Key<N>& key, Tensor<dataT>& t) {
function F (line 69) | F residual(const F& f) {
method F (line 21) | F(const functionT& x) : x(copy(x)) {}
method F (line 23) | F() : x(allocator().x) {}
method F (line 25) | F(const F& a) : x(copy(a.x)) {}
method F (line 27) | F operator=(const F& f) { // Assignment required for storage in vector
method F (line 34) | F operator-(const F& b) const { // Operator- necessary
method F (line 38) | F& operator+=(const F& b) { // Operator+= necessary
method F (line 43) | F operator*(const dataT& a) const { // Scale by a constant necessary
method functionT (line 47) | const functionT& get() const {return x;}
function main (line 75) | int main(int argc, char** argv) {
FILE: src/examples/testspectralprop.cc
class Fred (line 7) | class Fred
method Fred (line 40) | Fred(double a, double b, double c)
method set (line 42) | void set(int i, double a) {v[i] = a;}
method get (line 43) | double get(int i) const {return v[i];}
method Fred (line 48) | Fred(const Fred& f) : v(f.v) {}
method Fred (line 51) | Fred& operator=(const Fred& f) {
method Fred (line 57) | Fred& operator+=(const Fred& f) {
method Fred (line 63) | Fred operator*(const double& d) const {
type madness (line 8) | namespace madness {
function distance (line 72) | double distance(const Fred& a, const Fred& b)
function distance (line 230) | double distance(madness::Function<std::complex<double>, 1ul>& a, madne...
class Fred (line 32) | class Fred {
method Fred (line 40) | Fred(double a, double b, double c)
method set (line 42) | void set(int i, double a) {v[i] = a;}
method get (line 43) | double get(int i) const {return v[i];}
method Fred (line 48) | Fred(const Fred& f) : v(f.v) {}
method Fred (line 51) | Fred& operator=(const Fred& f) {
method Fred (line 57) | Fred& operator+=(const Fred& f) {
method Fred (line 63) | Fred operator*(const double& d) const {
type madness (line 70) | namespace madness {
function distance (line 72) | double distance(const Fred& a, const Fred& b)
function distance (line 230) | double distance(madness::Function<std::complex<double>, 1ul>& a, madne...
function expL_double (line 90) | double expL_double(double dt, double u) {
function N_double (line 94) | double N_double(double t, const double u) {
function Fred (line 98) | Fred expL(double dt, const Fred& f) {
method Fred (line 40) | Fred(double a, double b, double c)
method set (line 42) | void set(int i, double a) {v[i] = a;}
method get (line 43) | double get(int i) const {return v[i];}
method Fred (line 48) | Fred(const Fred& f) : v(f.v) {}
method Fred (line 51) | Fred& operator=(const Fred& f) {
method Fred (line 57) | Fred& operator+=(const Fred& f) {
method Fred (line 63) | Fred operator*(const double& d) const {
function Fred (line 104) | Fred N(double t, const Fred& f) {
method Fred (line 40) | Fred(double a, double b, double c)
method set (line 42) | void set(int i, double a) {v[i] = a;}
method get (line 43) | double get(int i) const {return v[i];}
method Fred (line 48) | Fred(const Fred& f) : v(f.v) {}
method Fred (line 51) | Fred& operator=(const Fred& f) {
method Fred (line 57) | Fred& operator+=(const Fred& f) {
method Fred (line 63) | Fred operator*(const double& d) const {
function exact (line 110) | double exact(double t, double u0) {
function test0 (line 114) | void test0(World& world) {
function test0GaussLobatto (line 146) | void test0GaussLobatto(World& world) {
function test1 (line 166) | void test1(World& world) {
type madness (line 228) | namespace madness {
function distance (line 72) | double distance(const Fred& a, const Fred& b)
function distance (line 230) | double distance(madness::Function<std::complex<double>, 1ul>& a, madne...
function atom_position (line 255) | double atom_position(double current_time) {
class PsiExact (line 259) | class PsiExact : public FunctionFunctorInterface<double_complex,1>
method PsiExact (line 264) | PsiExact(double current_time)
method double_complex (line 270) | double_complex operator()(const coord_1d& r) const {
class Vnuclear (line 288) | class Vnuclear : public FunctionFunctorInterface<double,1>
method Vnuclear (line 292) | Vnuclear(double current_time) : atom_x(atom_position(current_time)) {}
function complex_function_1d (line 303) | complex_function_1d APPLY(complex_operatorT* q1d, const complex_function...
function complex_operatorT (line 317) | complex_operatorT* MAKE_PROPAGATOR(World& world, double t)
function find_fuzzy (line 323) | std::pair<bool, T> find_fuzzy(double t, const std::vector< std::pair<dou...
function complex_operatorT (line 333) | complex_operatorT* G(World& world, double dt) {
function real_function_1d (line 347) | real_function_1d vnuc(World& world, double t) {
function complex_function_1d (line 360) | complex_function_1d applyexpLt(double dt, const complex_function_1d& u) {
function complex_function_1d (line 365) | complex_function_1d applyN(double t, const complex_function_1d& u) {
function print_info (line 369) | void print_info(World& world, double current_time, const complex_functio...
function test2 (line 391) | void test2(World& world) {
function main (line 438) | int main(int argc, char** argv) {
FILE: src/examples/testttg.cc
class Gaussian (line 44) | class Gaussian : public FunctionFunctorInterface<double,3> {
method Gaussian (line 51) | Gaussian(const coord_3d& center, double exponent, double coefficient)
class LevelPmapX (line 80) | class LevelPmapX : public WorldDCPmapInterface<Key<3>> {
method LevelPmapX (line 84) | LevelPmapX() : nproc(0) {}
method LevelPmapX (line 86) | LevelPmapX(World& world) : nproc(world.nproc()) {}
method ProcessID (line 89) | ProcessID owner(const Key<3>& key) const {
class PartitionPmap (line 100) | class PartitionPmap : public WorldDCPmapInterface<Key<3>> {
method PartitionPmap (line 105) | PartitionPmap()
method PartitionPmap (line 111) | PartitionPmap(size_t nproc, const Level target_level=0)
method ProcessID (line 128) | ProcessID owner(const Key<3>& key) const {
function test2 (line 141) | void test2(World& world, size_t nfunc, size_t k, double thresh) {
function main (line 240) | int main(int argc, char** argv) {
FILE: src/examples/tiny.cc
type madness (line 55) | namespace madness{
function load_function (line 59) | void load_function(World& world, Function<double,NDIM>& pair, const std:...
function save_function (line 76) | void save_function(World& world, Function<double,NDIM>& pair, const std:...
function draw_line (line 89) | void draw_line(World& world, Function<double,NDIM>& pair, const std::str...
function draw_circle (line 104) | void draw_circle(World& world, Function<double,NDIM>& pair, const std::s...
function dostuff (line 115) | void dostuff(World& world) {
function main (line 168) | int main(int argc, char** argv) {
FILE: src/examples/vnucso.cc
type Guess (line 98) | struct Guess : FunctionFunctorInterface<double_complex,3> {
method Guess (line 103) | Guess(double z, double exponent, int nx, int ny, int nz)
method double_complex (line 106) | double_complex operator()(const coordT& r) const {
function V (line 116) | static double V(const coordT& r)
function moments (line 126) | void moments(World& world, const std::vector<complex_functionT>& u, cons...
function gaxpy1 (line 150) | void gaxpy1(World& world,
function make_bsh_operators (line 165) | std::vector<poperatorT> make_bsh_operators(World& world, const Tensor<do...
function hamiltonian_matrix (line 178) | Tensor<double_complex> hamiltonian_matrix(World& world,
function apply_potential (line 198) | void apply_potential(World& world,
function normalize2 (line 251) | void normalize2(World& world, std::vector<complex_functionT>& u, std::ve...
function doit (line 267) | void doit(World& world) {
function main (line 526) | int main(int argc, char** argv) {
FILE: src/examples/vtk.cc
function doplotptk (line 38) | void doplotptk(World& world, int step, const functionT& psi, double Lplo...
function plotvtk (line 49) | void plotvtk(const Function<T,NDIM>& function,
FILE: src/examples/writecoeff.cc
function f (line 20) | static std::complex<double> f(const coordT& r)
class WriteCoeffImpl (line 26) | class WriteCoeffImpl : public Mutex {
method WriteCoeffImpl (line 30) | WriteCoeffImpl(const int k, std::ostream& out)
class WriteCoeff (line 42) | class WriteCoeff {
method WriteCoeff (line 46) | WriteCoeff(const int k, std::ostream& out)
function main (line 57) | int main(int argc, char** argv)
FILE: src/examples/writecoeff2.cc
function dataT (line 22) | static dataT f(const coordT &r) {
function write_function_coeffs (line 28) | void write_function_coeffs(const Function<T, NDIM> &f, std::ostream &out...
function count_leaf_nodes (line 52) | size_t count_leaf_nodes(const Function<T, NDIM> &f) {
function write_function (line 65) | void write_function(const Function<T, NDIM> &f, std::ostream &out) {
function read_function_coeffs (line 93) | void read_function_coeffs(Function<T, NDIM> &f, std::istream &in) {
function read_function (line 119) | Function<T, NDIM> read_function(World &world, std::istream &in) {
function test (line 143) | void test(World &world) {
function main (line 168) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/FunctionIO.h
function simple_pow (line 8) | constexpr int simple_pow(int a, int b) {
function FunctionIO (line 20) | size_t NDIM> class FunctionIO {
function write_function_coeffs (line 41) | static void write_function_coeffs(const Function<T, NDIM> &f,
function write_function (line 75) | static void write_function(const Function<T, NDIM> &f, std::ostream &out) {
function read_function_coeffs (line 103) | static void read_function_coeffs(Function<T, NDIM> &f, std::istream &in,
function num_leaf_nodes (line 164) | long num_leaf_nodes{}
function explicit (line 170) | explicit FunctionIOData(const Function<T, NDIM> &f) {
function initialize_func_coeffs (line 190) | void initialize_func_coeffs(const Function<T, NDIM> &f,
function set_function_coeffs (line 223) | void set_function_coeffs(Function<T, NDIM> &f, int num_leaf_nodes) {
FILE: src/examples/writecoeffs/FunctionIO2.h
function simple_pow (line 9) | constexpr int simple_pow(int a, int b) {
function FunctionIO (line 21) | size_t NDIM> class FunctionIO {
function write_function_coeffs (line 42) | static void write_function_coeffs(const Function<T, NDIM> &f,
function write_function (line 75) | static void write_function(const Function<T, NDIM> &f, std::ostream &out) {
function read_function_coeffs (line 103) | static void read_function_coeffs(Function<T, NDIM> &f, std::istream &in,
type FunctionIOData (line 159) | struct FunctionIOData {
function explicit (line 175) | explicit FunctionIOData(const Function<T, NDIM> &f) {
function initialize_func_coeffs (line 196) | void initialize_func_coeffs(const Function<T, NDIM> &f,
function set_function_coeffs (line 270) | void set_function_coeffs(Function<T, NDIM> &f, int num_leaf_nodes) {
FILE: src/examples/writecoeffs/FunctionIOHDF5.h
function simple_pow (line 10) | constexpr int simple_pow(int a, int b) {
function FunctionIO (line 22) | size_t NDIM> class FunctionIO {
function write_function_coeffs (line 43) | static void write_function_coeffs(const Function<T, NDIM> &f,
function write_function (line 72) | static void write_function(const Function<T, NDIM> &f, std::ostream &out) {
function read_function_coeffs (line 100) | static void read_function_coeffs(Function<T, NDIM> &f, std::istream &in,
type FunctionIOData (line 156) | struct FunctionIOData {
function explicit (line 172) | explicit FunctionIOData(const Function<T, NDIM> &f) {
function initialize_func_coeffs (line 192) | void initialize_func_coeffs(const Function<T, NDIM> &f,
function set_function_coeffs (line 252) | void set_function_coeffs(Function<T, NDIM> &f, int num_leaf_nodes) {
FILE: src/examples/writecoeffs/app.cpp
function createFile (line 3) | void createFile() {
function main (line 18) | int main() {
FILE: src/examples/writecoeffs/core.cpp
function create_file (line 3) | hdf5::file::File create_file(const std::string &name) {
FILE: src/examples/writecoeffs/core.hpp
function createFile (line 6) | void createFile() {
FILE: src/examples/writecoeffs/h2_write.cc
function guess (line 60) | static double guess(const coord_3d &r) {
function V (line 66) | static double V(const coord_3d &r) {
function iterate (line 72) | void iterate(World &world, real_function_3d &V, real_function_3d &psi,
function main (line 90) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/h2_write_json.cc
function guess (line 60) | static double guess(const coord_3d &r) {
function V (line 66) | static double V(const coord_3d &r) {
function iterate (line 72) | void iterate(World &world, real_function_3d &V, real_function_3d &psi,
function main (line 90) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/h2_write_json_2.cc
function guess (line 60) | static double guess(const coord_3d &r) {
function V (line 66) | static double V(const coord_3d &r) {
function iterate (line 72) | void iterate(World &world, real_function_3d &V, real_function_3d &psi,
function main (line 90) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/h5cpp_test.cc
function main (line 13) | int main() {
FILE: src/examples/writecoeffs/writecoeff.cc
function f (line 20) | static std::complex<double> f(const coordT& r)
class WriteCoeffImpl (line 26) | class WriteCoeffImpl : public Mutex {
method WriteCoeffImpl (line 30) | WriteCoeffImpl(const int k, std::ostream& out)
class WriteCoeff (line 42) | class WriteCoeff {
method WriteCoeff (line 46) | WriteCoeff(const int k, std::ostream& out)
function main (line 57) | int main(int argc, char** argv)
FILE: src/examples/writecoeffs/writecoeff2.cc
function dataT (line 22) | static dataT f(const coordT &r) {
function write_function_coeffs (line 28) | void write_function_coeffs(const Function<T, NDIM> &f, std::ostream &out,
function count_leaf_nodes (line 63) | size_t count_leaf_nodes(const Function<T, NDIM> &f) {
function write_function (line 78) | void write_function(const Function<T, NDIM> &f, std::ostream &out) {
function read_function_coeffs (line 107) | void read_function_coeffs(Function<T, NDIM> &f, std::istream &in,
function read_function (line 136) | Function<T, NDIM> read_function(World &world, std::istream &in) {
function test (line 163) | void test(World &world) {
function main (line 191) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/writecoeff3.cc
function dataT (line 21) | static dataT f(const coordT &r) {
function test (line 28) | void test(World &world) {
function main (line 82) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/writecoeff_hdf5.cc
function dataT (line 21) | static dataT f(const coordT &r) {
function test (line 28) | void test(World &world) {
function main (line 61) | int main(int argc, char **argv) {
FILE: src/examples/writecoeffs/writecoeff_json.cc
function dataT (line 21) | static dataT f(const coordT &r) {
function test (line 28) | void test(World &world) {
function main (line 63) | int main(int argc, char **argv) {
FILE: src/madness.h
function namespace (line 46) | namespace madness {
FILE: src/madness/chem/AC.cc
type madness (line 9) | namespace madness{
function slater_radius (line 11) | double slater_radius(int atomic_number){
function make_atom_vec (line 38) | std::vector<atom_information<3> >make_atom_vec(const Molecule& molecul...
FILE: src/madness/chem/AC.h
function namespace (line 19) | namespace madness {
function ACParameters (line 72) | long int NDIM>
function initialize (line 101) | bool initialize(Molecule molecule, std::string ac_data, double dft_coeff...
function check (line 156) | void check(World& world){
function ac_param_ (line 176) | ac_param_(ac_param) {}
function const (line 185) | double operator ()(const Vector<double, NDIM> &r)const{
function int_factor (line 224) | double int_factor(const Vector<double, NDIM> &r, std::vector<atom_inform...
function ac_param_ (line 269) | ac_param_(ac_param){}
function const (line 274) | double operator ()(const Vector<double, NDIM> &r)const{
function potential (line 326) | double potential(const Vector<double, NDIM> &r) const{
function int_factor (line 338) | double int_factor(const Vector<double, NDIM> &r, std::vector<atom_inform...
type UnaryOpStructure (line 351) | struct UnaryOpStructure {
function BinaryOpStructure (line 382) | long int NDIM>
function AC (line 426) | long int NDIM>
FILE: src/madness/chem/Applications.hpp
type madness (line 8) | namespace madness {
type ScopedCWD (line 11) | struct ScopedCWD {
method ScopedCWD (line 13) | explicit ScopedCWD(std::filesystem::path const& new_dir) {
class Application (line 22) | class Application {
method Application (line 24) | explicit Application(const Params& p) : params_(p) {}
method print_parameters (line 36) | virtual void print_parameters(World& world) const {
method path (line 42) | [[nodiscard]] path get_workdir() const {
method has_results (line 47) | [[nodiscard]] virtual bool has_results(std::string filename) const {
method verify_results (line 53) | [[nodiscard]] virtual bool verify_results(const nlohmann::json& j) c...
method read_results (line 69) | [[nodiscard]] virtual nlohmann::json read_results(std::string filena...
method has_wavefunctions (line 91) | [[nodiscard]] virtual bool has_wavefunctions(std::string filename) c...
method read_wavefunctions (line 96) | [[nodiscard]] virtual std::vector<double> read_wavefunctions(std::st...
method needs_redo (line 114) | [[nodiscard]] virtual bool needs_redo() const {
class SCFApplication (line 136) | class SCFApplication : public Application, public ScfT, public std::en...
method SCFApplication (line 141) | explicit SCFApplication(World& w, const Params& p)
method SCFApplication (line 146) | explicit SCFApplication(World& w, const Params& p)
method get_scf (line 149) | std::shared_ptr<const SCF> get_scf() const {
method is_nemo (line 153) | bool constexpr is_nemo() const {
method get_nemo (line 157) | std::shared_ptr<const Nemo> get_nemo() const {
method get_nemo (line 165) | std::shared_ptr<Nemo> get_nemo() {
method print_parameters (line 173) | void print_parameters(World& world) const override {
method QCCalculationParametersBase (line 186) | const QCCalculationParametersBase& get_parameters() const override {
method run (line 194) | void run(const std::filesystem::path& workdir) override {
method results (line 261) | nlohmann::json results() const override {
class ResponseApplication (line 279) | class ResponseApplication : public Application {
method ResponseApplication (line 286) | ResponseApplication(World& world, Params params, std::filesystem::pa...
method QCCalculationParametersBase (line 292) | const QCCalculationParametersBase& get_parameters() const override {
method run (line 298) | void run(const std::filesystem::path& workdir) override {
method results (line 315) | [[nodiscard]] nlohmann::json results() const override {
class CC2Application (line 329) | class CC2Application : public Application, public CC2 {
method CC2Application (line 331) | explicit CC2Application(World& w, const Params& p, const SCFApplicat...
method QCCalculationParametersBase (line 337) | const QCCalculationParametersBase& get_parameters() const override {
method run (line 341) | void run(const std::filesystem::path& workdir) override {
method
Copy disabled (too large)
Download .json
Condensed preview — 2071 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (35,967K chars).
[
{
"path": ".clang-tidy",
"chars": 4643,
"preview": "# Generated from CLion Inspection settings\n---\nChecks: '-*,\nbugprone-argument-comment,\nbugprone-assert-side-effect,\nbugp"
},
{
"path": ".github/workflows/cmake.yml",
"chars": 7073,
"preview": "name: Linux/MacOS Build\n\non:\n push:\n pull_request:\n branches: [master]\n\n#env:\n\njobs:\n build:\n strategy:\n f"
},
{
"path": ".github/workflows/conda-deploy.yml",
"chars": 3403,
"preview": "name: Conda Deploy\n\non:\n # Run after CI passes on master\n workflow_run:\n workflows: [\"Linux/MacOS Build\"]\n types"
},
{
"path": ".github/workflows/make_doxygen.yml",
"chars": 2130,
"preview": "name: publish-doxygen\n\n# Trigger this when a pull request is merged (which implies pushing to master).\non:\n push:\n b"
},
{
"path": ".gitignore",
"chars": 963,
"preview": "build*\ncmake-build-debug*\n.history*\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Compiled Dynamic libraries\n*.so\n*.d"
},
{
"path": ".readthedocs.yaml",
"chars": 706,
"preview": "# .readthedocs.yaml\n# Read the Docs configuration file\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html f"
},
{
"path": "AGENTS.md",
"chars": 18244,
"preview": "# Agent Instructions for MADNESS\n\nCanonical guidance for coding agents working on this repo. For installing\ndependencies"
},
{
"path": "CMakeLists.txt",
"chars": 32459,
"preview": "cmake_minimum_required (VERSION 3.12.0) # for FindPython\n\nif(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE Release)\nendi"
},
{
"path": "INSTALL.md",
"chars": 19533,
"preview": "## Introduction\n\nLinux and MacOS are supported with x86, Arm64, and IBM Power processors. GPUs are not yet utilized.\n\nMA"
},
{
"path": "LICENSE",
"chars": 14914,
"preview": "Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n\nEveryone "
},
{
"path": "README.md",
"chars": 3927,
"preview": "MADNESS\n=======\n\nMultiresolution Adaptive Numerical Environment for Scientific Simulation\n\n# Summary\n\nMADNESS provides a"
},
{
"path": "_config.yml",
"chars": 25,
"preview": "theme: jekyll-theme-slate"
},
{
"path": "admin/conda/README.md",
"chars": 3501,
"preview": "# Conda Packaging for MADNESS\n\nConda packages are built and uploaded to [anaconda.org/m-a-d-n-e-s-s](https://anaconda.or"
},
{
"path": "admin/conda/recipe/meta.yaml.in",
"chars": 189,
"preview": "{% set name = \"madness\" %}\n{% set version = \"0.10.1\" %}\n\npackage:\n name: \"{{ name|lower }}\"\n version: \"{{ version }}\"\n"
},
{
"path": "admin/docker/README.md",
"chars": 252,
"preview": "# What\nThis repo contains scripts for building MADNESS containers usable for running applications and for development.\n\n"
},
{
"path": "admin/docker/images/Makefile",
"chars": 489,
"preview": "repo = rjharrison\nlatest ?= 22.04\nALL = ${repo}/ubuntu\\:22.04\n\n${repo}/ubuntu\\:%: build = docker build --build-arg ubunt"
},
{
"path": "admin/docker/ubuntu/Dockerfile",
"chars": 858,
"preview": "ARG ubuntuImage\nFROM ${ubuntuImage}\n\nRUN apt-get update && \\\n DEBIAN_FRONTEND=noninteractive apt-get install -y local"
},
{
"path": "admin/docker/ubuntu/Makefile",
"chars": 2571,
"preview": "ubuntu_codename ?= $(shell lsb_release -sc)\nclang_version ?= 13\n\nexport DEBIAN_FRONTEND=noninteractive\n\nubuntu_release ="
},
{
"path": "admin/docker/ubuntu/sudoers",
"chars": 766,
"preview": "#\n# This file MUST be edited with the 'visudo' command as root.\n#\n# Please consider adding local content in /etc/sudoers"
},
{
"path": "bin/latex2oo",
"chars": 1878,
"preview": "#!/bin/csh\n\n# This sed script partially automates the conversion\n# from latex to openoffice focussing on the equations.\n"
},
{
"path": "bin/taskprofile.pl",
"chars": 12360,
"preview": "#!/usr/bin/perl\n\n#\n# This file is part of MADNESS.\n#\n# Copyright (C) 2012 Jinmei Zhang, Edward Valeev\n#\n# This progra"
},
{
"path": "bin/test_utilities.py",
"chars": 2924,
"preview": "import json\nimport subprocess\n\nclass madjsoncompare:\n # \"\"\"takes two json output files and compares individual keys, "
},
{
"path": "cmake/Makefile",
"chars": 493,
"preview": "CMAKE := cmake-3.5.1\nURL := https://cmake.org/files/v3.5/$(CMAKE).tar.gz\nPREFIX := $(PWD)\n\nall: cmake\n\nwget := $(shell w"
},
{
"path": "cmake/config.h.in",
"chars": 5958,
"preview": "/* Input file cmake/config.h.in. */\n\n/* Define of package information */\n#define MADNESS_PACKAGE_NAME \"@PROJECT_NAME@\"\n#"
},
{
"path": "cmake/doxygen.cfg.in",
"chars": 104676,
"preview": "# Doxyfile 1.8.9.1\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org"
},
{
"path": "cmake/madness-config.cmake.in",
"chars": 10019,
"preview": "# - CMAKE Config file for the MADNESS package\n#\n# Valid COMPONENTS: world tensor misc tensor linalg tinyxml muparser mra"
},
{
"path": "cmake/modules/AddCustomTargetSubproject.cmake",
"chars": 1898,
"preview": "# Copyright 2020 Eduard F Valeyev\n# Distributed under the OSI-approved BSD 3-Clause License.\n# See https://opensource.or"
},
{
"path": "cmake/modules/AddMADExecutable.cmake",
"chars": 202,
"preview": "macro(add_mad_executable _name _source_files _libs)\n\n add_executable(${_name} ${_source_files})\n target_link_libraries"
},
{
"path": "cmake/modules/AddMADLibrary.cmake",
"chars": 6326,
"preview": "macro(add_mad_library _name _source_files _header_files _dep_mad_comp _include_dir)\n\n if (NOT ${_source_files}) # no so"
},
{
"path": "cmake/modules/AddMPITests.cmake",
"chars": 5216,
"preview": "# AddMPITests.cmake\n# \n# This module provides a macro for adding MPI-based tests with different\n# process counts. All MP"
},
{
"path": "cmake/modules/AddOptions.cmake",
"chars": 4573,
"preview": "# see https://github.com/WVU-ASEL/glidar/blob/master/cmake/Modules/AddOptions.cmake\n\n# - Add options without repeating t"
},
{
"path": "cmake/modules/AddScriptedTests.cmake",
"chars": 2913,
"preview": "# macro will build (i.e. copy the test script to the build directory) and execute the script\n\n# example\n# CMakeLists.txt"
},
{
"path": "cmake/modules/AddUnittests.cmake",
"chars": 1367,
"preview": "macro(add_unittests _component _sources _libs _labels)\n\n # Add targets and for world_unittests\n if (NOT TARGET ${_comp"
},
{
"path": "cmake/modules/AppendFlags.cmake",
"chars": 189,
"preview": "macro(append_flags _flags _append_flag)\n\n string(STRIP \"${_append_flag}\" _append_flag )\n set(${_flags} \"${${_flags}} $"
},
{
"path": "cmake/modules/CheckCFortranFunctionExists.cmake",
"chars": 992,
"preview": "include(CheckFunctionExists)\n\nmacro(check_c_fortran_function_exists _func_base _result)\n string(TOLOWER \"${_func_base}\""
},
{
"path": "cmake/modules/CheckDisablePIESupport.cmake",
"chars": 1043,
"preview": "\ninclude(CheckCXXCompilerFlag)\n\nmacro(check_disablepie_support _outvar _disablepie_linker_flags)\n\n if(NOT ${_outvar})\n "
},
{
"path": "cmake/modules/ConvertIncludesListToCompilerArgs.cmake",
"chars": 1243,
"preview": "#\n# This file is a part of TiledArray.\n# Copyright (C) 2013 Virginia Tech\n#\n# This program is free software: you can"
},
{
"path": "cmake/modules/ConvertLibrariesListToCompilerArgs.cmake",
"chars": 1710,
"preview": "#\n# This file is a part of TiledArray.\n# Copyright (C) 2013 Virginia Tech\n#\n# This program is free software: you can"
},
{
"path": "cmake/modules/CopyTargetProperties.cmake",
"chars": 1309,
"preview": "macro(copy_target_properties _intarget _outtarget _props)\n\n foreach(_prop ${_props})\n get_property(_prop_set TARGET "
},
{
"path": "cmake/modules/EchoTargetProperty.cmake",
"chars": 10327,
"preview": "function(echo_target_property tgt prop)\n # v for value, d for defined, s for set\n get_property(s TARGET ${tgt} PROPERT"
},
{
"path": "cmake/modules/FindACML.cmake",
"chars": 1064,
"preview": "# - Try to find acml\n# Input variables:\n# ACML_ROOT_DIR - The acml install directory\n# ACML_LIBRARY - The acm"
},
{
"path": "cmake/modules/FindFFTW.cmake",
"chars": 12560,
"preview": "# see https://github.com/egpbos/findFFTW/blob/master/FindFFTW.cmake\n\n# - Find the FFTW library\n#\n# Original version of t"
},
{
"path": "cmake/modules/FindGperftools.cmake",
"chars": 6811,
"preview": "# - Try to find Google performance tools (gperftools)\n# Input variables:\n# GPERFTOOLS_ROOT_DIR - The gperftools ins"
},
{
"path": "cmake/modules/FindIntegratorXX.cmake",
"chars": 1867,
"preview": "# - Try to find INTEGRATORXX\n# Input variables:\n# INTEGRATORXX_ROOT_DIR - The INTEGRATORXX install directory\n# IN"
},
{
"path": "cmake/modules/FindLibunwind.cmake",
"chars": 2596,
"preview": "# - Try to find Libunwind\n# Input variables:\n# LIBUNWIND_DIR - The libunwind install directory;\n# "
},
{
"path": "cmake/modules/FindMKL.cmake",
"chars": 3913,
"preview": "# - Try to find MKL\n# Input variables:\n# MKL_ROOT_DIR - The MKL install directory\n# MKL_INCLUDE_DIR - The"
},
{
"path": "cmake/modules/FindOrFetchCereal.cmake",
"chars": 2585,
"preview": "if (NOT TARGET cereal)\n find_package(cereal QUIET CONFIG)\n\n if (TARGET cereal)\n message(STATUS \"Found Cerea"
},
{
"path": "cmake/modules/FindOrFetchPARSEC.cmake",
"chars": 2047,
"preview": "if (NOT TARGET PaRSEC::parsec)\n find_package(PaRSEC CONFIG QUIET COMPONENTS parsec HINTS ${PaRSEC_ROOT_DIR})\n if (TARG"
},
{
"path": "cmake/modules/FindPCM.cmake",
"chars": 1970,
"preview": "# - Try to find PCM\n# Input variables:\n# PCM_ROOT_DIR - The pcm install directory\n# PCM_INCLUDE_DIR - The pcm i"
},
{
"path": "cmake/modules/FindPapi.cmake",
"chars": 1646,
"preview": "# - Try to find Papi\n# Input variables:\n# PAPI_ROOT_DIR - The papi install directory\n# PAPI_INCLUDE_DIR - The pap"
},
{
"path": "cmake/modules/FindTBB.cmake",
"chars": 17200,
"preview": "# based https://github.com/Kitware/VTK/blob/master/CMake/FindTBB.cmake\n#\n# CHANGES:\n# - TBB_ROOT -> TBBROOT (tbb shell s"
},
{
"path": "cmake/modules/GetGitMetadata.cmake",
"chars": 3483,
"preview": "#\n# SPDX-FileCopyrightText: 2022 Eduard Valeyev <eduard@valeyev.net>\n#\n# SPDX-License-Identifier: BSD-2-Clause\n#\n\n#\n# vg"
},
{
"path": "cmake/modules/RedefaultableOption.cmake",
"chars": 378,
"preview": "# if local variable is defined, use its value as the default, otherwise use _default\n# this is consistent with cmake 3.1"
},
{
"path": "cmake/toolchains/arm-gnu-tbb.cmake",
"chars": 2789,
"preview": "#\n# ARM Toolchain for MPI + TBB\n#\n# REQUIREMENTS:\n# - in PATH:\n# mpicc and mpicxx\n#\n# OPTIONS:\n# - environment variabl"
},
{
"path": "cmake/toolchains/dancer_gcc.cmake",
"chars": 3709,
"preview": "# Set the system name so CMake uses the appropriate platform settings.\n# NOTE: The platforms settings for BlueGeneP are "
},
{
"path": "cmake/toolchains/generic-mkl-tbb.cmake",
"chars": 3282,
"preview": "#\n# Generic Toolchain for MPI + MKL + TBB\n#\n# REQUIREMENTS:\n# - in PATH:\n# mpicc and mpicxx\n#\n# OPTIONS:\n# - environme"
},
{
"path": "cmake/toolchains/mira-clang11-essl.cmake",
"chars": 2879,
"preview": "# Set the system name so CMake uses the appropriate platform settings.\n# NOTE: The platforms settings for BlueGeneP are "
},
{
"path": "cmake/toolchains/mira-gcc-essl.cmake",
"chars": 3565,
"preview": "# Set the system name so CMake uses the appropriate platform settings.\n# NOTE: The platforms settings for BlueGeneP are "
},
{
"path": "cmake/toolchains/osx-clang-accelerate-tbb.cmake",
"chars": 2080,
"preview": "#\n# Generic Toolchain for OS X + MPI + TBB\n#\n# REQUIREMENTS:\n# - in PATH:\n# mpicc and mpicxx, both using clang as the "
},
{
"path": "cmake/toolchains/osx-clang-mkl-tbb.cmake",
"chars": 2391,
"preview": "#\n# Generic Toolchain for OS X + MPI + MKL + TBB\n#\n# REQUIREMENTS:\n# - in PATH:\n# mpicc and mpicxx, both using clang a"
},
{
"path": "conda-recipe/.gitignore",
"chars": 106,
"preview": "# Override root .gitignore which excludes build*\n!build.sh\n\n# Ignore conda-build work directories\n.conda/\n"
},
{
"path": "conda-recipe/build.sh",
"chars": 1552,
"preview": "#!/bin/bash\nset -ex\n\nMPI_FLAG=\"-DENABLE_MPI=OFF\"\nif [ \"${MPI_VARIANT}\" = \"openmpi\" ]; then\n MPI_FLAG=\"-DENABLE_MPI=ON\"\n"
},
{
"path": "conda-recipe/meta.yaml",
"chars": 1480,
"preview": "{% set version = environ.get('GIT_DESCRIBE_TAG', 'dev') %}\n{% set mpi = environ.get('MPI_VARIANT', 'nompi') %}\n\npackage:"
},
{
"path": "config/MADNESS.pc.in",
"chars": 491,
"preview": "prefix=@prefix@\nexec_prefix=@exec_prefix@\nlibdir=@libdir@\nincludedir=@includedir@\n\ncc=@CC@\ncxx=@CXX@\ncppflags=@CPPFLAGS@"
},
{
"path": "doc/CMakeLists.txt",
"chars": 542,
"preview": "# doc\n\nif(DOXYGEN_FOUND)\n set_directory_properties(PROPERTY ADDITIONAL_MAKE_CLEAN_FILES html latex *~)\n\n add_custom_ta"
},
{
"path": "doc/INSTALL.md",
"chars": 42,
"preview": "# Installation\n\n```{include} ../INSTALL.md"
},
{
"path": "doc/Latex/api.tex",
"chars": 35899,
"preview": "% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.7\n% see http://writer2latex.sourceforge.net for more info\n\\d"
},
{
"path": "doc/Latex/apps/lrccs/LRCCS_Manual.tex",
"chars": 6979,
"preview": "\\documentclass[10pt,a4paper]{scrartcl}\n\n\\usepackage{amsmath}\n\\usepackage{amsfonts}\n\\usepackage{amssymb}\n\\usepackage{colo"
},
{
"path": "doc/Latex/apps/lrccs/references.bib",
"chars": 2196,
"preview": "@Article{mra-cis,\nauthor =\"Kottmann, Jakob S. and H{\\\"o}fener, Sebastian and Bischoff, Florian A.\",\ntitle =\"\\href{http:"
},
{
"path": "doc/Latex/apps/moldft/manual.tex",
"chars": 23166,
"preview": "\\documentclass[letterpaper]{book}\n\\usepackage{amssymb,amsmath,latexsym,hyperref,graphics,color}\n\n\\setlength{\\parindent}{"
},
{
"path": "doc/Latex/apps/nemo_mp2/aip.bst",
"chars": 18972,
"preview": "%% #define AIP 1\t\t% Fri Jun 15 10:51:17 1990\n%% #include \"TEX$ROOT:[BIBTEX]PHYSICS.BTX\"\n\t% Please notify Charles Karney "
},
{
"path": "doc/Latex/apps/nemo_mp2/aip.sty",
"chars": 9470,
"preview": "% AIP (style option to ARTICLE) for American Institute of Physics journals\n% AIP DOCUMENT SUBSTYLE -- released 17 Januar"
},
{
"path": "doc/Latex/apps/nemo_mp2/manual.tex",
"chars": 3234,
"preview": "\\documentclass[10pt]{article}\n\n\\usepackage{amsmath}\n\\usepackage{amssymb}\n\n\\title{Manual for nemo and mp2 programs in MAD"
},
{
"path": "doc/Latex/apps/nemo_mp2/references.bib",
"chars": 892,
"preview": "%% Created using Papers on Tue, 12 Jul 2016.\n%% http://papersapp.com/papers/\n\n@article{Bischoff:2013cx,\nauthor = {Bischo"
},
{
"path": "doc/Latex/implementation.tex",
"chars": 61259,
"preview": "\\documentclass[letterpaper]{book}\n%\\documentclass[letterpaper]{article}\n\\usepackage{hyperref}\n\\usepackage{amsmath}\n\\usep"
},
{
"path": "doc/Latex/parallel-runtime.tex",
"chars": 41881,
"preview": "% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.7\n% see http://writer2latex.sourceforge.net for more info\n\\d"
},
{
"path": "doc/Makefile",
"chars": 633,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
},
{
"path": "doc/applications.dox",
"chars": 1219,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/conf.py",
"chars": 2168,
"preview": "# Configuration file for the Sphinx documentation builder.\n#\n#\n# This file only contains a selection of the most common "
},
{
"path": "doc/configuration.dox",
"chars": 1241,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/contribution/style.dox",
"chars": 4495,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/contribution.dox",
"chars": 1201,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_basics.dox",
"chars": 10340,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_comp_run.dox",
"chars": 1512,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_env_var.dox",
"chars": 1279,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_functions.dox",
"chars": 8506,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_io.dox",
"chars": 7423,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_load_balance.dox",
"chars": 4123,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started/gstart_think_madness.dox",
"chars": 9659,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/getting_started.dox",
"chars": 3933,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/index.log",
"chars": 0,
"preview": ""
},
{
"path": "doc/index.rst",
"chars": 1501,
"preview": ".. madness documentation master file, created by\n sphinx-quickstart on Tue Jul 12 21:54:04 2022.\n You can adapt this"
},
{
"path": "doc/libraries/chemistry.dox",
"chars": 6473,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/containers.dox",
"chars": 1223,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/futures.dox",
"chars": 3986,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/mpi.dox",
"chars": 1145,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/serialization.dox",
"chars": 14195,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/threading/atomics.dox",
"chars": 1200,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/threading/taskq.dox",
"chars": 1177,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/threading/threads.dox",
"chars": 1125,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/threading.dox",
"chars": 1162,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/world.dox",
"chars": 1204,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime/world_object.dox",
"chars": 1190,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries/parallel_runtime.dox",
"chars": 9138,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/libraries.dox",
"chars": 1349,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2015 Stony Brook University\n\n This program is free software; you ca"
},
{
"path": "doc/madness.bib",
"chars": 57954,
"preview": "\n@article{PhysRevA.85.033403,\nauthor = {Vence, Nicholas and Harrison, Robert and Krsti\\'{c}, Predrag},\ndoi = {10.1103/Ph"
},
{
"path": "doc/mainpage.dox",
"chars": 7102,
"preview": "/// \\file mainpage.dox\n/// \\brief Top-level page for MADNESS documentation.\n\n/// \\defgroup configuration MADNESS install"
},
{
"path": "doc/make.bat",
"chars": 769,
"preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
},
{
"path": "doc/numerical_library.md",
"chars": 5937,
"preview": "# Numerical library\n\nMADNESS provides a high-level environment for the solution of integral and differential equations \n"
},
{
"path": "doc/quantum.md",
"chars": 10007,
"preview": "# Quantum chemistry\n\n\n## What you can do\nQuantum chemical capabilities are:\n * SCF: Hartree-Fock and DFT, also in strong"
},
{
"path": "doc/requirements.txt",
"chars": 128,
"preview": "sphinx==7.2.6\ntyping-extensions==4.2.0\ndocutils==0.18.1\nmarkupsafe==2.1.1\npyparsing==3.0.8\nalabaster==0.7.12\nmyst_parser"
},
{
"path": "doc/runtime.md",
"chars": 355,
"preview": "# Runtime\n\nThe MADNESS runtime allows for massively parallel and hybrid parallel computation of \nirregular algorithms. T"
},
{
"path": "doc/tutorial/API.md",
"chars": 2671,
"preview": "# Chemistry API\n\nThere are several interfaces and methods for writing quantum chemistry codes and we will write a simple"
},
{
"path": "doc/tutorial/CMakeLists.txt",
"chars": 326,
"preview": "cmake_minimum_required(VERSION 3.16)\nproject(madness-tutorial)\n\nfind_package(madness REQUIRED OPTIONAL_COMPONENTS chem)\n"
},
{
"path": "doc/tutorial/README.md",
"chars": 11312,
"preview": "# MADNESS tutorial\n\n## Table of contents\n\n1. Building MADNESS\n 1. [Building from source](#building-from-source)\n "
},
{
"path": "doc/tutorial/TODO.md",
"chars": 42,
"preview": "# To do list for completing the tutorial\n\n"
},
{
"path": "doc/tutorial/chemistry.md",
"chars": 7820,
"preview": "# Chemistry in MADNESS\n\n* More detailed documention is [here](https://madness.readthedocs.io/en/latest/quantum.html)\n\n##"
},
{
"path": "doc/tutorial/simple_hf.cpp",
"chars": 3391,
"preview": "#include <madness.h>\n#include <madchem.h>\n\nusing namespace madness;\n\nint main(int argc, char* argv[]) {\n World& world"
},
{
"path": "doc/tutorial/test_runtime.cpp",
"chars": 494,
"preview": "#include <madness/world/worldgop.h>\n#include <cassert>\n\nint task (int i) { return i + 1; }\n\nint main(int argc, char* arg"
},
{
"path": "external/boost.cmake",
"chars": 227,
"preview": "if(ENABLE_BOOST)\n\n cmake_minimum_required(VERSION 3.15.0) # for Boost::headers\n find_package(Boost 1.35 REQUIRED)"
},
{
"path": "external/elemental.cmake",
"chars": 12049,
"preview": "# -*- mode: cmake -*-\n\n######################\n# Find Elemental\n######################\n\nif(ENABLE_ELEMENTAL AND DEFINED E"
},
{
"path": "external/gperftools.cmake",
"chars": 1038,
"preview": "if(ENABLE_GPERFTOOLS OR ENABLE_TCMALLOC_MINIMAL)\n \n if(ENABLE_GPERFTOOLS)\n find_package(Gperftools COMPONENTS tcmal"
},
{
"path": "external/integratorxx.cmake",
"chars": 170,
"preview": "if(ENABLE_INTEGRATORXX)\n\n find_package(IntegratorXX)\n\n # Set the output variables\n if(INTEGRATORXX_FOUND)\n set(MAD"
},
{
"path": "external/lapack.cmake",
"chars": 6059,
"preview": "# Find BLAS and LAPACK.\n\nset(lapack_is_optional 0)\nset(missing_lapack_message_level \"FATAL_ERROR\")\n\n# if building just t"
},
{
"path": "external/libunwind.cmake",
"chars": 211,
"preview": "if(NOT LIBUNWIND_FOUND AND (ENABLE_LIBUNWIND OR ENABLE_TASK_PROFILER))\n\n find_package(Libunwind)\n \n # Set the outpu"
},
{
"path": "external/libxc.cmake",
"chars": 158,
"preview": "if(ENABLE_LIBXC)\n\n find_package(Libxc CONFIG)\n \n # Set the output variables\n if(TARGET Libxc::xc)\n set(MADNESS_"
},
{
"path": "external/mpi.cmake",
"chars": 2269,
"preview": "# Find MPI\n\nif(ENABLE_MPI)\n\n # find threads first\n if (NOT TARGET Threads::Threads)\n message(FATAL_ERROR \"include e"
},
{
"path": "external/papi.cmake",
"chars": 113,
"preview": "if(ENABLE_PAPI)\n \n find_package(Papi REQUIRED)\n \n # Set the output variables\n set(HAVE_PAPI 1)\n\nendif()\n"
},
{
"path": "external/parsec.cmake",
"chars": 1358,
"preview": "if(ENABLE_PARSEC)\n include(${PROJECT_SOURCE_DIR}/cmake/modules/FindOrFetchPARSEC.cmake)\n\n if(TARGET PaRSEC::parsec)\n "
},
{
"path": "external/pcm.cmake",
"chars": 153,
"preview": "if(ENABLE_PCM)\n\n find_package(PCM COMPONENTS pcm)\n \n # Set the output variables\n if(PCM_FOUND)\n set(MADNESS_HAS"
},
{
"path": "external/pthread.cmake",
"chars": 129,
"preview": "# Find Threads\nif (NOT TARGET Threads::Threads)\n set(CMAKE_THREAD_PREFER_PTHREAD TRUE)\n find_package(Threads REQUIRED)"
},
{
"path": "external/pybind11.cmake",
"chars": 692,
"preview": "if(ENABLE_PYTHON)\n\n find_package(Python3 COMPONENTS Interpreter Development.Module REQUIRED)\n find_package(pybind11 2."
},
{
"path": "external/tbb.cmake",
"chars": 1944,
"preview": "if (ENABLE_TBB)\n find_package(TBB 4.3.5)\n\n if (TBB_FOUND AND TARGET TBB::tbb)\n set(HAVE_INTEL_TBB 1)\n message(ST"
},
{
"path": "external/versions.cmake",
"chars": 73,
"preview": "set(MADNESS_TRACKED_PARSEC_TAG 064918a398327371789999591c224aff3df8077b)\n"
},
{
"path": "src/CMakeLists.txt",
"chars": 426,
"preview": "# src\n\nadd_subdirectory(madness)\nif(NOT (MADNESS_BUILD_MADWORLD_ONLY OR MADNESS_BUILD_LIBRARIES_ONLY) AND LAPACK_FOUND)\n"
},
{
"path": "src/apps/CMakeLists.txt",
"chars": 481,
"preview": "# src/apps\n\ninclude_directories(${CMAKE_CURRENT_SOURCE_DIR})\n\nadd_subdirectory(plot)\nadd_subdirectory(tdse)\nadd_subdirec"
},
{
"path": "src/apps/QCSchema_json.md",
"chars": 2704,
"preview": "# QCSchema Json\n\nIntegration of Madness into QCArchive requires to ability to translate data\ngenerated by Madness into a"
},
{
"path": "src/apps/cc2/CMakeLists.txt",
"chars": 326,
"preview": "# src/apps/cc2\n\nadd_mad_executable(cc2 cc2.cc \"MADchem\")\nadd_dependencies(applications-madness cc2)\n\n#if (ENABLE_GENTENS"
},
{
"path": "src/apps/cc2/cc2.cc",
"chars": 3508,
"preview": "/*\n * cc2.cc\n *\n * Created on: Aug 10, 2015\n * Author: kottmanj\n */\n/*\n This file is part of MADNESS.\n\n Copyrigh"
},
{
"path": "src/apps/cis/CMakeLists.txt",
"chars": 426,
"preview": "# src/apps/cis\n\nadd_mad_executable(cis cis.cpp \"MADchem\")\nadd_dependencies(applications-madness cis)\n\nif(BUILD_TESTING)\n"
},
{
"path": "src/apps/cis/cis.cpp",
"chars": 3963,
"preview": "/*\n * cis.cpp\n *\n * Created on: Aug 10, 2015\n * Author: Jakob S. Kottmann\n */\n\n#include <madness/chem/TDHF.h>\n#inc"
},
{
"path": "src/apps/cis/input",
"chars": 172,
"preview": "plot\nend\n\ndft\nno_compute true\nxc hf\nL 30\neconv 1.e-4\ndconv 3.e-4\nk 7\nend\n\nnemo\nncf (none,1.0)\nend\n\nresponse\nfreeze 0\nexc"
},
{
"path": "src/apps/dirac/CMakeLists.txt",
"chars": 332,
"preview": "# src/apps/dirac\n\nadd_mad_executable(DFdriver \"DFdriver.cc;DF.cc;fcwf.cc\" MADchem)\n\n#target_link_libraries(DFdriver MADc"
},
{
"path": "src/apps/dirac/DF.cc",
"chars": 72935,
"preview": "/*\n *\n * Written by: bsundahl and jscanderson\n * Date: A long time ago...\n *\n * TODO:\n * - Reading input from NWChe"
},
{
"path": "src/apps/dirac/DF.h",
"chars": 5879,
"preview": "#ifndef MADNESS_APPS_DF_H_INCLUDED\n#define MADNESS_APPS_DF_H_INCLUDED\n\n#include <madness/mra/mra.h>\n#include <madness/mr"
},
{
"path": "src/apps/dirac/DFParameters.h",
"chars": 8963,
"preview": "\n/// \\file DFParameters\n/// \\brief Input parameters for a Dirac Fock calculation.\n\n#ifndef MADNESS_APPS_DFPARAMS_H_INCLU"
},
{
"path": "src/apps/dirac/DFdriver.cc",
"chars": 2270,
"preview": "/*\n *\n * Main source file for the Dirac Fock code\n *\n */\n\n\n#include <madness/misc/info.h>\n#include \"DF.h\" // All Di"
},
{
"path": "src/apps/dirac/DFinput_sample",
"chars": 128,
"preview": "DiracFock\narchive /gpfs/projects/rjh/JoelsRestartData/H2Orestartdata\njob 0\nsmall 1e-5\nthresh 1e-6\nk 8\nkain\nmaxsub 5\nno_s"
},
{
"path": "src/apps/dirac/DKops.h",
"chars": 14541,
"preview": "#ifndef MADNESS_APPS_MOLDFT_DKOPS_H_INCLUDED\n#define MADNESS_APPS_MOLDFT_DKOPS_H_INCLUDED\n\n\n#include <madness/mra/mra.h>"
},
{
"path": "src/apps/dirac/InitParameters.h",
"chars": 24079,
"preview": "\n/// \\file InitParameters\n/// \\brief Input parameters for a Dirac Fock calculation, read from a specified archive result"
},
{
"path": "src/apps/dirac/README",
"chars": 2271,
"preview": "Basic instructions to run the Dirac Hartree-Fock code.\n\nCan start from moldft or a previous DFdriver calculation. There"
},
{
"path": "src/apps/dirac/fcwf.cc",
"chars": 16322,
"preview": "#include \"fcwf.h\"\n\n//Fcwf (Four component wavefunction) implementation file\n//NOTE: The small component of an Fcwf is sc"
},
{
"path": "src/apps/dirac/fcwf.h",
"chars": 3127,
"preview": "#ifndef MADNESS_APPS_MOLDFT_FCWF_H_INCLUDED\n#define MADNESS_APPS_MOLDFT_FCWF_H_INCLUDED\n\n#include <madness/mra/mra.h>\n#i"
},
{
"path": "src/apps/dirac/relops.cc",
"chars": 17775,
"preview": "#include <cmath>\n#include <iostream>\n#include <vector>\n#include <algorithm>\n#include <math.h> //for erfc\n\n#include \"../."
},
{
"path": "src/apps/dirac/rk.cc",
"chars": 19291,
"preview": "#include <madness/mra/mra.h>\n#include <madness/mra/operator.h>\n#include <madness/world/vector.h>\n#include <madness/mra/n"
},
{
"path": "src/apps/interior_bc/CMakeLists.txt",
"chars": 194,
"preview": "# src/apps/interior_bc\n\nadd_mad_executable(embedded_dirichlet embedded_dirichlet.cc embedded_dirichlet MADmra)\n\n#install"
},
{
"path": "src/apps/interior_bc/embedded_dirichlet.cc",
"chars": 11700,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2007,2010 Oak Ridge National Laboratory\n\n This program is free soft"
},
{
"path": "src/apps/interior_bc/test_problems.h",
"chars": 17307,
"preview": "/*\n This file is part of MADNESS.\n \n Copyright (C) 2007,2010 Oak Ridge National Laboratory\n \n This program is free "
},
{
"path": "src/apps/madqc_v2/CMakeLists.txt",
"chars": 1150,
"preview": "# src/apps/moldft\n\nadd_mad_executable(madqc madqc.cpp \"MADchem;MADresponse2\")\nadd_dependencies(applications-madness madq"
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_cc2_callable.py.calc_info.ref.json",
"chars": 2223,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 10000000000.0,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_cis_energy_he.py.calc_info.ref.json",
"chars": 2496,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 10000000000.0,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_cis_symmetry_h2o.py_a2.calc_info.ref.json",
"chars": 2644,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 10000000000.0,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_cis_symmetry_h2o.py_b1.calc_info.ref.json",
"chars": 2631,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.0001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_lrcc2_helium.py.calc_info.ref.json",
"chars": 3137,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_moldft_energy.py.calc_info.ref.json",
"chars": 1184,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_moldft_energy_mpi_parallel.py.calc_info.ref.json",
"chars": 1198,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 10000000000.0,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_mp2_helium.py.calc_info.ref.json",
"chars": 2285,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_nemo_energy.py.calc_info.ref.json",
"chars": 1748,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_nemo_localization.py.calc_info.ref.json",
"chars": 2183,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 0.001,\n "
},
{
"path": "src/apps/madqc_v2/mad_madqc_test_oep_energy.py.calc_info.ref.json",
"chars": 3512,
"preview": "{\n \"tasks\": [\n {\n \"convergence_info\": {\n \"converged_for_dconv\": 10000000000.0,\n "
},
{
"path": "src/apps/madqc_v2/madqc.cpp",
"chars": 12256,
"preview": "/*\n This file is part of MADNESS.\n\n Copyright (C) 2007,2010 Oak Ridge National Laboratory\n\n This program is free soft"
},
{
"path": "src/apps/madqc_v2/test_cc2_callable.py",
"chars": 1866,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nimport argparse\n\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom tes"
},
{
"path": "src/apps/madqc_v2/test_cis_energy_he.py",
"chars": 1495,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impor"
},
{
"path": "src/apps/madqc_v2/test_cis_symmetry_h2o.py",
"chars": 2573,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impor"
},
{
"path": "src/apps/madqc_v2/test_lrcc2_helium.py",
"chars": 2266,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nimport argparse\n\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom tes"
},
{
"path": "src/apps/madqc_v2/test_moldft_energy.py",
"chars": 1277,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impor"
},
{
"path": "src/apps/madqc_v2/test_moldft_energy_mpi_parallel.py",
"chars": 1342,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impor"
},
{
"path": "src/apps/madqc_v2/test_mp2_helium.py",
"chars": 2125,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nimport argparse\n\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom tes"
},
{
"path": "src/apps/madqc_v2/test_nemo_energy.py",
"chars": 1370,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impor"
},
{
"path": "src/apps/madqc_v2/test_nemo_localization.py",
"chars": 1457,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\n\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom test_utilities impo"
},
{
"path": "src/apps/madqc_v2/test_oep_energy.py",
"chars": 2159,
"preview": "#!/usr/bin/env python3\n\nimport sys\nimport subprocess\nimport argparse\n\nsys.path.append(\"@CMAKE_SOURCE_DIR@/bin\")\nfrom tes"
},
{
"path": "src/apps/moldft/CMakeLists.txt",
"chars": 697,
"preview": "# src/apps/moldft\n\nadd_mad_executable(moldft moldft.cc MADchem)\nadd_dependencies(applications-madness moldft)\n\n# removed"
},
{
"path": "src/apps/moldft/calcguess.nw",
"chars": 4972,
"preview": "start\n\n# As the first step in generating the XML guess data,\n# run NWChem on this file to generate data for each atom.\n#"
},
{
"path": "src/apps/moldft/fci/GNUmakefile",
"chars": 2772,
"preview": "#\n# $Id: GNUmakefile,v 1.2 1999/07/28 00:23:43 d3e129 Exp $\n#\n\n ARFLAGS = urs\n RANLIB = ranlib\n\n# SUN SOLARIS\n# "
},
{
"path": "src/apps/moldft/fci/bitops.fh",
"chars": 110,
"preview": "*\n* $Id: bitops.fh,v 1.2 1999/07/28 00:23:38 d3e129 Exp $\n*\n#ifdef LINUXF2C\n#define ieor(a,b) xor(a,b)\n#endif\n"
},
{
"path": "src/apps/moldft/fci/crayio.c",
"chars": 7232,
"preview": "/*\n $Id$\n Simulate the cray 64 bit word addressable I/O routines and\n allow for large buffering in core.\n\n\n CALL W"
},
{
"path": "src/apps/moldft/fci/daxpy.F",
"chars": 1248,
"preview": "*\n* $Id: daxpy.F,v 1.2 1999/07/28 00:23:38 d3e129 Exp $\n*\n subroutine daxpy(n,da,dx,incx,dy,incy)\nc \nc cons"
},
{
"path": "src/apps/moldft/fci/dcopy.F",
"chars": 1186,
"preview": "*\n* $Id: dcopy.F,v 1.2 1999/07/28 00:23:38 d3e129 Exp $\n*\n subroutine dcopy(n,dx,incx,dy,incy)\nc\nc copies a ve"
},
{
"path": "src/apps/moldft/fci/ddot.F",
"chars": 1244,
"preview": "*\n* $Id: ddot.F,v 1.2 1999/07/28 00:23:38 d3e129 Exp $\n*\n double precision function ddot(n,dx,incx,dy,incy)\nc\nc "
},
{
"path": "src/apps/moldft/fci/dgemm.F",
"chars": 13890,
"preview": "*\n* $Id: dgemm.F,v 1.2 1999/07/28 00:23:38 d3e129 Exp $\n*\n SUBROUTINE DGEMM (TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,"
},
{
"path": "src/apps/moldft/fci/doc/GNUmakefile",
"chars": 366,
"preview": "\nSOURCE = matrixelements.tex \\\n mspingraph.eps orbitalgraph.eps spingraph.eps \\\n orbitalarcs.eps "
},
{
"path": "src/apps/moldft/fci/doc/bibstuff.tex",
"chars": 417,
"preview": "\n% \\journal{label}{authors}{journal}{volume}{year}{page}\n\n% \\book{label}{authors}{title}{publisher}{year}\n\n% chem phys l"
},
{
"path": "src/apps/moldft/fci/doc/commands.tex",
"chars": 2271,
"preview": "\\newcommand{\\abinitio}{\\mbox{\\em ab initio\\/}}\n\\newcommand{\\Abinitio}{\\mbox{\\em Ab initio\\/}}\n\\newcommand{\\AbInitio}{\\mb"
},
{
"path": "src/apps/moldft/fci/doc/matrixelements.ps",
"chars": 344384,
"preview": "%!PS-Adobe-2.0\n%%Creator: dvips(k) 5.96.1 Copyright 2007 Radical Eye Software\n%%Title: matrixelements.dvi\n%%CreationDate"
},
{
"path": "src/apps/moldft/fci/doc/matrixelements.tex",
"chars": 59791,
"preview": "\\documentstyle [psfig,12pt,fleqn]{article}\n\n\\input{commands}\n\\input{bibstuff}\n\n\\newcommand{\\RN}[1]{\\underline{r}_{#1}}\n\\"
},
{
"path": "src/apps/moldft/fci/doc/matrixelements.toc",
"chars": 3671,
"preview": "\\contentsline {section}{\\numberline {1}Introduction}{4}\n\\contentsline {section}{\\numberline {2}Determinant bases}{4}\n\\co"
},
{
"path": "src/apps/moldft/fci/doc/mspingraph.eps",
"chars": 5450,
"preview": "%!PS-Adobe-2.0 EPSF\n%%Title: /tmp/xfig-fig009186\n%%Creator: fig2dev\n%%CreationDate: Tue Nov 26 18:17:07 1996\n%%For: d3g6"
},
{
"path": "src/apps/moldft/fci/doc/mspingraph.fig",
"chars": 2714,
"preview": "#FIG 2.1\n80 2\n6 7 8 414 345\n2 1 0 1 -1 0 0 0 0.000 -1 0 0\n\t 62 182 382 182 9999 9999\n2 1 0 1 -1 0 0 0 0.000 -1 0 0\n\t 62 "
},
{
"path": "src/apps/moldft/fci/doc/orbitalarcs.eps",
"chars": 2409,
"preview": "%!PS-Adobe-2.0 EPSF\n%%Title: /tmp/xfig-fig009186\n%%Creator: fig2dev\n%%CreationDate: Wed Nov 27 18:40:01 1996\n%%For: d3g6"
},
{
"path": "src/apps/moldft/fci/doc/orbitalarcs.fig",
"chars": 829,
"preview": "#FIG 2.1\n80 2\n6 119 49 164 79\n4 0 0 12 0 -1 0 0.00000 4 9 8 119 69 Z\u0001\n4 0 0 12 0 -1 0 0.00000 4 12 32 129 64 (l-1)2\u0001\n4 0"
}
]
// ... and 1871 more files (download for full content)
About this extraction
This page contains the full source code of the m-a-d-n-e-s-s/madness GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2071 files (75.9 MB), approximately 8.8M tokens, and a symbol index with 14309 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.