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

This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte library for the two standard supported Fortran and C-Fortran Interoperation (CFI) modes.
More...

Data Types

type  model_type
 This is the abstract derived type for creating objects of class model_type that contain the characteristics of the processor representation model used for the requested data object.
More...
 
type  modelb_type
 This is the abstract derived type for creating objects of class modelb_type that contain the characteristics of the processor representation model used for the requested numeric data object.
More...
 
type  modeli_type
 This is the abstract derived type for creating objects of class modeli_type that contain the characteristics of the processor representation model used for the requested integer data object.
More...
 
type  modeln_type
 This is the abstract derived type for creating objects of class modeln_type that contain the characteristics of the processor representation model used for the requested numeric data object.
More...
 
type  modelr_type
 This is the abstract derived type for creating objects of class modelr_type that contain the characteristics of the processor representation model used for the requested integer data object.
More...
 

Variables

integer, parameter SK_DEF = kind("a")
 
integer, parameter IK_DEF = kind(1)
 
integer, parameter CK_DEF = kind(1.d0)
 
integer, parameter RK_DEF = kind(1.d0)
 
integer, parameter LK_DEF = kind(.true.)
 
integer, parameter SK5 = character_kinds(SK5_ENABLED)
 
integer, parameter SK4 = character_kinds(SK4_ENABLED)
 
integer, parameter SK3 = character_kinds(SK3_ENABLED)
 
integer, parameter SK2 = character_kinds(SK2_ENABLED)
 
integer, parameter SK1 = character_kinds(SK1_ENABLED)
 
integer, parameter IK5 = integer_kinds(IK5_ENABLED)
 
integer, parameter IR5 = range(0_IK5)
 
integer, parameter IK4 = integer_kinds(IK4_ENABLED)
 
integer, parameter IR4 = range(0_IK4)
 
integer, parameter IK3 = integer_kinds(IK3_ENABLED)
 
integer, parameter IR3 = range(0_IK3)
 
integer, parameter IK2 = integer_kinds(IK2_ENABLED)
 
integer, parameter IR2 = range(0_IK2)
 
integer, parameter IK1 = integer_kinds(IK1_ENABLED)
 
integer, parameter IR1 = range(0_IK1)
 
integer, parameter LK5 = logical_kinds(LK5_ENABLED)
 
integer, parameter LK4 = logical_kinds(LK4_ENABLED)
 
integer, parameter LK3 = logical_kinds(LK3_ENABLED)
 
integer, parameter LK2 = logical_kinds(LK2_ENABLED)
 
integer, parameter LK1 = logical_kinds(LK1_ENABLED)
 
integer, parameter CK5 = real_kinds(CK5_ENABLED)
 
integer, parameter CP5 = precision(0._CK5)
 
integer, parameter CR5 = range(0._CK5)
 
integer, parameter CK4 = real_kinds(CK4_ENABLED)
 
integer, parameter CP4 = precision(0._CK4)
 
integer, parameter CR4 = range(0._CK4)
 
integer, parameter CK3 = real_kinds(CK3_ENABLED)
 
integer, parameter CP3 = precision(0._CK3)
 
integer, parameter CR3 = range(0._CK3)
 
integer, parameter CK2 = real_kinds(CK2_ENABLED)
 
integer, parameter CP2 = precision(0._CK2)
 
integer, parameter CR2 = range(0._CK2)
 
integer, parameter CK1 = real_kinds(CK1_ENABLED)
 
integer, parameter CP1 = precision(0._CK1)
 
integer, parameter CR1 = range(0._CK1)
 
integer, parameter RK5 = real_kinds(RK5_ENABLED)
 
integer, parameter RP5 = precision(0._RK5)
 
integer, parameter RR5 = range(0._RK5)
 
integer, parameter RK4 = real_kinds(RK4_ENABLED)
 
integer, parameter RP4 = precision(0._RK4)
 
integer, parameter RR4 = range(0._RK4)
 
integer, parameter RK3 = real_kinds(RK3_ENABLED)
 
integer, parameter RP3 = precision(0._RK3)
 
integer, parameter RR3 = range(0._RK3)
 
integer, parameter RK2 = real_kinds(RK2_ENABLED)
 
integer, parameter RP2 = precision(0._RK2)
 
integer, parameter RR2 = range(0._RK2)
 
integer, parameter RK1 = real_kinds(RK1_ENABLED)
 
integer, parameter RP1 = precision(0._RK1)
 
integer, parameter RR1 = range(0._RK1)
 
integer, parameter SK = SK_DEF
 The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Interoperation mode. More...
 
integer, parameter IK = IK_DEF
 The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoperation mode. More...
 
integer, parameter LK = LK_DEF
 The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(.true.) in C-Fortran Interoperation mode. More...
 
integer, parameter CK = CK_DEF
 The default complex kind in the ParaMonte library: real64 in Fortran, c_double_complex in C-Fortran Interoperation mode. More...
 
integer, parameter RK = RK_DEF
 The default real kind in the ParaMonte library: real64 in Fortran, c_double in C-Fortran Interoperation mode. More...
 
integer, parameter IK64 = IK64_DEF
 The integer kind for a 64-bits container. More...
 
integer, parameter IK32 = IK32_DEF
 The integer kind for a 32-bits container. More...
 
integer, parameter IK16 = IK16_DEF
 The integer kind for a 16-bits container. More...
 
integer, parameter IK8 = IK8_DEF
 The integer kind for an 8-bits container. More...
 
integer, parameter CK128 = CK128_DEF
 The complex kind for a 128-bits container. More...
 
integer, parameter CK64 = CK64_DEF
 The complex kind for a 64-bits container. More...
 
integer, parameter CK32 = CK32_DEF
 The complex kind for a 32-bits container. More...
 
integer, parameter RK128 = RK128_DEF
 The real kind for a 128-bits container. More...
 
integer, parameter RK64 = RK64_DEF
 The real kind for a 64-bits container. More...
 
integer, parameter RK32 = RK32_DEF
 The real kind for a 32-bits container. More...
 
integer, parameter SKU = selected_char_kind("iso_10646")
 The UNICODE string kind in Fortran mode. More...
 
integer, parameter SKD = selected_char_kind("default")
 The DEFAULT string kind in Fortran mode. More...
 
integer, parameter SKA = selected_char_kind("ascii")
 The ASCII string kind in Fortran mode. More...
 
integer, parameter IKS = kind(1)
 The single-precision integer kind in Fortran mode. On most platforms, this is a 32-bit integer kind. More...
 
integer, parameter IKD = selected_int_kind(18)
 The double precision integer kind in Fortran mode. On most platforms, this is a 64-bit integer kind. More...
 
integer, parameter IKQ = selected_int_kind(36)
 The quadru-precision integer kind in Fortran mode. On most platforms, this is a 128-bit integer kind. There is no guarantee of the existence of this kind (e.g., Intel does not support this). More...
 
integer, parameter RKS = kind(1.)
 The single-precision real kind in Fortran mode. On most platforms, this is an 32-bit real kind. More...
 
integer, parameter RKD = kind(1.d0)
 The double precision real kind in Fortran mode. On most platforms, this is an 64-bit real kind. More...
 
integer, parameter RKQ = selected_real_kind(2*precision(1._RKD))
 The quadru-precision real kind in Fortran mode. On most platforms, this is an 128-bit real kind. More...
 
integer, parameter CKS = RKS
 The single-precision complex kind in Fortran mode. On most platforms, this is a 32-bit real kind. More...
 
integer, parameter CKD = RKD
 The double precision complex kind in Fortran mode. On most platforms, this is a 64-bit real kind. More...
 
integer, parameter CKQ = RKQ
 The quadru-precision complex kind in Fortran mode. On most platforms, this is a 128-bit real kind. More...
 
integer, dimension(*), parameter SKALL = pack([SK1, SK2, SK3, SK4, SK5], 0 < [SK1, SK2, SK3, SK4, SK5])
 The integer vector containing all defined character kinds within the ParaMonte library.
More...
 
integer, dimension(*), parameter IKALL = pack([IK1, IK2, IK3, IK4, IK5], 0 < [IK1, IK2, IK3, IK4, IK5])
 The integer vector containing all defined integer kinds within the ParaMonte library.
More...
 
integer, dimension(*), parameter LKALL = pack([LK1, LK2, LK3, LK4, LK5], 0 < [LK1, LK2, LK3, LK4, LK5])
 The integer vector containing all defined logical kinds within the ParaMonte library.
More...
 
integer, dimension(*), parameter CKALL = pack([CK1, CK2, CK3, CK4, CK5], 0 < [CK1, CK2, CK3, CK4, CK5])
 The integer vector containing all defined complex kinds within the ParaMonte library.
