ParaMonte Fortran 2.0.0
Parallel Monte Carlo and Machine Learning Library
See the latest version documentation.
pm_mathSum Module Reference

This module contains procedures and generic interfaces for computing sum(x) accurately when x is a long array of wildly varying real or complex values.
More...

Data Types

type  fablocked_type
 This is a concrete derived type whose instances are exclusively used to request the Fast Accurate Blocked summation method of Blanchard, Higham, and Mary, 2020 within the generic interfaces of the ParaMonte library.
More...
 
interface  getDot
 Generate and return the expression dot_product(x, y) accurately (almost without roundoff error).
More...
 
interface  getSum
 Generate and return the expression sum(x) accurately (almost without roundoff error).
More...
 
type  kahanbabu_type
 This is a concrete derived type whose instances are exclusively used to request the Kahan-Babuska summation method within the generic interfaces of the ParaMonte library.
More...
 
type  nablocked_type
 This is a concrete derived type whose instances are exclusively used to request the Naive Blocked summation method of Blanchard, Higham, and Mary, 2020 within the generic interfaces of the ParaMonte library.
More...
 
type  sum_type
 

Variables

character(*, SK), parameter MODULE_NAME = "@pm_mathSum"
 
type(fablocked_type), parameter fablocked = fablocked_type()
 This is a scalar parameter object of type fablocked_type.
More...
 
type(nablocked_type), parameter nablocked = nablocked_type()
 This is a scalar parameter object of type nablocked_type.
More...
 
type(kahanbabu_type), parameter kahanbabu = kahanbabu_type()
 This is a scalar parameter object of type kahanbabu_type.
More...
 

Detailed Description

This module contains procedures and generic interfaces for computing sum(x) accurately when x is a long array of wildly varying real or complex values.

Some of the algorithms of this module are inspired by the work of Blanchard, Higham, and Mary, 2020, A Class of Fast and Accurate Summation Algorithms.

See also
pm_mathCumSum
Benchmarks:


Benchmark :: The effects of method on runtime efficiency

