penf_stringify

PENF string-to-number (and viceversa) facility.

Uses

Help

Graph Key

Nodes of different colours represent the following:

Solid arrows point from a submodule to the (sub)module which it is descended from. Dashed arrows point from a module or program unit to modules which it uses.

Interfaces

public interface str_ascii

Convert string of any kind to ASCII string.

private pure function str_ascii_default(input) result(output)

Convert string of default kind to ASCII string.

 use penf
 character(len=:, kind=ASCII), allocatable :: string
 string = str_ascii('I was DEFAULT kind, but now I am ASCII')
 print "(A)", string

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	input	Input string of default kind.

Return Value character(kind=ASCII, len=:), allocatable

Output string of ASCII kind.

public interface str_ucs4

Convert string of any kind to UCS4 string.

private pure function str_ucs4_default(input) result(output)

Convert string of default kind to UCS4 string.

 use penf
 character(len=:, kind=UCS4), allocatable :: string
 string = str_ascii('I was DEFAULT kind, but now I am UCS4')
 print "(A)", string

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	input	Input string of default kind.

Return Value character(kind=UCS4, len=:), allocatable

Output string of UCS4 kind.

public interface str

Convert number (real and integer) to string (number to string type casting).

private elemental function strf_R8P(fm, n) result(str)

Convert real to string.

 use penf
 print "(A)", str(fm=FR8P, n=1._R8P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
real(kind=R8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=DR8P)

Returned string containing input number.

private elemental function str_R8P(n, no_sign, compact) result(str)

Convert real to string.

 use penf
 print "(A)", str(n=-1._R8P)

 use penf
 print "(A)", str(n=-1._R8P, no_sign=.true.)

 use penf
 print "(A)", str(n=-1._R8P, compact=.true.)

Arguments

Type	Intent	Optional		Name
real(kind=R8P),	intent(in)		::	n	Real to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=DR8P)

Returned string containing input number.

private elemental function strf_R4P(fm, n) result(str)

Convert real to string.

 use penf
 print "(A)", str(fm=FR4P, n=1._R4P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
real(kind=R4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=DR4P)

Returned string containing input number.

private elemental function str_R4P(n, no_sign, compact) result(str)

Convert real to string.

 use penf
 print "(A)", str(n=-1._R4P)

 use penf
 print "(A)", str(n=-1._R4P, no_sign=.true.)

 use penf
 print "(A)", str(n=-1._R4P, compact=.true.)

Arguments

Type	Intent	Optional		Name
real(kind=R4P),	intent(in)		::	n	Real to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=DR4P)

Returned string containing input number.

private elemental function strf_I8P(fm, n) result(str)

Convert integer to string.

 use penf
 print "(A)", str(fm=FI8P, n=1_I8P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI8P)

Returned string containing input number.

private elemental function str_I8P(n, no_sign) result(str)

Convert integer to string.

 use penf
 print "(A)", str(n=-1_I8P)

 use penf
 print "(A)", str(n=-1_I8P, no_sign=.true.)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI8P)

Returned string containing input number plus padding zeros.

private elemental function strf_I4P(fm, n) result(str)

Convert integer to string.

 use penf
 print "(A)", str(fm=FI4P, n=1_I4P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI4P)

Returned string containing input number.

private elemental function str_I4P(n, no_sign) result(str)

Converting integer to string.

 use penf
 print "(A)", str(n=-1_I4P)

 use penf
 print "(A)", str(n=-1_I4P, no_sign=.true.)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI4P)

Returned string containing input number plus padding zeros.

private elemental function strf_I2P(fm, n) result(str)

Convert integer to string.

 use penf
 print "(A)", str(fm=FI2P, n=1_I2P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI2P)

Returned string containing input number.

private elemental function str_I2P(n, no_sign) result(str)

Convert integer to string.

 use penf
 print "(A)", str(n=-1_I2P)

 use penf
 print "(A)", str(n=-1_I2P, no_sign=.true.)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI2P)

Returned string containing input number plus padding zeros.

private elemental function strf_I1P(fm, n) result(str)

Convert integer to string.

 use penf
 print "(A)", str(fm=FI1P, n=1_I1P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI1P)

Returned string containing input number.

private elemental function str_I1P(n, no_sign) result(str)

Convert integer to string.

 use penf
 print "(A)", str(n=-1_I1P)

 use penf
 print "(A)", str(n=-1_I1P, no_sign=.true.)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI1P)

