[{"data":1,"prerenderedAt":709},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr02-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr02-f":515,"sidebar-sei-cert-fortran-coding-standard":524},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":30,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24,27],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard\u002F",{"title":25,"path":26},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":28,"path":29},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":32,"title":33,"body":34,"description":44,"extension":509,"meta":510,"navigation":7,"path":511,"seo":512,"stem":513,"__hash__":514},"content\u002F9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F3.arr02-f.md","ARR02-F. Declare array dummy arguments as assumed-shape",{"type":35,"value":36,"toc":503},"minimark",[37,41,45,48,51,73,76,81,107,244,248,258,353,357,360,439,442,465,469,499],[38,39,33],"h1",{"id":40},"arr02-f-declare-array-dummy-arguments-as-assumed-shape",[42,43,44],"p",{},"Array dummy arguments should be declared as assumed-shape arrays to let the compiler automatically infer dimensions and perform rank compatibility checks.",[42,46,47],{},"Legacy approaches such as explicit-shape and assumed-size arrays mimic C behavior by requiring programmers to manually pass and manage the sizes of array dimensions. This is error-prone, as mismatches between actual and dummy shapes are not checked by the compiler, potentially causing runtime errors, memory corruption, or silent logic errors.",[42,49,50],{},"Assumed-shape arrays mitigate these risks by inheriting the shape and size directly from the effective argument, enabling:",[52,53,54,67,70],"ol",{},[55,56,57,58,62,63,66],"li",{},"Automatic dimension inference using intrinsic functions like ",[59,60,61],"code",{},"size()"," and ",[59,64,65],{},"shape()"," .",[55,68,69],{},"Compile-time rank checking to verify that the dummy array matches the actual argument.",[55,71,72],{},"Safe handling of slices or strided accesses without creating temporary contiguous copies.",[42,74,75],{},"Beware that any procedure utilizing assumed-shape arrays must have an explicit interface at the point of call (e.g., by being encapsulated in a module or utilizing an interface block).",[77,78,80],"h2",{"id":79},"noncompliant-code-example","Noncompliant Code Example",[42,82,83,84,87,88,91,92,95,96,99,100,103,104,106],{},"In this noncompliant example, a subroutine is designed to calculate the average value of a vector. The array is passed as an explicit-shape array, requiring the dimension ",[59,85,86],{},"n"," to be passed manually. In the call to ",[59,89,90],{},"calculate_average()"," , the programmer mistakenly passes a constant ",[59,93,94],{},"5"," that is smaller than the actual array size ",[59,97,98],{},"10",". While this specific instance might only result in a partial calculation, a similar error passing a larger value (e.g., passing ",[59,101,102],{},"100"," for a ",[59,105,98],{},"-element array) would lead to an out-of-bounds read and undefined behavior.",[108,109,111],"code-block",{"quality":110},"bad",[112,113,118],"pre",{"className":114,"code":115,"language":116,"meta":117,"style":117},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program test_average\n  implicit none\n  real :: data_points(10) = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n  real :: avg\n\n  ! Noncompliant: Array size is passed manually, passing only 5 elements out of 10.\n  call calculate_average(data_points, 5, avg)\n  print *, \"Average: \", avg\n\ncontains\n\n  subroutine calculate_average(v, n, result)\n    integer, intent(in) :: n\n    ! Noncompliant: Explicit-shape array declared in terms of the dummy argument n\n    real, intent(in)    :: v(n)\n    real, intent(out)   :: result\n\n    result = sum(v) \u002F real(n)\n  end subroutine calculate_average\n\nend program test_average\n","fortran","",[59,119,120,128,134,140,146,152,158,164,170,175,181,186,192,198,204,210,216,221,227,233,238],{"__ignoreMap":117},[121,122,125],"span",{"class":123,"line":124},"line",1,[121,126,127],{},"program test_average\n",[121,129,131],{"class":123,"line":130},2,[121,132,133],{},"  implicit none\n",[121,135,137],{"class":123,"line":136},3,[121,138,139],{},"  real :: data_points(10) = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n",[121,141,143],{"class":123,"line":142},4,[121,144,145],{},"  real :: avg\n",[121,147,149],{"class":123,"line":148},5,[121,150,151],{"emptyLinePlaceholder":7},"\n",[121,153,155],{"class":123,"line":154},6,[121,156,157],{},"  ! Noncompliant: Array size is passed manually, passing only 5 elements out of 10.\n",[121,159,161],{"class":123,"line":160},7,[121,162,163],{},"  call calculate_average(data_points, 5, avg)\n",[121,165,167],{"class":123,"line":166},8,[121,168,169],{},"  print *, \"Average: \", avg\n",[121,171,173],{"class":123,"line":172},9,[121,174,151],{"emptyLinePlaceholder":7},[121,176,178],{"class":123,"line":177},10,[121,179,180],{},"contains\n",[121,182,184],{"class":123,"line":183},11,[121,185,151],{"emptyLinePlaceholder":7},[121,187,189],{"class":123,"line":188},12,[121,190,191],{},"  subroutine calculate_average(v, n, result)\n",[121,193,195],{"class":123,"line":194},13,[121,196,197],{},"    integer, intent(in) :: n\n",[121,199,201],{"class":123,"line":200},14,[121,202,203],{},"    ! Noncompliant: Explicit-shape array declared in terms of the dummy argument n\n",[121,205,207],{"class":123,"line":206},15,[121,208,209],{},"    real, intent(in)    :: v(n)\n",[121,211,213],{"class":123,"line":212},16,[121,214,215],{},"    real, intent(out)   :: result\n",[121,217,219],{"class":123,"line":218},17,[121,220,151],{"emptyLinePlaceholder":7},[121,222,224],{"class":123,"line":223},18,[121,225,226],{},"    result = sum(v) \u002F real(n)\n",[121,228,230],{"class":123,"line":229},19,[121,231,232],{},"  end subroutine calculate_average\n",[121,234,236],{"class":123,"line":235},20,[121,237,151],{"emptyLinePlaceholder":7},[121,239,241],{"class":123,"line":240},21,[121,242,243],{},"end program test_average\n",[77,245,247],{"id":246},"compliant-solution","Compliant Solution",[42,249,250,251,254,255,257],{},"In this compliant solution, the vector is declared as an assumed-shape array using a colon ",[59,252,253],{},"(:)"," . The dimension argument is removed, and the subroutine uses the intrinsic function ",[59,256,61],{}," to determine the bounds. The error is prevented because the subroutine automatically inherits the correct dimensions from the calling program, and the compiler enforces rank compatibility.",[108,259,261],{"quality":260},"good",[112,262,264],{"className":114,"code":263,"language":116,"meta":117,"style":117},"program test_average\n  implicit none\n  real :: data_points(10) = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n  real :: avg\n\n  ! Compliant: The array carries its own shape information.\n  call calculate_average(data_points, avg)\n  print *, \"Average: \", avg\n\ncontains\n\n  subroutine calculate_average(v, result)\n    ! Compliant: Assumed-shape inherits dimensions automatically, using the declaration syntax (:).\n    real, intent(in)  :: v(:)\n    real, intent(out) :: result\n\n    result = sum(v) \u002F real(size(v))\n  end subroutine calculate_average\n\nend program test_average\n",[59,265,266,270,274,278,282,286,291,296,300,304,308,312,317,322,327,332,336,341,345,349],{"__ignoreMap":117},[121,267,268],{"class":123,"line":124},[121,269,127],{},[121,271,272],{"class":123,"line":130},[121,273,133],{},[121,275,276],{"class":123,"line":136},[121,277,139],{},[121,279,280],{"class":123,"line":142},[121,281,145],{},[121,283,284],{"class":123,"line":148},[121,285,151],{"emptyLinePlaceholder":7},[121,287,288],{"class":123,"line":154},[121,289,290],{},"  ! Compliant: The array carries its own shape information.\n",[121,292,293],{"class":123,"line":160},[121,294,295],{},"  call calculate_average(data_points, avg)\n",[121,297,298],{"class":123,"line":166},[121,299,169],{},[121,301,302],{"class":123,"line":172},[121,303,151],{"emptyLinePlaceholder":7},[121,305,306],{"class":123,"line":177},[121,307,180],{},[121,309,310],{"class":123,"line":183},[121,311,151],{"emptyLinePlaceholder":7},[121,313,314],{"class":123,"line":188},[121,315,316],{},"  subroutine calculate_average(v, result)\n",[121,318,319],{"class":123,"line":194},[121,320,321],{},"    ! Compliant: Assumed-shape inherits dimensions automatically, using the declaration syntax (:).\n",[121,323,324],{"class":123,"line":200},[121,325,326],{},"    real, intent(in)  :: v(:)\n",[121,328,329],{"class":123,"line":206},[121,330,331],{},"    real, intent(out) :: result\n",[121,333,334],{"class":123,"line":212},[121,335,151],{"emptyLinePlaceholder":7},[121,337,338],{"class":123,"line":218},[121,339,340],{},"    result = sum(v) \u002F real(size(v))\n",[121,342,343],{"class":123,"line":223},[121,344,232],{},[121,346,347],{"class":123,"line":229},[121,348,151],{"emptyLinePlaceholder":7},[121,350,351],{"class":123,"line":235},[121,352,243],{},[77,354,356],{"id":355},"risk-assessment","Risk Assessment",[42,358,359],{},"Using explicit-shape or assumed-size arrays increases the programmer's cognitive load and prevents the compiler from automating safety checks. This leads to high-risk memory interpretation errors and buffer overflows that are difficult to detect through static analysis.",[361,362,363,384],"table",{},[364,365,366],"thead",{},[367,368,369,372,374,376,378,380,382],"tr",{},[370,371],"th",{},[370,373],{},[370,375],{},[370,377],{},[370,379],{},[370,381],{},[370,383],{},[385,386,387,411],"tbody",{},[367,388,389,393,396,399,402,405,408],{},[390,391,392],"td",{},"Recommendation",[390,394,395],{},"Severity",[390,397,398],{},"Likelihood",[390,400,401],{},"Detectable",[390,403,404],{},"Repairable",[390,406,407],{},"Priority",[390,409,410],{},"Level",[367,412,413,416,419,422,425,428,434],{},[390,414,415],{},"ARR02-F",[390,417,418],{},"Low",[390,420,421],{},"Probable",[390,423,424],{},"Yes",[390,426,427],{},"No",[390,429,430],{},[431,432,433],"strong",{},"P4",[390,435,436],{},[431,437,438],{},"L3",[440,441],"hr",{},[42,443,444,452,453,452,459],{},[445,446,448],"a",{"href":447},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[449,450],"img",{"src":451},"attachments\u002F629047326\u002F638779615.png"," ",[445,454,456],{"href":455},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[449,457],{"src":458},"attachments\u002F629047326\u002F638779616.png",[445,460,462],{"href":461},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[449,463],{"src":464},"attachments\u002F629047326\u002F638779617.png",[77,466,468],{"id":467},"attachments","Attachments:",[470,471,475],"div",{"className":472,"align":474},[473],"greybox","left",[42,476,477,452,480,483,484,487,452,489,483,492,494,452,496,483],{},[449,478],{"alt":117,"src":479},"images\u002Ficons\u002Fbullet_blue.gif",[445,481,482],{"href":451},"button_arrow_left.png"," (image\u002Fpng)",[485,486],"br",{},[449,488],{"alt":117,"src":479},[445,490,491],{"href":458},"button_arrow_up.png",[485,493],{},[449,495],{"alt":117,"src":479},[445,497,498],{"href":464},"button_arrow_right.png",[500,501,502],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":117,"searchDepth":130,"depth":130,"links":504},[505,506,507,508],{"id":79,"depth":130,"text":80},{"id":246,"depth":130,"text":247},{"id":355,"depth":130,"text":356},{"id":467,"depth":130,"text":468},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr02-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F3.arr02-f","Vf5WKCatGjt6ZRZP9asRTwH2ZKAy38NaqdW9QLZ-9iM",[516,520],{"title":517,"path":518,"stem":519,"children":-1},"ARR01-F. Do not use out-of-bounds arrays subscripts","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr01-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F2.arr01-f",{"title":521,"path":522,"stem":523,"children":-1},"ARR03-F. Specify array bounds when copying data to device memory","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr03-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F4.arr03-f",[525],{"title":526,"path":527,"stem":528,"children":529},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[530,533,546,560,586,596,600,610,614,618,622,626,644,662,666,684,705],{"title":531,"path":527,"stem":532},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":534,"path":535,"stem":536,"children":537},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[538,539,540,541,542],{"title":534,"path":535,"stem":536},{"title":517,"path":518,"stem":519},{"title":33,"path":511,"stem":513},{"title":521,"path":522,"stem":523},{"title":543,"path":544,"stem":545},"ARR04-F. Ensure arrays ranges mapped to devices cover all accessed elements","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr04-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F5.arr04-f",{"title":547,"path":548,"stem":549,"children":550},"Attribute Declarations and Specifications (ADS)","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F1.index",[551,552,556],{"title":547,"path":548,"stem":549},{"title":553,"path":554,"stem":555},"ADS01-F. Explicitly declare pure procedures","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads01-f",{"title":557,"path":558,"stem":559},"ADS02-F. Separate initialization from declaration to avoid implicit variable persistence","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads02-f",{"title":561,"path":562,"stem":563,"children":564},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[565,566,570,574,578,582],{"title":561,"path":562,"stem":563},{"title":567,"path":568,"stem":569},"CON01-F. Explicitly declare OpenMP data-sharing attributes for all variables","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon01-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F2.con01-f",{"title":571,"path":572,"stem":573},"CON02-F. Protect reduction variables in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon02-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F3.con02-f",{"title":575,"path":576,"stem":577},"CON03-F. Protect multithreading recurrences to avoid data races","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon03-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F4.con03-f",{"title":579,"path":580,"stem":581},"CON04-F. Do not use out-of-dimension subscripts in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon04-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F5.con04-f",{"title":583,"path":584,"stem":585},"CON05-F. Ensure correct OpenMP datascoping of variables in parallel regions","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon05-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F6.con05-f",{"title":587,"path":588,"stem":589,"children":590},"Exceptions and IEEE Arithmetic (EIA)","\u002Fsei-cert-fortran-coding-standard\u002Fexceptions-and-ieee-arithmetic-eia","9.sei-cert-fortran-coding-standard\u002F05.exceptions-and-ieee-arithmetic-eia\u002F1.index",[591,592],{"title":587,"path":588,"stem":589},{"title":593,"path":594,"stem":595},"EIA01-F. Enforce evaluation order in floating-point expressions","\u002Fsei-cert-fortran-coding-standard\u002Fexceptions-and-ieee-arithmetic-eia\u002Feia01-f","9.sei-cert-fortran-coding-standard\u002F05.exceptions-and-ieee-arithmetic-eia\u002F2.eia01-f",{"title":597,"path":598,"stem":599},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":601,"path":602,"stem":603,"children":604},"Expressions and Assignment (EXA)","\u002Fsei-cert-fortran-coding-standard\u002Fexpressions-and-assignment-exa","9.sei-cert-fortran-coding-standard\u002F07.expressions-and-assignment-exa\u002F1.index",[605,606],{"title":601,"path":602,"stem":603},{"title":607,"path":608,"stem":609},"EXA01-F. Do not read uninitialized memory","\u002Fsei-cert-fortran-coding-standard\u002Fexpressions-and-assignment-exa\u002Fexa01-f","9.sei-cert-fortran-coding-standard\u002F07.expressions-and-assignment-exa\u002F2.exa01-f",{"title":611,"path":612,"stem":613},"Input and Output Editing (IOE)","\u002Fsei-cert-fortran-coding-standard\u002Finput-and-output-editing-ioe","9.sei-cert-fortran-coding-standard\u002F08.input-and-output-editing-ioe",{"title":615,"path":616,"stem":617},"Input and Output Statements (IOS)","\u002Fsei-cert-fortran-coding-standard\u002Finput-and-output-statements-ios","9.sei-cert-fortran-coding-standard\u002F09.input-and-output-statements-ios",{"title":619,"path":620,"stem":621},"Interoperability with C (IWC)","\u002Fsei-cert-fortran-coding-standard\u002Finteroperability-with-c-iwc","9.sei-cert-fortran-coding-standard\u002F10.interoperability-with-c-iwc",{"title":623,"path":624,"stem":625},"Intrinsic Procedures and Modules (IPM)","\u002Fsei-cert-fortran-coding-standard\u002Fintrinsic-procedures-and-modules-ipm","9.sei-cert-fortran-coding-standard\u002F11.intrinsic-procedures-and-modules-ipm",{"title":627,"path":628,"stem":629,"children":630},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[631,632,636,640],{"title":627,"path":628,"stem":629},{"title":633,"path":634,"stem":635},"MSC01-F. Avoid using legacy or obsolescent Fortran constructs","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc01-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F2.msc01-f",{"title":637,"path":638,"stem":639},"MSC02-F. Beware of compiler-specific extensions","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc02-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F3.msc02-f",{"title":641,"path":642,"stem":643},"MSC03-F. Do not depend on undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc03-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F4.msc03-f",{"title":645,"path":646,"stem":647,"children":648},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[649,650,654,658],{"title":645,"path":646,"stem":647},{"title":651,"path":652,"stem":653},"PRC01-F. Disable the implicit declaration of procedures","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc01-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F2.prc01-f",{"title":655,"path":656,"stem":657},"PRC02-F. Avoid implicit interfaces by using module procedures","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc02-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F3.prc02-f",{"title":659,"path":660,"stem":661},"PRC03-F. Declare the intent for all dummy arguments","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc03-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F4.prc03-f",{"title":663,"path":664,"stem":665},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":667,"path":668,"stem":669,"children":670},"Scope, Association, and Definition (SAD)","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F1.index",[671,672,676,680],{"title":667,"path":668,"stem":669},{"title":673,"path":674,"stem":675},"SAD02-F. Minimize imported module entities using the ONLY clause","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad02-f","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F2.sad02-f",{"title":677,"path":678,"stem":679},"SAD03-F. Replace common block with modules for safer data encapsulation","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad03-f","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F3.sad03-f",{"title":681,"path":682,"stem":683},"Limit the scope of variables and procedures","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Flimit-the-scope-of-variables-and-procedures","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F4.limit-the-scope-of-variables-and-procedures",{"title":685,"path":686,"stem":687,"children":688},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[689,690,693,697,701],{"title":685,"path":686,"stem":687},{"title":691,"path":461,"stem":692},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":694,"path":695,"stem":696},"TYP02-F. Prohibit implicit typing in all program units","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp02-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F3.typ02-f",{"title":698,"path":699,"stem":700},"TYP03-F. Ensure intrinsic function arguments match intended precision","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp03-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F4.typ03-f",{"title":702,"path":703,"stem":704},"TYP04-F. Centralize kind definitions to ensure consistent precision","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp04-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F5.typ04-f",{"title":706,"path":707,"stem":708},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167195]