The following program compares the runtime performance of getSum algorithms with the default Fortran sum() intrinsic function.
1! Test the performance of `getSum()` with and without the selection `control` argument.
2program benchmark
3
4 use pm_bench, only: bench_type
5 use pm_distUnif, only: setUnifRand
6 use pm_mathCumSum, only: setCumSum
8 use pm_kind, only: SK, IK, LK, RKH, RK, RKG => RKD
9 use iso_fortran_env, only: error_unit
10
11 implicit none
12
13 integer(IK) :: ibench
14 integer(IK) :: iarr
15 integer(IK) :: arrlen
16 integer(IK) :: fileUnit
17 real(RKG) :: dumsum = 0._RKG
18 real(RKG) :: array(10**8)
19 real(RKG) :: sumres
20 type(bench_type) , allocatable :: bench(:)
21
22 bench = [ bench_type(name = SK_"sum()", exec = getSumFortran, overhead = setOverhead) &
23 , bench_type(name = SK_"fablocked", exec = getSumFAB, overhead = setOverhead) &
24 , bench_type(name = SK_"nablocked", exec = getSumNAB, overhead = setOverhead) &
25 , bench_type(name = SK_"kahanbabu", exec = getSumKAB, overhead = setOverhead) &
26 , bench_type(name = SK_"iteration", exec = getSumIte, overhead = setOverhead) &
27 , bench_type(name = SK_"recursion", exec = getSumRec, overhead = setOverhead) &
28 ]
29
30 write(*,"(*(g0,:,' '))")
31 write(*,"(*(g0,:,' '))") "sum() vs. getSum()"
32 write(*,"(*(g0,:,' '))")
33
34 open(newunit = fileUnit, file = "main.out", status = "replace")
35
36 call setUnifRand(array)
37 write(fileUnit, "(*(g0,:,','))") "Array Size", (bench(ibench)%name, ibench = 1, size(bench))
38 loopOverArraySize: do iarr = 2, 26, 2
39
40 arrlen = 2**iarr
41 write(*,"(*(g0,:,' '))") "Benchmarking with array size", arrlen
42 do ibench = 1, size(bench)
43 bench(ibench)%timing = bench(ibench)%getTiming(minsec = 0.07_RK)
44 end do
45 write(fileUnit,"(*(g0,:,','))") arrlen, (bench(ibench)%timing%mean, ibench = 1, size(bench))
46
47 end do loopOverArraySize
48 write(*,"(*(g0,:,' '))") dumsum
49 write(*,"(*(g0,:,' '))")
50
51 close(fileUnit)
52
53contains
54
55 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
56 ! procedure wrappers.
57 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
58
59 subroutine setOverhead()
60 call getDummy()
61 end subroutine
62
63 subroutine getDummy()
64 dumsum = dumsum + sumres
65 end subroutine
66
67 subroutine getSumFortran()
68 sumres = sum(array(1 : arrlen))
69 call getDummy()
70 end subroutine
71
72 subroutine getSumFAB()
73 use pm_mathSum, only: getSum!, fablocked
74 sumres = getSum(array(1 : arrlen))!, fablocked)
75 call getDummy()
76 end subroutine
77
78 subroutine getSumNAB()
79 use pm_mathSum, only: getSum, nablocked
80 sumres = getSum(array(1 : arrlen), nablocked)
81 call getDummy()
82 end subroutine
83
84 subroutine getSumKAB()
85 use pm_mathSum, only: getSum, kahanbabu
86 sumres = getSum(array(1 : arrlen), kahanbabu)
87 call getDummy()
88 end subroutine
89
90 subroutine getSumIte()
91 use pm_mathSum, only: getSum, iteration
92 sumres = getSum(array(1 : arrlen), iteration)
93 call getDummy()
94 end subroutine
95
96 subroutine getSumRec()
97 use pm_mathSum, only: getSum, recursion
98 sumres = getSum(array(1 : arrlen), recursion)
99 call getDummy()
100 end subroutine
101
102end program benchmark
Allocate or resize (shrink or expand) an input allocatable scalar string or array of rank 1....
Generate and return an object of type timing_type containing the benchmark timing information and sta...
Definition: pm_bench.F90:574
Return a uniform random scalar or contiguous array of arbitrary rank of randomly uniformly distribute...
Return the cumulative sum of the input array, optionally in the backward direction and optionally,...
Generate and return the expression sum(x) accurately (almost without roundoff error).
Definition: pm_mathSum.F90:367
This module contains procedures and generic interfaces for resizing allocatable arrays of various typ...
This module contains abstract interfaces and types that facilitate benchmarking of different procedur...
Definition: pm_bench.F90:41
This module contains classes and procedures for computing various statistical quantities related to t...
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268
integer, parameter RK
The default real kind in the ParaMonte library: real64 in Fortran, c_double in C-Fortran Interoperati...
Definition: pm_kind.F90:543
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
Definition: pm_kind.F90:541
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
Definition: pm_kind.F90:540
integer, parameter RKD
The double precision real kind in Fortran mode. On most platforms, this is an 64-bit real kind.
Definition: pm_kind.F90:568
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
Definition: pm_kind.F90:539
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
Definition: pm_kind.F90:858
This module contains the procedures and interfaces for computing the cumulative sum of an array.
This module contains procedures and generic interfaces for computing sum(x) accurately when x is a lo...
Definition: pm_mathSum.F90:72
type(kahanbabu_type), parameter kahanbabu
This is a scalar parameter object of type kahanbabu_type.
Definition: pm_mathSum.F90:266
type(nablocked_type), parameter nablocked
This is a scalar parameter object of type nablocked_type.
Definition: pm_mathSum.F90:206
This is the class for creating benchmark and performance-profiling objects.
Definition: pm_bench.F90:386


Example Unix compile command via Intel ifort compiler

1#!/usr/bin/env sh
2rm main.exe
3ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe


Example Windows Batch compile command via Intel ifort compiler

1del main.exe
2set PATH=..\..\..\lib;%PATH%
3ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
4main.exe


Example Unix / MinGW compile command via GNU gfortran compiler

1#!/usr/bin/env sh
2rm main.exe
3gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe


Postprocessing of the benchmark output