Returned string containing input number plus padding zeros.

private elemental function str_bol(n) result(str)

Convert logical to string.

 use penf
 print "(A)", str(n=.true.)

Arguments

Type	Intent	Optional	Attributes		Name
logical,	intent(in)			::	n	Logical to be converted.

Return Value character(len=1)

Returned string containing input number plus padding zeros.

private pure function str_a_R8P(n, no_sign, separator, delimiters, compact) result(str)

Convert real array to string.

 use penf
 print "(A)", str(n=[1._R8P, -2._R8P])

 use penf
 print "(A)", str(n=[1._R8P, 2._R8P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1._R8P, -2._R8P], separator='|')

 use penf
 print "(A)", str(n=[1._R8P, -2._R8P], delimiters=['(', ')'])

 use penf
 print "(A)", str(n=[1._R8P, -2._R8P], compact=.true.)

Arguments

Type	Intent	Optional		Name
real(kind=R8P),	intent(in)		::	n(:)	Real array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_R4P(n, no_sign, separator, delimiters, compact) result(str)

Convert real array to string.

 use penf
 print "(A)", str(n=[1._R4P, -2._R4P])

 use penf
 print "(A)", str(n=[1._R4P, 2._R4P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1._R4P, -2._R4P], separator='|')

 use penf
 print "(A)", str(n=[1._R4P, -2._R4P], delimiters=['(', ')'])

 use penf
 print "(A)", str(n=[1._R4P, -2._R4P], compact=.true.)

Arguments

Type	Intent	Optional		Name
real(kind=R4P),	intent(in)		::	n(:)	Real array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I8P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

 use penf
 print "(A)", str(n=[1_I8P, -2_I8P])

 use penf
 print "(A)", str(n=[1_I8P, 2_I8P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1_I8P, -2_I8P], separator='|')

 use penf
 print "(A)", str(n=[1_I8P, -2_I8P], delimiters=['(', ')'])

Arguments

Type	Intent	Optional		Name
integer(kind=I8P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I4P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

 use penf
 print "(A)", str(n=[1_I4P, -2_I4P])

 use penf
 print "(A)", str(n=[1_I4P, 2_I4P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1_I4P, -2_I4P], separator='|')

 use penf
 print "(A)", str(n=[1_I4P, -2_I4P], delimiters=['(', ')'])

Arguments

Type	Intent	Optional		Name
integer(kind=I4P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I2P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

 use penf
 print "(A)", str(n=[1_I2P, -2_I2P])

 use penf
 print "(A)", str(n=[1_I2P, 2_I2P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1_I2P, -2_I2P], separator='|')

 use penf
 print "(A)", str(n=[1_I2P, -2_I2P], delimiters=['(', ')'])

Arguments

Type	Intent	Optional		Name
integer(kind=I2P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I1P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

 use penf
 print "(A)", str(n=[1_I1P, -2_I1P])

 use penf
 print "(A)", str(n=[1_I1P, 2_I1P], no_sign=.true.)

 use penf
 print "(A)", str(n=[1_I1P, -2_I1P], separator='|')

 use penf
 print "(A)", str(n=[1_I1P, -2_I1P], delimiters=['(', ')'])

Arguments

Type	Intent	Optional		Name
integer(kind=I1P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

public interface strz

Convert integer, to string, prefixing with the right number of zeros (integer to string type casting with zero padding).

private elemental function strz_I8P(n, nz_pad) result(str)

Converting integer to string, prefixing with the right number of zeros.

 use penf
 print "(A)", strz(n=1_I8P)

 use penf
 print "(A)", strz(n=1_I8P, nz_pad=5)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI8P)

Returned string containing input number plus padding zeros.

private elemental function strz_I4P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

 use penf
 print "(A)", strz(n=1_I4P)

 use penf
 print "(A)", strz(n=1_I4P, nz_pad=5)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI4P)

Returned string containing input number plus padding zeros.

private elemental function strz_I2P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

 use penf
 print "(A)", strz(n=1_I2P)

 use penf
 print "(A)", strz(n=1_I2P, nz_pad=3)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI2P)

Returned string containing input number plus padding zeros.

private elemental function strz_I1P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

 use penf
 print "(A)", strz(n=1_I1P)

 use penf
 print "(A)", strz(n=1_I1P, nz_pad=3)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI1P)

Returned string containing input number plus padding zeros.

public interface cton

Convert string to number (real and integer, string to number type casting).

private function ctor_R8P(str, knd, pref, error) result(n)

