710#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
711 !DIR$ ATTRIBUTES DLLEXPORT ::
brent
798#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
799 !DIR$ ATTRIBUTES DLLEXPORT ::
toms748
886#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
887 !DIR$ ATTRIBUTES DLLEXPORT ::
false
974#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
975 !DIR$ ATTRIBUTES DLLEXPORT ::
secant
1062#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1063 !DIR$ ATTRIBUTES DLLEXPORT ::
newton
1150#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1151 !DIR$ ATTRIBUTES DLLEXPORT ::
halley
1238#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1239 !DIR$ ATTRIBUTES DLLEXPORT ::
schroder
1326#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1327 !DIR$ ATTRIBUTES DLLEXPORT ::
ridders
1414#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1594 recursive module function getRootDef_RK5(getFunc, lb, ub, abstol, neval, niter)
result(root)
1595#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1596 !DEC$ ATTRIBUTES DLLEXPORT :: getRootDef_RK5
1599 procedure(
real(RKG)) :: getFunc
1600 real(RKG) ,
intent(in) :: lb, ub
1601 real(RKG) ,
intent(in) ,
optional :: abstol
1602 integer(IK) ,
intent(in) ,
optional :: niter
1603 integer(IK) ,
intent(out) ,
optional :: neval
1609 recursive module function getRootDef_RK4(getFunc, lb, ub, abstol, neval, niter)
result(root)
1610#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1611 !DEC$ ATTRIBUTES DLLEXPORT :: getRootDef_RK4
1614 procedure(
real(RKG)) :: getFunc
1615 real(RKG) ,
intent(in) :: lb, ub
1616 real(RKG) ,
intent(in) ,
optional :: abstol
1617 integer(IK) ,
intent(in) ,
optional :: niter
1618 integer(IK) ,
intent(out) ,
optional :: neval
1624 recursive module function getRootDef_RK3(getFunc, lb, ub, abstol, neval, niter)
result(root)
1625#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1626 !DEC$ ATTRIBUTES DLLEXPORT :: getRootDef_RK3
1629 procedure(
real(RKG)) :: getFunc
1630 real(RKG) ,
intent(in) :: lb, ub
1631 real(RKG) ,
intent(in) ,
optional :: abstol
1632 integer(IK) ,
intent(in) ,
optional :: niter
1633 integer(IK) ,
intent(out) ,
optional :: neval
1639 recursive module function getRootDef_RK2(getFunc, lb, ub, abstol, neval, niter)
result(root)
1640#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1641 !DEC$ ATTRIBUTES DLLEXPORT :: getRootDef_RK2
1644 procedure(
real(RKG)) :: getFunc
1645 real(RKG) ,
intent(in) :: lb, ub
1646 real(RKG) ,
intent(in) ,
optional :: abstol
1647 integer(IK) ,
intent(in) ,
optional :: niter
1648 integer(IK) ,
intent(out) ,
optional :: neval
1654 recursive module function getRootDef_RK1(getFunc, lb, ub, abstol, neval, niter)
result(root)
1655#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1656 !DEC$ ATTRIBUTES DLLEXPORT :: getRootDef_RK1
1659 procedure(
real(RKG)) :: getFunc
1660 real(RKG) ,
intent(in) :: lb, ub
1661 real(RKG) ,
intent(in) ,
optional :: abstol
1662 integer(IK) ,
intent(in) ,
optional :: niter
1663 integer(IK) ,
intent(out) ,
optional :: neval
1679 recursive module function getRootFalse_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1680#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1681 !DEC$ ATTRIBUTES DLLEXPORT :: getRootFalse_RK5
1684 procedure(
real(RKG)) :: getFunc
1685 type(false_type) ,
intent(in) :: method
1686 real(RKG) ,
intent(in) :: lb, ub
1687 real(RKG) ,
intent(in) ,
optional :: abstol
1688 integer(IK) ,
intent(in) ,
optional :: niter
1689 integer(IK) ,
intent(out) ,
optional :: neval
1695 recursive module function getRootFalse_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1696#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1697 !DEC$ ATTRIBUTES DLLEXPORT :: getRootFalse_RK4
1700 procedure(
real(RKG)) :: getFunc
1701 type(false_type) ,
intent(in) :: method
1702 real(RKG) ,
intent(in) :: lb, ub
1703 real(RKG) ,
intent(in) ,
optional :: abstol
1704 integer(IK) ,
intent(in) ,
optional :: niter
1705 integer(IK) ,
intent(out) ,
optional :: neval
1711 recursive module function getRootFalse_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1712#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1713 !DEC$ ATTRIBUTES DLLEXPORT :: getRootFalse_RK3
1716 procedure(
real(RKG)) :: getFunc
1717 type(false_type) ,
intent(in) :: method
1718 real(RKG) ,
intent(in) :: lb, ub
1719 real(RKG) ,
intent(in) ,
optional :: abstol
1720 integer(IK) ,
intent(in) ,
optional :: niter
1721 integer(IK) ,
intent(out) ,
optional :: neval
1727 recursive module function getRootFalse_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1728#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1729 !DEC$ ATTRIBUTES DLLEXPORT :: getRootFalse_RK2
1732 procedure(
real(RKG)) :: getFunc
1733 type(false_type) ,
intent(in) :: method
1734 real(RKG) ,
intent(in) :: lb, ub
1735 real(RKG) ,
intent(in) ,
optional :: abstol
1736 integer(IK) ,
intent(in) ,
optional :: niter
1737 integer(IK) ,
intent(out) ,
optional :: neval
1743 recursive module function getRootFalse_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1744#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1745 !DEC$ ATTRIBUTES DLLEXPORT :: getRootFalse_RK1
1748 procedure(
real(RKG)) :: getFunc
1749 type(false_type) ,
intent(in) :: method
1750 real(RKG) ,
intent(in) :: lb, ub
1751 real(RKG) ,
intent(in) ,
optional :: abstol
1752 integer(IK) ,
intent(in) ,
optional :: niter
1753 integer(IK) ,
intent(out) ,
optional :: neval
1769 recursive module function getRootBisection_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1770#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1771 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBisection_RK5
1774 procedure(
real(RKG)) :: getFunc
1775 type(bisection_type) ,
intent(in) :: method
1776 real(RKG) ,
intent(in) :: lb, ub
1777 real(RKG) ,
intent(in) ,
optional :: abstol
1778 integer(IK) ,
intent(in) ,
optional :: niter
1779 integer(IK) ,
intent(out) ,
optional :: neval
1785 recursive module function getRootBisection_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1786#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1787 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBisection_RK4
1790 procedure(
real(RKG)) :: getFunc
1791 type(bisection_type) ,
intent(in) :: method
1792 real(RKG) ,
intent(in) :: lb, ub
1793 real(RKG) ,
intent(in) ,
optional :: abstol
1794 integer(IK) ,
intent(in) ,
optional :: niter
1795 integer(IK) ,
intent(out) ,
optional :: neval
1801 recursive module function getRootBisection_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1802#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1803 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBisection_RK3
1806 procedure(
real(RKG)) :: getFunc
1807 type(bisection_type) ,
intent(in) :: method
1808 real(RKG) ,
intent(in) :: lb, ub
1809 real(RKG) ,
intent(in) ,
optional :: abstol
1810 integer(IK) ,
intent(in) ,
optional :: niter
1811 integer(IK) ,
intent(out) ,
optional :: neval
1817 recursive module function getRootBisection_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1818#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1819 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBisection_RK2
1822 procedure(
real(RKG)) :: getFunc
1823 type(bisection_type) ,
intent(in) :: method
1824 real(RKG) ,
intent(in) :: lb, ub
1825 real(RKG) ,
intent(in) ,
optional :: abstol
1826 integer(IK) ,
intent(in) ,
optional :: niter
1827 integer(IK) ,
intent(out) ,
optional :: neval
1833 recursive module function getRootBisection_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1834#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1835 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBisection_RK1
1838 procedure(
real(RKG)) :: getFunc
1839 type(bisection_type) ,
intent(in) :: method
1840 real(RKG) ,
intent(in) :: lb, ub
1841 real(RKG) ,
intent(in) ,
optional :: abstol
1842 integer(IK) ,
intent(in) ,
optional :: niter
1843 integer(IK) ,
intent(out) ,
optional :: neval
1859 recursive module function getRootSecant_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1860#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1861 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSecant_RK5
1864 procedure(
real(RKG)) :: getFunc
1865 type(secant_type) ,
intent(in) :: method
1866 real(RKG) ,
intent(in) :: lb, ub
1867 real(RKG) ,
intent(in) ,
optional :: abstol
1868 integer(IK) ,
intent(in) ,
optional :: niter
1869 integer(IK) ,
intent(out) ,
optional :: neval
1875 recursive module function getRootSecant_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1876#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1877 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSecant_RK4
1880 procedure(
real(RKG)) :: getFunc
1881 type(secant_type) ,
intent(in) :: method
1882 real(RKG) ,
intent(in) :: lb, ub
1883 real(RKG) ,
intent(in) ,
optional :: abstol
1884 integer(IK) ,
intent(in) ,
optional :: niter
1885 integer(IK) ,
intent(out) ,
optional :: neval
1891 recursive module function getRootSecant_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1892#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1893 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSecant_RK3
1896 procedure(
real(RKG)) :: getFunc
1897 type(secant_type) ,
intent(in) :: method
1898 real(RKG) ,
intent(in) :: lb, ub
1899 real(RKG) ,
intent(in) ,
optional :: abstol
1900 integer(IK) ,
intent(in) ,
optional :: niter
1901 integer(IK) ,
intent(out) ,
optional :: neval
1907 recursive module function getRootSecant_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1908#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1909 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSecant_RK2
1912 procedure(
real(RKG)) :: getFunc
1913 type(secant_type) ,
intent(in) :: method
1914 real(RKG) ,
intent(in) :: lb, ub
1915 real(RKG) ,
intent(in) ,
optional :: abstol
1916 integer(IK) ,
intent(in) ,
optional :: niter
1917 integer(IK) ,
intent(out) ,
optional :: neval
1923 recursive module function getRootSecant_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1924#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1925 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSecant_RK1
1928 procedure(
real(RKG)) :: getFunc
1929 type(secant_type) ,
intent(in) :: method
1930 real(RKG) ,
intent(in) :: lb, ub
1931 real(RKG) ,
intent(in) ,
optional :: abstol
1932 integer(IK) ,
intent(in) ,
optional :: niter
1933 integer(IK) ,
intent(out) ,
optional :: neval
1949 recursive module function getRootBrent_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1950#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1951 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBrent_RK5
1954 procedure(
real(RKG)) :: getFunc
1955 type(brent_type) ,
intent(in) :: method
1956 real(RKG) ,
intent(in) :: lb, ub
1957 real(RKG) ,
intent(in) ,
optional :: abstol
1958 integer(IK) ,
intent(in) ,
optional :: niter
1959 integer(IK) ,
intent(out) ,
optional :: neval
1965 recursive module function getRootBrent_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1966#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1967 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBrent_RK4
1970 procedure(
real(RKG)) :: getFunc
1971 type(brent_type) ,
intent(in) :: method
1972 real(RKG) ,
intent(in) :: lb, ub
1973 real(RKG) ,
intent(in) ,
optional :: abstol
1974 integer(IK) ,
intent(in) ,
optional :: niter
1975 integer(IK) ,
intent(out) ,
optional :: neval
1981 recursive module function getRootBrent_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1982#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1983 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBrent_RK3
1986 procedure(
real(RKG)) :: getFunc
1987 type(brent_type) ,
intent(in) :: method
1988 real(RKG) ,
intent(in) :: lb, ub
1989 real(RKG) ,
intent(in) ,
optional :: abstol
1990 integer(IK) ,
intent(in) ,
optional :: niter
1991 integer(IK) ,
intent(out) ,
optional :: neval
1997 recursive module function getRootBrent_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
1998#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1999 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBrent_RK2
2002 procedure(
real(RKG)) :: getFunc
2003 type(brent_type) ,
intent(in) :: method
2004 real(RKG) ,
intent(in) :: lb, ub
2005 real(RKG) ,
intent(in) ,
optional :: abstol
2006 integer(IK) ,
intent(in) ,
optional :: niter
2007 integer(IK) ,
intent(out) ,
optional :: neval
2013 recursive module function getRootBrent_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2014#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2015 !DEC$ ATTRIBUTES DLLEXPORT :: getRootBrent_RK1
2018 procedure(
real(RKG)) :: getFunc
2019 type(brent_type) ,
intent(in) :: method
2020 real(RKG) ,
intent(in) :: lb, ub
2021 real(RKG) ,
intent(in) ,
optional :: abstol
2022 integer(IK) ,
intent(in) ,
optional :: niter
2023 integer(IK) ,
intent(out) ,
optional :: neval
2039 recursive module function getRootRidders_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2040#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2041 !DEC$ ATTRIBUTES DLLEXPORT :: getRootRidders_RK5
2044 procedure(
real(RKG)) :: getFunc
2045 type(ridders_type) ,
intent(in) :: method
2046 real(RKG) ,
intent(in) :: lb, ub
2047 real(RKG) ,
intent(in) ,
optional :: abstol
2048 integer(IK) ,
intent(in) ,
optional :: niter
2049 integer(IK) ,
intent(out) ,
optional :: neval
2055 recursive module function getRootRidders_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2056#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2057 !DEC$ ATTRIBUTES DLLEXPORT :: getRootRidders_RK4
2060 procedure(
real(RKG)) :: getFunc
2061 type(ridders_type) ,
intent(in) :: method
2062 real(RKG) ,
intent(in) :: lb, ub
2063 real(RKG) ,
intent(in) ,
optional :: abstol
2064 integer(IK) ,
intent(in) ,
optional :: niter
2065 integer(IK) ,
intent(out) ,
optional :: neval
2071 recursive module function getRootRidders_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2072#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2073 !DEC$ ATTRIBUTES DLLEXPORT :: getRootRidders_RK3
2076 procedure(
real(RKG)) :: getFunc
2077 type(ridders_type) ,
intent(in) :: method
2078 real(RKG) ,
intent(in) :: lb, ub
2079 real(RKG) ,
intent(in) ,
optional :: abstol
2080 integer(IK) ,
intent(in) ,
optional :: niter
2081 integer(IK) ,
intent(out) ,
optional :: neval
2087 recursive module function getRootRidders_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2088#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2089 !DEC$ ATTRIBUTES DLLEXPORT :: getRootRidders_RK2
2092 procedure(
real(RKG)) :: getFunc
2093 type(ridders_type) ,
intent(in) :: method
2094 real(RKG) ,
intent(in) :: lb, ub
2095 real(RKG) ,
intent(in) ,
optional :: abstol
2096 integer(IK) ,
intent(in) ,
optional :: niter
2097 integer(IK) ,
intent(out) ,
optional :: neval
2103 recursive module function getRootRidders_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2104#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2105 !DEC$ ATTRIBUTES DLLEXPORT :: getRootRidders_RK1
2108 procedure(
real(RKG)) :: getFunc
2109 type(ridders_type) ,
intent(in) :: method
2110 real(RKG) ,
intent(in) :: lb, ub
2111 real(RKG) ,
intent(in) ,
optional :: abstol
2112 integer(IK) ,
intent(in) ,
optional :: niter
2113 integer(IK) ,
intent(out) ,
optional :: neval
2129 recursive module function getRootTOMS748_RK5(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2130#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2131 !DEC$ ATTRIBUTES DLLEXPORT :: getRootTOMS748_RK5
2134 procedure(
real(RKG)) :: getFunc
2135 type(toms748_type) ,
intent(in) :: method
2136 real(RKG) ,
intent(in) :: lb, ub
2137 real(RKG) ,
intent(in) ,
optional :: abstol
2138 integer(IK) ,
intent(in) ,
optional :: niter
2139 integer(IK) ,
intent(out) ,
optional :: neval
2145 recursive module function getRootTOMS748_RK4(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2146#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2147 !DEC$ ATTRIBUTES DLLEXPORT :: getRootTOMS748_RK4
2150 procedure(
real(RKG)) :: getFunc
2151 type(toms748_type) ,
intent(in) :: method
2152 real(RKG) ,
intent(in) :: lb, ub
2153 real(RKG) ,
intent(in) ,
optional :: abstol
2154 integer(IK) ,
intent(in) ,
optional :: niter
2155 integer(IK) ,
intent(out) ,
optional :: neval
2161 recursive module function getRootTOMS748_RK3(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2162#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2163 !DEC$ ATTRIBUTES DLLEXPORT :: getRootTOMS748_RK3
2166 procedure(
real(RKG)) :: getFunc
2167 type(toms748_type) ,
intent(in) :: method
2168 real(RKG) ,
intent(in) :: lb, ub
2169 real(RKG) ,
intent(in) ,
optional :: abstol
2170 integer(IK) ,
intent(in) ,
optional :: niter
2171 integer(IK) ,
intent(out) ,
optional :: neval
2177 recursive module function getRootTOMS748_RK2(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2178#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2179 !DEC$ ATTRIBUTES DLLEXPORT :: getRootTOMS748_RK2
2182 procedure(
real(RKG)) :: getFunc
2183 type(toms748_type) ,
intent(in) :: method
2184 real(RKG) ,
intent(in) :: lb, ub
2185 real(RKG) ,
intent(in) ,
optional :: abstol
2186 integer(IK) ,
intent(in) ,
optional :: niter
2187 integer(IK) ,
intent(out) ,
optional :: neval
2193 recursive module function getRootTOMS748_RK1(method, getFunc, lb, ub, abstol, neval, niter)
result(root)
2194#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2195 !DEC$ ATTRIBUTES DLLEXPORT :: getRootTOMS748_RK1
2198 procedure(
real(RKG)) :: getFunc
2199 type(toms748_type) ,
intent(in) :: method
2200 real(RKG) ,
intent(in) :: lb, ub
2201 real(RKG) ,
intent(in) ,
optional :: abstol
2202 integer(IK) ,
intent(in) ,
optional :: niter
2203 integer(IK) ,
intent(out) ,
optional :: neval
2219 recursive module function getRootNewton_RK5(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2220#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2221 !DEC$ ATTRIBUTES DLLEXPORT :: getRootNewton_RK5
2224 procedure(
real(RKG)) :: getFunc
2225 type(newton_type) ,
intent(in) :: method
2226 real(RKG) ,
intent(in) :: lb, ub
2227 real(RKG) ,
intent(in) ,
optional :: abstol
2228 integer(IK) ,
intent(in) ,
optional :: niter
2229 integer(IK) ,
intent(out) ,
optional :: neval
2230 real(RKG) ,
intent(in) ,
optional :: init
2236 recursive module function getRootNewton_RK4(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2237#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2238 !DEC$ ATTRIBUTES DLLEXPORT :: getRootNewton_RK4
2241 procedure(
real(RKG)) :: getFunc
2242 type(newton_type) ,
intent(in) :: method
2243 real(RKG) ,
intent(in) :: lb, ub
2244 real(RKG) ,
intent(in) ,
optional :: abstol
2245 integer(IK) ,
intent(in) ,
optional :: niter
2246 integer(IK) ,
intent(out) ,
optional :: neval
2247 real(RKG) ,
intent(in) ,
optional :: init
2253 recursive module function getRootNewton_RK3(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2254#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2255 !DEC$ ATTRIBUTES DLLEXPORT :: getRootNewton_RK3
2258 procedure(
real(RKG)) :: getFunc
2259 type(newton_type) ,
intent(in) :: method
2260 real(RKG) ,
intent(in) :: lb, ub
2261 real(RKG) ,
intent(in) ,
optional :: abstol
2262 integer(IK) ,
intent(in) ,
optional :: niter
2263 integer(IK) ,
intent(out) ,
optional :: neval
2264 real(RKG) ,
intent(in) ,
optional :: init
2270 recursive module function getRootNewton_RK2(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2271#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2272 !DEC$ ATTRIBUTES DLLEXPORT :: getRootNewton_RK2
2275 procedure(
real(RKG)) :: getFunc
2276 type(newton_type) ,
intent(in) :: method
2277 real(RKG) ,
intent(in) :: lb, ub
2278 real(RKG) ,
intent(in) ,
optional :: abstol
2279 integer(IK) ,
intent(in) ,
optional :: niter
2280 integer(IK) ,
intent(out) ,
optional :: neval
2281 real(RKG) ,
intent(in) ,
optional :: init
2287 recursive module function getRootNewton_RK1(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2288#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2289 !DEC$ ATTRIBUTES DLLEXPORT :: getRootNewton_RK1
2292 procedure(
real(RKG)) :: getFunc
2293 type(newton_type) ,
intent(in) :: method
2294 real(RKG) ,
intent(in) :: lb, ub
2295 real(RKG) ,
intent(in) ,
optional :: abstol
2296 integer(IK) ,
intent(in) ,
optional :: niter
2297 integer(IK) ,
intent(out) ,
optional :: neval
2298 real(RKG) ,
intent(in) ,
optional :: init
2314 recursive module function getRootHalley_RK5(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2315#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2316 !DEC$ ATTRIBUTES DLLEXPORT :: getRootHalley_RK5
2319 procedure(
real(RKG)) :: getFunc
2320 type(halley_type) ,
intent(in) :: method
2321 real(RKG) ,
intent(in) :: lb, ub
2322 real(RKG) ,
intent(in) ,
optional :: abstol
2323 integer(IK) ,
intent(in) ,
optional :: niter
2324 integer(IK) ,
intent(out) ,
optional :: neval
2325 real(RKG) ,
intent(in) ,
optional :: init
2331 recursive module function getRootHalley_RK4(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2332#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2333 !DEC$ ATTRIBUTES DLLEXPORT :: getRootHalley_RK4
2336 procedure(
real(RKG)) :: getFunc
2337 type(halley_type) ,
intent(in) :: method
2338 real(RKG) ,
intent(in) :: lb, ub
2339 real(RKG) ,
intent(in) ,
optional :: abstol
2340 integer(IK) ,
intent(in) ,
optional :: niter
2341 integer(IK) ,
intent(out) ,
optional :: neval
2342 real(RKG) ,
intent(in) ,
optional :: init
2348 recursive module function getRootHalley_RK3(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2349#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2350 !DEC$ ATTRIBUTES DLLEXPORT :: getRootHalley_RK3
2353 procedure(
real(RKG)) :: getFunc
2354 type(halley_type) ,
intent(in) :: method
2355 real(RKG) ,
intent(in) :: lb, ub
2356 real(RKG) ,
intent(in) ,
optional :: abstol
2357 integer(IK) ,
intent(in) ,
optional :: niter
2358 integer(IK) ,
intent(out) ,
optional :: neval
2359 real(RKG) ,
intent(in) ,
optional :: init
2365 recursive module function getRootHalley_RK2(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2366#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2367 !DEC$ ATTRIBUTES DLLEXPORT :: getRootHalley_RK2
2370 procedure(
real(RKG)) :: getFunc
2371 type(halley_type) ,
intent(in) :: method
2372 real(RKG) ,
intent(in) :: lb, ub
2373 real(RKG) ,
intent(in) ,
optional :: abstol
2374 integer(IK) ,
intent(in) ,
optional :: niter
2375 integer(IK) ,
intent(out) ,
optional :: neval
2376 real(RKG) ,
intent(in) ,
optional :: init
2382 recursive module function getRootHalley_RK1(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2383#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2384 !DEC$ ATTRIBUTES DLLEXPORT :: getRootHalley_RK1
2387 procedure(
real(RKG)) :: getFunc
2388 type(halley_type) ,
intent(in) :: method
2389 real(RKG) ,
intent(in) :: lb, ub
2390 real(RKG) ,
intent(in) ,
optional :: abstol
2391 integer(IK) ,
intent(in) ,
optional :: niter
2392 integer(IK) ,
intent(out) ,
optional :: neval
2393 real(RKG) ,
intent(in) ,
optional :: init
2409 recursive module function getRootSchroder_RK5(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2410#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2411 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSchroder_RK5
2414 procedure(
real(RKG)) :: getFunc
2415 type(schroder_type) ,
intent(in) :: method
2416 real(RKG) ,
intent(in) :: lb, ub
2417 real(RKG) ,
intent(in) ,
optional :: abstol
2418 integer(IK) ,
intent(in) ,
optional :: niter
2419 integer(IK) ,
intent(out) ,
optional :: neval
2420 real(RKG) ,
intent(in) ,
optional :: init
2426 recursive module function getRootSchroder_RK4(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2427#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2428 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSchroder_RK4
2431 procedure(
real(RKG)) :: getFunc
2432 type(schroder_type) ,
intent(in) :: method
2433 real(RKG) ,
intent(in) :: lb, ub
2434 real(RKG) ,
intent(in) ,
optional :: abstol
2435 integer(IK) ,
intent(in) ,
optional :: niter
2436 integer(IK) ,
intent(out) ,
optional :: neval
2437 real(RKG) ,
intent(in) ,
optional :: init
2443 recursive module function getRootSchroder_RK3(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2444#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2445 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSchroder_RK3
2448 procedure(
real(RKG)) :: getFunc
2449 type(schroder_type) ,
intent(in) :: method
2450 real(RKG) ,
intent(in) :: lb, ub
2451 real(RKG) ,
intent(in) ,
optional :: abstol
2452 integer(IK) ,
intent(in) ,
optional :: niter
2453 integer(IK) ,
intent(out) ,
optional :: neval
2454 real(RKG) ,
intent(in) ,
optional :: init
2460 recursive module function getRootSchroder_RK2(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2461#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2462 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSchroder_RK2
2465 procedure(
real(RKG)) :: getFunc
2466 type(schroder_type) ,
intent(in) :: method
2467 real(RKG) ,
intent(in) :: lb, ub
2468 real(RKG) ,
intent(in) ,
optional :: abstol
2469 integer(IK) ,
intent(in) ,
optional :: niter
2470 integer(IK) ,
intent(out) ,
optional :: neval
2471 real(RKG) ,
intent(in) ,
optional :: init
2477 recursive module function getRootSchroder_RK1(method, getFunc, lb, ub, abstol, neval, niter, init)
result(root)
2478#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2479 !DEC$ ATTRIBUTES DLLEXPORT :: getRootSchroder_RK1
2482 procedure(
real(RKG)) :: getFunc
2483 type(schroder_type) ,
intent(in) :: method
2484 real(RKG) ,
intent(in) :: lb, ub
2485 real(RKG) ,
intent(in) ,
optional :: abstol
2486 integer(IK) ,
intent(in) ,
optional :: niter
2487 integer(IK) ,
intent(out) ,
optional :: neval
2488 real(RKG) ,
intent(in) ,
optional :: init
2680 recursive module subroutine setRootFalseFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2681#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2682 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseFixed_RK5
2685 procedure(
real(RKG)) :: getFunc
2686 type(false_type) ,
intent(in) :: method
2687 real(RKG) ,
intent(out) :: root
2688 real(RKG) ,
value :: lb, ub
2689 real(RKG) ,
value :: lf, uf
2690 real(RKG) ,
intent(in) :: abstol
2691 integer(IK) ,
intent(out) :: neval
2696 recursive module subroutine setRootFalseFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2697#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2698 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseFixed_RK4
2701 procedure(
real(RKG)) :: getFunc
2702 type(false_type) ,
intent(in) :: method
2703 real(RKG) ,
intent(out) :: root
2704 real(RKG) ,
value :: lb, ub
2705 real(RKG) ,
value :: lf, uf
2706 real(RKG) ,
intent(in) :: abstol
2707 integer(IK) ,
intent(out) :: neval
2712 recursive module subroutine setRootFalseFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2713#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2714 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseFixed_RK3
2717 procedure(
real(RKG)) :: getFunc
2718 type(false_type) ,
intent(in) :: method
2719 real(RKG) ,
intent(out) :: root
2720 real(RKG) ,
value :: lb, ub
2721 real(RKG) ,
value :: lf, uf
2722 real(RKG) ,
intent(in) :: abstol
2723 integer(IK) ,
intent(out) :: neval
2728 recursive module subroutine setRootFalseFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2729#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2730 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseFixed_RK2
2733 procedure(
real(RKG)) :: getFunc
2734 type(false_type) ,
intent(in) :: method
2735 real(RKG) ,
intent(out) :: root
2736 real(RKG) ,
value :: lb, ub
2737 real(RKG) ,
value :: lf, uf
2738 real(RKG) ,
intent(in) :: abstol
2739 integer(IK) ,
intent(out) :: neval
2744 recursive module subroutine setRootFalseFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2745#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2746 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseFixed_RK1
2749 procedure(
real(RKG)) :: getFunc
2750 type(false_type) ,
intent(in) :: method
2751 real(RKG) ,
intent(out) :: root
2752 real(RKG) ,
value :: lb, ub
2753 real(RKG) ,
value :: lf, uf
2754 real(RKG) ,
intent(in) :: abstol
2755 integer(IK) ,
intent(out) :: neval
2762 recursive module subroutine setRootFalseNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2763#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2764 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseNiter_RK5
2767 procedure(
real(RKG)) :: getFunc
2768 type(false_type) ,
intent(in) :: method
2769 real(RKG) ,
intent(out) :: root
2770 real(RKG) ,
value :: lb, ub
2771 real(RKG) ,
value :: lf, uf
2772 real(RKG) ,
intent(in) :: abstol
2773 integer(IK) ,
intent(out) :: neval
2774 integer(IK) ,
intent(in) :: niter
2779 recursive module subroutine setRootFalseNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2780#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2781 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseNiter_RK4
2784 procedure(
real(RKG)) :: getFunc
2785 type(false_type) ,
intent(in) :: method
2786 real(RKG) ,
intent(out) :: root
2787 real(RKG) ,
value :: lb, ub
2788 real(RKG) ,
value :: lf, uf
2789 real(RKG) ,
intent(in) :: abstol
2790 integer(IK) ,
intent(out) :: neval
2791 integer(IK) ,
intent(in) :: niter
2796 recursive module subroutine setRootFalseNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2797#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2798 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseNiter_RK3
2801 procedure(
real(RKG)) :: getFunc
2802 type(false_type) ,
intent(in) :: method
2803 real(RKG) ,
intent(out) :: root
2804 real(RKG) ,
value :: lb, ub
2805 real(RKG) ,
value :: lf, uf
2806 real(RKG) ,
intent(in) :: abstol
2807 integer(IK) ,
intent(out) :: neval
2808 integer(IK) ,
intent(in) :: niter
2813 recursive module subroutine setRootFalseNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2814#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2815 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseNiter_RK2
2818 procedure(
real(RKG)) :: getFunc
2819 type(false_type) ,
intent(in) :: method
2820 real(RKG) ,
intent(out) :: root
2821 real(RKG) ,
value :: lb, ub
2822 real(RKG) ,
value :: lf, uf
2823 real(RKG) ,
intent(in) :: abstol
2824 integer(IK) ,
intent(out) :: neval
2825 integer(IK) ,
intent(in) :: niter
2830 recursive module subroutine setRootFalseNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2831#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2832 !DEC$ ATTRIBUTES DLLEXPORT :: setRootFalseNiter_RK1
2835 procedure(
real(RKG)) :: getFunc
2836 type(false_type) ,
intent(in) :: method
2837 real(RKG) ,
intent(out) :: root
2838 real(RKG) ,
value :: lb, ub
2839 real(RKG) ,
value :: lf, uf
2840 real(RKG) ,
intent(in) :: abstol
2841 integer(IK) ,
intent(out) :: neval
2842 integer(IK) ,
intent(in) :: niter
2857 recursive module subroutine setRootBisectionFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2858#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2859 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionFixed_RK5
2862 procedure(
real(RKG)) :: getFunc
2863 type(bisection_type) ,
intent(in) :: method
2864 real(RKG) ,
intent(out) :: root
2865 real(RKG) ,
value :: lb, ub
2866 real(RKG) ,
value :: lf, uf
2867 real(RKG) ,
intent(in) :: abstol
2868 integer(IK) ,
intent(out) :: neval
2873 recursive module subroutine setRootBisectionFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2874#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2875 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionFixed_RK4
2878 procedure(
real(RKG)) :: getFunc
2879 type(bisection_type) ,
intent(in) :: method
2880 real(RKG) ,
intent(out) :: root
2881 real(RKG) ,
value :: lb, ub
2882 real(RKG) ,
value :: lf, uf
2883 real(RKG) ,
intent(in) :: abstol
2884 integer(IK) ,
intent(out) :: neval
2889 recursive module subroutine setRootBisectionFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2890#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2891 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionFixed_RK3
2894 procedure(
real(RKG)) :: getFunc
2895 type(bisection_type) ,
intent(in) :: method
2896 real(RKG) ,
intent(out) :: root
2897 real(RKG) ,
value :: lb, ub
2898 real(RKG) ,
value :: lf, uf
2899 real(RKG) ,
intent(in) :: abstol
2900 integer(IK) ,
intent(out) :: neval
2905 recursive module subroutine setRootBisectionFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2906#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2907 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionFixed_RK2
2910 procedure(
real(RKG)) :: getFunc
2911 type(bisection_type) ,
intent(in) :: method
2912 real(RKG) ,
intent(out) :: root
2913 real(RKG) ,
value :: lb, ub
2914 real(RKG) ,
value :: lf, uf
2915 real(RKG) ,
intent(in) :: abstol
2916 integer(IK) ,
intent(out) :: neval
2921 recursive module subroutine setRootBisectionFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
2922#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2923 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionFixed_RK1
2926 procedure(
real(RKG)) :: getFunc
2927 type(bisection_type) ,
intent(in) :: method
2928 real(RKG) ,
intent(out) :: root
2929 real(RKG) ,
value :: lb, ub
2930 real(RKG) ,
value :: lf, uf
2931 real(RKG) ,
intent(in) :: abstol
2932 integer(IK) ,
intent(out) :: neval
2939 recursive module subroutine setRootBisectionNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2940#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2941 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionNiter_RK5
2944 procedure(
real(RKG)) :: getFunc
2945 type(bisection_type) ,
intent(in) :: method
2946 real(RKG) ,
intent(out) :: root
2947 real(RKG) ,
value :: lb, ub
2948 real(RKG) ,
value :: lf, uf
2949 real(RKG) ,
intent(in) :: abstol
2950 integer(IK) ,
intent(out) :: neval
2951 integer(IK) ,
intent(in) :: niter
2956 recursive module subroutine setRootBisectionNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2957#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2958 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionNiter_RK4
2961 procedure(
real(RKG)) :: getFunc
2962 type(bisection_type) ,
intent(in) :: method
2963 real(RKG) ,
intent(out) :: root
2964 real(RKG) ,
value :: lb, ub
2965 real(RKG) ,
value :: lf, uf
2966 real(RKG) ,
intent(in) :: abstol
2967 integer(IK) ,
intent(out) :: neval
2968 integer(IK) ,
intent(in) :: niter
2973 recursive module subroutine setRootBisectionNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2974#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2975 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionNiter_RK3
2978 procedure(
real(RKG)) :: getFunc
2979 type(bisection_type) ,
intent(in) :: method
2980 real(RKG) ,
intent(out) :: root
2981 real(RKG) ,
value :: lb, ub
2982 real(RKG) ,
value :: lf, uf
2983 real(RKG) ,
intent(in) :: abstol
2984 integer(IK) ,
intent(out) :: neval
2985 integer(IK) ,
intent(in) :: niter
2990 recursive module subroutine setRootBisectionNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
2991#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2992 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionNiter_RK2
2995 procedure(
real(RKG)) :: getFunc
2996 type(bisection_type) ,
intent(in) :: method
2997 real(RKG) ,
intent(out) :: root
2998 real(RKG) ,
value :: lb, ub
2999 real(RKG) ,
value :: lf, uf
3000 real(RKG) ,
intent(in) :: abstol
3001 integer(IK) ,
intent(out) :: neval
3002 integer(IK) ,
intent(in) :: niter
3007 recursive module subroutine setRootBisectionNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3008#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3009 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBisectionNiter_RK1
3012 procedure(
real(RKG)) :: getFunc
3013 type(bisection_type) ,
intent(in) :: method
3014 real(RKG) ,
intent(out) :: root
3015 real(RKG) ,
value :: lb, ub
3016 real(RKG) ,
value :: lf, uf
3017 real(RKG) ,
intent(in) :: abstol
3018 integer(IK) ,
intent(out) :: neval
3019 integer(IK) ,
intent(in) :: niter
3034 recursive module subroutine setRootSecantFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3035#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3036 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantFixed_RK5
3039 procedure(
real(RKG)) :: getFunc
3040 type(secant_type) ,
intent(in) :: method
3041 real(RKG) ,
intent(out) :: root
3042 real(RKG) ,
value :: lb, ub
3043 real(RKG) ,
value :: lf, uf
3044 real(RKG) ,
intent(in) :: abstol
3045 integer(IK) ,
intent(out) :: neval
3050 recursive module subroutine setRootSecantFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3051#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3052 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantFixed_RK4
3055 procedure(
real(RKG)) :: getFunc
3056 type(secant_type) ,
intent(in) :: method
3057 real(RKG) ,
intent(out) :: root
3058 real(RKG) ,
value :: lb, ub
3059 real(RKG) ,
value :: lf, uf
3060 real(RKG) ,
intent(in) :: abstol
3061 integer(IK) ,
intent(out) :: neval
3066 recursive module subroutine setRootSecantFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3067#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3068 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantFixed_RK3
3071 procedure(
real(RKG)) :: getFunc
3072 type(secant_type) ,
intent(in) :: method
3073 real(RKG) ,
intent(out) :: root
3074 real(RKG) ,
value :: lb, ub
3075 real(RKG) ,
value :: lf, uf
3076 real(RKG) ,
intent(in) :: abstol
3077 integer(IK) ,
intent(out) :: neval
3082 recursive module subroutine setRootSecantFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3083#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3084 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantFixed_RK2
3087 procedure(
real(RKG)) :: getFunc
3088 type(secant_type) ,
intent(in) :: method
3089 real(RKG) ,
intent(out) :: root
3090 real(RKG) ,
value :: lb, ub
3091 real(RKG) ,
value :: lf, uf
3092 real(RKG) ,
intent(in) :: abstol
3093 integer(IK) ,
intent(out) :: neval
3098 recursive module subroutine setRootSecantFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3099#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3100 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantFixed_RK1
3103 procedure(
real(RKG)) :: getFunc
3104 type(secant_type) ,
intent(in) :: method
3105 real(RKG) ,
intent(out) :: root
3106 real(RKG) ,
value :: lb, ub
3107 real(RKG) ,
value :: lf, uf
3108 real(RKG) ,
intent(in) :: abstol
3109 integer(IK) ,
intent(out) :: neval
3116 recursive module subroutine setRootSecantNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3117#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3118 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantNiter_RK5
3121 procedure(
real(RKG)) :: getFunc
3122 type(secant_type) ,
intent(in) :: method
3123 real(RKG) ,
intent(out) :: root
3124 real(RKG) ,
value :: lb, ub
3125 real(RKG) ,
value :: lf, uf
3126 real(RKG) ,
intent(in) :: abstol
3127 integer(IK) ,
intent(out) :: neval
3128 integer(IK) ,
intent(in) :: niter
3133 recursive module subroutine setRootSecantNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3134#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3135 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantNiter_RK4
3138 procedure(
real(RKG)) :: getFunc
3139 type(secant_type) ,
intent(in) :: method
3140 real(RKG) ,
intent(out) :: root
3141 real(RKG) ,
value :: lb, ub
3142 real(RKG) ,
value :: lf, uf
3143 real(RKG) ,
intent(in) :: abstol
3144 integer(IK) ,
intent(out) :: neval
3145 integer(IK) ,
intent(in) :: niter
3150 recursive module subroutine setRootSecantNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3151#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3152 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantNiter_RK3
3155 procedure(
real(RKG)) :: getFunc
3156 type(secant_type) ,
intent(in) :: method
3157 real(RKG) ,
intent(out) :: root
3158 real(RKG) ,
value :: lb, ub
3159 real(RKG) ,
value :: lf, uf
3160 real(RKG) ,
intent(in) :: abstol
3161 integer(IK) ,
intent(out) :: neval
3162 integer(IK) ,
intent(in) :: niter
3167 recursive module subroutine setRootSecantNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3168#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3169 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantNiter_RK2
3172 procedure(
real(RKG)) :: getFunc
3173 type(secant_type) ,
intent(in) :: method
3174 real(RKG) ,
intent(out) :: root
3175 real(RKG) ,
value :: lb, ub
3176 real(RKG) ,
value :: lf, uf
3177 real(RKG) ,
intent(in) :: abstol
3178 integer(IK) ,
intent(out) :: neval
3179 integer(IK) ,
intent(in) :: niter
3184 recursive module subroutine setRootSecantNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3185#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3186 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSecantNiter_RK1
3189 procedure(
real(RKG)) :: getFunc
3190 type(secant_type) ,
intent(in) :: method
3191 real(RKG) ,
intent(out) :: root
3192 real(RKG) ,
value :: lb, ub
3193 real(RKG) ,
value :: lf, uf
3194 real(RKG) ,
intent(in) :: abstol
3195 integer(IK) ,
intent(out) :: neval
3196 integer(IK) ,
intent(in) :: niter
3211 recursive module subroutine setRootBrentFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3212#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3213 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentFixed_RK5
3216 procedure(
real(RKG)) :: getFunc
3217 type(brent_type) ,
intent(in) :: method
3218 real(RKG) ,
intent(out) :: root
3219 real(RKG) ,
value :: lb, ub
3220 real(RKG) ,
value :: lf, uf
3221 real(RKG) ,
intent(in) :: abstol
3222 integer(IK) ,
intent(out) :: neval
3227 recursive module subroutine setRootBrentFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3228#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3229 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentFixed_RK4
3232 procedure(
real(RKG)) :: getFunc
3233 type(brent_type) ,
intent(in) :: method
3234 real(RKG) ,
intent(out) :: root
3235 real(RKG) ,
value :: lb, ub
3236 real(RKG) ,
value :: lf, uf
3237 real(RKG) ,
intent(in) :: abstol
3238 integer(IK) ,
intent(out) :: neval
3243 recursive module subroutine setRootBrentFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3244#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3245 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentFixed_RK3
3248 procedure(
real(RKG)) :: getFunc
3249 type(brent_type) ,
intent(in) :: method
3250 real(RKG) ,
intent(out) :: root
3251 real(RKG) ,
value :: lb, ub
3252 real(RKG) ,
value :: lf, uf
3253 real(RKG) ,
intent(in) :: abstol
3254 integer(IK) ,
intent(out) :: neval
3259 recursive module subroutine setRootBrentFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3260#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3261 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentFixed_RK2
3264 procedure(
real(RKG)) :: getFunc
3265 type(brent_type) ,
intent(in) :: method
3266 real(RKG) ,
intent(out) :: root
3267 real(RKG) ,
value :: lb, ub
3268 real(RKG) ,
value :: lf, uf
3269 real(RKG) ,
intent(in) :: abstol
3270 integer(IK) ,
intent(out) :: neval
3275 recursive module subroutine setRootBrentFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3276#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3277 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentFixed_RK1
3280 procedure(
real(RKG)) :: getFunc
3281 type(brent_type) ,
intent(in) :: method
3282 real(RKG) ,
intent(out) :: root
3283 real(RKG) ,
value :: lb, ub
3284 real(RKG) ,
value :: lf, uf
3285 real(RKG) ,
intent(in) :: abstol
3286 integer(IK) ,
intent(out) :: neval
3293 recursive module subroutine setRootBrentNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3294#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3295 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentNiter_RK5
3298 procedure(
real(RKG)) :: getFunc
3299 type(brent_type) ,
intent(in) :: method
3300 real(RKG) ,
intent(out) :: root
3301 real(RKG) ,
value :: lb, ub
3302 real(RKG) ,
value :: lf, uf
3303 real(RKG) ,
intent(in) :: abstol
3304 integer(IK) ,
intent(out) :: neval
3305 integer(IK) ,
intent(in) :: niter
3310 recursive module subroutine setRootBrentNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3311#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3312 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentNiter_RK4
3315 procedure(
real(RKG)) :: getFunc
3316 type(brent_type) ,
intent(in) :: method
3317 real(RKG) ,
intent(out) :: root
3318 real(RKG) ,
value :: lb, ub
3319 real(RKG) ,
value :: lf, uf
3320 real(RKG) ,
intent(in) :: abstol
3321 integer(IK) ,
intent(out) :: neval
3322 integer(IK) ,
intent(in) :: niter
3327 recursive module subroutine setRootBrentNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3328#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3329 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentNiter_RK3
3332 procedure(
real(RKG)) :: getFunc
3333 type(brent_type) ,
intent(in) :: method
3334 real(RKG) ,
intent(out) :: root
3335 real(RKG) ,
value :: lb, ub
3336 real(RKG) ,
value :: lf, uf
3337 real(RKG) ,
intent(in) :: abstol
3338 integer(IK) ,
intent(out) :: neval
3339 integer(IK) ,
intent(in) :: niter
3344 recursive module subroutine setRootBrentNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3345#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3346 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentNiter_RK2
3349 procedure(
real(RKG)) :: getFunc
3350 type(brent_type) ,
intent(in) :: method
3351 real(RKG) ,
intent(out) :: root
3352 real(RKG) ,
value :: lb, ub
3353 real(RKG) ,
value :: lf, uf
3354 real(RKG) ,
intent(in) :: abstol
3355 integer(IK) ,
intent(out) :: neval
3356 integer(IK) ,
intent(in) :: niter
3361 recursive module subroutine setRootBrentNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3362#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3363 !DEC$ ATTRIBUTES DLLEXPORT :: setRootBrentNiter_RK1
3366 procedure(
real(RKG)) :: getFunc
3367 type(brent_type) ,
intent(in) :: method
3368 real(RKG) ,
intent(out) :: root
3369 real(RKG) ,
value :: lb, ub
3370 real(RKG) ,
value :: lf, uf
3371 real(RKG) ,
intent(in) :: abstol
3372 integer(IK) ,
intent(out) :: neval
3373 integer(IK) ,
intent(in) :: niter
3388 recursive module subroutine setRootRiddersFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3389#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3390 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersFixed_RK5
3393 procedure(
real(RKG)) :: getFunc
3394 type(ridders_type) ,
intent(in) :: method
3395 real(RKG) ,
intent(out) :: root
3396 real(RKG) ,
value :: lb, ub
3397 real(RKG) ,
value :: lf, uf
3398 real(RKG) ,
intent(in) :: abstol
3399 integer(IK) ,
intent(out) :: neval
3404 recursive module subroutine setRootRiddersFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3405#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3406 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersFixed_RK4
3409 procedure(
real(RKG)) :: getFunc
3410 type(ridders_type) ,
intent(in) :: method
3411 real(RKG) ,
intent(out) :: root
3412 real(RKG) ,
value :: lb, ub
3413 real(RKG) ,
value :: lf, uf
3414 real(RKG) ,
intent(in) :: abstol
3415 integer(IK) ,
intent(out) :: neval
3420 recursive module subroutine setRootRiddersFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3421#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3422 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersFixed_RK3
3425 procedure(
real(RKG)) :: getFunc
3426 type(ridders_type) ,
intent(in) :: method
3427 real(RKG) ,
intent(out) :: root
3428 real(RKG) ,
value :: lb, ub
3429 real(RKG) ,
value :: lf, uf
3430 real(RKG) ,
intent(in) :: abstol
3431 integer(IK) ,
intent(out) :: neval
3436 recursive module subroutine setRootRiddersFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3437#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3438 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersFixed_RK2
3441 procedure(
real(RKG)) :: getFunc
3442 type(ridders_type) ,
intent(in) :: method
3443 real(RKG) ,
intent(out) :: root
3444 real(RKG) ,
value :: lb, ub
3445 real(RKG) ,
value :: lf, uf
3446 real(RKG) ,
intent(in) :: abstol
3447 integer(IK) ,
intent(out) :: neval
3452 recursive module subroutine setRootRiddersFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3453#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3454 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersFixed_RK1
3457 procedure(
real(RKG)) :: getFunc
3458 type(ridders_type) ,
intent(in) :: method
3459 real(RKG) ,
intent(out) :: root
3460 real(RKG) ,
value :: lb, ub
3461 real(RKG) ,
value :: lf, uf
3462 real(RKG) ,
intent(in) :: abstol
3463 integer(IK) ,
intent(out) :: neval
3470 recursive module subroutine setRootRiddersNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3471#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3472 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersNiter_RK5
3475 procedure(
real(RKG)) :: getFunc
3476 type(ridders_type) ,
intent(in) :: method
3477 real(RKG) ,
intent(out) :: root
3478 real(RKG) ,
value :: lb, ub
3479 real(RKG) ,
value :: lf, uf
3480 real(RKG) ,
intent(in) :: abstol
3481 integer(IK) ,
intent(out) :: neval
3482 integer(IK) ,
intent(in) :: niter
3487 recursive module subroutine setRootRiddersNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3488#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3489 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersNiter_RK4
3492 procedure(
real(RKG)) :: getFunc
3493 type(ridders_type) ,
intent(in) :: method
3494 real(RKG) ,
intent(out) :: root
3495 real(RKG) ,
value :: lb, ub
3496 real(RKG) ,
value :: lf, uf
3497 real(RKG) ,
intent(in) :: abstol
3498 integer(IK) ,
intent(out) :: neval
3499 integer(IK) ,
intent(in) :: niter
3504 recursive module subroutine setRootRiddersNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3505#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3506 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersNiter_RK3
3509 procedure(
real(RKG)) :: getFunc
3510 type(ridders_type) ,
intent(in) :: method
3511 real(RKG) ,
intent(out) :: root
3512 real(RKG) ,
value :: lb, ub
3513 real(RKG) ,
value :: lf, uf
3514 real(RKG) ,
intent(in) :: abstol
3515 integer(IK) ,
intent(out) :: neval
3516 integer(IK) ,
intent(in) :: niter
3521 recursive module subroutine setRootRiddersNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3522#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3523 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersNiter_RK2
3526 procedure(
real(RKG)) :: getFunc
3527 type(ridders_type) ,
intent(in) :: method
3528 real(RKG) ,
intent(out) :: root
3529 real(RKG) ,
value :: lb, ub
3530 real(RKG) ,
value :: lf, uf
3531 real(RKG) ,
intent(in) :: abstol
3532 integer(IK) ,
intent(out) :: neval
3533 integer(IK) ,
intent(in) :: niter
3538 recursive module subroutine setRootRiddersNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3539#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3540 !DEC$ ATTRIBUTES DLLEXPORT :: setRootRiddersNiter_RK1
3543 procedure(
real(RKG)) :: getFunc
3544 type(ridders_type) ,
intent(in) :: method
3545 real(RKG) ,
intent(out) :: root
3546 real(RKG) ,
value :: lb, ub
3547 real(RKG) ,
value :: lf, uf
3548 real(RKG) ,
intent(in) :: abstol
3549 integer(IK) ,
intent(out) :: neval
3550 integer(IK) ,
intent(in) :: niter
3565 recursive module subroutine setRootTOMS748Fixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3566#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3567 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Fixed_RK5
3570 procedure(
real(RKG)) :: getFunc
3571 type(toms748_type) ,
intent(in) :: method
3572 real(RKG) ,
intent(out) :: root
3573 real(RKG) ,
value :: lb, ub
3574 real(RKG) ,
value :: lf, uf
3575 real(RKG) ,
intent(in) :: abstol
3576 integer(IK) ,
intent(out) :: neval
3581 recursive module subroutine setRootTOMS748Fixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3582#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3583 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Fixed_RK4
3586 procedure(
real(RKG)) :: getFunc
3587 type(toms748_type) ,
intent(in) :: method
3588 real(RKG) ,
intent(out) :: root
3589 real(RKG) ,
value :: lb, ub
3590 real(RKG) ,
value :: lf, uf
3591 real(RKG) ,
intent(in) :: abstol
3592 integer(IK) ,
intent(out) :: neval
3597 recursive module subroutine setRootTOMS748Fixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3598#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3599 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Fixed_RK3
3602 procedure(
real(RKG)) :: getFunc
3603 type(toms748_type) ,
intent(in) :: method
3604 real(RKG) ,
intent(out) :: root
3605 real(RKG) ,
value :: lb, ub
3606 real(RKG) ,
value :: lf, uf
3607 real(RKG) ,
intent(in) :: abstol
3608 integer(IK) ,
intent(out) :: neval
3613 recursive module subroutine setRootTOMS748Fixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3614#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3615 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Fixed_RK2
3618 procedure(
real(RKG)) :: getFunc
3619 type(toms748_type) ,
intent(in) :: method
3620 real(RKG) ,
intent(out) :: root
3621 real(RKG) ,
value :: lb, ub
3622 real(RKG) ,
value :: lf, uf
3623 real(RKG) ,
intent(in) :: abstol
3624 integer(IK) ,
intent(out) :: neval
3629 recursive module subroutine setRootTOMS748Fixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3630#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3631 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Fixed_RK1
3634 procedure(
real(RKG)) :: getFunc
3635 type(toms748_type) ,
intent(in) :: method
3636 real(RKG) ,
intent(out) :: root
3637 real(RKG) ,
value :: lb, ub
3638 real(RKG) ,
value :: lf, uf
3639 real(RKG) ,
intent(in) :: abstol
3640 integer(IK) ,
intent(out) :: neval
3647 recursive module subroutine setRootTOMS748Niter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3648#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3649 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Niter_RK5
3652 procedure(
real(RKG)) :: getFunc
3653 type(toms748_type) ,
intent(in) :: method
3654 real(RKG) ,
intent(out) :: root
3655 real(RKG) ,
value :: lb, ub
3656 real(RKG) ,
value :: lf, uf
3657 real(RKG) ,
intent(in) :: abstol
3658 integer(IK) ,
intent(out) :: neval
3659 integer(IK) ,
intent(in) :: niter
3664 recursive module subroutine setRootTOMS748Niter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3665#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3666 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Niter_RK4
3669 procedure(
real(RKG)) :: getFunc
3670 type(toms748_type) ,
intent(in) :: method
3671 real(RKG) ,
intent(out) :: root
3672 real(RKG) ,
value :: lb, ub
3673 real(RKG) ,
value :: lf, uf
3674 real(RKG) ,
intent(in) :: abstol
3675 integer(IK) ,
intent(out) :: neval
3676 integer(IK) ,
intent(in) :: niter
3681 recursive module subroutine setRootTOMS748Niter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3682#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3683 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Niter_RK3
3686 procedure(
real(RKG)) :: getFunc
3687 type(toms748_type) ,
intent(in) :: method
3688 real(RKG) ,
intent(out) :: root
3689 real(RKG) ,
value :: lb, ub
3690 real(RKG) ,
value :: lf, uf
3691 real(RKG) ,
intent(in) :: abstol
3692 integer(IK) ,
intent(out) :: neval
3693 integer(IK) ,
intent(in) :: niter
3698 recursive module subroutine setRootTOMS748Niter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3699#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3700 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Niter_RK2
3703 procedure(
real(RKG)) :: getFunc
3704 type(toms748_type) ,
intent(in) :: method
3705 real(RKG) ,
intent(out) :: root
3706 real(RKG) ,
value :: lb, ub
3707 real(RKG) ,
value :: lf, uf
3708 real(RKG) ,
intent(in) :: abstol
3709 integer(IK) ,
intent(out) :: neval
3710 integer(IK) ,
intent(in) :: niter
3715 recursive module subroutine setRootTOMS748Niter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3716#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3717 !DEC$ ATTRIBUTES DLLEXPORT :: setRootTOMS748Niter_RK1
3720 procedure(
real(RKG)) :: getFunc
3721 type(toms748_type) ,
intent(in) :: method
3722 real(RKG) ,
intent(out) :: root
3723 real(RKG) ,
value :: lb, ub
3724 real(RKG) ,
value :: lf, uf
3725 real(RKG) ,
intent(in) :: abstol
3726 integer(IK) ,
intent(out) :: neval
3727 integer(IK) ,
intent(in) :: niter
3742 recursive module subroutine setRootNewtonFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3743#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3744 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonFixed_RK5
3747 procedure(
real(RKG)) :: getFunc
3748 type(newton_type) ,
intent(in) :: method
3749 real(RKG) ,
intent(inout) :: root
3750 real(RKG) ,
value :: lb, ub
3751 real(RKG) ,
value :: lf, uf
3752 real(RKG) ,
intent(in) :: abstol
3753 integer(IK) ,
intent(out) :: neval
3758 recursive module subroutine setRootNewtonFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3759#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3760 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonFixed_RK4
3763 procedure(
real(RKG)) :: getFunc
3764 type(newton_type) ,
intent(in) :: method
3765 real(RKG) ,
intent(inout) :: root
3766 real(RKG) ,
value :: lb, ub
3767 real(RKG) ,
value :: lf, uf
3768 real(RKG) ,
intent(in) :: abstol
3769 integer(IK) ,
intent(out) :: neval
3774 recursive module subroutine setRootNewtonFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3775#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3776 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonFixed_RK3
3779 procedure(
real(RKG)) :: getFunc
3780 type(newton_type) ,
intent(in) :: method
3781 real(RKG) ,
intent(inout) :: root
3782 real(RKG) ,
value :: lb, ub
3783 real(RKG) ,
value :: lf, uf
3784 real(RKG) ,
intent(in) :: abstol
3785 integer(IK) ,
intent(out) :: neval
3790 recursive module subroutine setRootNewtonFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3791#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3792 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonFixed_RK2
3795 procedure(
real(RKG)) :: getFunc
3796 type(newton_type) ,
intent(in) :: method
3797 real(RKG) ,
intent(inout) :: root
3798 real(RKG) ,
value :: lb, ub
3799 real(RKG) ,
value :: lf, uf
3800 real(RKG) ,
intent(in) :: abstol
3801 integer(IK) ,
intent(out) :: neval
3806 recursive module subroutine setRootNewtonFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3807#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3808 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonFixed_RK1
3811 procedure(
real(RKG)) :: getFunc
3812 type(newton_type) ,
intent(in) :: method
3813 real(RKG) ,
intent(inout) :: root
3814 real(RKG) ,
value :: lb, ub
3815 real(RKG) ,
value :: lf, uf
3816 real(RKG) ,
intent(in) :: abstol
3817 integer(IK) ,
intent(out) :: neval
3824 recursive module subroutine setRootNewtonNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3825#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3826 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonNiter_RK5
3829 procedure(
real(RKG)) :: getFunc
3830 type(newton_type) ,
intent(in) :: method
3831 real(RKG) ,
intent(inout) :: root
3832 real(RKG) ,
value :: lb, ub
3833 real(RKG) ,
value :: lf, uf
3834 real(RKG) ,
intent(in) :: abstol
3835 integer(IK) ,
intent(out) :: neval
3836 integer(IK) ,
intent(in) :: niter
3841 recursive module subroutine setRootNewtonNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3842#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3843 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonNiter_RK4
3846 procedure(
real(RKG)) :: getFunc
3847 type(newton_type) ,
intent(in) :: method
3848 real(RKG) ,
intent(inout) :: root
3849 real(RKG) ,
value :: lb, ub
3850 real(RKG) ,
value :: lf, uf
3851 real(RKG) ,
intent(in) :: abstol
3852 integer(IK) ,
intent(out) :: neval
3853 integer(IK) ,
intent(in) :: niter
3858 recursive module subroutine setRootNewtonNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3859#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3860 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonNiter_RK3
3863 procedure(
real(RKG)) :: getFunc
3864 type(newton_type) ,
intent(in) :: method
3865 real(RKG) ,
intent(inout) :: root
3866 real(RKG) ,
value :: lb, ub
3867 real(RKG) ,
value :: lf, uf
3868 real(RKG) ,
intent(in) :: abstol
3869 integer(IK) ,
intent(out) :: neval
3870 integer(IK) ,
intent(in) :: niter
3875 recursive module subroutine setRootNewtonNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3876#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3877 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonNiter_RK2
3880 procedure(
real(RKG)) :: getFunc
3881 type(newton_type) ,
intent(in) :: method
3882 real(RKG) ,
intent(inout) :: root
3883 real(RKG) ,
value :: lb, ub
3884 real(RKG) ,
value :: lf, uf
3885 real(RKG) ,
intent(in) :: abstol
3886 integer(IK) ,
intent(out) :: neval
3887 integer(IK) ,
intent(in) :: niter
3892 recursive module subroutine setRootNewtonNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
3893#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3894 !DEC$ ATTRIBUTES DLLEXPORT :: setRootNewtonNiter_RK1
3897 procedure(
real(RKG)) :: getFunc
3898 type(newton_type) ,
intent(in) :: method
3899 real(RKG) ,
intent(inout) :: root
3900 real(RKG) ,
value :: lb, ub
3901 real(RKG) ,
value :: lf, uf
3902 real(RKG) ,
intent(in) :: abstol
3903 integer(IK) ,
intent(out) :: neval
3904 integer(IK) ,
intent(in) :: niter
3919 recursive module subroutine setRootHalleyFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3920#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3921 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyFixed_RK5
3924 procedure(
real(RKG)) :: getFunc
3925 type(halley_type) ,
intent(in) :: method
3926 real(RKG) ,
intent(inout) :: root
3927 real(RKG) ,
value :: lb, ub
3928 real(RKG) ,
value :: lf, uf
3929 real(RKG) ,
intent(in) :: abstol
3930 integer(IK) ,
intent(out) :: neval
3935 recursive module subroutine setRootHalleyFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3936#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3937 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyFixed_RK4
3940 procedure(
real(RKG)) :: getFunc
3941 type(halley_type) ,
intent(in) :: method
3942 real(RKG) ,
intent(inout) :: root
3943 real(RKG) ,
value :: lb, ub
3944 real(RKG) ,
value :: lf, uf
3945 real(RKG) ,
intent(in) :: abstol
3946 integer(IK) ,
intent(out) :: neval
3951 recursive module subroutine setRootHalleyFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3952#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3953 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyFixed_RK3
3956 procedure(
real(RKG)) :: getFunc
3957 type(halley_type) ,
intent(in) :: method
3958 real(RKG) ,
intent(inout) :: root
3959 real(RKG) ,
value :: lb, ub
3960 real(RKG) ,
value :: lf, uf
3961 real(RKG) ,
intent(in) :: abstol
3962 integer(IK) ,
intent(out) :: neval
3967 recursive module subroutine setRootHalleyFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3968#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3969 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyFixed_RK2
3972 procedure(
real(RKG)) :: getFunc
3973 type(halley_type) ,
intent(in) :: method
3974 real(RKG) ,
intent(inout) :: root
3975 real(RKG) ,
value :: lb, ub
3976 real(RKG) ,
value :: lf, uf
3977 real(RKG) ,
intent(in) :: abstol
3978 integer(IK) ,
intent(out) :: neval
3983 recursive module subroutine setRootHalleyFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
3984#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3985 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyFixed_RK1
3988 procedure(
real(RKG)) :: getFunc
3989 type(halley_type) ,
intent(in) :: method
3990 real(RKG) ,
intent(inout) :: root
3991 real(RKG) ,
value :: lb, ub
3992 real(RKG) ,
value :: lf, uf
3993 real(RKG) ,
intent(in) :: abstol
3994 integer(IK) ,
intent(out) :: neval
4001 recursive module subroutine setRootHalleyNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4002#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4003 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyNiter_RK5
4006 procedure(
real(RKG)) :: getFunc
4007 type(halley_type) ,
intent(in) :: method
4008 real(RKG) ,
intent(inout) :: root
4009 real(RKG) ,
value :: lb, ub
4010 real(RKG) ,
value :: lf, uf
4011 real(RKG) ,
intent(in) :: abstol
4012 integer(IK) ,
intent(out) :: neval
4013 integer(IK) ,
intent(in) :: niter
4018 recursive module subroutine setRootHalleyNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4019#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4020 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyNiter_RK4
4023 procedure(
real(RKG)) :: getFunc
4024 type(halley_type) ,
intent(in) :: method
4025 real(RKG) ,
intent(inout) :: root
4026 real(RKG) ,
value :: lb, ub
4027 real(RKG) ,
value :: lf, uf
4028 real(RKG) ,
intent(in) :: abstol
4029 integer(IK) ,
intent(out) :: neval
4030 integer(IK) ,
intent(in) :: niter
4035 recursive module subroutine setRootHalleyNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4036#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4037 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyNiter_RK3
4040 procedure(
real(RKG)) :: getFunc
4041 type(halley_type) ,
intent(in) :: method
4042 real(RKG) ,
intent(inout) :: root
4043 real(RKG) ,
value :: lb, ub
4044 real(RKG) ,
value :: lf, uf
4045 real(RKG) ,
intent(in) :: abstol
4046 integer(IK) ,
intent(out) :: neval
4047 integer(IK) ,
intent(in) :: niter
4052 recursive module subroutine setRootHalleyNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4053#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4054 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyNiter_RK2
4057 procedure(
real(RKG)) :: getFunc
4058 type(halley_type) ,
intent(in) :: method
4059 real(RKG) ,
intent(inout) :: root
4060 real(RKG) ,
value :: lb, ub
4061 real(RKG) ,
value :: lf, uf
4062 real(RKG) ,
intent(in) :: abstol
4063 integer(IK) ,
intent(out) :: neval
4064 integer(IK) ,
intent(in) :: niter
4069 recursive module subroutine setRootHalleyNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4070#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4071 !DEC$ ATTRIBUTES DLLEXPORT :: setRootHalleyNiter_RK1
4074 procedure(
real(RKG)) :: getFunc
4075 type(halley_type) ,
intent(in) :: method
4076 real(RKG) ,
intent(inout) :: root
4077 real(RKG) ,
value :: lb, ub
4078 real(RKG) ,
value :: lf, uf
4079 real(RKG) ,
intent(in) :: abstol
4080 integer(IK) ,
intent(out) :: neval
4081 integer(IK) ,
intent(in) :: niter
4096 recursive module subroutine setRootSchroderFixed_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
4097#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4098 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderFixed_RK5
4101 procedure(
real(RKG)) :: getFunc
4102 type(schroder_type) ,
intent(in) :: method
4103 real(RKG) ,
intent(inout) :: root
4104 real(RKG) ,
value :: lb, ub
4105 real(RKG) ,
value :: lf, uf
4106 real(RKG) ,
intent(in) :: abstol
4107 integer(IK) ,
intent(out) :: neval
4112 recursive module subroutine setRootSchroderFixed_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
4113#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4114 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderFixed_RK4
4117 procedure(
real(RKG)) :: getFunc
4118 type(schroder_type) ,
intent(in) :: method
4119 real(RKG) ,
intent(inout) :: root
4120 real(RKG) ,
value :: lb, ub
4121 real(RKG) ,
value :: lf, uf
4122 real(RKG) ,
intent(in) :: abstol
4123 integer(IK) ,
intent(out) :: neval
4128 recursive module subroutine setRootSchroderFixed_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
4129#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4130 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderFixed_RK3
4133 procedure(
real(RKG)) :: getFunc
4134 type(schroder_type) ,
intent(in) :: method
4135 real(RKG) ,
intent(inout) :: root
4136 real(RKG) ,
value :: lb, ub
4137 real(RKG) ,
value :: lf, uf
4138 real(RKG) ,
intent(in) :: abstol
4139 integer(IK) ,
intent(out) :: neval
4144 recursive module subroutine setRootSchroderFixed_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
4145#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4146 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderFixed_RK2
4149 procedure(
real(RKG)) :: getFunc
4150 type(schroder_type) ,
intent(in) :: method
4151 real(RKG) ,
intent(inout) :: root
4152 real(RKG) ,
value :: lb, ub
4153 real(RKG) ,
value :: lf, uf
4154 real(RKG) ,
intent(in) :: abstol
4155 integer(IK) ,
intent(out) :: neval
4160 recursive module subroutine setRootSchroderFixed_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval)
4161#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4162 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderFixed_RK1
4165 procedure(
real(RKG)) :: getFunc
4166 type(schroder_type) ,
intent(in) :: method
4167 real(RKG) ,
intent(inout) :: root
4168 real(RKG) ,
value :: lb, ub
4169 real(RKG) ,
value :: lf, uf
4170 real(RKG) ,
intent(in) :: abstol
4171 integer(IK) ,
intent(out) :: neval
4178 recursive module subroutine setRootSchroderNiter_RK5(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4179#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4180 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderNiter_RK5
4183 procedure(
real(RKG)) :: getFunc
4184 type(schroder_type) ,
intent(in) :: method
4185 real(RKG) ,
intent(inout) :: root
4186 real(RKG) ,
value :: lb, ub
4187 real(RKG) ,
value :: lf, uf
4188 real(RKG) ,
intent(in) :: abstol
4189 integer(IK) ,
intent(out) :: neval
4190 integer(IK) ,
intent(in) :: niter
4195 recursive module subroutine setRootSchroderNiter_RK4(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4196#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4197 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderNiter_RK4
4200 procedure(
real(RKG)) :: getFunc
4201 type(schroder_type) ,
intent(in) :: method
4202 real(RKG) ,
intent(inout) :: root
4203 real(RKG) ,
value :: lb, ub
4204 real(RKG) ,
value :: lf, uf
4205 real(RKG) ,
intent(in) :: abstol
4206 integer(IK) ,
intent(out) :: neval
4207 integer(IK) ,
intent(in) :: niter
4212 recursive module subroutine setRootSchroderNiter_RK3(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4213#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4214 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderNiter_RK3
4217 procedure(
real(RKG)) :: getFunc
4218 type(schroder_type) ,
intent(in) :: method
4219 real(RKG) ,
intent(inout) :: root
4220 real(RKG) ,
value :: lb, ub
4221 real(RKG) ,
value :: lf, uf
4222 real(RKG) ,
intent(in) :: abstol
4223 integer(IK) ,
intent(out) :: neval
4224 integer(IK) ,
intent(in) :: niter
4229 recursive module subroutine setRootSchroderNiter_RK2(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4230#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4231 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderNiter_RK2
4234 procedure(
real(RKG)) :: getFunc
4235 type(schroder_type) ,
intent(in) :: method
4236 real(RKG) ,
intent(inout) :: root
4237 real(RKG) ,
value :: lb, ub
4238 real(RKG) ,
value :: lf, uf
4239 real(RKG) ,
intent(in) :: abstol
4240 integer(IK) ,
intent(out) :: neval
4241 integer(IK) ,
intent(in) :: niter
4246 recursive module subroutine setRootSchroderNiter_RK1(method, getFunc, root, lb, ub, lf, uf, abstol, neval, niter)
4247#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4248 !DEC$ ATTRIBUTES DLLEXPORT :: setRootSchroderNiter_RK1
4251 procedure(
real(RKG)) :: getFunc
4252 type(schroder_type) ,
intent(in) :: method
4253 real(RKG) ,
intent(inout) :: root
4254 real(RKG) ,
value :: lb, ub
4255 real(RKG) ,
value :: lf, uf
4256 real(RKG) ,
intent(in) :: abstol
4257 integer(IK) ,
intent(out) :: neval
4258 integer(IK) ,
intent(in) :: niter
4268end module pm_mathRoot
Generate and return a root of a specified continuous real-valued one-dimensional mathematical functio...
Return a root of a specified continuous real-valued one-dimensional mathematical function such that ...
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
This module contains classes and procedures for computing the roots of one-dimensional continuous mat...
type(brent_type), parameter brent
This is a scalar parameter object of type brent_type that is exclusively used to signify the use of B...
type(ridders_type), parameter ridders
This is a scalar parameter object of type ridders_type that is exclusively used to signify the use of...
type(toms748_type), parameter toms748
This is a scalar parameter object of type toms748_type that is exclusively used to signify the use of...
type(newton_type), parameter newton
This is a scalar parameter object of type newton_type that is exclusively used to signify the use of ...
type(bisection_type), parameter bisection
This is a scalar parameter object of type bisection_type that is exclusively used to signify the use ...
type(false_type), parameter false
This is a scalar parameter object of type false_type that is exclusively used to signify the use of F...
type(halley_type), parameter halley
This is a scalar parameter object of type halley_type that is exclusively used to signify the use of ...
type(schroder_type), parameter schroder
This is a scalar parameter object of type schroder_type that is exclusively used to signify the use o...
type(secant_type), parameter secant
This is a scalar parameter object of type secant_type that is exclusively used to signify the use of ...
character(*, SK), parameter MODULE_NAME
This is a concrete derived type whose instances are exclusively used to signify the use of the Bisect...
This is an abstract derived type for constructing concrete derived types to distinguish various proce...
This is a concrete derived type whose instances are exclusively used to signify the use of the Brent ...
This is a concrete derived type whose instances are exclusively used to signify the use of the False-...
This is a concrete derived type whose instances are exclusively used to signify the use of the Halley...
This is an abstract derived type for constructing concrete derived types to distinguish various proce...
This is an abstract derived type for constructing concrete derived types to distinguish various proce...
This is an abstract derived type for constructing concrete derived types to distinguish various proce...
This is a concrete derived type whose instances are exclusively used to signify the use of the Newton...
This is a concrete derived type whose instances are exclusively used to signify the use of the Ridder...
This is a concrete derived type whose instances are exclusively used to signify the use of the Schrod...
This is a concrete derived type whose instances are exclusively used to signify the use of the Secant...
This is a concrete derived type whose instances are exclusively used to signify the use of the TOMS74...