1#!/usr/bin/env python
2
3import matplotlib.pyplot as plt
4import pandas as pd
5import numpy as np
6
7import os
8dirname = os.path.basename(os.getcwd())
9
10fontsize = 14
11
12df = pd.read_csv("main.out", delimiter = ",")
13colnames = list(df.columns.values)
14
15
18
19ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
20ax = plt.subplot()
21
22for colname in colnames[1:]:
23 plt.plot( df[colnames[0]].values
24 , df[colname].values
25 , linewidth = 2
26 )
27
28plt.xticks(fontsize = fontsize)
29plt.yticks(fontsize = fontsize)
30ax.set_xlabel(colnames[0], fontsize = fontsize)
31ax.set_ylabel("Runtime [ seconds ]", fontsize = fontsize)
32ax.set_title(" vs. ".join(colnames[1:])+"\nLower is better.", fontsize = fontsize)
33ax.set_xscale("log")
34ax.set_yscale("log")
35plt.minorticks_on()
36plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
37ax.tick_params(axis = "y", which = "minor")
38ax.tick_params(axis = "x", which = "minor")
39ax.legend ( colnames[1:]
40 #, loc='center left'
41 #, bbox_to_anchor=(1, 0.5)
42 , fontsize = fontsize
43 )
44
45plt.tight_layout()
46plt.savefig("benchmark." + dirname + ".runtime.png")
47
48
51
52ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
53ax = plt.subplot()
54
55plt.plot( df[colnames[0]].values
56 , np.ones(len(df[colnames[0]].values))
57 , linestyle = "--"
58 #, color = "black"
59 , linewidth = 2
60 )
61for colname in colnames[2:]:
62 plt.plot( df[colnames[0]].values
63 , df[colname].values / df[colnames[1]].values
64 , linewidth = 2
65 )
66
67plt.xticks(fontsize = fontsize)
68plt.yticks(fontsize = fontsize)
69ax.set_xlabel(colnames[0], fontsize = fontsize)
70ax.set_ylabel("Runtime compared to {}".format(colnames[1]), fontsize = fontsize)
71ax.set_title("Runtime Ratio Comparison. Lower means faster.\nLower than 1 means faster than {}.".format(colnames[1]), fontsize = fontsize)
72ax.set_xscale("log")
73ax.set_yscale("log")
74plt.minorticks_on()
75plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
76ax.tick_params(axis = "y", which = "minor")
77ax.tick_params(axis = "x", which = "minor")
78ax.legend ( colnames[1:]
79 #, bbox_to_anchor = (1, 0.5)
80 #, loc = "center left"
81 , fontsize = fontsize
82 )
83
84plt.tight_layout()
85plt.savefig("benchmark." + dirname + ".runtime.ratio.png")


Visualization of the benchmark output


Benchmark moral

  1. Among all summation algorithms, fablocked_type appears to offer the most accurate result while also being even faster than the default Fortran sum() and all other implemented summation algorithms for array sizes > 100.


Benchmark :: The effects of method on runtime efficiency