More...
 
integer, dimension(*), parameter RKALL = pack([RK1, RK2, RK3, RK4, RK5], 0 < [RK1, RK2, RK3, RK4, RK5])
 The integer vector containing all defined real kinds within the ParaMonte library.
More...
 
integer, parameter IRL = minval([IR1, IR2, IR3, IR4, IR5], mask = 0 < [IR1, IR2, IR3, IR4, IR5])
 The scalar integer constant of intrinsic default kind, representing the lowest range among all integer kinds supported by the specific library build.
More...
 
integer, parameter IRH = maxval([IR1, IR2, IR3, IR4, IR5], mask = 0 < [IR1, IR2, IR3, IR4, IR5])
 The scalar integer constant of intrinsic default kind, representing the highest range among all integer kinds supported by the specific library build.
More...
 
integer, parameter CPL = minval([CP1, CP2, CP3, CP4, CP5], mask = 0 < [CP1, CP2, CP3, CP4, CP5])
 The scalar integer constant of intrinsic default kind, representing the lowest precision among all complex kinds supported by the specific library build.
More...
 
integer, parameter CPH = maxval([CP1, CP2, CP3, CP4, CP5], mask = 0 < [CP1, CP2, CP3, CP4, CP5])
 The scalar integer constant of intrinsic default kind, representing the highest precision among all complex kinds supported by the specific library build.
More...
 
integer, parameter CRL = minval([CR1, CR2, CR3, CR4, CR5], mask = 0 < [CR1, CR2, CR3, CR4, CR5])
 The scalar integer constant of intrinsic default kind, representing the lowest decimal exponent range among all complex kinds supported by the specific library build.
More...
 
integer, parameter CRH = maxval([CR1, CR2, CR3, CR4, CR5], mask = 0 < [CR1, CR2, CR3, CR4, CR5])
 The scalar integer constant of intrinsic default kind, representing the highest decimal exponent range among all complex kinds supported by the specific library build.
More...
 
integer, parameter RPL = minval([RP1, RP2, RP3, RP4, RP5], mask = 0 < [RP1, RP2, RP3, RP4, RP5])
 The scalar integer constant of intrinsic default kind, representing the lowest precision among all real kinds supported by the specific library build.
More...
 
integer, parameter RPH = maxval([RP1, RP2, RP3, RP4, RP5], mask = 0 < [RP1, RP2, RP3, RP4, RP5])
 The scalar integer constant of intrinsic default kind, representing the highest precision among all real kinds supported by the specific library build.
More...
 
integer, parameter RRL = minval([RR1, RR2, RR3, RR4, RR5], mask = 0 < [RR1, RR2, RR3, RR4, RR5])
 The scalar integer constant of intrinsic default kind, representing the lowest decimal exponent range among all real kinds supported by the specific library build.
More...
 
integer, parameter RRH = maxval([RR1, RR2, RR3, RR4, RR5], mask = 0 < [RR1, RR2, RR3, RR4, RR5])
 The scalar integer constant of intrinsic default kind, representing the highest decimal exponent range among all real kinds supported by the specific library build.
More...
 
integer, parameter IKL = selected_int_kind(IRL)
 The scalar integer constant of intrinsic default kind, representing the lowest range integer kind type parameter available in the specific library build.
More...
 
integer, parameter CKL = selected_real_kind(CPL)
 The scalar integer constant of intrinsic default kind, representing the lowest-precision complex kind type parameter available in the specific library build.
More...
 
integer, parameter RKL = selected_real_kind(RPL)
 The scalar integer constant of intrinsic default kind, representing the lowest-precision real kind type parameter available in the specific library build.
More...
 
integer, parameter CKLR = selected_real_kind(r = CRL)
 The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range complex kind type parameter available in the specific library build.
More...
 
integer, parameter RKLR = selected_real_kind(r = RRL)
 The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range real kind type parameter available in the specific library build.
More...
 
integer, parameter IKH = selected_int_kind(IRH)
 The scalar integer constant of intrinsic default kind, representing the highest range integer kind type parameter available in the specific library build.
More...
 
integer, parameter CKH = selected_real_kind(CPH)
 The scalar integer constant of intrinsic default kind, representing the highest-precision complex kind type parameter available in the specific library build.
More...
 
integer, parameter RKH = selected_real_kind(RPH)
 The scalar integer constant of intrinsic default kind, representing the highest-precision real kind type parameter available in the specific library build.
More...
 
integer, dimension(*), parameter CKHR_VEC_RAW = [ selected_real_kind(merge(huge(1), CP5, CP5 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP4, CP4 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP3, CP3 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP2, CP2 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP1, CP1 < 1), r = CRH) ]
 
integer, dimension(*), parameter CKHR_VEC = pack(CKHR_VEC_RAW, 0 <= CKHR_VEC_RAW)
 
integer, parameter CKHR = CKHR_VEC(1)
 The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range complex kind type parameter available in the specific library build.
More...
 
integer, dimension(*), parameter RKHR_VEC_RAW = [ selected_real_kind(merge(huge(1), RP5, RP5 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP4, RP4 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP3, RP3 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP2, RP2 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP1, RP1 < 1), r = RRH) ]
 
integer, dimension(*), parameter RKHR_VEC = pack(RKHR_VEC_RAW, 0 <= RKHR_VEC_RAW)
 
integer, parameter RKHR = RKHR_VEC(1)
 The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range real kind type parameter available in the specific library build.
More...
 
integer, parameter IKW = selected_int_kind(1)
 The scalar integer constant of intrinsic default kind, representing the Worst-range integer kind supported by the processor.
More...
 
integer, parameter CKW = selected_real_kind(1)
 The scalar integer constant of intrinsic default kind, representing the Worst-precision complex kind supported by the processor.
More...
 
integer, parameter RKW = selected_real_kind(1)
 The scalar integer constant of intrinsic default kind, representing the Worst-precision real kind supported by the processor.
More...
 
integer, parameter CKWR = selected_real_kind(r = 1)
 The scalar integer constant of intrinsic default kind, representing the Worst-decimal-exponent-range complex kind supported by the processor.
More...
 
integer, parameter RKWR = selected_real_kind(r = 1)
 The scalar integer constant of intrinsic default kind, representing the Worst-decimal-exponent-range real kind supported by the processor.
More...
 
integer, dimension(*), parameter integer_kinds_range = [ range(int(0, kind = integer_kinds(min(size(integer_kinds), 1)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 2)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 3)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 4)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 5)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 6)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 7)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 8)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 9)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 10)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 11)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 12)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 13)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 14)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 15)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 16)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 17)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 18)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 19)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 20)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 21)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 22)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 23)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 24)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 25)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 26)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 27)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 28)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 29)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 30)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 31)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 32)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 33)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 34)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 35)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 36)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 37)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 38)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 39)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 40)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 40)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 41)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 42)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 43)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 44)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 45)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 46)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 47)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 48)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 49)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 50)))) ]
 The vector of integer constants of intrinsic default kind, representing the vector of 50 possible integer ranges of the kinds provided in integer_kinds of the intrinsic Fortran module iso_fortran_env.
More...
 
integer, dimension(*), parameter real_kinds_range = [ range(real(0, kind = real_kinds(min(size(real_kinds), 1)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 2)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 3)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 4)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 5)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 6)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 7)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 8)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 9)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 10)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 11)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 12)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 13)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 14)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 15)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 16)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 17)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 18)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 19)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 20)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 21)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 22)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 23)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 24)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 25)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 26)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 27)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 28)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 29)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 30)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 31)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 32)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 33)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 34)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 35)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 36)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 37)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 38)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 39)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 41)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 42)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 43)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 44)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 45)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 46)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 47)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 48)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 49)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 50)))) ]
 The vector of integer constants of intrinsic default kind, representing the vector of 50 possible real precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.
More...
 
integer, dimension(*), parameter real_kinds_precision = [ precision(real(0, kind = real_kinds(min(size(real_kinds), 1)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 2)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 3)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 4)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 5)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 6)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 7)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 8)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 9)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 10)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 11)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 12)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 13)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 14)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 15)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 16)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 17)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 18)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 19)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 20)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 21)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 22)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 23)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 24)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 25)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 26)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 27)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 28)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 29)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 30)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 31)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 32)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 33)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 34)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 35)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 36)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 37)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 38)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 39)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 41)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 42)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 43)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 44)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 45)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 46)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 47)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 48)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 49)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 50)))) ]
 The vector of integer constants of intrinsic default kind, representing the vector of 50 possible real highest-range precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.
More...
 
