pm_container::cvi_type Type Reference

This is the derived type for generating a container of a vector component of type integer of default kind IK.
More...

Public Attributes
integer(IK), dimension(:), allocatable	val

Detailed Description

This is the derived type for generating a container of a vector component of type integer of default kind IK.

The css_type container is widely known as varying string or string container within the Fortran language.
The constructor of this derived type takes the following arguments.

Parameters

[in]	val	: The input scalar or array of arbitrary rank of type character of default kind SK.
[in]	trimmed	: The input scalar or array of the same shape as the input val, of type logical of default kind LK. If .true., the corresponding elements of the input val will not be trimmed. Setting this argument to .true. will lead to better runtime performance. (optional, default = .false., i.e., the trailing blanks in all input val will be trimmed).

Returns

container : The output object of type css_type of the same kind, rank, and shape as the input val, each element of which contains the corresponding element of the input val.

Possible calling interfaces ⛓

use pm_kind, only: SK
use pm_container, only: css_type
type(css_type), allocatable  :: containers(:)
type(css_type) :: container
 
container = css_type(val, trimmed = trimmed)
 
! example
 
container = css_type(SK_"aaa")
containers = css_type([character(3, SK) :: "a", "aa", "aaa"])
containers = css_type([character(3, SK) :: "a", "aa", "aaa"], trimmed = .false._LK)

Remarks

The procedures under discussion are pure.

The procedures under discussion are elemental.

The existence of this derived type is primarily motivated by the persistent bugs in the implementations of allocatable parameterized derived types in gfortran compilers < 12.
As such, this definition might be redundant once gfortran PDT bugs are resolved.

See also

css_pdt
cvs_pdt
cms_pdt
ccs_pdt
css_type
cvs_type
cms_type
ccs_type

Example usage ⛓

program example
    use pm_kind, only: SK, IK, LK
    use pm_io, only: display_type
    use pm_arrayRange, only: getRange
    use pm_str, only: getCharVec
 
    implicit none
 
    type(display_type) :: disp
    disp = display_type(file = "main.out.F90")
 
    block
 
        use pm_kind, only: SKG => SK
        use pm_container, only: css_type
        type(css_type), allocatable :: scalar, vector(:), matrix(:,:), cube(:,:,:)
 
        call disp%skip()
        call disp%show("scalar = css_type(SKG_'ParaMonte')")
                        scalar = css_type(SKG_'ParaMonte')
        call disp%show("scalar")
        call disp%show( scalar , deliml = SK_"""" )
        call disp%skip()
 
        call disp%skip()
        call disp%show("vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'])")
                        vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'])
        call disp%show("vector")
        call disp%show( vector , deliml = SK_"""" )
        call disp%skip()
 
        call disp%skip()
        call disp%show("vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .false._LK)")
                        vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .false._LK)
        call disp%show("vector")
        call disp%show( vector , deliml = SK_"""" )
        call disp%skip()
 
        call disp%skip()
        call disp%show("vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .true._LK) ! This will avoid the automatic application of `trim()` to the input string vector.")
                        vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .true._LK)
        call disp%show("vector")
        call disp%show( vector , deliml = SK_"""" )
        call disp%skip()
 
        call disp%skip()
        call disp%show("matrix = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [3, 8]) )")
                        matrix = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [3, 8]) )
        call disp%show("matrix")
        call disp%show( matrix , deliml = SK_"""" )
        call disp%skip()
 
        call disp%skip()
        call disp%show("cube = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [2, 3, 4]) )")
                        cube = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [2, 3, 4]) )
        call disp%show("cube")
        call disp%show( cube , deliml = SK_"""" )
        call disp%skip()
 
    end block
 
end program example

Example Unix compile command via Intel ifort compiler ⛓

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

Example Windows Batch compile command via Intel ifort compiler ⛓

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

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

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

Example output ⛓

 
scalar = css_type(SKG_'ParaMonte')
scalar
"ParaMonte"
 
 
vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'])
vector
"a", "aa", "aaa"
 
 
vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .false._LK)
vector
"a", "aa", "aaa"
 
 
vector = css_type([character(3,SKG) :: 'a', 'aa', 'aaa'], trimmed = .true._LK) ! This will avoid the automatic application of `trim()` to the input string vector.
vector
"a  ", "aa ", "aaa"
 
 
matrix = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [3, 8]) )
matrix
"A", "D", "G", "J", "M", "P", "S", "V"
"B", "E", "H", "K", "N", "Q", "T", "W"
"C", "F", "I", "L", "O", "R", "U", "X"
 
 
cube = css_type( reshape(getCharVec(getRange(SKG_'A', SKG_'X')), shape = [2, 3, 4]) )
cube
object(:,:,1)%val = 
"A", "C", "E"
"B", "D", "F"
object(:,:,2)%val = 
"G", "I", "K"
"H", "J", "L"
object(:,:,3)%val = 
"M", "O", "Q"
"N", "P", "R"
object(:,:,4)%val = 
"S", "U", "W"
"T", "V", "X"
 
 

Test:

test_pm_container

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.

Copyright

Computational Data Science Lab

Author:

Fatemeh Bagheri, Tuesday, April 30, 2019, 12:58 PM, SEIR, UTA Amir Shahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 566 of file pm_container.F90.

Member Data Documentation

val

integer(IK), dimension(:), allocatable pm_container::cvi_type::val

Definition at line 567 of file pm_container.F90.

---

The documentation for this type was generated from the following file:

• src/fortran/main/pm_container.F90