The following program compares the runtime performance of getDot algorithms with the default Fortran dot_product() intrinsic function.
1! Test the performance of `getDot()` with and without the selection `control` argument.
2program benchmark
3
4 use pm_bench, only: bench_type
5 use pm_distUnif, only: setUnifRand
6 use pm_mathCumSum, only: setCumSum
8 use pm_kind, only: SK, IK, LK, RKH, RK, RKG => RKD
9 use iso_fortran_env, only: error_unit
10
11 implicit none
12
13 integer(IK) :: ibench
14 integer(IK) :: iarr
15 integer(IK) :: arrlen
16 integer(IK) :: fileUnit
17 real(RKG) :: dumsum = 0._RKG
18 real(RKG) :: array(10**8)
19 real(RKG) :: dotres
20 type(bench_type) , allocatable :: bench(:)
21 logical(LK) :: underflowEnabled
22
23 bench = [ bench_type(name = SK_"dot_product()", exec = getDotFortran, overhead = setOverhead) &
24 , bench_type(name = SK_"fablocked", exec = getDotFAB, overhead = setOverhead) &
25 , bench_type(name = SK_"nablocked", exec = getDotNAB, overhead = setOverhead) &
26 , bench_type(name = SK_"kahanbabu", exec = getDotKAB, overhead = setOverhead) &
27 , bench_type(name = SK_"iteration", exec = getDotIte, overhead = setOverhead) &
28 , bench_type(name = SK_"recursion", exec = getDotRec, overhead = setOverhead) &
29 ]
30
31 write(*,"(*(g0,:,' '))")
32 write(*,"(*(g0,:,' '))") "dot_product() vs. getDot()"
33 write(*,"(*(g0,:,' '))")
34
35 open(newunit = fileUnit, file = "main.out", status = "replace")
36
37 call setUnifRand(array)
38 !truth = array; call setCumSum(truth)
39 write(fileUnit, "(*(g0,:,','))") "Array Size", (bench(ibench)%name, ibench = 1, size(bench))
40 loopOverArraySize: do iarr = 2, 26, 2
41
42 arrlen = 2**iarr
43 write(*,"(*(g0,:,' '))") "Benchmarking with array size", arrlen
44 do ibench = 1, size(bench)
45 bench(ibench)%timing = bench(ibench)%getTiming(minsec = 0.07_RK)
46 end do
47 write(fileUnit,"(*(g0,:,','))") arrlen, (bench(ibench)%timing%mean, ibench = 1, size(bench))
48
49 end do loopOverArraySize
50 write(*,"(*(g0,:,' '))") dumsum
51 write(*,"(*(g0,:,' '))")
52
53 close(fileUnit)
54
55contains
56
57 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
58 ! procedure wrappers.
59 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
60
61 subroutine setOverhead()
62 call getDummy()
63 end subroutine
64
65 subroutine getDummy()
66 dumsum = dumsum + dotres
67 end subroutine
68
69 subroutine getDotFortran()
70 dotres = dot_product(array(1 : arrlen), array(1 : arrlen))
71 call getDummy()
72 end subroutine
73
74 subroutine getDotFAB()
75 use pm_mathSum, only: getDot!, fablocked
76 dotres = getDot(array(1 : arrlen), array(1 : arrlen))!, fablocked)
77 call getDummy()
78 end subroutine
79
80 subroutine getDotNAB()
81 use pm_mathSum, only: getDot, nablocked
82 dotres = getDot(array(1 : arrlen), array(1 : arrlen), nablocked)
83 call getDummy()
84 end subroutine
85
86 subroutine getDotKAB()
87 use pm_mathSum, only: getDot, kahanbabu
88 dotres = getDot(array(1 : arrlen), array(1 : arrlen), kahanbabu)
89 call getDummy()
90 end subroutine
91
92 subroutine getDotIte()
93 use pm_mathSum, only: getDot, iteration
94 dotres = getDot(array(1 : arrlen), array(1 : arrlen), iteration)
95 call getDummy()
96 end subroutine
97
98 subroutine getDotRec()
99 use pm_mathSum, only: getDot, recursion
100 dotres = getDot(array(1 : arrlen), array(1 : arrlen), recursion)
101 call getDummy()
102 end subroutine
103
104end program benchmark
Generate and return the expression dot_product(x, y) accurately (almost without roundoff error).


Example Unix compile command via Intel ifort compiler

1#!/usr/bin/env sh
2rm main.exe
3ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe


Example Windows Batch compile command via Intel ifort compiler

1del main.exe
2set PATH=..\..\..\lib;%PATH%
3ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
4main.exe


Example Unix / MinGW compile command via GNU gfortran compiler

1#!/usr/bin/env sh
2rm main.exe
3gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe


Postprocessing of the benchmark output