integer, parameter real_kinds_range_max = maxval(real_kinds_range, dim = 1)
 The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range of real types made available by the processor. More...
 
integer, parameter real_kinds_precision_max = maxval(real_kinds_precision, dim = 1)
 The scalar integer constant of intrinsic default kind, representing the highest-precision of real types made available by the processor. More...
 
integer, parameter real_kinds_precision_min = minval(real_kinds_precision, dim = 1)
 The scalar integer constant of intrinsic default kind, representing the lowest-precision of real types made available by the processor. More...
 
real, parameter real_kinds_precision_hop = real(real_kinds_precision_max - real_kinds_precision_min) / size(real_kinds_precision)
 The scalar real constant of intrinsic default kind, representing the step size between the highest and lowest-precision of real types made available by the processor. More...
 
integer, dimension(*), parameter real_kinds_prmax_kind = [ selected_real_kind(p = real_kinds_precision_max, r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 0)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 1)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 2)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 3)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 4)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 5)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 6)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 7)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 8)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 9)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 10)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 11)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 12)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 13)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 14)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 15)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 16)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 17)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 18)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 19)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 20)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 21)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 22)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 23)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 24)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 25)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 26)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 27)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 28)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 29)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 30)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 31)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 32)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 33)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 34)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 35)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 36)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 37)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 38)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 39)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 40)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 41)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 42)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 43)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 44)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 45)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 46)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 47)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 48)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 49)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 50)), r = real_kinds_range_max) , selected_real_kind(p = real_kinds_precision_min, r = real_kinds_range_max) ]
 The vector of integer constants of intrinsic default kind, representing the 50 possible real highest-range precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.
More...
 
integer, dimension(*), parameter real_kinds_prmax_kind_avail = pack(real_kinds_prmax_kind, 0 <= real_kinds_prmax_kind)
 The vector of integer constants of intrinsic default kind, containing all maximum-range real kind type parameters corresponding to various precisions provided in real_kinds of the intrinsic Fortran module iso_fortran_env.
More...
 
integer, parameter IKB = selected_int_kind(maxval(integer_kinds_range, dim = 1))
 The scalar integer constant of intrinsic default kind, representing the Best-range integer kind supported by the processor.
More...
 
integer, parameter CKB = selected_real_kind(maxval(real_kinds_precision, dim = 1))
 The scalar integer constant of intrinsic default kind, representing the Best-precision complex kind supported by the processor.
More...
 
integer, parameter RKB = selected_real_kind(maxval(real_kinds_precision, dim = 1))
 The scalar integer constant of intrinsic default kind, representing the Best-precision real kind supported by the processor.
More...
 
integer, parameter CKBR = real_kinds_prmax_kind_avail(1)
 The scalar integer constant of intrinsic default kind, representing the Best-decimal-exponent-range complex kind supported by the processor.
More...
 
integer, parameter RKBR = real_kinds_prmax_kind_avail(1)
 The scalar integer constant of intrinsic default kind, representing the Best-decimal-exponent-range real kind supported by the processor.
More...
 

Detailed Description

This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte library for the two standard supported Fortran and C-Fortran Interoperation (CFI) modes.

Default Kind Type Parameters

The following list contains the default kind type parameters of interest to the end users of the ParaMonte library.
Note that the default kind type parameters may not necessarily correspond to the default kind type parameters used by the processor.

  1. The constant SK represents the default character kind type parameter used within the entire ParaMonte library.
  2. The constant IK represents the default integer kind type parameter used within the entire ParaMonte library.
  3. The constant LK represents the default logical kind type parameter used within the entire ParaMonte library.
  4. The constant CK represents the default complex kind type parameter used within the entire ParaMonte library.
  5. The constant RK represents the default real kind type parameter used within the entire ParaMonte library.

Single-Range/Precision Kind Type Parameters

  1. The constant IKS represents the single-range integer kind type parameter used within the entire ParaMonte library.
    This corresponds to the default integer kind type parameter of the processor.
  2. The constant CKS represents the single-precision complex kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.
  3. The constant RKS represents the single-precision real kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.

All of the above kind type parameters are guaranteed by the standard to exist and be supported.

Double-Range/Precision Kind Type Parameters

  1. The constant IKD represents the double-range integer kind type parameter used within the entire ParaMonte library.
    This corresponds to the default integer kind type parameter of the processor.
  2. The constant CKD represents the double-precision complex kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.
  3. The constant RKD represents the double-precision real kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.

All of the above kind type parameters are guaranteed by the standard to exist and be supported.

Quadru-Range/Precision Kind Type Parameters

  1. The constant IKQ represents the quadru-range integer kind type parameter used within the entire ParaMonte library.
    This corresponds to the default integer kind type parameter of the processor.
  2. The constant CKQ represents the quadru-precision complex kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.
  3. The constant RKQ represents the quadru-precision real kind type parameter used within the entire ParaMonte library.
    This corresponds to the default real kind type parameter of the processor.

There is no guarantee of the existence of the above kind type parameters on all processors and compilers.
If a kind type parameter does not exist, the processor assigns a negative value to it.

Lowest-Range Kind Type Parameters

This module specifies the kind type parameters that yield the lowest range intrinsic integer, complex, and real types that are supported by the specific ParaMonte library build as in the following:

  1. The constant IKL represents the lowest-range integer kind type parameter supported by the ParaMonte library.
  2. The constant CKLR represents the lowest-range complex kind type parameter supported by the ParaMonte library.
  3. The constant RKLR represents the lowest-range real kind type parameter supported by the ParaMonte library.

Highest-Range Kind Type Parameters

This module specifies the kind type parameters that yield the highest range intrinsic integer, complex, and real types that are supported by the specific ParaMonte library build as in the following:

  1. The constant IKH represents the highest-range integer kind type parameter supported by the ParaMonte library.
  2. The constant CKHR represents the highest-range complex kind type parameter supported by the ParaMonte library.
  3. The constant RKHR represents the highest-range real kind type parameter supported by the ParaMonte library.

Lowest-Precision Kind Type Parameters

This module specifies the kind type parameters that yield the lowest precision intrinsic complex and and real types that are supported by the specific ParaMonte library build as in the following:

  1. The constant CKL represents the lowest-precision complex kind type parameter supported by the ParaMonte library.
  2. The constant RKL represents the lowest-precision real kind type parameter supported by the ParaMonte library.

Highest-Precision Kind Type Parameters

This module specifies the kind type parameters that yield the highest precision intrinsic complex and and real types that are supported by the specific ParaMonte library build as in the following:

  1. The constant CKH represents the highest-precision complex kind type parameter supported by the ParaMonte library.
  2. The constant RKH represents the highest-precision real kind type parameter supported by the ParaMonte library.

Worst-Range Kind Type Parameters

This module specifies the kind type parameters that yield the worst range intrinsic integer, complex, and real types that supported by the processor (whether or not supported by the specific ParaMonte library build) as in the following:

  1. The constant IKW represents the worst-range integer kind type parameter supported by the processor.
  2. The constant CKWR represents the worst-range complex kind type parameter supported by the processor.
  3. The constant RKWR represents the worst-range real kind type parameter supported by the processor.

Best-Range Kind Type Parameters

This module specifies the kind type parameters that yield the highest range intrinsic integer, complex, and real types that supported by the processor (whether or not supported by the specific ParaMonte library build) as in the following:

  1. The constant IKB represents the highest-range integer kind type parameter supported by the processor.
  2. The constant CKBR represents the highest-range complex kind type parameter supported by the processor.
  3. The constant RKBR represents the highest-range real kind type parameter supported by the processor.

Worst-Precision Kind Type Parameters

This module specifies the kind type parameters that yield the worst precision intrinsic complex and and real types that supported by the processor (whether or not supported by the specific ParaMonte library build) as in the following:

  1. The constant CKW represents the worst-precision complex kind type parameter supported by the processor.
  2. The constant RKW represents the worst-precision real kind type parameter supported by the processor.

Best-Precision Kind Type Parameters

This module specifies the kind type parameters that yield the highest precision intrinsic complex and and real types that supported by the processor (whether or not supported by the specific ParaMonte library build) as in the following:

  1. The constant CKB represents the highest-precision complex kind type parameter supported by the processor.
  2. The constant RKB represents the highest-precision real kind type parameter supported by the processor.

Developer Guidelines