Convert string to real.

 use penf
 print FR8P, cton(str='-1.0', knd=1._R8P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
real(kind=R8P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value real(kind=R8P)

Number returned.

private function ctor_R4P(str, knd, pref, error) result(n)

Convert string to real.

 use penf
 print FR4P, cton(str='-1.0', knd=1._R4P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
real(kind=R4P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value real(kind=R4P)

Number returned.

private function ctoi_I8P(str, knd, pref, error) result(n)

Convert string to integer.

 use penf
 print FI8P, cton(str='-1', knd=1_I8P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I8P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I8P)

Number returned.

private function ctoi_I4P(str, knd, pref, error) result(n)

Convert string to integer.

 use penf
 print FI4P, cton(str='-1', knd=1_I4P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I4P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I4P)

Number returned.

private function ctoi_I2P(str, knd, pref, error) result(n)

Convert string to integer.

 use penf
 print FI2P, cton(str='-1', knd=1_I2P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I2P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I2P)

Number returned.

private function ctoi_I1P(str, knd, pref, error) result(n)

Convert string to integer.

 use penf
 print FI1P, cton(str='-1', knd=1_I1P)

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I1P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I1P)

Number returned.

public interface bstr

Convert number (real and integer) to bit-string (number to bit-string type casting).

private elemental function bstr_R8P(n) result(bstr)

Convert real to string of bits.

@note Note It is assumed that R8P is represented by means of 64 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1._R8P)

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=64)

Returned bit-string containing input number.

private elemental function bstr_R4P(n) result(bstr)

Convert real to string of bits.

@note Note It is assumed that R4P is represented by means of 32 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1._R4P)

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=32)

Returned bit-string containing input number.

private elemental function bstr_I8P(n) result(bstr)

Convert integer to string of bits.

@note Note It is assumed that I8P is represented by means of 64 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1_I8P)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=64)

Returned bit-string containing input number.

private elemental function bstr_I4P(n) result(bstr)

Convert integer to string of bits.

@note Note It is assumed that I4P is represented by means of 32 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1_I4P)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=32)

Returned bit-string containing input number.

private elemental function bstr_I2P(n) result(bstr)

Convert integer to string of bits.

@note Note It is assumed that I2P is represented by means of 16 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1_I2P)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Real to be converted.

Return Value character(len=16)

Returned bit-string containing input number.

private elemental function bstr_I1P(n) result(bstr)

Convert integer to string of bits.

@note Note It is assumed that I1P is represented by means of 8 bits, but this is not ensured in all architectures.

 use penf
 print "(A)", bstr(n=1_I1P)

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Real to be converted.

Return Value character(len=8)

Returned bit-string containing input number.

public interface bcton

Convert bit-string to number (real and integer, bit-string to number type casting).

private elemental function bctor_R8P(bstr, knd) result(n)