1#!/usr/bin/env python
2
3import matplotlib.pyplot as plt
4import pandas as pd
5import numpy as np
6
7import os
8dirname = os.path.basename(os.getcwd())
9
10fontsize = 14
11
12df = pd.read_csv("main.out", delimiter = ",")
13colnames = list(df.columns.values)
14
15
18
19ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
20ax = plt.subplot()
21
22for colname in colnames[1:]:
23 plt.plot( df[colnames[0]].values
24 , df[colname].values
25 , linewidth = 2
26 )
27
28plt.xticks(fontsize = fontsize)
29plt.yticks(fontsize = fontsize)
30ax.set_xlabel(colnames[0], fontsize = fontsize)
31ax.set_ylabel("Runtime [ seconds ]", fontsize = fontsize)
32ax.set_title(" vs. ".join(colnames[1:])+"\nLower is better.", fontsize = fontsize)
33ax.set_xscale("log")
34ax.set_yscale("log")
35plt.minorticks_on()
36plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
37ax.tick_params(axis = "y", which = "minor")
38ax.tick_params(axis = "x", which = "minor")
39ax.legend ( colnames[1:]
40 #, loc='center left'
41 #, bbox_to_anchor=(1, 0.5)
42 , fontsize = fontsize
43 )
44
45plt.tight_layout()
46plt.savefig("benchmark." + dirname + ".runtime.png")
47
48
51
52ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
53ax = plt.subplot()
54
55plt.plot( df[colnames[0]].values
56 , np.ones(len(df[colnames[0]].values))
57 , linestyle = "--"
58 #, color = "black"
59 , linewidth = 2
60 )
61for colname in colnames[2:]:
62 plt.plot( df[colnames[0]].values
63 , df[colname].values / df[colnames[1]].values
64 , linewidth = 2
65 )
66
67plt.xticks(fontsize = fontsize)
68plt.yticks(fontsize = fontsize)
69ax.set_xlabel(colnames[0], fontsize = fontsize)
70ax.set_ylabel("Runtime compared to {}".format(colnames[1]), fontsize = fontsize)
71ax.set_title("Runtime Ratio Comparison. Lower means faster.\nLower than 1 means faster than {}.".format(colnames[1]), fontsize = fontsize)
72ax.set_xscale("log")
73ax.set_yscale("log")
74plt.minorticks_on()
75plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
76ax.tick_params(axis = "y", which = "minor")
77ax.tick_params(axis = "x", which = "minor")
78ax.legend ( colnames[1:]
79 #, bbox_to_anchor = (1, 0.5)
80 #, loc = "center left"
81 , fontsize = fontsize
82 )
83
84plt.tight_layout()
85plt.savefig("benchmark." + dirname + ".runtime.ratio.png")


Visualization of the benchmark output


Benchmark moral

  1. Among all summation algorithms, fablocked_type appears to offer the most accurate result while also being even faster than the default Fortran dot_product() and all other implemented summation algorithms for array sizes > 100.


Final Remarks


If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

  1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
  2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Test:
test_pm_mathSum
Author:
Amir Shahmoradi, August 8, 2024, 8:45 PM, NASA Goddard Space Flight Center, Washington, D.C.

Variable Documentation

◆ fablocked

type(fablocked_type), parameter pm_mathSum::fablocked = fablocked_type()

This is a scalar parameter object of type fablocked_type.

For example usage, see the documentation of the target procedure requiring this object.

See also
fablocked
kahanbabu
iteration
recursion
fablocked_type
kahanbabu_type
iteration_type
recursion_type


Final Remarks


If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

  1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
  2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Author:
Amir Shahmoradi, August 8, 2024, 8:45 PM, NASA Goddard Space Flight Center, Washington, D.C.

Definition at line 143 of file pm_mathSum.F90.

◆ kahanbabu

type(kahanbabu_type), parameter pm_mathSum::kahanbabu = kahanbabu_type()

This is a scalar parameter object of type kahanbabu_type.

For example usage, see the documentation of the target procedure requiring this object.

See also
fablocked
kahanbabu
iteration
recursion
fablocked_type
kahanbabu_type
iteration_type
recursion_type


Final Remarks


If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

  1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
  2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Author:
Amir Shahmoradi, August 8, 2024, 8:45 PM, NASA Goddard Space Flight Center, Washington, D.C.

Definition at line 266 of file pm_mathSum.F90.

◆ MODULE_NAME

character(*, SK), parameter pm_mathSum::MODULE_NAME = "@pm_mathSum"

Definition at line 80 of file pm_mathSum.F90.

◆ nablocked

type(nablocked_type), parameter pm_mathSum::nablocked = nablocked_type()

This is a scalar parameter object of type nablocked_type.

For example usage, see the documentation of the target procedure requiring this object.

See also
fablocked
kahanbabu
iteration
recursion
fablocked_type
kahanbabu_type
iteration_type
recursion_type


Final Remarks


If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

  1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
  2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Author:
Amir Shahmoradi, August 8, 2024, 8:45 PM, NASA Goddard Space Flight Center, Washington, D.C.

Definition at line 206 of file pm_mathSum.F90.