The current implementation of the ParaMonte library can recognize up to five kind type parameters for each of the five intrinsic types in the latest Fortran programming language standard 2023:

  1. The character kinds are prefixed by SK standing for string kind type:
    1. SK5
    2. SK4
    3. SK3
    4. SK2
    5. SK1
  2. The integer kinds are prefixed by IK standing for integer kind type:
    1. IK5
    2. IK4
    3. IK3
    4. IK2
    5. IK1
  3. The logical kinds are prefixed by LK standing for logical kind type:
    1. LK5
    2. LK4
    3. LK3
    4. LK2
    5. LK1
  4. The complex kinds are prefixed by CK standing for complex kind type:
    1. CK5
    2. CK4
    3. CK3
    4. CK2
    5. CK1
  5. The real kinds are prefixed by CK standing for real kind type:
    1. RK5
    2. RK4
    3. RK3
    4. RK2
    5. RK1

A few remarks are in order:

  1. Any unsupported or non-existing kind type parameter is given a negative value.
  2. Not all five kinds per intrinsic type may be available on a given platform or compiler or desired for a particular library build.
  3. The availability of the above kind type parameters can be also controlled via the optional library build flags.
  4. The above kind type parameters are considered internal library implementations.
  5. An end user must never use these kind type parameters from this module.

Precision Parameters

The precisions of the corresponding real and complex kind type parameters are represented by the letter R.

  1. complex precisions are prefixed by CP standing for complex precision:
    1. CP5
    2. CP4
    3. CP3
    4. CP2
    5. CP1
  2. real kinds are prefixed by CK standing for real precision:
    1. RP5
    2. RP4
    3. RP3
    4. RP2
    5. RP1

The precision of non-existing kind type parameters are set to zero.

Intrinsic Type Representation Models

The following representation model derived types also exist in this module:

  1. modelb_type can hold information about binary (bit) containers.
  2. modeli_type can hold information about integer containers of various kinds.
  3. modelr_type can hold information about complex and real containers of various kinds.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Variable Documentation

◆ CK

integer, parameter pm_kind::CK = CK_DEF

The default complex kind in the ParaMonte library: real64 in Fortran, c_double_complex in C-Fortran Interoperation mode.

Definition at line 542 of file pm_kind.F90.

◆ CK1

integer, parameter pm_kind::CK1 = real_kinds(CK1_ENABLED)

Definition at line 464 of file pm_kind.F90.

◆ CK128

integer, parameter pm_kind::CK128 = CK128_DEF

The complex kind for a 128-bits container.

Definition at line 549 of file pm_kind.F90.

◆ CK2

integer, parameter pm_kind::CK2 = real_kinds(CK2_ENABLED)

Definition at line 453 of file pm_kind.F90.

◆ CK3

integer, parameter pm_kind::CK3 = real_kinds(CK3_ENABLED)

Definition at line 442 of file pm_kind.F90.

◆ CK32

integer, parameter pm_kind::CK32 = CK32_DEF

The complex kind for a 32-bits container.

Definition at line 551 of file pm_kind.F90.

◆ CK4

integer, parameter pm_kind::CK4 = real_kinds(CK4_ENABLED)

Definition at line 431 of file pm_kind.F90.

◆ CK5

integer, parameter pm_kind::CK5 = real_kinds(CK5_ENABLED)

Definition at line 420 of file pm_kind.F90.

◆ CK64

integer, parameter pm_kind::CK64 = CK64_DEF

The complex kind for a 64-bits container.

Definition at line 550 of file pm_kind.F90.

◆ CK_DEF

integer, parameter pm_kind::CK_DEF = kind(1.d0)

Definition at line 314 of file pm_kind.F90.

◆ CKALL

integer, dimension(*), parameter pm_kind::CKALL = pack([CK1, CK2, CK3, CK4, CK5], 0 < [CK1, CK2, CK3, CK4, CK5])

The integer vector containing all defined complex kinds within the ParaMonte library.

Note that this vector may only be a subset of the complex kinds supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 624 of file pm_kind.F90.

◆ CKB

integer, parameter pm_kind::CKB = selected_real_kind(maxval(real_kinds_precision, dim = 1))

The scalar integer constant of intrinsic default kind, representing the Best-precision complex kind supported by the processor.

Although the value of CKH is the same as the value of CKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the highest-precision kind supported by the processor.
In other words, the highest-precision complex kind CKH supported by a specific library build is not necessarily the same as the best-precision complex kind CKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-precision complex kind of the library CKH, the same does not hold for CKB when its value is different from CKH.

The current Fortran standard does not allow automatic selection of the highest-precision complex kind made available by the processor.
However, such a kind is essential for defining complex constants of highest-precision that can be later coerced to complex kinds of lower precision.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1352 of file pm_kind.F90.

◆ CKBR

integer, parameter pm_kind::CKBR = real_kinds_prmax_kind_avail(1)

The scalar integer constant of intrinsic default kind, representing the Best-decimal-exponent-range complex kind supported by the processor.

Although the value of CKHR is the same as the value of CKBR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the highest-decimal-exponent-range kind supported by the processor.
In other words, the highest-decimal-exponent-range complex kind CKHR supported by a specific library build is not necessarily the same as the best-decimal-exponent-range complex kind CKBR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-decimal-exponent-range complex kind of the library CKHR, the same does not hold for CKBR when its value is different from CKHR.

The current Fortran standard does not allow automatic selection of the highest-decimal-exponent-range complex kind made available by the processor.
However, such a kind is essential for defining complex constants of highest-decimal-exponent-range that can be later coerced to complex kinds of lower decimal-exponent-range.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1389 of file pm_kind.F90.

◆ CKD

integer, parameter pm_kind::CKD = RKD

The double precision complex kind in Fortran mode. On most platforms, this is a 64-bit real kind.

Definition at line 571 of file pm_kind.F90.

Referenced by pm_lapack::lapackGETRF::zgetrf().

◆ CKH

integer, parameter pm_kind::CKH = selected_real_kind(CPH)

The scalar integer constant of intrinsic default kind, representing the highest-precision complex kind type parameter available in the specific library build.

Although the value of CKH is the same as the value of CKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the highest-precision kind supported by the processor.
In other words, the highest-precision complex kind CKH supported by a specific library build is not necessarily the same as the best-precision complex kind CKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-precision complex kind of the library CKH, the same does not hold for CKB when its value is different from CKH.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 843 of file pm_kind.F90.

◆ CKHR

integer, parameter pm_kind::CKHR = CKHR_VEC(1)

The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range complex kind type parameter available in the specific library build.

Although the value of CKHR is the same as the value of CKBR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the highest-range kind supported by the processor.
In other words, the highest-range complex kind CKHR supported by a specific library build is not necessarily the same as the best-range complex kind CKBR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range complex kind of the library CKHR, the same does not hold for CKBR when its value is different from CKHR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 880 of file pm_kind.F90.

◆ CKHR_VEC

integer, dimension(*), parameter pm_kind::CKHR_VEC = pack(CKHR_VEC_RAW, 0 <= CKHR_VEC_RAW)

Definition at line 865 of file pm_kind.F90.

◆ CKHR_VEC_RAW

integer, dimension(*), parameter pm_kind::CKHR_VEC_RAW = [ selected_real_kind(merge(huge(1), CP5, CP5 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP4, CP4 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP3, CP3 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP2, CP2 < 1), r = CRH) , selected_real_kind(merge(huge(1), CP1, CP1 < 1), r = CRH) ]

Definition at line 860 of file pm_kind.F90.

◆ CKL

integer, parameter pm_kind::CKL = selected_real_kind(CPL)

The scalar integer constant of intrinsic default kind, representing the lowest-precision complex kind type parameter available in the specific library build.

Although the value of CKL is the same as the value of CKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the lowest-precision kind supported by the processor.
In other words, the lowest-precision complex kind CKL supported by a specific library build is not necessarily the same as the worst-precision complex kind CKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-precision complex kind of the library CKL, the same does not hold for CKW when its value is different from CKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 764 of file pm_kind.F90.

◆ CKLR

integer, parameter pm_kind::CKLR = selected_real_kind(r = CRL)

The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range complex kind type parameter available in the specific library build.

Although the value of CKLR is the same as the value of CKWR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the highest-range kind supported by the processor.
In other words, the highest-range complex kind CKLR supported by a specific library build is not necessarily the same as the best-range complex kind CKWR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range complex kind of the library CKLR, the same does not hold for CKWR when its value is different from CKLR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 794 of file pm_kind.F90.

◆ CKQ

integer, parameter pm_kind::CKQ = RKQ

The quadru-precision complex kind in Fortran mode. On most platforms, this is a 128-bit real kind.

Definition at line 572 of file pm_kind.F90.

◆ CKS

integer, parameter pm_kind::CKS = RKS

The single-precision complex kind in Fortran mode. On most platforms, this is a 32-bit real kind.

Definition at line 570 of file pm_kind.F90.

Referenced by pm_lapack::lapackGETRF::cgetrf().

◆ CKW

