Sort integer array x(isize) using the radix sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. iradix should be -1 in input.
Sort integer array x(isize) using the radix sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. iradix should be -1 in input.
Sort integer array x(isize) using the radix sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. iradix should be -1 in input.
Sort integer array x(isize) using the radix sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. iradix should be -1 in input.
Sort integer array x(isize) using the radix sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. iradix should be -1 in input.
Theta phi values together with the weights values for the angular integration : integral [dphi,dtheta] f(x,y,z) = 4 * pi * sum (1<i<n_points_integration_angular_lebedev) f(xi,yi,zi) Note that theta and phi are in DEGREES !!
Theta phi values together with the weights values for the angular integration : integral [dphi,dtheta] f(x,y,z) = 4 * pi * sum (1<i<n_points_integration_angular_lebedev) f(xi,yi,zi) Note that theta and phi are in DEGREES !!
Theta phi values together with the weights values for the angular integration : integral [dphi,dtheta] f(x,y,z) = 4 * pi * sum (1<i<n_points_integration_angular_lebedev) f(xi,yi,zi) Note that theta and phi are in DEGREES !!
Subroutines / functions
-----------------------
..c:function:: a_coef
..code:: text
double precision function a_coef(n)
File: :file:`need.irp.f`
..c:function:: add_poly
..code:: text
subroutine add_poly(b,nb,c,nc,d,nd)
File: :file:`integration.irp.f`
Add two polynomials D(t) =! D(t) +( B(t)+C(t))
..c:function:: add_poly_multiply
..code:: text
subroutine add_poly_multiply(b,nb,cst,d,nd)
File: :file:`integration.irp.f`
Add a polynomial multiplied by a constant D(t) =! D(t) +( cst * B(t))
double precision function dble_fact_even(n) result(fact2)
File: :file:`util.irp.f`
n!!
..c:function:: dble_fact_odd
..code:: text
double precision function dble_fact_odd(n) result(fact2)
File: :file:`util.irp.f`
n!!
..c:function:: dble_logfact
..code:: text
double precision function dble_logfact(n) result(logfact2)
File: :file:`util.irp.f`
n!!
..c:function:: ddfact2
..code:: text
double precision function ddfact2(n)
File: :file:`need.irp.f`
..c:function:: dset_order
..code:: text
subroutine dset_order(x,iorder,isize)
File: :file:`sort.irp.f_template_347`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A.
..c:function:: dset_order_big
..code:: text
subroutine dset_order_big(x,iorder,isize)
File: :file:`sort.irp.f_template_412`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: dsort
..code:: text
subroutine dsort(x,iorder,isize)
File: :file:`sort.irp.f_template_293`
Sort array x(isize). iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
Transform the product of (x-x_A)^a(1) (x-x_B)^b(1) (x-x_A)^a(2) (y-y_B)^b(2) (z-z_A)^a(3) (z-z_B)^b(3) exp(-(r-A)^2 alpha) exp(-(r-B)^2 beta) into fact_k (x-x_P)^iorder(1) (y-y_P)^iorder(2) (z-z_P)^iorder(3) exp(-p(r-P)^2)
..c:function:: gser
..code:: text
subroutine gser(gamser,a,x,gln)
File: :file:`need.irp.f`
..c:function:: heap_dsort
..code:: text
subroutine heap_dsort(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: heap_dsort_big
..code:: text
subroutine heap_dsort_big(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: heap_i2sort
..code:: text
subroutine heap_i2sort(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: heap_i2sort_big
..code:: text
subroutine heap_i2sort_big(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: heap_i8sort
..code:: text
subroutine heap_i8sort(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: heap_i8sort_big
..code:: text
subroutine heap_i8sort_big(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: heap_isort
..code:: text
subroutine heap_isort(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: heap_isort_big
..code:: text
subroutine heap_isort_big(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: heap_sort
..code:: text
subroutine heap_sort(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: heap_sort_big
..code:: text
subroutine heap_sort_big(x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the heap sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: hermite
..code:: text
double precision function hermite(n,x)
File: :file:`integration.irp.f`
Hermite polynomial
..c:function:: i2set_order
..code:: text
subroutine i2set_order(x,iorder,isize)
File: :file:`sort.irp.f_template_347`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A.
..c:function:: i2set_order_big
..code:: text
subroutine i2set_order_big(x,iorder,isize)
File: :file:`sort.irp.f_template_412`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: i2sort
..code:: text
subroutine i2sort(x,iorder,isize)
File: :file:`sort.irp.f_template_315`
Sort array x(isize). iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: i8set_order
..code:: text
subroutine i8set_order(x,iorder,isize)
File: :file:`sort.irp.f_template_347`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A.
..c:function:: i8set_order_big
..code:: text
subroutine i8set_order_big(x,iorder,isize)
File: :file:`sort.irp.f_template_412`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: i8sort
..code:: text
subroutine i8sort(x,iorder,isize)
File: :file:`sort.irp.f_template_315`
Sort array x(isize). iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_dsort
..code:: text
subroutine insertion_dsort (x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_dsort_big
..code:: text
subroutine insertion_dsort_big (x,iorder,isize)
File: :file:`sort.irp.f_template_412`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: insertion_i2sort
..code:: text
subroutine insertion_i2sort (x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_i2sort_big
..code:: text
subroutine insertion_i2sort_big (x,iorder,isize)
File: :file:`sort.irp.f_template_412`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: insertion_i8sort
..code:: text
subroutine insertion_i8sort (x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_i8sort_big
..code:: text
subroutine insertion_i8sort_big (x,iorder,isize)
File: :file:`sort.irp.f_template_412`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: insertion_isort
..code:: text
subroutine insertion_isort (x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_isort_big
..code:: text
subroutine insertion_isort_big (x,iorder,isize)
File: :file:`sort.irp.f_template_412`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: insertion_sort
..code:: text
subroutine insertion_sort (x,iorder,isize)
File: :file:`sort.irp.f_template_261`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
..c:function:: insertion_sort_big
..code:: text
subroutine insertion_sort_big (x,iorder,isize)
File: :file:`sort.irp.f_template_412`
Sort array x(isize) using the insertion sort algorithm. iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: iset_order
..code:: text
subroutine iset_order(x,iorder,isize)
File: :file:`sort.irp.f_template_347`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A.
..c:function:: iset_order_big
..code:: text
subroutine iset_order_big(x,iorder,isize)
File: :file:`sort.irp.f_template_412`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: isort
..code:: text
subroutine isort(x,iorder,isize)
File: :file:`sort.irp.f_template_315`
Sort array x(isize). iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.
double precision function rint_sum(n_pt_out,rho,d1)
File: :file:`integration.irp.f`
Needed for the calculation of two-electron integrals.
..c:function:: rinteg
..code:: text
double precision function rinteg(n,u)
File: :file:`need.irp.f`
..c:function:: rintgauss
..code:: text
double precision function rintgauss(n)
File: :file:`need.irp.f`
..c:function:: sabpartial
..code:: text
double precision function SABpartial(zA,zB,A,B,nA,nB,gamA,gamB,l)
File: :file:`need.irp.f`
..c:function:: set_order
..code:: text
subroutine set_order(x,iorder,isize)
File: :file:`sort.irp.f_template_347`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A.
..c:function:: set_order_big
..code:: text
subroutine set_order_big(x,iorder,isize)
File: :file:`sort.irp.f_template_412`
array A has already been sorted, and iorder has contains the new order of elements of A. This subroutine changes the order of x to match the new order of A. This is a version for very large arrays where the indices need to be in integer*8 format
..c:function:: sort
..code:: text
subroutine sort(x,iorder,isize)
File: :file:`sort.irp.f_template_293`
Sort array x(isize). iorder in input should be (1,2,3,...,isize), and in output contains the new order of the elements.