prg_c_interface.F90

Go to the documentation of this file.

module prg_c_interface
 
  use iso_c_binding
 
  use prg_densitymatrix_mod
  use prg_charges_mod
  use prg_chebyshev_mod
  use prg_ewald_mod
  use prg_dos_mod
  use prg_genz_mod
  use prg_graphsolver_mod
  use prg_normalize_mod
  use prg_system_mod
  use prg_openfiles_mod
  use prg_parallel_mod
  use prg_progress_mod
  use prg_pulaycomponent_mod
  use prg_sp2_fermi_mod
  use prg_sp2_mod
  use prg_timer_mod
  use bml_types_m
  use prg_implicit_fermi_mod
 
  implicit none
 
  public :: prg_version_c
  public :: prg_progress_init_c
  public :: prg_progress_shutdown_c
 
  ! density matrix module
  public :: prg_build_density_t0_c
  public :: prg_check_idempotency_c, prg_get_eigenvalues_c
  public :: prg_get_flevel_c, prg_build_density_t_c, prg_build_atomic_density_c
  public :: prg_build_density_t_fermi_c, prg_get_flevel_nt_c, prg_build_density_t_fulldata_c
  public :: prg_build_density_t_ed_c, prg_toeigenspace_c, prg_tocanonicalspace_c
  public :: canon_dm_prt_c, prg_get_evalsdvalsevects_c, prg_build_density_fromevalsandevects_c
 