integer, parameter pm_kind::CKW = selected_real_kind(1)

The scalar integer constant of intrinsic default kind, representing the Worst-precision complex kind supported by the processor.

Although the value of CKL is the same as the value of CKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the lowest-precision kind supported by the processor.
In other words, the lowest-precision complex kind CKL supported by a specific library build is not necessarily the same as the worst-precision complex kind CKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-precision complex kind of the library CKL, the same does not hold for CKW when its value is different from CKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 936 of file pm_kind.F90.

◆ CKWR

integer, parameter pm_kind::CKWR = selected_real_kind(r = 1)

The scalar integer constant of intrinsic default kind, representing the Worst-decimal-exponent-range complex kind supported by the processor.

Although the value of CKLR is the same as the value of CKWR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for complex kind type parameters that exclude the lowest-decimal-exponent-range kind supported by the processor.
In other words, the lowest-decimal-exponent-range complex kind CKLR supported by a specific library build is not necessarily the same as the worst-decimal-exponent-range complex kind CKWR supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-decimal-exponent-range complex kind of the library CKLR, the same does not hold for CKWR when its value is different from CKLR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 966 of file pm_kind.F90.

◆ CP1

integer, parameter pm_kind::CP1 = precision(0._CK1)

Definition at line 465 of file pm_kind.F90.

◆ CP2

integer, parameter pm_kind::CP2 = precision(0._CK2)

Definition at line 454 of file pm_kind.F90.

◆ CP3

integer, parameter pm_kind::CP3 = precision(0._CK3)

Definition at line 443 of file pm_kind.F90.

◆ CP4

integer, parameter pm_kind::CP4 = precision(0._CK4)

Definition at line 432 of file pm_kind.F90.

◆ CP5

integer, parameter pm_kind::CP5 = precision(0._CK5)

Definition at line 421 of file pm_kind.F90.

◆ CPH

integer, parameter pm_kind::CPH = maxval([CP1, CP2, CP3, CP4, CP5], mask = 0 < [CP1, CP2, CP3, CP4, CP5])

The scalar integer constant of intrinsic default kind, representing the highest precision among all complex kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 676 of file pm_kind.F90.

◆ CPL

integer, parameter pm_kind::CPL = minval([CP1, CP2, CP3, CP4, CP5], mask = 0 < [CP1, CP2, CP3, CP4, CP5])

The scalar integer constant of intrinsic default kind, representing the lowest precision among all complex kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 667 of file pm_kind.F90.

◆ CR1

integer, parameter pm_kind::CR1 = range(0._CK1)

Definition at line 466 of file pm_kind.F90.

◆ CR2

integer, parameter pm_kind::CR2 = range(0._CK2)

Definition at line 455 of file pm_kind.F90.

◆ CR3

integer, parameter pm_kind::CR3 = range(0._CK3)

Definition at line 444 of file pm_kind.F90.

◆ CR4

integer, parameter pm_kind::CR4 = range(0._CK4)

Definition at line 433 of file pm_kind.F90.

◆ CR5

integer, parameter pm_kind::CR5 = range(0._CK5)

Definition at line 422 of file pm_kind.F90.

◆ CRH

integer, parameter pm_kind::CRH = maxval([CR1, CR2, CR3, CR4, CR5], mask = 0 < [CR1, CR2, CR3, CR4, CR5])

The scalar integer constant of intrinsic default kind, representing the highest decimal exponent range among all complex kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 694 of file pm_kind.F90.

◆ CRL

integer, parameter pm_kind::CRL = minval([CR1, CR2, CR3, CR4, CR5], mask = 0 < [CR1, CR2, CR3, CR4, CR5])

The scalar integer constant of intrinsic default kind, representing the lowest decimal exponent range among all complex kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 685 of file pm_kind.F90.

◆ IK

integer, parameter pm_kind::IK = IK_DEF

The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoperation mode.

Definition at line 540 of file pm_kind.F90.

Referenced by pm_blas::blasGEMM::cgemm(), pm_blas::blasGEMV::cgemv(), pm_lapack::lapackGETRF::cgetrf(), pm_blas::blasHEMM::chemm(), pm_blas::blasHEMV::chemv(), pm_blas::blasHERK::cherk(), pm_blas::blasHPMV::chpmv(), pm_blas::blasSWAP::cswap(), pm_blas::blasSYMM::csymm(), pm_blas::blasSYRK::csyrk(), pm_blas::blasTRMM::ctrmm(), pm_blas::blasTRMV::ctrmv(), pm_blas::blasTRSM::ctrsm(), pm_blas::blasTRSV::ctrsv(), pm_blas::blasGEMM::dgemm(), pm_blas::blasGEMV::dgemv(), pm_lapack::lapackGETRF::dgetrf(), pm_blas::blasSPMV::dspmv(), pm_blas::blasSWAP::dswap(), pm_blas::blasSYMM::dsymm(), pm_blas::blasSYMV::dsymv(), pm_blas::blasSYRK::dsyrk(), pm_blas::blasTRMM::dtrmm(), pm_blas::blasTRMV::dtrmv(), pm_blas::blasTRSM::dtrsm(), pm_blas::blasTRSV::dtrsv(), pm_dateTime::getHour(), pm_arrayReplace::getReplaced_recurs_alloc(), pm_timer::getTimeDAT(), pm_timer::getTimeMPI(), pm_timer::getTimeOMP(), pm_sampling::runParaDRAMF(), pm_blas::blasGEMM::sgemm(), pm_blas::blasGEMV::sgemv(), pm_lapack::lapackGETRF::sgetrf(), pm_blas::blasSPMV::sspmv(), pm_blas::blasSWAP::sswap(), pm_blas::blasSYMM::ssymm(), pm_blas::blasSYMV::ssymv(), pm_blas::blasSYRK::ssyrk(), pm_blas::blasTRMM::strmm(), pm_blas::blasTRMV::strmv(), pm_blas::blasTRSM::strsm(), pm_blas::blasTRSV::strsv(), pm_blas::blasGEMM::zgemm(), pm_blas::blasGEMV::zgemv(), pm_lapack::lapackGETRF::zgetrf(), pm_blas::blasHEMM::zhemm(), pm_blas::blasHEMV::zhemv(), pm_blas::blasHERK::zherk(), pm_blas::blasHPMV::zhpmv(), pm_blas::blasSWAP::zswap(), pm_blas::blasSYMM::zsymm(), pm_blas::blasSYRK::zsyrk(), pm_blas::blasTRMM::ztrmm(), pm_blas::blasTRMV::ztrmv(), pm_blas::blasTRSM::ztrsm(), and pm_blas::blasTRSV::ztrsv().

◆ IK1

integer parameter pm_kind::IK1 = integer_kinds(IK1_ENABLED)

Definition at line 382 of file pm_kind.F90.

◆ IK16

integer, parameter pm_kind::IK16 = IK16_DEF

The integer kind for a 16-bits container.

Definition at line 547 of file pm_kind.F90.

◆ IK2

integer parameter pm_kind::IK2 = integer_kinds(IK2_ENABLED)

Definition at line 375 of file pm_kind.F90.

◆ IK3

integer parameter pm_kind::IK3 = integer_kinds(IK3_ENABLED)

Definition at line 368 of file pm_kind.F90.

◆ IK32

integer, parameter pm_kind::IK32 = IK32_DEF

The integer kind for a 32-bits container.

Definition at line 546 of file pm_kind.F90.

◆ IK4

integer parameter pm_kind::IK4 = integer_kinds(IK4_ENABLED)

Definition at line 361 of file pm_kind.F90.

◆ IK5

integer parameter pm_kind::IK5 = integer_kinds(IK5_ENABLED)

Definition at line 354 of file pm_kind.F90.

◆ IK64

integer, parameter pm_kind::IK64 = IK64_DEF

The integer kind for a 64-bits container.

Definition at line 545 of file pm_kind.F90.

◆ IK8

integer, parameter pm_kind::IK8 = IK8_DEF

The integer kind for an 8-bits container.

Definition at line 548 of file pm_kind.F90.

◆ IK_DEF

integer, parameter pm_kind::IK_DEF = kind(1)

Definition at line 313 of file pm_kind.F90.

◆ IKALL

integer, dimension(*), parameter pm_kind::IKALL = pack([IK1, IK2, IK3, IK4, IK5], 0 < [IK1, IK2, IK3, IK4, IK5])

The integer vector containing all defined integer kinds within the ParaMonte library.

Note that this vector may only be a subset of the integer kinds supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 600 of file pm_kind.F90.

◆ IKB

integer, parameter pm_kind::IKB = selected_int_kind(maxval(integer_kinds_range, dim = 1))