Convert bit-string to real.

 use penf
 print FR8P, bcton('0000000000000000000000000000000000000000000000001111000000111111', knd=1._R8P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
real(kind=R8P),	intent(in)			::	knd	Number kind.

Return Value real(kind=R8P)

Number returned.

private elemental function bctor_R4P(bstr, knd) result(n)

Convert bit-string to real.

 use penf
 print FR4P, bcton('00000000000000001000000000111111', knd=1._R4P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
real(kind=R4P),	intent(in)			::	knd	Number kind.

Return Value real(kind=R4P)

Number returned.

private elemental function bctoi_I8P(bstr, knd) result(n)

Convert bit-string to integer.

 use penf
 print FI8P, bcton('0000000000000000000000000000000000000000000000000000000000000001', knd=1_I8P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I8P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I8P)

Number returned.

private elemental function bctoi_I4P(bstr, knd) result(n)

Convert bit-string to integer.

 use penf
 print FI4P, bcton('00000000000000000000000000000001', knd=1_I4P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I4P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I4P)

Number returned.

private elemental function bctoi_I2P(bstr, knd) result(n)

Convert bit-string to integer.

 use penf
 print FI2P, bcton('0000000000000001', knd=1_I2P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I2P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I2P)

Number returned.

private elemental function bctoi_I1P(bstr, knd) result(n)

Convert bit-string to integer.

 use penf
 print FI1P, bcton('00000001', knd=1_I1P)

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I1P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I1P)

Number returned.

Functions

private pure function str_ascii_default(input) result(output)

Convert string of default kind to ASCII string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	input	Input string of default kind.

Return Value character(kind=ASCII, len=:), allocatable

Output string of ASCII kind.

private pure function str_ascii_ascii(input) result(output)

Convert string of ASCII kind to ASCII string, just for convenience in sanitize strings.

Arguments

Type	Intent	Optional	Attributes		Name
character(kind=ASCII, len=*),	intent(in)			::	input	Input string of ASCII kind.

Return Value character(kind=ASCII, len=:), allocatable

Output string of ASCII kind.

private pure function str_ascii_ucs4(input) result(output)

Convert string of UCS4 kind to ASCII string.

Arguments

Type	Intent	Optional	Attributes		Name
character(kind=UCS4, len=*),	intent(in)			::	input	Input string of UCS4 kind.

Return Value character(kind=ASCII, len=:), allocatable

Output string of ASCII kind.

private pure function str_ucs4_default(input) result(output)

Convert string of default kind to UCS4 string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	input	Input string of default kind.

Return Value character(kind=UCS4, len=:), allocatable

Output string of UCS4 kind.

private pure function str_ucs4_ascii(input) result(output)

Convert string of ASCII kind to UCS4 string.

Arguments

Type	Intent	Optional	Attributes		Name
character(kind=ASCII, len=*),	intent(in)			::	input	Input string of ASCII kind.

Return Value character(kind=UCS4, len=:), allocatable

Output string of UCS4 kind.

private pure function str_ucs4_ucs4(input) result(output)

Convert string of UCS4 kind to UCS4 string, just for convenience in sanitize strings.

Arguments

Type	Intent	Optional	Attributes		Name
character(kind=UCS4, len=*),	intent(in)			::	input	Input string of UCS4 kind.

Return Value character(kind=UCS4, len=:), allocatable

Output string of UCS4 kind.

private elemental function strf_R16P(fm, n) result(str)

Convert real to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
real(kind=R16P),	intent(in)			::	n	Real to be converted.

Return Value character(len=DR16P)

Returned string containing input number.

private elemental function strf_R8P(fm, n) result(str)

Convert real to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
real(kind=R8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=DR8P)

Returned string containing input number.

private elemental function strf_R4P(fm, n) result(str)

Convert real to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
real(kind=R4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=DR4P)

Returned string containing input number.

private elemental function strf_I8P(fm, n) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI8P)

Returned string containing input number.

private elemental function strf_I4P(fm, n) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI4P)

Returned string containing input number.

private elemental function strf_I2P(fm, n) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI2P)

Returned string containing input number.

private elemental function strf_I1P(fm, n) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	fm	Format different from the standard for the kind.
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.

Return Value character(len=DI1P)

Returned string containing input number.

private elemental function str_R16P(n, no_sign, compact) result(str)

Convert real to string.

Arguments

Type	Intent	Optional		Name
real(kind=R16P),	intent(in)		::	n	Real to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=DR16P)

Returned string containing input number.

private elemental function str_R8P(n, no_sign, compact) result(str)

Convert real to string.

Arguments

Type	Intent	Optional		Name
real(kind=R8P),	intent(in)		::	n	Real to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=DR8P)

Returned string containing input number.

private elemental function str_R4P(n, no_sign, compact) result(str)

Convert real to string.

Arguments

Type	Intent	Optional		Name
real(kind=R4P),	intent(in)		::	n	Real to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=DR4P)

Returned string containing input number.

private elemental function str_I8P(n, no_sign) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI8P)

Returned string containing input number plus padding zeros.

private elemental function str_I4P(n, no_sign) result(str)

Converting integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI4P)

Returned string containing input number plus padding zeros.

private elemental function str_I2P(n, no_sign) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI2P)

Returned string containing input number plus padding zeros.

private elemental function str_I1P(n, no_sign) result(str)

Convert integer to string.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.
logical,	intent(in),	optional		::	no_sign	Flag for leaving out the sign.

Return Value character(len=DI1P)

Returned string containing input number plus padding zeros.

private elemental function str_bol(n) result(str)

Convert logical to string.

Arguments

Type	Intent	Optional	Attributes		Name
logical,	intent(in)			::	n	Logical to be converted.

Return Value character(len=1)

Returned string containing input number plus padding zeros.

private pure function str_a_R16P(n, no_sign, separator, delimiters, compact) result(str)

Converting real array to string.

Arguments

Type	Intent	Optional		Name
real(kind=R16P),	intent(in)		::	n(:)	Real array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_R8P(n, no_sign, separator, delimiters, compact) result(str)