contains
 
  function string_c2f(c_str) result(f_str)
    character(c_char), dimension(:), intent(in) :: c_str
    character(len=size(c_str)) :: f_str
    integer :: i
    do i = 1, size(c_str)
      if (c_str(i) == c_null_char) exit
      f_str(i:i) = c_str(i)
    end do
  end function string_c2f
 
  ! C wrapper subroutine
  subroutine prg_version_c() bind(C, name="prg_version")
    call prg_version()
  end subroutine prg_version_c
 
  subroutine prg_progress_init_c() bind(C, name="prg_progress_init")
    call prg_progress_init()
  end subroutine prg_progress_init_c
 
  subroutine prg_progress_shutdown_c() bind(C, name="prg_progress_shutdown")
    call prg_progress_shutdown()
  end subroutine prg_progress_shutdown_c
 
 
  !------------------------------------------------
  !  Beginning of prg_densitymatrix_mod
  !------------------------------------------------
 
  subroutine prg_build_density_t0_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil,&
       eigenvalues_out) bind(C, name="prg_build_density_T0")
    integer(c_int), value :: norbs
    real(c_double), intent(in), value :: threshold, bndfil
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_build_density_t0(ham_bml, rho_bml, threshold, bndfil, eigenvalues)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
 
  end subroutine prg_build_density_t0_c
 
  subroutine prg_build_density_t_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil, kbt,&
       ef, eigenvalues_out) bind(C, name="prg_build_density_T")
    integer(c_int), value :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_t(ham_bml, rho_bml, threshold, bndfil, kbt, ef, eigenvalues)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
  end subroutine prg_build_density_t_c
 
  subroutine prg_build_density_t_fulldata_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil, kbt, &
       ef, eigenvalues_out, evects_bml_c, fvals_out) bind(C, name="prg_build_density_T_fulldata")
    integer(c_int), value :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double) :: fvals_out(norbs)
 
    real(c_double), allocatable :: fvals(:)
    real(c_double), allocatable :: eigenvalues(:)
 
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    type(bml_matrix_t) :: evects_bml
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    evects_bml%ptr = evects_bml_c
    call prg_build_density_t_fulldata(ham_bml, rho_bml, threshold, bndfil, kbt, ef,&
         eigenvalues, evects_bml, fvals)
    fvals_out = fvals
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
    deallocate(fvals)
 
  end subroutine prg_build_density_t_fulldata_c
 
  subroutine prg_build_density_t_ed_c(norbs, ham_bml_c, rho_bml_c, evects_bml_c, threshold,&
       bndfil, kbt, ef, evals_out, dvals_out, hindex_out, llsize, verbose)&
       bind(C, name="prg_build_density_T_ed")
    integer(c_int), value :: norbs
    integer(c_int), value :: llsize
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: evals_out(norbs)
    real(c_double) :: dvals_out(norbs)
    integer(c_int) :: hindex_out(norbs, norbs)
 
    integer(c_int), allocatable  :: hindex(:,:)
    real(c_double), allocatable  :: evals(:)
    real(c_double), allocatable  :: dvals(:)
 
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    evects_bml%ptr = evects_bml_c
 
    call prg_build_density_t_ed(ham_bml, rho_bml, evects_bml, threshold, bndfil, kbt, ef, evals,&
         dvals, hindex, llsize, verbose)
 
    evals_out = evals
    dvals_out = dvals
    hindex_out = hindex
    deallocate(evals)
    deallocate(dvals)
    deallocate(hindex)
 
  end subroutine prg_build_density_t_ed_c
 
  subroutine prg_get_evalsdvalsevects_c(norbs, ham_bml_c, threshold, hindex_in, llsize, evals_out,&
       dvals_out, evects_bml_c, verbose) bind(C, name="prg_get_evalsDvalsEvects")
    integer(c_int), value :: norbs, llsize, verbose
    real(c_double), value :: threshold
    integer(c_int)  :: hindex_in(norbs,norbs)
    real(c_double)  :: evals_out(norbs)
    real(c_double)  :: dvals_out(norbs)
    integer(c_int), allocatable  :: hindex(:,:)
    real(c_double), allocatable  :: evals(:)
    real(c_double), allocatable  :: dvals(:)
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: evects_bml_c
 
    ham_bml%ptr = ham_bml_c
    evects_bml%ptr = evects_bml_c
    allocate(hindex(2, llsize))
    hindex = hindex_in
    call prg_get_evalsdvalsevects(ham_bml, threshold, hindex, llsize, evals, dvals, evects_bml,&
         verbose)
    evals_out = evals
    dvals_out = dvals
    deallocate(hindex, evals, dvals)
 
  end subroutine prg_get_evalsdvalsevects_c
 
  subroutine prg_build_density_fromevalsandevects_c(norbs,evects_bml_c, evals,rho_bml_c,threshold,&
       bndfil, kbt, ef, verbose) bind(C, name="prg_build_density_fromEvalsAndEvects")
    integer(c_int), value :: norbs, verbose
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: evals(norbs)
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
 
    evects_bml%ptr = evects_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_fromevalsandevects(evects_bml, evals, rho_bml, threshold, bndfil, kbt,&
         ef, verbose)
 
  end subroutine prg_build_density_fromevalsandevects_c
 
  subroutine prg_build_density_t_fermi_c(ham_bml_c, rho_bml_c, threshold, kbt, ef, verbose, drho)&
       bind(C, name="prg_build_density_T_fermi")
    integer(c_int), value  :: verbose
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    real(c_double), intent(inout) :: drho
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_t_fermi(ham_bml, rho_bml, threshold, kbt, ef, verbose, drho)
  end subroutine prg_build_density_t_fermi_c
 
  subroutine prg_build_atomic_density_c(rhoat_bml_c, numel, hindex, spindex, norb, bml_type)&
       bind(C, name="prg_build_atomic_density")
    character(c_char), value :: bml_type
    integer(c_int), target :: hindex(norb, norb)
    integer(c_int), value :: norb
    integer(c_int), target :: spindex(norb)
    real(c_double), target :: numel(norb)
    type(c_ptr), value :: rhoat_bml_c
    type(bml_matrix_t) :: rhoat_bml
    rhoat_bml%ptr = rhoat_bml_c
    call prg_build_atomic_density(rhoat_bml, numel, hindex, spindex, norb, bml_type)
  end subroutine prg_build_atomic_density_c
 
  subroutine prg_get_flevel_c(norbs, eigenvalues, kbt, bndfil, tol, Ef)&
       bind(C, name="prg_get_flevel")
    integer(c_int) :: norbs
    real(c_double), value :: tol
    real(c_double), value :: bndfil
    real(c_double), target :: eigenvalues(norbs)
    real(c_double), value :: kbt
    real(c_double), value :: ef
    logical :: err
    call prg_get_flevel(eigenvalues, kbt, bndfil, tol, ef, err)
  end subroutine prg_get_flevel_c
 
  subroutine prg_get_flevel_nt_c(norbs, eigenvalues, kbt, bndfil, tol, ef, verbose)&
       bind(C, name="prg_get_flevel_nt")
    integer(c_int) :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: kbt
    real(c_double), value :: tol
    real(c_double), target :: eigenvalues(norbs)
    real(c_double), value :: ef
    integer(c_int), optional  :: verbose
    logical :: err
    call prg_get_flevel_nt(eigenvalues, kbt, bndfil, tol, ef, err, verbose)
  end subroutine prg_get_flevel_nt_c
 
  subroutine prg_get_eigenvalues_c(norbs, ham_bml_c, eigenvalues_out, verbose)&
       bind(C, name="prg_get_eigenvalues")
    integer(c_int) :: norbs
    integer(c_int), value :: verbose
    real(c_double)     :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    ham_bml%ptr = ham_bml_c
    call prg_get_eigenvalues(ham_bml, eigenvalues, verbose)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
  end subroutine prg_get_eigenvalues_c
 
  subroutine prg_check_idempotency_c(mat_bml_c, threshold, idempotency)&
       bind(C, name="prg_check_idempotency")
    real(c_double), value :: threshold
    real(c_double), intent(inout) :: idempotency
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    mat_bml%ptr = mat_bml_c
 
    call prg_check_idempotency(mat_bml, threshold, idempotency)
 
  end subroutine prg_check_idempotency_c
 
  subroutine prg_toeigenspace_c(mat_bml_c, matEig_bml_c, evects_bml_c, threshold, verbose)&
       bind(C, name="prg_toEigenspace")
    integer(c_int), optional  :: verbose
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: mateig_bml_c
    type(bml_matrix_t) :: mateig_bml
    real(c_double), value :: threshold
    mat_bml%ptr = mat_bml_c
    evects_bml%ptr = evects_bml_c
    mateig_bml%ptr = mateig_bml_c
    call prg_toeigenspace(mat_bml, mateig_bml, evects_bml, threshold, verbose)
  end subroutine prg_toeigenspace_c
 
  subroutine prg_tocanonicalspace_c(mat_bml_c, matCan_bml_c, evects_bml_c, threshold, verbose)&
       bind(C, name="prg_toCanonicalspace")
    integer(c_int), optional  :: verbose
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: matcan_bml_c
    type(bml_matrix_t) :: matcan_bml
    real(c_double), value :: threshold
    mat_bml%ptr = mat_bml_c
    evects_bml%ptr = evects_bml_c
    matcan_bml%ptr = matcan_bml_c
    call prg_tocanonicalspace(mat_bml, matcan_bml, evects_bml, threshold, verbose)
  end subroutine prg_tocanonicalspace_c
 
  subroutine canon_dm_prt_c(P1, H1, Nocc, T, Q, e, mu0, m, HDIM) bind(C, name="Canon_DM_PRT")
    integer(c_int), value :: hdim
    integer(c_int), value :: m
    real(c_double), intent(in) :: h1(hdim, hdim), q(hdim, hdim), e(hdim)
    real(c_double), intent(out) :: p1(hdim, hdim)
    real(c_double), value :: t, mu0, nocc
 
    call canon_dm_prt(p1, h1, nocc, t, q, e, mu0, m, hdim)
  end subroutine canon_dm_prt_c
 
  !------------------------------------------------
  !  end of prg_densitymatrix_mod
  !------------------------------------------------
 
  !------------------------------------------------
  !  Beginning of prg_charges_mod
  !------------------------------------------------
  subroutine prg_get_charges_c(nats, norbs, rho_bml_c, over_bml_c, hindex, charges, numel,&
       spindex, mdimin, threshold) bind(C, name="prg_get_charges")
    integer(c_int), value :: nats, norbs
    integer(c_int), value :: mdimin
    integer(c_int) :: hindex(nats,nats)
    integer(c_int) :: spindex(nats)
    real(c_double) :: charges_out(nats)
    real(c_double) :: numel_in(norbs)
    real(c_double), value :: threshold
 
    real(c_double), allocatable :: charges(:)
    real(c_double), allocatable :: numel(:)
 
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    over_bml%ptr = over_bml_c
    rho_bml%ptr = rho_bml_c
    allocate(numel(norbs))
    numel = numel_in
    call prg_get_charges(rho_bml, over_bml, hindex, charges, numel, spindex, mdimin, threshold)
    charges_out = charges
    deallocate(charges, numel)
 
  end subroutine prg_get_charges_c
 
  subroutine prg_get_hscf_c(nats, ham0_bml_c, over_bml_c, ham_bml_c, spindex, hindex, hubbardu,&
       charges, coulomb_pot_r, coulomb_pot_k, mdimin, threshold) bind(C, name="prg_get_hscf")
    integer(c_int), value :: nats
    integer(c_int), target :: hindex(nats, nats)
    integer(c_int), value :: mdimin
    integer(c_int), target :: spindex(nats)
    real(c_double), target :: charges(nats)
    real(c_double), target :: coulomb_pot_r(nats)
    real(c_double), target :: coulomb_pot_k(nats)
    real(c_double), target :: hubbardu(nats)
    real(c_double), value :: threshold
    type(c_ptr), value :: ham0_bml_c
    type(bml_matrix_t) :: ham0_bml
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    ham0_bml%ptr = ham0_bml_c
    over_bml%ptr = over_bml_c
    ham_bml%ptr = ham_bml_c
    call prg_get_hscf(ham0_bml, over_bml, ham_bml, spindex, hindex, hubbardu, charges,&
         coulomb_pot_r, coulomb_pot_k, mdimin, threshold)
  end subroutine prg_get_hscf_c
 
  subroutine prg_get_hscf_v2_c(nats, ham0_bml_c, over_bml_c, ham_bml_c, spindex, hindex, hubbardu,&
       charges, coulomb_pot_r, coulomb_pot_k, mdimin, threshold) bind(C, name="prg_get_hscf_v2")
    integer(c_int), value :: nats
    integer(c_int) :: hindex(nats, nats)
    integer(c_int), value :: mdimin
    real(c_double), value :: threshold
    integer(c_int) :: spindex(nats)
    real(c_double) :: charges(nats)
    real(c_double) :: coulomb_pot_r(nats)
    real(c_double) :: coulomb_pot_k(nats)
    real(c_double) :: hubbardu(nats)
    type(c_ptr), value :: ham0_bml_c
    type(bml_matrix_t) :: ham0_bml
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
 
    ham0_bml%ptr = ham0_bml_c
    over_bml%ptr = over_bml_c
    ham_bml%ptr = ham_bml_c
    call prg_get_hscf_v2(ham0_bml, over_bml, ham_bml, spindex, hindex, hubbardu, charges,&
         coulomb_pot_r, coulomb_pot_k, mdimin, threshold)
  end subroutine prg_get_hscf_v2_c
 
  !------------------------------------------------
  !  End of prg_charges_mod
  !------------------------------------------------
 
 
  !------------------------------------------------
  !  prg_implicit_fermi_mod
  !------------------------------------------------
  subroutine prg_implicit_fermi_save_inverse_c(Inv_bml_c, h_bml_c, p_bml_c, nsteps, nocc, mu,&
       beta, occErrLimit, threshold, tol, SCF_IT, occiter, totns)&
       bind(C, name="prg_implicit_fermi_save_inverse")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: p_bml_c
    type(bml_matrix_t) :: p_bml
    type(c_ptr), target :: Inv_bml_c(nsteps)
    type(bml_matrix_t) :: Inv_bml(nsteps)
    integer(c_int), value :: nsteps
    integer(c_int), value :: SCF_IT
    real(c_double), value :: nocc
    real(c_double), value :: threshold
    real(c_double), value :: tol
    real(c_double), value :: occErrLimit
    real(c_double), value :: beta
    real(c_double), intent(inout) :: mu
    integer(c_int), value :: occiter
    integer(c_int), value :: totns
    integer :: i
    h_bml%ptr = h_bml_c
    p_bml%ptr = p_bml_c
 
    ! Use the transfer intrinsic to move data from C pointer array to Fortran derived type array.
    inv_bml = transfer(inv_bml_c, inv_bml)
    call prg_implicit_fermi_save_inverse(inv_bml, h_bml, p_bml, nsteps, nocc, mu, beta,&
         occerrlimit, threshold, tol, scf_it, occiter, totns)
 
  end subroutine prg_implicit_fermi_save_inverse_c
 
  subroutine prg_implicit_fermi_c(h_bml_c, p_bml_c, nsteps, k, nocc, mu, beta, method, osteps,&
       occErrLimit, threshold, tol) bind(C, name="prg_implicit_fermi")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: p_bml_c
    type(bml_matrix_t) :: p_bml
    integer(c_int), value :: osteps
    integer(c_int), value :: nsteps
    integer(c_int), value :: method
    integer(c_int), value :: k
    real(c_double), value :: nocc
    real(c_double), value :: threshold
    real(c_double), value :: tol
    real(c_double), value :: occErrLimit
    real(c_double), value :: beta
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    p_bml%ptr = p_bml_c
    call prg_implicit_fermi(h_bml, p_bml, nsteps, k, nocc, mu, beta, method, osteps,&
         occerrlimit, threshold, tol)
  end subroutine prg_implicit_fermi_c
 
  subroutine prg_implicit_fermi_zero_c(h_bml_c, p_bml_c, nsteps, mu, method, threshold, tol)&
       bind(C, name="prg_implicit_fermi_zero")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: p_bml_c
    type(bml_matrix_t) :: p_bml
    integer(c_int), value :: nsteps
    integer(c_int), value :: method
    real(c_double), value :: mu
    real(c_double), value :: threshold
    real(c_double), value :: tol
    h_bml%ptr = h_bml_c
    p_bml%ptr = p_bml_c
    call prg_implicit_fermi_zero(h_bml, p_bml, nsteps, mu, method, threshold, tol)
  end subroutine prg_implicit_fermi_zero_c
 
  subroutine prg_implicit_fermi_first_order_response_c(H0_bml_c, H1_bml_c, P0_bml_c, P1_bml_c,&
       Inv_bml_c, nsteps, mu0, beta, nocc, threshold)&
       bind(C, name="prg_implicit_fermi_first_order_response")
    type(c_ptr), value :: H0_bml_c
    type(bml_matrix_t) :: H0_bml
    type(c_ptr), value :: H1_bml_c
    type(bml_matrix_t) :: H1_bml
    type(c_ptr), target :: Inv_bml_c(nsteps)
    type(bml_matrix_t) :: Inv_bml(nsteps)
    type(c_ptr), value :: P0_bml_c
    type(bml_matrix_t) :: P0_bml
    type(c_ptr), value :: P1_bml_c
    type(bml_matrix_t) :: P1_bml
    real(c_double), value :: mu0
    real(c_double), value :: threshold
    real(c_double), value :: beta
    real(c_double), value :: nocc
    integer(c_int), value :: nsteps
    h0_bml%ptr = h0_bml_c
    h1_bml%ptr = h1_bml_c
    p0_bml%ptr = p0_bml_c
    p1_bml%ptr = p1_bml_c
    inv_bml = transfer(inv_bml_c, inv_bml)
    call prg_implicit_fermi_first_order_response(h0_bml, h1_bml, p0_bml, p1_bml, inv_bml, nsteps,&
         mu0, beta, nocc, threshold)
  end subroutine prg_implicit_fermi_first_order_response_c
 
  subroutine prg_test_density_matrix_c(ham_bml_c, p_bml_c, beta, mu, nocc, osteps, occErrLimit, threshold) bind(C, name="prg_test_density_matrix")
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: p_bml_c
    type(bml_matrix_t) :: p_bml
    real(c_double), value :: beta
    real(c_double), value :: nocc
    real(c_double), value :: occErrLimit
    real(c_double), value :: threshold
    real(c_double), value :: mu
    integer(c_int), value :: osteps
    ham_bml%ptr = ham_bml_c
    p_bml%ptr = p_bml_c
    call prg_test_density_matrix(ham_bml, p_bml, beta, mu, nocc, osteps, occerrlimit, threshold)
  end subroutine prg_test_density_matrix_c
 
  !------------------------------------------------
  !  End of prg_implicit_fermi_mod
  !------------------------------------------------
 
  !------------------------------------------------
  ! prg_chebyshev_mod
  !------------------------------------------------
 
  subroutine prg_build_density_cheb_c(ham_bml_c, rho_bml_c, athr, threshold, ncoeffs, kbt, ef,&
       bndfil, jon, verbose) bind(C, name="prg_build_density_cheb")
    integer(c_int), value :: ncoeffs
    integer(c_int), value :: verbose
    real(c_double), value :: athr
    real(c_double), value :: kbt
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: ef
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int), value :: jon
    logical :: jon_l = .false.
    if (jon==1) jon_l = .true.
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_cheb(ham_bml, rho_bml, athr, threshold, ncoeffs, kbt, ef, bndfil,&
         jon_l, verbose)
  end subroutine prg_build_density_cheb_c
 
  subroutine prg_build_density_cheb_fermi_c(ham_bml_c, rho_bml_c, athr, threshold, ncoeffs, kbt,&
       ef, bndfil, getef, fermitol, jon, npts, trkfunc, verbose)&
       bind(C, name="prg_build_density_cheb_fermi")
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    integer(c_int), value :: npts
    integer(c_int), value :: ncoeffs
    integer(c_int), value :: verbose
    real(c_double), value :: fermitol
    real(c_double), value :: athr
    real(c_double), value :: kbt
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: ef
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    integer(c_int), value :: getef
    integer(c_int), value :: jon
    integer(c_int), value :: trkfunc
    logical :: getef_l = .false., jon_l = .false., trkfunc_l = .false.
 
    if (jon == 1) jon_l = .true.
    if (getef == 1) getef_l = .true.
    if (trkfunc == 1) trkfunc_l = .true.
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_build_density_cheb_fermi(ham_bml, rho_bml, athr, threshold, ncoeffs, kbt, ef, bndfil,&
         getef_l, fermitol, jon_l, npts, trkfunc_l, verbose)
 
  end subroutine prg_build_density_cheb_fermi_c
 
  !------------------------------------------------
  ! prg_dos_mod
  !------------------------------------------------
 
  subroutine prg_write_tdos_c(nstates, eigenvals, gamma, npts, emin, emax, filename)&
       bind(C, name="prg_write_tdos")
    integer(c_int), value :: nstates, npts
    real(c_double), target :: eigenvals(nstates)
    real(c_double), value :: emax
    real(c_double), value :: emin
    real(c_double), value :: gamma
    character(c_char), value :: filename
 
    call prg_write_tdos(eigenvals, gamma, npts, emin, emax, filename)
  end subroutine prg_write_tdos_c
 
  !------------------------------------------------
  ! prg_ewald_mod
  !------------------------------------------------
 
  subroutine ewald_real_space_single_latte_c(COULOMBV, I, RXYZ, Box, Nr_elem, DELTAQ, J, U,&
       Element_Pointer, Nr_atoms, COULACC, HDIM, Max_Nr_Neigh) bind(C, name="Ewald_Real_Space_Single_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: Nr_elem
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: J
    integer(c_int),    target :: Element_Pointer(Nr_atoms)
    real(c_double), value :: COULACC
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: U(Nr_elem)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_single_latte(coulombv, i, rxyz, box, nr_elem, deltaq, j, u, element_pointer,&
         nr_atoms, coulacc, hdim, max_nr_neigh)
  end subroutine ewald_real_space_single_latte_c
 
  subroutine ewald_real_space_single_c(COULOMBV, FCOUL, I, RX, RY, RZ, LBox, DELTAQ, J, U,&
       Element_Type, Nr_atoms, COULACC, TIMERATIO, HDIM, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space_Single")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: J
    real(c_double), value :: COULACC
    real(c_double), value :: TIMERATIO
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    real(c_double), intent(out) :: COULOMBV
    real(c_double), intent(out) :: FCOUL(3)
    call ewald_real_space_single(coulombv, fcoul, i, rx, ry, rz, lbox, deltaq, j, u, element_type,&
         nr_atoms, coulacc, timeratio, hdim, max_nr_neigh)
  end subroutine ewald_real_space_single_c
 
  subroutine ewald_real_space_matrix_latte_c(E, RXYZ, Box, U, Element_Pointer, Nr_atoms, COULACC,&
       nebcoul, totnebcoul, HDIM, Max_Nr_Neigh, Nr_Elem)&
       bind(C, name="Ewald_Real_Space_Matrix_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: Nr_Elem
    real(c_double), value :: COULACC
    real(c_double), intent(out) :: E(Nr_atoms,Nr_atoms)
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: U(Nr_elem)
    integer(c_int), target :: Element_Pointer(Nr_atoms)
    integer(c_int),    target :: totnebcoul(Nr_atoms)
    integer(c_int),    target :: nebcoul(4,Max_Nr_Neigh,Nr_atoms)
    call ewald_real_space_matrix_latte(e, rxyz, box, u, element_pointer, nr_atoms, coulacc, nebcoul,&
         totnebcoul, hdim, max_nr_neigh, nr_elem)
  end subroutine ewald_real_space_matrix_latte_c
 
  subroutine ewald_real_space_latte_c(COULOMBV, I, RXYZ, Box, DELTAQ, U, Element_Pointer, Nr_atoms,&
       COULACC, nebcoul, totnebcoul, HDIM, Max_Nr_Neigh, Nr_Elem)&
       bind(C, name="Ewald_Real_Space_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: Nr_Elem
    real(c_double), value :: COULACC
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_elem)
    integer(c_int), target :: Element_Pointer(Nr_atoms)
    integer(c_int),    target :: totnebcoul(Nr_atoms)
    integer(c_int),    target :: nebcoul(4,Max_Nr_Neigh,Nr_atoms)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_latte(coulombv, i, rxyz, box, deltaq, u, element_pointer, nr_atoms, coulacc, &
         nebcoul, totnebcoul, hdim, max_nr_neigh, nr_elem)
  end subroutine ewald_real_space_latte_c
 
  subroutine ewald_real_space_test_c(COULOMBV, I, RX, RY, RZ, LBox, DELTAQ, U, Element_Type,&
       Nr_atoms, COULACC, nnRx, nnRy, nnRz, nrnnlist, nnType, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space_Test")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    real(c_double), value :: COULACC
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    integer(c_int),    target :: nrnnlist(Nr_atoms)
    integer(c_int),    target :: nnType(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRx(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRy(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRz(Nr_atoms,Max_Nr_Neigh)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_test(coulombv, i, rx, ry, rz, lbox, deltaq, u, element_type, nr_atoms,&
         coulacc, nnrx, nnry, nnrz, nrnnlist, nntype, max_nr_neigh)
  end subroutine ewald_real_space_test_c
 
  subroutine ewald_real_space_c(COULOMBV, FCOUL, I, RX, RY, RZ, LBox, DELTAQ, U, Element_Type,&
       Nr_atoms, COULACC, TIMERATIO, nnRx, nnRy, nnRz, nrnnlist, nnType, HDIM, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    real(c_double), value :: COULACC
    real(c_double), value :: TIMERATIO
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    integer(c_int),    target :: nrnnlist(Nr_atoms)
    integer(c_int),    target :: nnType(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRx(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRy(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRz(Nr_atoms,Max_Nr_Neigh)
    real(c_double), intent(out) :: COULOMBV
    real(c_double), intent(out) :: FCOUL(3)
    call ewald_real_space(coulombv, fcoul, i, rx, ry, rz, lbox, deltaq, u, element_type, nr_atoms,&
         coulacc, timeratio, nnrx, nnry, nnrz, nrnnlist, nntype, hdim, max_nr_neigh)
  end subroutine ewald_real_space_c
 
  !------------------------------------------------
  ! prg_genz_mod
  !------------------------------------------------
 
  subroutine prg_init_zspmat_c(igenz, zk1_bml_c, zk2_bml_c, zk3_bml_c, zk4_bml_c,&
       zk5_bml_c, zk6_bml_c, norb, bml_type, bml_element_type) &
       bind(C, name="prg_init_ZSPmat")
    integer(c_int), value :: norb
    integer(c_int), value :: igenz
    character(c_char), value :: bml_type
    character(c_char), value :: bml_element_type
    type(c_ptr), value :: zk1_bml_c
    type(bml_matrix_t) :: zk1_bml
    type(c_ptr), value :: zk2_bml_c
    type(bml_matrix_t) :: zk2_bml
    type(c_ptr), value :: zk3_bml_c
    type(bml_matrix_t) :: zk3_bml
    type(c_ptr), value :: zk4_bml_c
    type(bml_matrix_t) :: zk4_bml
    type(c_ptr), value :: zk5_bml_c
    type(bml_matrix_t) :: zk5_bml
    type(c_ptr), value :: zk6_bml_c
    type(bml_matrix_t) :: zk6_bml
    zk1_bml%ptr = zk1_bml_c
    zk2_bml%ptr = zk2_bml_c
    zk3_bml%ptr = zk3_bml_c
    zk4_bml%ptr = zk4_bml_c
    zk5_bml%ptr = zk5_bml_c
    zk6_bml%ptr = zk6_bml_c
    call prg_init_zspmat(igenz, zk1_bml, zk2_bml, zk3_bml, zk4_bml, zk5_bml, zk6_bml, norb, bml_type, bml_element_type)
  end subroutine prg_init_zspmat_c
 
  subroutine prg_genz_sp_initialz0_c(smat_bml_c, zmat_bml_c, norb, mdim, bml_type_f, threshold)&
       bind(C, name="prg_genz_sp_initialz0")
    character(c_char), value :: bml_type_f
    integer(c_int), value :: mdim
    integer(c_int), value :: norb
    real(c_double), value :: threshold
    type(c_ptr), value :: zmat_bml_c
    type(bml_matrix_t) :: zmat_bml
    type(c_ptr), value :: smat_bml_c
    type(bml_matrix_t) :: smat_bml
    zmat_bml%ptr = zmat_bml_c
    smat_bml%ptr = smat_bml_c
    call prg_genz_sp_initialz0(smat_bml, zmat_bml, norb, mdim, bml_type_f, threshold)
  end subroutine prg_genz_sp_initialz0_c
 
  subroutine prg_genz_sp_initial_zmat_c(smat_bml_c, zmat_bml_c, norb, mdim, bml_type_f, threshold)&
       bind(C, name="prg_genz_sp_initial_zmat")
    character(c_char), value :: bml_type_f
    integer(c_int), value :: mdim
    integer(c_int), value :: norb
    real(c_double), value :: threshold
    type(c_ptr), value :: zmat_bml_c
    type(bml_matrix_t) :: zmat_bml
    type(c_ptr), value :: smat_bml_c
    type(bml_matrix_t) :: smat_bml
    zmat_bml%ptr = zmat_bml_c
    smat_bml%ptr = smat_bml_c
    call prg_genz_sp_initial_zmat(smat_bml, zmat_bml, norb, mdim, bml_type_f, threshold)
  end subroutine prg_genz_sp_initial_zmat_c
 
  subroutine prg_genz_sp_ref_c(smat_bml_c, zmat_bml_c, nref, norb, bml_type, threshold)&
       bind(C, name="prg_genz_sp_ref")
    integer(c_int), value :: norb
    integer(c_int), value :: nref
    character(c_char), value :: bml_type
    real(c_double), value :: threshold
    type(c_ptr), value :: smat_bml_c
    type(c_ptr), value :: zmat_bml_c
    type(bml_matrix_t) :: smat_bml
    type(bml_matrix_t) :: zmat_bml
    smat_bml%ptr = smat_bml_c
    zmat_bml%ptr = zmat_bml_c
    call prg_genz_sp_ref(smat_bml, zmat_bml, nref, norb, bml_type, threshold)
  end subroutine prg_genz_sp_ref_c
 
  !------------------------------------------------
  ! prg_normalize_mod
  !------------------------------------------------
 
  subroutine prg_normalize_c(h_bml_c) bind(C, name="prg_normalize")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    h_bml%ptr = h_bml_c
    call prg_normalize(h_bml)
  end subroutine prg_normalize_c
 
  subroutine prg_normalize_fermi_c(h_bml_c, h1, hN, mu) bind(C, name="prg_normalize_fermi")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: h1
    real(c_double), value :: hN
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    call prg_normalize_fermi(h_bml, h1, hn, mu)
  end subroutine prg_normalize_fermi_c
 
  subroutine prg_normalize_implicit_fermi_c(h_bml_c, cnst, mu)&
       bind(C, name="prg_normalize_implicit_fermi")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: cnst
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    call prg_normalize_implicit_fermi(h_bml, cnst, mu)
  end subroutine prg_normalize_implicit_fermi_c
 
  subroutine prg_normalize_cheb_c(h_bml_c, mu, emin, emax, alpha, scaledmu)&
       bind(C, name="prg_normalize_cheb")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: mu
    real(c_double), value :: emin
    real(c_double), value :: emax
    real(c_double), value :: scaledmu
    real(c_double), value :: alpha
    h_bml%ptr = h_bml_c
    call prg_normalize_cheb(h_bml, mu, emin, emax, alpha, scaledmu)
  end subroutine prg_normalize_cheb_c
 
  !------------------------------------------------
  ! prg_sys_mod
  !------------------------------------------------
 
  subroutine prg_get_nameandext_c(fullfilename, filename, ext) bind(C, name="prg_get_nameandext")
    character(c_char), value :: fullfilename
    character(c_char), value :: filename
    character(c_char), value :: ext
    call prg_get_nameandext(fullfilename, filename, ext)
  end subroutine prg_get_nameandext_c
 
  !------------------------------------------------
  ! prg_sp2_mod
  !------------------------------------------------
 
  subroutine prg_sp2_fermi_init_c(h_bml_c, nsteps, nocc, tscale, threshold, occErrLimit,&
       traceLimit, x_bml_c, mu, beta, h1, hN, sgnlist, verbose) &
       bind(C, name="prg_sp2_fermi_init")
    type(c_ptr), value :: h_bml_c
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: h_bml
    type(bml_matrix_t) :: x_bml
    integer(c_int), value :: nsteps
    integer(c_int), intent(inout) :: sgnlist(nsteps)
    integer(c_int), value :: verbose
    real(c_double), value :: nocc
    real(c_double), value :: tscale
    real(c_double), value :: threshold
    real(c_double), value :: occErrLimit
    real(c_double), value :: traceLimit
    real(c_double), intent(inout) :: mu
    real(c_double), intent(inout) :: beta
    real(c_double), intent(inout) :: h1
    real(c_double), intent(inout) :: hN
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi_init(h_bml, nsteps, nocc, tscale, threshold, occerrlimit, tracelimit,&
         x_bml, mu, beta, h1, hn, sgnlist)
  end subroutine prg_sp2_fermi_init_c
 
  subroutine prg_sp2_fermi_init_norecs_c(h_bml_c, nsteps, nocc, tscale, threshold, occErrLimit,&
       traceLimit, x_bml_c, mu, beta, h1, hN, sgnlist, verbose)&
       bind(C, name="prg_sp2_fermi_init_norecs")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: x_bml
    integer(c_int), intent(inout) :: nsteps
    integer(c_int), intent(inout) :: sgnlist(nsteps)
    real(c_double), value :: nocc
    real(c_double), value :: tscale
    real(c_double), value :: threshold
    real(c_double), value :: occErrLimit
    real(c_double), value :: traceLimit
    real(c_double), intent(inout) :: mu
    real(c_double), intent(inout) :: beta
    real(c_double), intent(inout) :: h1
    real(c_double), intent(inout) :: hN
    integer(c_int), value :: verbose
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi_init_norecs(h_bml, nsteps, nocc, tscale, threshold, occerrlimit,&
         tracelimit, x_bml, mu, beta, h1, hn, sgnlist, verbose)
  end subroutine prg_sp2_fermi_init_norecs_c
 
  subroutine prg_sp2_fermi_c(h_bml_c, osteps, nsteps, nocc, mu, beta, h1, hN, sgnlist,&
       threshold, eps, traceLimit, x_bml_c) bind(C, name="prg_sp2_fermi")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: x_bml
    integer(c_int), value :: osteps
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double), value :: nocc
    real(c_double), value :: threshold
    real(c_double), value :: eps
    real(c_double), value :: traceLimit
    real(c_double), intent(inout) :: beta
    real(c_double), intent(inout) :: h1
    real(c_double), intent(inout) :: hN
    real(c_double), intent(inout) :: mu
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi(h_bml, osteps, nsteps, nocc, mu, beta, h1, hn, sgnlist, threshold,&
         eps, tracelimit, x_bml)
  end subroutine prg_sp2_fermi_c
 
  subroutine prg_sp2_entropy_function_c(mu, h1, hN, nsteps, sgnlist, GG, ee)&
       bind(C, name="prg_sp2_entropy_function")
    real(c_double), value :: mu
    real(c_double), value :: h1
    real(c_double), value :: hN
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double) :: GG(1001)
    real(c_double) :: ee(1001)
    real(c_double), allocatable :: GG_tmp(:), ee_tmp(:)
    call prg_sp2_entropy_function(mu, h1, hn, nsteps, sgnlist, gg_tmp, ee_tmp)
    gg = gg_tmp
    ee = ee_tmp
    deallocate(gg_tmp, ee_tmp)
  end subroutine prg_sp2_entropy_function_c
 
  !------------------------------------------------
  ! prg_pulaycomponent_mod
  !------------------------------------------------
  subroutine prg_pulaycomponent0_c(rho_bml_c, ham_bml_c, pcm_bml_c, threshold, M, &
       verbose) bind(C, name="prg_PulayComponent0")
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: pcm_bml_c
    type(bml_matrix_t) :: pcm_bml
    integer(c_int), value :: M
    integer(c_int), value :: verbose
    real(c_double), value :: threshold
    rho_bml%ptr = rho_bml_c
    ham_bml%ptr = ham_bml_c
    pcm_bml%ptr = pcm_bml_c
    call prg_pulaycomponent0(rho_bml, ham_bml, pcm_bml, threshold, m, verbose)
  end subroutine prg_pulaycomponent0_c
 
  subroutine prg_pulaycomponentt_c(rho_bml_c, ham_bml_c, zmat_bml_c, pcm_bml_c, threshold, M,&
       bml_type, verbose) bind(C, name="prg_PulayComponentT")
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: zmat_bml_c
    type(bml_matrix_t) :: zmat_bml
    type(c_ptr), value :: pcm_bml_c
    type(bml_matrix_t) :: pcm_bml
    integer(c_int), value :: M
    integer(c_int), value :: verbose
    real(c_double), value :: threshold
    character(c_char), value :: bml_type
    rho_bml%ptr = rho_bml_c
    ham_bml%ptr = ham_bml_c
    zmat_bml%ptr = zmat_bml_c
    pcm_bml%ptr = pcm_bml_c
    call prg_pulaycomponentt(rho_bml, ham_bml, zmat_bml, pcm_bml, threshold, m, bml_type, verbose)
  end subroutine prg_pulaycomponentt_c
 
  subroutine prg_get_pulayforce_c(nats, zmat_bml_c, ham_bml_c, rho_bml_c, dSx_bml_c, dSy_bml_c,&
       dSz_bml_c, hindex_out, fpul_out, threshold) bind(C, name="prg_get_pulayforce")
    integer(c_int), value :: nats
    type(c_ptr), value :: dSx_bml_c
    type(bml_matrix_t) :: dSx_bml
    type(c_ptr), value :: dSy_bml_c
    type(bml_matrix_t) :: dSy_bml
    type(c_ptr), value :: dSz_bml_c
    type(bml_matrix_t) :: dSz_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: zmat_bml_c
    type(bml_matrix_t) :: zmat_bml
    integer(c_int) :: hindex_out(2,nats)
    real(c_double) :: fpul_out(3,nats)
    real(c_double), allocatable :: fpul(:,:)
    integer(c_int), allocatable :: hindex(:,:)
    real(c_double), value :: threshold
    dsx_bml%ptr = dsx_bml_c
    dsy_bml%ptr = dsy_bml_c
    dsz_bml%ptr = dsz_bml_c
    rho_bml%ptr = rho_bml_c
    ham_bml%ptr = ham_bml_c
    zmat_bml%ptr = zmat_bml_c
 
    allocate(fpul(3,nats), hindex(2,nats))
    call prg_get_pulayforce(nats, zmat_bml, ham_bml, rho_bml, dsx_bml, dsy_bml, dsz_bml, hindex, fpul, threshold)
    fpul_out = fpul
    hindex_out = hindex
    deallocate(fpul, hindex)
 
  end subroutine prg_get_pulayforce_c
 
  !------------------------------------------------
  ! prg_sp2_mod
  !------------------------------------------------
 
  subroutine prg_sp2_basic_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, verbose) bind(C, name="prg_sp2_basic")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    rho_bml%ptr = rho_bml_c
    h_bml%ptr = h_bml_c
    call prg_sp2_basic(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol, verbose)
  end subroutine prg_sp2_basic_c
 
  subroutine prg_sp2_basic_tcore_c(h_bml_c, rho_bml_c, rhofull_bml_c, threshold, bndfil, minsp2iter,&
       maxsp2iter, sp2conv, idemtol, verbose) bind(C, name="prg_sp2_basic_tcore")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: rhofull_bml_c
    type(bml_matrix_t) :: rhofull_bml
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    rho_bml%ptr = rho_bml_c
    rhofull_bml%ptr = rhofull_bml_c
    h_bml%ptr = h_bml_c
    call prg_sp2_basic_tcore(h_bml, rho_bml, rhofull_bml, threshold, bndfil, minsp2iter, maxsp2iter,&
         sp2conv, idemtol, verbose)
  end subroutine prg_sp2_basic_tcore_c
 
  subroutine prg_sp2_alg2_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, verbose) bind(C, name="prg_sp2_alg2")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    integer(c_int), value  :: verbose
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol, verbose)
  end subroutine prg_sp2_alg2_c
 
  subroutine prg_sp2_alg2_genseq_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, pp, icount, vv, verbose) bind(C, name="prg_sp2_alg2_genseq")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), intent(inout) :: icount
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    integer(c_int), target :: pp(maxsp2iter)
    real(c_double), target :: vv(maxsp2iter)
    character(c_char), value :: sp2conv
    integer(c_int), value :: verbose
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2_genseq(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol,&
         pp, icount, vv, verbose)
  end subroutine prg_sp2_alg2_genseq_c
 
  subroutine prg_sp2_alg2_seq_c(h_bml_c, rho_bml_c, threshold, pp, icount, vv, verbose)&
       bind(C, name="prg_sp2_alg2_seq")
    integer(c_int), intent(inout) :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int), value :: verbose
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2_seq(h_bml, rho_bml, threshold, pp, icount, vv, verbose)
  end subroutine prg_sp2_alg2_seq_c
 
  subroutine prg_prg_sp2_alg2_seq_inplace_c(rho_bml_c, threshold, ppsize, pp, icount, vv, mineval, maxeval) &
                                !verbose)
       bind(C, name="prg_prg_sp2_alg2_seq_inplace")
    integer(c_int), intent(inout) :: icount
    integer(c_int), value :: ppsize
    integer(c_int), target :: pp(ppsize)
    real(c_double), value :: threshold
    real(c_double), target :: vv(ppsize)
    real(c_double), value  :: mineval
    real(c_double), value  :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    !integer(c_int), value  :: verbose
    rho_bml%ptr = rho_bml_c
    call prg_prg_sp2_alg2_seq_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval) !verbose)
  end subroutine prg_prg_sp2_alg2_seq_inplace_c
 
  subroutine prg_sp2_alg1_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter,&
       sp2conv, idemtol, verbose) bind(C, name="prg_sp2_alg1")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_sp2_alg1(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
         idemtol, verbose)
  end subroutine prg_sp2_alg1_c
 
  subroutine prg_sp2_alg1_genseq_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, &
       maxsp2iter, sp2conv, idemtol, pp, icount, vv) bind(C, name="prg_sp2_alg1_genseq")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), intent(inout) :: icount
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    real(c_double), target :: vv(maxsp2iter)
    integer(c_int), target :: pp(maxsp2iter)
    character(c_char), value :: sp2conv
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg1_genseq(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol, pp, icount, vv)
  end subroutine prg_sp2_alg1_genseq_c
 
  subroutine prg_sp2_alg1_seq_c(h_bml_c, rho_bml_c, threshold, pp, icount, vv)&
       bind(C, name="prg_sp2_alg1_seq")
    integer(c_int), intent(inout) :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg1_seq(h_bml, rho_bml, threshold, pp, icount, vv)
  end subroutine prg_sp2_alg1_seq_c
 
  subroutine prg_prg_sp2_alg1_seq_inplace_c(rho_bml_c, threshold, ppsize, pp, icount, vv, mineval, maxeval)&
       bind(C, name="prg_prg_sp2_alg1_seq_inplace")
    integer(c_int), value :: ppsize
    integer(c_int), intent(inout) :: icount
    integer(c_int), target :: pp(ppsize)
    real(c_double), value :: threshold
    real(c_double), target :: vv(ppsize)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    rho_bml%ptr = rho_bml_c
    call prg_prg_sp2_alg1_seq_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval)
 
  end subroutine prg_prg_sp2_alg1_seq_inplace_c
 
  subroutine prg_sp2_submatrix_c(ham_bml_c, rho_bml_c, threshold, pp, icount, vv, mineval, maxeval,&
       core_size) bind(C, name="prg_sp2_submatrix")
    integer(c_int), intent(inout) :: icount
    integer(c_int), target :: pp(:)
    integer(c_int), value :: core_size
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_submatrix(ham_bml, rho_bml, threshold, pp, icount, vv, mineval, maxeval, core_size)
  end subroutine prg_sp2_submatrix_c
 
  subroutine prg_sp2_submatrix_inplace_c(rho_bml_c, threshold, pp, icount, vv, mineval, maxeval,&
       core_size) bind(C, name="prg_sp2_submatrix_inplace")
    integer(c_int), intent(inout) :: icount
    integer(c_int), target :: pp(:)
    integer(c_int), value :: core_size
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    rho_bml%ptr = rho_bml_c
    call prg_sp2_submatrix_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval, core_size)
  end subroutine prg_sp2_submatrix_inplace_c
 
  !------------------------------------------------
  ! prg_timer_mod
  !------------------------------------------------
 
  subroutine timer_prg_init_c() bind(C, name="timer_prg_init")
    call timer_prg_init()
  end subroutine timer_prg_init_c
 
  subroutine prg_timer_shutdown_c() bind(C, name="prg_timer_shutdown")
    call prg_timer_shutdown()
  end subroutine prg_timer_shutdown_c
 
  subroutine prg_timer_start_c(itimer, tag) bind(C, name="prg_timer_start")
    integer(c_int) :: itimer
    character(c_char), value :: tag
    call prg_timer_start(itimer, tag)
  end subroutine prg_timer_start_c
 
  subroutine prg_timer_stop_c(itimer, verbose) bind(C, name="prg_timer_stop")
    integer(c_int) :: itimer, verbose
    call prg_timer_stop(itimer, verbose)
  end subroutine prg_timer_stop_c
 
  subroutine prg_timer_collect_c() bind(C, name="prg_timer_collect")
    call prg_timer_collect()
  end subroutine prg_timer_collect_c
 
  subroutine prg_timer_results_c() bind(C, name="prg_timer_results")
    call prg_timer_results()
  end subroutine prg_timer_results_c
 
  subroutine prg_print_date_and_time_c(tag) bind(C, name="prg_print_date_and_time")
    character(c_char), value :: tag
    call prg_print_date_and_time(tag)
  end subroutine prg_print_date_and_time_c
 
 
 
  !------------------------------------------------
  ! prg_openfiles_mod
  !------------------------------------------------
 
  subroutine prg_open_file_c(io, name) bind(C, name="prg_open_file")
    character(c_char), value :: name
    integer(c_int), value :: io
    call prg_open_file(io, name)
  end subroutine prg_open_file_c
 
  subroutine prg_open_file_to_read_c(io, name) bind(C, name="prg_open_file_to_read")
    character(c_char), value :: name
    integer(c_int), value :: io
    call prg_open_file_to_read(io, name)
  end subroutine prg_open_file_to_read_c
 
  !------------------------------------------------
  ! prg_parallel_mod
  !------------------------------------------------
  subroutine prg_initparallel_c() bind(C, name="prg_initParallel")
    call prg_initparallel()
  end subroutine prg_initparallel_c
 
  subroutine prg_shutdownparallel_c() bind(C, name="prg_shutdownParallel")
    call prg_shutdownparallel()
  end subroutine prg_shutdownparallel_c
 
  subroutine prg_barrierparallel_c() bind(C, name="prg_barrierParallel")
    call prg_barrierparallel()
  end subroutine prg_barrierparallel_c
 
  subroutine sendreceiveparallel_c(sendBuf, sendLen, dest, recvBuf, recvLen, source, nreceived) bind(C, name="sendReceiveParallel")
    integer(c_int), value :: sendLen
    integer(c_int), value :: recvLen
    real(c_double), target :: sendBuf(sendLen)
    real(c_double), intent(out) :: recvBuf(recvLen)
    integer(c_int), value :: dest
    integer(c_int), value :: source
    integer(c_int), value :: nreceived
    call sendreceiveparallel(sendbuf, sendlen, dest, recvbuf, recvlen, source, nreceived)
  end subroutine sendreceiveparallel_c
 
  subroutine isendparallel_c(sendBuf, sendLen, dest) bind(C, name="isendParallel")
    real(c_double),target :: sendBuf(sendLen)
    integer(c_int),value :: sendLen
    integer(c_int),value :: dest
    call isendparallel(sendbuf, sendlen, dest)
  end subroutine isendparallel_c
 
  subroutine sendparallel_c(sendBuf, sendLen, dest) bind(C, name="sendParallel")
    real(c_double),target :: sendBuf(sendLen)
    integer(c_int),value :: sendLen
    integer(c_int),value :: dest
    call sendparallel(sendbuf, sendlen, dest)
  end subroutine sendparallel_c
 
  subroutine prg_iprg_recvparallel_c(recvBuf, recvLen, rind) bind(C, name="prg_iprg_recvParallel")
    real(c_double), target :: recvBuf(recvLen)
    integer(c_int),value :: recvLen
    integer(c_int), value :: rind
    call prg_iprg_recvparallel(recvbuf, recvlen, rind)
  end subroutine prg_iprg_recvparallel_c
 
  subroutine prg_recvparallel_c(recvBuf, recvLen) bind(C, name="prg_recvParallel")
    real(c_double), target :: recvBuf(recvLen)
    integer(c_int),value :: recvLen
    call prg_recvparallel(recvbuf, recvlen)
  end subroutine prg_recvparallel_c
 
  subroutine sumintparallel_c(sendBuf, recvBuf, icount) bind(C, name="sumIntParallel")
    integer(c_int),target :: sendBuf(icount)
    integer(c_int), target :: recvBuf(icount)
    integer(c_int),value :: icount
    call sumintparallel(sendbuf, recvbuf, icount)
  end subroutine sumintparallel_c
 
  subroutine sumrealparallel_c(sendBuf, recvBuf, icount) bind(C, name="sumRealParallel")
    real(c_double),target :: sendBuf(icount)
    real(c_double),intent(out) :: recvBuf(icount)
    integer(c_int),value :: icount
    call sumrealparallel(sendbuf, recvbuf, icount)
  end subroutine sumrealparallel_c
 
  subroutine maxintparallel_c(sendBuf, recvBuf, icount) bind(C, name="maxIntParallel")
    integer(c_int),target :: sendBuf(icount)
    integer(c_int),intent(out) :: recvBuf(icount)
    integer(c_int),value :: icount
    call maxintparallel(sendbuf, recvbuf, icount)
  end subroutine maxintparallel_c
 
  subroutine maxrealparallel_c(sendBuf, recvBuf, icount) bind(C, name="maxRealParallel")
    real(c_double),target :: sendBuf(icount)
    real(c_double),intent(out) :: recvBuf(icount)
    integer(c_int),value :: icount
    call maxrealparallel(sendbuf, recvbuf, icount)
  end subroutine maxrealparallel_c
 
  subroutine minintparallel_c(sendBuf, recvBuf, icount) bind(C, name="minIntParallel")
    integer(c_int),target :: sendBuf(icount)
    integer(c_int),intent(out) :: recvBuf(icount)
    integer(c_int),value :: icount
    call minintparallel(sendbuf, recvbuf, icount)
  end subroutine minintparallel_c
 
  subroutine minrealparallel_c(sendBuf, recvBuf, icount) bind(C, name="minRealParallel")
    real(c_double),target :: sendBuf(icount)
    real(c_double),intent(out) :: recvBuf(icount)
    integer(c_int),value :: icount
    call minrealparallel(sendbuf, recvbuf, icount)
  end subroutine minrealparallel_c
 
  subroutine prg_minrealreduce_c(rvalue) bind(C, name="prg_minRealReduce")
    real(c_double),value :: rvalue
    call prg_minrealreduce(rvalue)
  end subroutine prg_minrealreduce_c
 
  subroutine prg_maxrealreduce_c(rvalue) bind(C, name="prg_maxRealReduce")
    real(c_double),value :: rvalue
    call prg_maxrealreduce(rvalue)
  end subroutine prg_maxrealreduce_c
 
  subroutine prg_maxintreduce2_c(value1, value2) bind(C, name="prg_maxIntReduce2")
    integer(c_int),value :: value1
    integer(c_int),value :: value2
    call prg_maxintreduce2(value1, value2)
  end subroutine prg_maxintreduce2_c
 
  subroutine prg_sumintreduce2_c(value1, value2) bind(C, name="prg_sumIntReduce2")
    integer(c_int), value :: value1
    integer(c_int), value :: value2
    call prg_sumintreduce2(value1, value2)
  end subroutine prg_sumintreduce2_c
 
 
end module prg_c_interface