The scalar integer constant of intrinsic default kind, representing the Best-range integer kind supported by the processor.

Although the value of IKH is the same as the value of IKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for integer kind type parameters that exclude the highest-range kind supported by the processor.
In other words, the highest-range integer kind IKH supported by a specific library build is not necessarily the same as the best-range integer kind IKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range integer kind of the library IKH, the same does not hold for IKB when its value is different from IKH.

The current Fortran standard does not allow automatic selection of the highest-range integer kind made available by the processor.
However, such a kind is essential for defining integer constants of highest-range that can be later coerced to integer kinds of lower range.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1334 of file pm_kind.F90.

◆ IKD

integer, parameter pm_kind::IKD = selected_int_kind(18)

The double precision integer kind in Fortran mode. On most platforms, this is a 64-bit integer kind.

Definition at line 564 of file pm_kind.F90.

◆ IKH

integer, parameter pm_kind::IKH = selected_int_kind(IRH)

The scalar integer constant of intrinsic default kind, representing the highest range integer kind type parameter available in the specific library build.

Although the value of IKH is the same as the value of IKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest range integer kind supported by the processor.
In other words, the highest-range integer kind IKH supported by a specific library build is not necessarily the same as the best-range integer kind IKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range integer kind of the library IKH, the same does not hold for IKB when its value is different from IKH.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 828 of file pm_kind.F90.

◆ IKL

integer, parameter pm_kind::IKL = selected_int_kind(IRL)

The scalar integer constant of intrinsic default kind, representing the lowest range integer kind type parameter available in the specific library build.

Although the value of IKL is the same as the value of IKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the lowest range integer kind supported by the processor.
In other words, the lowest-range integer kind IKL supported by a specific library build is not necessarily the same as the worst-range integer kind IKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-range integer kind of the library IKL, the same does not hold for IKW when its value is different from IKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 749 of file pm_kind.F90.

◆ IKQ

integer, parameter pm_kind::IKQ = selected_int_kind(36)

The quadru-precision integer kind in Fortran mode. On most platforms, this is a 128-bit integer kind. There is no guarantee of the existence of this kind (e.g., Intel does not support this).

Definition at line 565 of file pm_kind.F90.

◆ IKS

integer, parameter pm_kind::IKS = kind(1)

The single-precision integer kind in Fortran mode. On most platforms, this is a 32-bit integer kind.

Definition at line 563 of file pm_kind.F90.

◆ IKW

integer, parameter pm_kind::IKW = selected_int_kind(1)

The scalar integer constant of intrinsic default kind, representing the Worst-range integer kind supported by the processor.

Although the value of IKL is the same as the value of IKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for integer kind type parameters that exclude the lowest-range kind supported by the processor.
In other words, the lowest-range integer kind IKL supported by a specific library build is not necessarily the same as the worst-range integer kind IKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-range integer kind of the library IKL, the same does not hold for IKW when its value is different from IKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 921 of file pm_kind.F90.

◆ integer_kinds_range

integer, dimension(*), parameter pm_kind::integer_kinds_range = [ range(int(0, kind = integer_kinds(min(size(integer_kinds), 1)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 2)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 3)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 4)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 5)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 6)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 7)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 8)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 9)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 10)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 11)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 12)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 13)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 14)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 15)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 16)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 17)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 18)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 19)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 20)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 21)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 22)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 23)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 24)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 25)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 26)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 27)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 28)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 29)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 30)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 31)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 32)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 33)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 34)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 35)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 36)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 37)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 38)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 39)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 40)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 40)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 41)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 42)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 43)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 44)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 45)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 46)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 47)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 48)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 49)))) , range(int(0, kind = integer_kinds(min(size(integer_kinds), 50)))) ]

The vector of integer constants of intrinsic default kind, representing the vector of 50 possible integer ranges of the kinds provided in integer_kinds of the intrinsic Fortran module iso_fortran_env.

This nightmare is necessary to identify the highest-range integer kind type parameter supported by the processor.

Warning
The current implementation assumes the integer_kinds vector of the intrinsic Fortran module iso_fortran_env has a maximum length of 50.
While this assumption will likely hold for many more decades to come, it is bound to fail in the distant future.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1002 of file pm_kind.F90.

◆ IR1

integer parameter pm_kind::IR1 = range(0_IK1)

Definition at line 383 of file pm_kind.F90.

◆ IR2

integer parameter pm_kind::IR2 = range(0_IK2)

Definition at line 376 of file pm_kind.F90.

◆ IR3

integer parameter pm_kind::IR3 = range(0_IK3)

Definition at line 369 of file pm_kind.F90.

◆ IR4

integer parameter pm_kind::IR4 = range(0_IK4)

Definition at line 362 of file pm_kind.F90.

◆ IR5

integer parameter pm_kind::IR5 = range(0_IK5)

Definition at line 355 of file pm_kind.F90.

◆ IRH

integer, parameter pm_kind::IRH = maxval([IR1, IR2, IR3, IR4, IR5], mask = 0 < [IR1, IR2, IR3, IR4, IR5])

The scalar integer constant of intrinsic default kind, representing the highest range among all integer kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 658 of file pm_kind.F90.

◆ IRL

integer, parameter pm_kind::IRL = minval([IR1, IR2, IR3, IR4, IR5], mask = 0 < [IR1, IR2, IR3, IR4, IR5])

The scalar integer constant of intrinsic default kind, representing the lowest range among all integer kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 649 of file pm_kind.F90.

◆ LK

integer, parameter pm_kind::LK = LK_DEF

The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(.true.) in C-Fortran Interoperation mode.

Definition at line 541 of file pm_kind.F90.

◆ LK1

integer parameter pm_kind::LK1 = logical_kinds(LK1_ENABLED)

Definition at line 412 of file pm_kind.F90.

◆ LK2

integer parameter pm_kind::LK2 = logical_kinds(LK2_ENABLED)

Definition at line 407 of file pm_kind.F90.

◆ LK3

integer parameter pm_kind::LK3 = logical_kinds(LK3_ENABLED)

Definition at line 402 of file pm_kind.F90.

◆ LK4

integer parameter pm_kind::LK4 = logical_kinds(LK4_ENABLED)

Definition at line 397 of file pm_kind.F90.

◆ LK5

integer parameter pm_kind::LK5 = logical_kinds(LK5_ENABLED)

Definition at line 392 of file pm_kind.F90.

◆ LK_DEF

integer, parameter pm_kind::LK_DEF = kind(.true.)

Definition at line 319 of file pm_kind.F90.

◆ LKALL

integer, dimension(*), parameter pm_kind::LKALL = pack([LK1, LK2, LK3, LK4, LK5], 0 < [LK1, LK2, LK3, LK4, LK5])

The integer vector containing all defined logical kinds within the ParaMonte library.

Note that this vector may only be a subset of the logical kinds supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 612 of file pm_kind.F90.

◆ real_kinds_precision

integer, dimension(*), parameter pm_kind::real_kinds_precision = [ precision(real(0, kind = real_kinds(min(size(real_kinds), 1)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 2)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 3)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 4)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 5)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 6)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 7)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 8)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 9)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 10)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 11)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 12)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 13)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 14)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 15)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 16)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 17)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 18)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 19)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 20)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 21)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 22)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 23)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 24)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 25)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 26)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 27)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 28)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 29)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 30)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 31)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 32)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 33)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 34)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 35)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 36)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 37)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 38)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 39)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 41)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 42)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 43)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 44)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 45)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 46)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 47)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 48)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 49)))) , precision(real(0, kind = real_kinds(min(size(real_kinds), 50)))) ]

The vector of integer constants of intrinsic default kind, representing the vector of 50 possible real highest-range precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.

This nightmare is necessary to identify the highest-range highest-precision real kind type parameter supported by the processor.

Warning
The current implementation assumes the real_kinds vector of the intrinsic Fortran module iso_fortran_env has a maximum length of 50.
While this assumption will likely hold for many more decades to come, it is bound to fail in the distant future.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1138 of file pm_kind.F90.

◆ real_kinds_precision_hop

real, parameter pm_kind::real_kinds_precision_hop = real(real_kinds_precision_max - real_kinds_precision_min) / size(real_kinds_precision)

The scalar real constant of intrinsic default kind, representing the step size between the highest and lowest-precision of real types made available by the processor.

This constant is internally used within the module to identify the highest-range highest-precision real kind type parameter.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1232 of file pm_kind.F90.

◆ real_kinds_precision_max

integer, parameter pm_kind::real_kinds_precision_max = maxval(real_kinds_precision, dim = 1)

The scalar integer constant of intrinsic default kind, representing the highest-precision of real types made available by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1209 of file pm_kind.F90.