Convert real array to string.

Arguments

Type	Intent	Optional		Name
real(kind=R8P),	intent(in)		::	n(:)	Real array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_R4P(n, no_sign, separator, delimiters, compact) result(str)

Convert real array to string.

Arguments

Type	Intent	Optional		Name
real(kind=R4P),	intent(in)		::	n(:)	Real array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.
logical,	intent(in),	optional	::	compact	Flag for compacting string encoding.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I8P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

Arguments

Type	Intent	Optional		Name
integer(kind=I8P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I4P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

Arguments

Type	Intent	Optional		Name
integer(kind=I4P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I2P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

Arguments

Type	Intent	Optional		Name
integer(kind=I2P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private pure function str_a_I1P(n, no_sign, separator, delimiters) result(str)

Convert integer array to string.

Arguments

Type	Intent	Optional		Name
integer(kind=I1P),	intent(in)		::	n(:)	Integer array to be converted.
logical,	intent(in),	optional	::	no_sign	Flag for leaving out the sign.
character(len=1),	intent(in),	optional	::	separator	Eventual separator of array values.
character(len=*),	intent(in),	optional	::	delimiters(1:2)	Eventual delimiters of array values.

Return Value character(len=:), allocatable

Returned string containing input number.

private elemental function strz_I8P(n, nz_pad) result(str)

Converting integer to string, prefixing with the right number of zeros.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI8P)

Returned string containing input number plus padding zeros.

private elemental function strz_I4P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI4P)

Returned string containing input number plus padding zeros.

private elemental function strz_I2P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI2P)

Returned string containing input number plus padding zeros.

private elemental function strz_I1P(n, nz_pad) result(str)

Convert integer to string, prefixing with the right number of zeros.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Integer to be converted.
integer(kind=I4P),	intent(in),	optional		::	nz_pad	Number of zeros padding.

Return Value character(len=DI1P)

Returned string containing input number plus padding zeros.

private function ctor_R16P(str, knd, pref, error) result(n)

Convert string to real.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
real(kind=R16P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value real(kind=R16P)

Number returned.

private function ctor_R8P(str, knd, pref, error) result(n)

Convert string to real.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
real(kind=R8P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value real(kind=R8P)

Number returned.

private function ctor_R4P(str, knd, pref, error) result(n)

Convert string to real.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
real(kind=R4P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value real(kind=R4P)

Number returned.

private function ctoi_I8P(str, knd, pref, error) result(n)

Convert string to integer.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I8P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I8P)

Number returned.

private function ctoi_I4P(str, knd, pref, error) result(n)

Convert string to integer.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I4P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I4P)

Number returned.

private function ctoi_I2P(str, knd, pref, error) result(n)

Convert string to integer.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I2P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I2P)

Number returned.

private function ctoi_I1P(str, knd, pref, error) result(n)

Convert string to integer.

Arguments

Type	Intent	Optional		Name
character(len=*),	intent(in)		::	str	String containing input number.
integer(kind=I1P),	intent(in)		::	knd	Number kind.
character(len=*),	intent(in),	optional	::	pref	Prefixing string.
integer(kind=I4P),	intent(out),	optional	::	error	Error trapping flag: 0 no errors, >0 error occurs.

Return Value integer(kind=I1P)

Number returned.

private elemental function bstr_R16P(n) result(bstr)

Convert real to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R16P),	intent(in)			::	n	Real to be converted.

Return Value character(len=128)

Returned bit-string containing input number.

private elemental function bstr_R8P(n) result(bstr)

Convert real to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=64)

Returned bit-string containing input number.

private elemental function bstr_R4P(n) result(bstr)

Convert real to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=32)

Returned bit-string containing input number.

private elemental function bstr_I8P(n) result(bstr)

Convert integer to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I8P),	intent(in)			::	n	Real to be converted.

Return Value character(len=64)

Returned bit-string containing input number.

private elemental function bstr_I4P(n) result(bstr)

Convert integer to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I4P),	intent(in)			::	n	Real to be converted.

Return Value character(len=32)

Returned bit-string containing input number.

private elemental function bstr_I2P(n) result(bstr)

Convert integer to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I2P),	intent(in)			::	n	Real to be converted.

Return Value character(len=16)

Returned bit-string containing input number.

private elemental function bstr_I1P(n) result(bstr)

Convert integer to string of bits.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=I1P),	intent(in)			::	n	Real to be converted.