◆ real_kinds_precision_min

integer, parameter pm_kind::real_kinds_precision_min = minval(real_kinds_precision, dim = 1)

The scalar integer constant of intrinsic default kind, representing the lowest-precision of real types made available by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1219 of file pm_kind.F90.

◆ real_kinds_prmax_kind

integer, dimension(*), parameter pm_kind::real_kinds_prmax_kind = [ selected_real_kind(p = real_kinds_precision_max, r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 0)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 1)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 2)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 3)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 4)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 5)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 6)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 7)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 8)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 9)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 10)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 11)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 12)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 13)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 14)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 15)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 16)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 17)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 18)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 19)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 20)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 21)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 22)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 23)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 24)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 25)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 26)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 27)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 28)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 29)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 30)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 31)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 32)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 33)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 34)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 35)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 36)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 37)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 38)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 39)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 40)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 41)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 42)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 43)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 44)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 45)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 46)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 47)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 48)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 49)), r = real_kinds_range_max) , selected_real_kind(p = max(real_kinds_precision_min, nint(real_kinds_precision_max - real_kinds_precision_hop * 50)), r = real_kinds_range_max) , selected_real_kind(p = real_kinds_precision_min, r = real_kinds_range_max) ]

The vector of integer constants of intrinsic default kind, representing the 50 possible real highest-range precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.

This nightmare is necessary to identify the highest-range highest-precision real kind type parameter supported by the processor.

Warning
The current implementation assumes the real_kinds vector of the intrinsic Fortran module iso_fortran_env has a maximum length of 50.
While this assumption will likely hold for many more decades to come, it is bound to fail in the distant future.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1249 of file pm_kind.F90.

◆ real_kinds_prmax_kind_avail

integer, dimension(*), parameter pm_kind::real_kinds_prmax_kind_avail = pack(real_kinds_prmax_kind, 0 <= real_kinds_prmax_kind)

The vector of integer constants of intrinsic default kind, containing all maximum-range real kind type parameters corresponding to various precisions provided in real_kinds of the intrinsic Fortran module iso_fortran_env.

This nightmare is necessary to identify the highest-range highest-precision real kind type parameter supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1315 of file pm_kind.F90.

◆ real_kinds_range

integer, dimension(*), parameter pm_kind::real_kinds_range = [ range(real(0, kind = real_kinds(min(size(real_kinds), 1)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 2)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 3)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 4)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 5)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 6)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 7)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 8)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 9)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 10)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 11)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 12)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 13)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 14)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 15)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 16)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 17)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 18)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 19)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 20)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 21)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 22)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 23)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 24)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 25)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 26)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 27)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 28)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 29)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 30)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 31)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 32)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 33)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 34)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 35)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 36)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 37)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 38)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 39)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 40)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 41)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 42)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 43)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 44)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 45)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 46)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 47)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 48)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 49)))) , range(real(0, kind = real_kinds(min(size(real_kinds), 50)))) ]

The vector of integer constants of intrinsic default kind, representing the vector of 50 possible real precisions of the kinds provided in real_kinds of the intrinsic Fortran module iso_fortran_env.

This nightmare is necessary to identify the highest-range/precision real kind type parameter supported by the processor.

Warning
The current implementation assumes the real_kinds vector of the intrinsic Fortran module iso_fortran_env has a maximum length of 50.
While this assumption will likely hold for many more decades to come, it is bound to fail in the distant future.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1070 of file pm_kind.F90.

◆ real_kinds_range_max

integer, parameter pm_kind::real_kinds_range_max = maxval(real_kinds_range, dim = 1)

The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range of real types made available by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1199 of file pm_kind.F90.

◆ RK

integer, parameter pm_kind::RK = RK_DEF

The default real kind in the ParaMonte library: real64 in Fortran, c_double in C-Fortran Interoperation mode.

Definition at line 543 of file pm_kind.F90.

Referenced by pm_mathCumPropExp::getCumPropExp_RK().

◆ RK1

integer, parameter pm_kind::RK1 = real_kinds(RK1_ENABLED)

Definition at line 522 of file pm_kind.F90.

◆ RK128

integer, parameter pm_kind::RK128 = RK128_DEF

The real kind for a 128-bits container.

Definition at line 552 of file pm_kind.F90.

◆ RK2

integer, parameter pm_kind::RK2 = real_kinds(RK2_ENABLED)

Definition at line 511 of file pm_kind.F90.

◆ RK3

integer, parameter pm_kind::RK3 = real_kinds(RK3_ENABLED)

Definition at line 500 of file pm_kind.F90.

◆ RK32

integer, parameter pm_kind::RK32 = RK32_DEF

The real kind for a 32-bits container.

Definition at line 554 of file pm_kind.F90.

◆ RK4

integer, parameter pm_kind::RK4 = real_kinds(RK4_ENABLED)

Definition at line 489 of file pm_kind.F90.

◆ RK5

integer, parameter pm_kind::RK5 = real_kinds(RK5_ENABLED)

Definition at line 478 of file pm_kind.F90.

◆ RK64

integer, parameter pm_kind::RK64 = RK64_DEF

The real kind for a 64-bits container.

Definition at line 553 of file pm_kind.F90.

◆ RK_DEF

integer, parameter pm_kind::RK_DEF = kind(1.d0)

Definition at line 315 of file pm_kind.F90.

◆ RKALL

integer, dimension(*), parameter pm_kind::RKALL = pack([RK1, RK2, RK3, RK4, RK5], 0 < [RK1, RK2, RK3, RK4, RK5])

The integer vector containing all defined real kinds within the ParaMonte library.

Note that this vector may only be a subset of the real kinds supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 636 of file pm_kind.F90.

Referenced by pm_sampling::runParaDRAMF().

◆ RKB

integer, parameter pm_kind::RKB = selected_real_kind(maxval(real_kinds_precision, dim = 1))

The scalar integer constant of intrinsic default kind, representing the Best-precision real kind supported by the processor.

Although the value of RKH is the same as the value of RKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest-precision kind supported by the processor.
In other words, the highest-precision real kind RKH supported by a specific library build is not necessarily the same as the best-precision real kind RKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-precision real kind of the library RKH, the same does not hold for RKB when its value is different from RKH.

The current Fortran standard does not allow automatic selection of the highest-precision real kind made available by the processor.
However, such a kind is essential for defining real constants of highest-precision that can be later coerced to real kinds of lower precision.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1371 of file pm_kind.F90.

◆ RKBR

integer, parameter pm_kind::RKBR = real_kinds_prmax_kind_avail(1)

The scalar integer constant of intrinsic default kind, representing the Best-decimal-exponent-range real kind supported by the processor.

Although the value of RKHR is the same as the value of RKBR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest-decimal-exponent-range kind supported by the processor.
In other words, the highest-decimal-exponent-range real kind RKHR supported by a specific library build is not necessarily the same as the best-decimal-exponent-range real kind RKBR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-decimal-exponent-range real kind of the library RKHR, the same does not hold for RKBR when its value is different from RKHR.

The current Fortran standard does not allow automatic selection of the highest-decimal-exponent-range real kind made available by the processor.
However, such a kind is essential for defining real constants of highest-decimal-exponent-range that can be later coerced to real kinds of lower decimal-exponent-range.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 1407 of file pm_kind.F90.

◆ RKD

◆ RKH

integer, parameter pm_kind::RKH = selected_real_kind(RPH)

The scalar integer constant of intrinsic default kind, representing the highest-precision real kind type parameter available in the specific library build.

Although the value of RKH is the same as the value of RKB under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest-precision kind supported by the processor.
In other words, the highest-precision real kind RKH supported by a specific library build is not necessarily the same as the best-precision real kind RKB supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-precision real kind of the library RKH, the same does not hold for RKB when its value is different from RKH.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 858 of file pm_kind.F90.

Referenced by pm_mathRootTest::func1_type::get(), pm_quadTest::int1_type::get(), pm_quadTest::int2_type::get(), pm_quadTest::int3_type::get(), pm_quadTest::int4_type::get(), pm_quadTest::int5_type::get(), pm_quadTest::int6_type::get(), pm_quadTest::int7_type::get(), pm_quadTest::int8_type::get(), pm_quadTest::int9_type::get(), pm_quadTest::intCauchy1_type::get(), pm_quadTest::intCauchy2_type::get(), pm_quadTest::intDoncker1_type::get(), pm_quadTest::intDoncker2_type::get(), pm_quadTest::intGamUpp_type::get(), pm_quadTest::intGenExpGammaPDF_type::get(), pm_quadTest::intLogNormPDF_type::get(), pm_quadTest::intNormPDF_type::get(), pm_quadTest::intPentaGammaInf_type::get(), pm_quadTest::intSinCos_type::get(), pm_mathRootTest::get_proc::get_proc(), and pm_quadTest::get_proc::get_proc().

◆ RKHR

integer, parameter pm_kind::RKHR = RKHR_VEC(1)

The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range real kind type parameter available in the specific library build.

Although the value of RKHR is the same as the value of RKBR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest-range kind supported by the processor.
In other words, the highest-range real kind RKHR supported by a specific library build is not necessarily the same as the best-range real kind RKBR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range real kind of the library RKHR, the same does not hold for RKBR when its value is different from RKHR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 902 of file pm_kind.F90.

◆ RKHR_VEC

integer, dimension(*), parameter pm_kind::RKHR_VEC = pack(RKHR_VEC_RAW, 0 <= RKHR_VEC_RAW)

Definition at line 887 of file pm_kind.F90.

◆ RKHR_VEC_RAW

integer, dimension(*), parameter pm_kind::RKHR_VEC_RAW = [ selected_real_kind(merge(huge(1), RP5, RP5 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP4, RP4 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP3, RP3 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP2, RP2 < 1), r = RRH) , selected_real_kind(merge(huge(1), RP1, RP1 < 1), r = RRH) ]

Definition at line 882 of file pm_kind.F90.

◆ RKL

integer, parameter pm_kind::RKL = selected_real_kind(RPL)

The scalar integer constant of intrinsic default kind, representing the lowest-precision real kind type parameter available in the specific library build.

Although the value of RKL is the same as the value of RKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the lowest-precision kind supported by the processor.
In other words, the lowest-precision real kind RKL supported by a specific library build is not necessarily the same as the worst-precision real kind RKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-precision real kind of the library RKL, the same does not hold for RKW when its value is different from RKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 779 of file pm_kind.F90.

◆ RKLR

integer, parameter pm_kind::RKLR = selected_real_kind(r = RRL)

The scalar integer constant of intrinsic default kind, representing the highest-decimal-exponent-range real kind type parameter available in the specific library build.

Although the value of RKLR is the same as the value of RKWR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the highest-range kind supported by the processor.
In other words, the highest-range real kind RKLR supported by a specific library build is not necessarily the same as the best-range real kind RKWR supported by the processor.
While all relevant routines of the library are guaranteed to support the highest-range real kind of the library RKLR, the same does not hold for RKWR when its value is different from RKLR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 809 of file pm_kind.F90.

◆ RKQ

integer, parameter pm_kind::RKQ = selected_real_kind(2*precision(1._RKD))

The quadru-precision real kind in Fortran mode. On most platforms, this is an 128-bit real kind.

Definition at line 569 of file pm_kind.F90.

◆ RKS

◆ RKW

integer, parameter pm_kind::RKW = selected_real_kind(1)

The scalar integer constant of intrinsic default kind, representing the Worst-precision real kind supported by the processor.

Although the value of RKL is the same as the value of RKW under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the lowest-precision kind supported by the processor.
In other words, the lowest-precision real kind RKL supported by a specific library build is not necessarily the same as the worst-precision real kind RKW supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-precision real kind of the library RKL, the same does not hold for RKW when its value is different from RKL.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 951 of file pm_kind.F90.

◆ RKWR

integer, parameter pm_kind::RKWR = selected_real_kind(r = 1)

The scalar integer constant of intrinsic default kind, representing the Worst-decimal-exponent-range real kind supported by the processor.

Although the value of RKLR is the same as the value of RKWR under normal (default) library builds, the two are not necessarily the same.
This situation occurs when the library is built for real kind type parameters that exclude the lowest-decimal-exponent-range kind supported by the processor.
In other words, the lowest-decimal-exponent-range real kind RKLR supported by a specific library build is not necessarily the same as the worst-decimal-exponent-range real kind RKWR supported by the processor.
While all relevant routines of the library are guaranteed to support the lowest-decimal-exponent-range real kind of the library RKLR, the same does not hold for RKWR when its value is different from RKLR.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 981 of file pm_kind.F90.

◆ RP1

integer, parameter pm_kind::RP1 = precision(0._RK1)

Definition at line 523 of file pm_kind.F90.

◆ RP2

integer, parameter pm_kind::RP2 = precision(0._RK2)

Definition at line 512 of file pm_kind.F90.

◆ RP3

integer, parameter pm_kind::RP3 = precision(0._RK3)

Definition at line 501 of file pm_kind.F90.

◆ RP4

integer, parameter pm_kind::RP4 = precision(0._RK4)

Definition at line 490 of file pm_kind.F90.

◆ RP5

integer, parameter pm_kind::RP5 = precision(0._RK5)

Definition at line 479 of file pm_kind.F90.

◆ RPH

integer, parameter pm_kind::RPH = maxval([RP1, RP2, RP3, RP4, RP5], mask = 0 < [RP1, RP2, RP3, RP4, RP5])

The scalar integer constant of intrinsic default kind, representing the highest precision among all real kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 712 of file pm_kind.F90.

◆ RPL

integer, parameter pm_kind::RPL = minval([RP1, RP2, RP3, RP4, RP5], mask = 0 < [RP1, RP2, RP3, RP4, RP5])

The scalar integer constant of intrinsic default kind, representing the lowest precision among all real kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 703 of file pm_kind.F90.

◆ RR1

integer, parameter pm_kind::RR1 = range(0._RK1)

Definition at line 524 of file pm_kind.F90.

◆ RR2

integer, parameter pm_kind::RR2 = range(0._RK2)

Definition at line 513 of file pm_kind.F90.

◆ RR3

integer, parameter pm_kind::RR3 = range(0._RK3)

Definition at line 502 of file pm_kind.F90.

◆ RR4

integer, parameter pm_kind::RR4 = range(0._RK4)

Definition at line 491 of file pm_kind.F90.

◆ RR5

integer, parameter pm_kind::RR5 = range(0._RK5)

Definition at line 480 of file pm_kind.F90.

◆ RRH

integer, parameter pm_kind::RRH = maxval([RR1, RR2, RR3, RR4, RR5], mask = 0 < [RR1, RR2, RR3, RR4, RR5])

The scalar integer constant of intrinsic default kind, representing the highest decimal exponent range among all real kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 730 of file pm_kind.F90.

◆ RRL

integer, parameter pm_kind::RRL = minval([RR1, RR2, RR3, RR4, RR5], mask = 0 < [RR1, RR2, RR3, RR4, RR5])

The scalar integer constant of intrinsic default kind, representing the lowest decimal exponent range among all real kinds supported by the specific library build.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 721 of file pm_kind.F90.

◆ SK

integer, parameter pm_kind::SK = SK_DEF

The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Interoperation mode.

Definition at line 539 of file pm_kind.F90.

Referenced by pm_sampling::runParaDRAMF().

◆ SK1

integer parameter pm_kind::SK1 = character_kinds(SK1_ENABLED)

Definition at line 346 of file pm_kind.F90.

◆ SK2

integer parameter pm_kind::SK2 = character_kinds(SK2_ENABLED)

Definition at line 341 of file pm_kind.F90.

◆ SK3

integer parameter pm_kind::SK3 = character_kinds(SK3_ENABLED)

Definition at line 336 of file pm_kind.F90.

◆ SK4

integer parameter pm_kind::SK4 = character_kinds(SK4_ENABLED)

Definition at line 331 of file pm_kind.F90.

◆ SK5

integer parameter pm_kind::SK5 = character_kinds(SK5_ENABLED)

Definition at line 326 of file pm_kind.F90.

◆ SK_DEF

integer, parameter pm_kind::SK_DEF = kind("a")

Definition at line 312 of file pm_kind.F90.

◆ SKA

integer, parameter pm_kind::SKA = selected_char_kind("ascii")

The ASCII string kind in Fortran mode.

Definition at line 562 of file pm_kind.F90.

◆ SKALL

integer, dimension(*), parameter pm_kind::SKALL = pack([SK1, SK2, SK3, SK4, SK5], 0 < [SK1, SK2, SK3, SK4, SK5])

The integer vector containing all defined character kinds within the ParaMonte library.

Note that this vector may only be a subset of the character kinds supported by the processor.


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, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 588 of file pm_kind.F90.

◆ SKD

integer, parameter pm_kind::SKD = selected_char_kind("default")

The DEFAULT string kind in Fortran mode.

Definition at line 561 of file pm_kind.F90.

◆ SKU

integer, parameter pm_kind::SKU = selected_char_kind("iso_10646")

The UNICODE string kind in Fortran mode.

Definition at line 560 of file pm_kind.F90.