Return Value character(len=8)

Returned bit-string containing input number.

private elemental function bctor_R16P(bstr, knd) result(n)

Convert bit-string to real.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
real(kind=R16P),	intent(in)			::	knd	Number kind.

Return Value real(kind=R16P)

Number returned.

private elemental function bctor_R8P(bstr, knd) result(n)

Convert bit-string to real.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
real(kind=R8P),	intent(in)			::	knd	Number kind.

Return Value real(kind=R8P)

Number returned.

private elemental function bctor_R4P(bstr, knd) result(n)

Convert bit-string to real.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
real(kind=R4P),	intent(in)			::	knd	Number kind.

Return Value real(kind=R4P)

Number returned.

private elemental function bctoi_I8P(bstr, knd) result(n)

Convert bit-string to integer.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I8P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I8P)

Number returned.

private elemental function bctoi_I4P(bstr, knd) result(n)

Convert bit-string to integer.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I4P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I4P)

Number returned.

private elemental function bctoi_I2P(bstr, knd) result(n)

Convert bit-string to integer.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I2P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I2P)

Number returned.

private elemental function bctoi_I1P(bstr, knd) result(n)

Convert bit-string to integer.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(in)			::	bstr	String containing input number.
integer(kind=I1P),	intent(in)			::	knd	Number kind.

Return Value integer(kind=I1P)

Number returned.

Subroutines

private pure subroutine compact_real_string(string)

Author: Izaak Beekman
Date: 02/24/2015

Compact a string representing a real number, so that the same value is displayed with fewer characters.

Arguments

Type	Intent	Optional	Attributes		Name
character(len=*),	intent(inout)			::	string	string representation of a real number.

penf_stringify Module

Contents

Interfaces

Functions

Subroutines

Uses

Used by

Interfaces

public interface str_ascii

private pure function str_ascii_default(input) result(output)

Arguments

Return Value character(kind=ASCII, len=:), allocatable

public interface str_ucs4

private pure function str_ucs4_default(input) result(output)

Arguments

Return Value character(kind=UCS4, len=:), allocatable

public interface str

private elemental function strf_R8P(fm, n) result(str)

Arguments

Return Value character(len=DR8P)

private elemental function str_R8P(n, no_sign, compact) result(str)

Arguments

Return Value character(len=DR8P)

private elemental function strf_R4P(fm, n) result(str)

Arguments

Return Value character(len=DR4P)

private elemental function str_R4P(n, no_sign, compact) result(str)

Arguments

Return Value character(len=DR4P)

private elemental function strf_I8P(fm, n) result(str)

Arguments

Return Value character(len=DI8P)

private elemental function str_I8P(n, no_sign) result(str)

Arguments

Return Value character(len=DI8P)

private elemental function strf_I4P(fm, n) result(str)

Arguments

Return Value character(len=DI4P)

private elemental function str_I4P(n, no_sign) result(str)

Arguments

Return Value character(len=DI4P)

private elemental function strf_I2P(fm, n) result(str)

Arguments

Return Value character(len=DI2P)

private elemental function str_I2P(n, no_sign) result(str)

Arguments

Return Value character(len=DI2P)

private elemental function strf_I1P(fm, n) result(str)

Arguments

Return Value character(len=DI1P)

private elemental function str_I1P(n, no_sign) result(str)

Arguments

Return Value character(len=DI1P)

private elemental function str_bol(n) result(str)

Arguments

Return Value character(len=1)

private pure function str_a_R8P(n, no_sign, separator, delimiters, compact) result(str)

Arguments

Return Value character(len=:), allocatable

private pure function str_a_R4P(n, no_sign, separator, delimiters, compact) result(str)

Arguments

Return Value character(len=:), allocatable

private pure function str_a_I8P(n, no_sign, separator, delimiters) result(str)

Arguments

Return Value character(len=:), allocatable

private pure function str_a_I4P(n, no_sign, separator, delimiters) result(str)

Arguments

Return Value character(len=:), allocatable

private pure function str_a_I2P(n, no_sign, separator, delimiters) result(str)

Arguments

Return Value character(len=:), allocatable

private pure function str_a_I1P(n, no_sign, separator, delimiters) result(str)

Arguments

Return Value character(len=:), allocatable

public interface strz

private elemental function strz_I8P(n, nz_pad) result(str)

Arguments

Return Value character(len=DI8P)

private elemental function strz_I4P(n, nz_pad) result(str)

Arguments