[{"data":1,"prerenderedAt":862},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp04-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp04-f":668,"sidebar-sei-cert-fortran-coding-standard":677},[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":661,"extension":662,"meta":663,"navigation":7,"path":664,"seo":665,"stem":666,"__hash__":667},"content\u002F9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F5.typ04-f.md","TYP04-F. Centralize kind definitions to ensure consistent precision",{"type":35,"value":36,"toc":653},"minimark",[37,41,54,71,85,94,99,125,234,238,244,372,375,381,472,476,479,558,562,590,593,615,619,649],[38,39,33],"h1",{"id":40},"typ04-f-centralize-kind-definitions-to-ensure-consistent-precision",[42,43,44,45,49,50,53],"p",{},"Programmers should define numeric kind parameters in a centralized module using standard-compliant mechanisms, such as ",[46,47,48],"code",{},"selected_real_kind"," or ",[46,51,52],{},"iso_fortran_env"," , to ensure consistent and portable precision throughout the codebase.",[42,55,56,57,60,61,60,64,67,68,70],{},"In Fortran, the precision and range of intrinsic numeric types ( ",[46,58,59],{},"integer"," , ",[46,62,63],{},"real",[46,65,66],{},"complex"," ) are determined by their kind type parameter. Relying on default types (e.g., ",[46,69,63],{}," ) is hazardous because their actual precision is unspecified and may vary depending on the compiler or compiler flags.",[42,72,73,74,49,77,80,81,84],{},"Legacy extensions, such as ",[46,75,76],{},"real*4",[46,78,79],{},"real*8,"," are not standard and reduce code portability. Similarly, hard-coding kind values (e.g., ",[46,82,83],{},"kind=8"," ) is discouraged, as compilers may interpret them differently, either as byte sizes or as sequential kind identifiers.",[42,86,87,88,90,91,93],{},"To ensure consistent and portable precision, developers should define numeric kinds using standard inquiry functions, such as ",[46,89,48],{}," or constants provided by the ",[46,92,52],{}," module. Centralizing these definitions in a module allows changes to precision requirements to propagate throughout the codebase by modifying a single line, improving reliability and maintainability.",[95,96,98],"h2",{"id":97},"noncompliant-code-example","Noncompliant Code Example",[42,100,101,102,104,105,108,109,112,113,116,117,120,121,124],{},"This code mixes default ",[46,103,63],{}," , legacy ",[46,106,107],{},"  double precision "," , and non-standard ",[46,110,111],{},"real*8"," . The precision of ",[46,114,115],{},"x"," and ",[46,118,119],{},"y"," is compiler-dependent, while ",[46,122,123],{},"z"," relies on a non-standard extension, reducing portability and introducing potential numerical inconsistencies.",[126,127,129],"code-block",{"quality":128},"bad",[130,131,136],"pre",{"className":132,"code":133,"language":134,"meta":135,"style":135},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program test_inconsistent_precision\n  implicit none\n\n  ! Noncompliant: Default REAL depends on compiler defaults\n  real :: x\n  ! Noncompliant: DOUBLE PRECISION is legacy and varies by compiler\n  double precision :: y\n  ! Noncompliant: REAL*8 is a non-standard extension\n  real*8 :: z\n\n  x = 0.123456\n  y = 0.123456789012345d0\n  z = 1.0e0\n\n  print *, x, y, z\nend program\n","fortran","",[46,137,138,146,152,158,164,170,176,182,188,194,199,205,211,217,222,228],{"__ignoreMap":135},[139,140,143],"span",{"class":141,"line":142},"line",1,[139,144,145],{},"program test_inconsistent_precision\n",[139,147,149],{"class":141,"line":148},2,[139,150,151],{},"  implicit none\n",[139,153,155],{"class":141,"line":154},3,[139,156,157],{"emptyLinePlaceholder":7},"\n",[139,159,161],{"class":141,"line":160},4,[139,162,163],{},"  ! Noncompliant: Default REAL depends on compiler defaults\n",[139,165,167],{"class":141,"line":166},5,[139,168,169],{},"  real :: x\n",[139,171,173],{"class":141,"line":172},6,[139,174,175],{},"  ! Noncompliant: DOUBLE PRECISION is legacy and varies by compiler\n",[139,177,179],{"class":141,"line":178},7,[139,180,181],{},"  double precision :: y\n",[139,183,185],{"class":141,"line":184},8,[139,186,187],{},"  ! Noncompliant: REAL*8 is a non-standard extension\n",[139,189,191],{"class":141,"line":190},9,[139,192,193],{},"  real*8 :: z\n",[139,195,197],{"class":141,"line":196},10,[139,198,157],{"emptyLinePlaceholder":7},[139,200,202],{"class":141,"line":201},11,[139,203,204],{},"  x = 0.123456\n",[139,206,208],{"class":141,"line":207},12,[139,209,210],{},"  y = 0.123456789012345d0\n",[139,212,214],{"class":141,"line":213},13,[139,215,216],{},"  z = 1.0e0\n",[139,218,220],{"class":141,"line":219},14,[139,221,157],{"emptyLinePlaceholder":7},[139,223,225],{"class":141,"line":224},15,[139,226,227],{},"  print *, x, y, z\n",[139,229,231],{"class":141,"line":230},16,[139,232,233],{},"end program\n",[95,235,237],{"id":236},"compliant-solution","Compliant Solution",[42,239,240,241,243],{},"By defining kinds centrally using ",[46,242,48],{}," , this solution ensures consistent precision across the codebase and abstracts away compiler-specific defaults. Updating precision later requires modifying only the module.",[126,245,247],{"quality":246},"good",[130,248,250],{"className":132,"code":249,"language":134,"meta":135,"style":135},"module precision_mod\n  implicit none\n  public\n\n  ! Compliant: sp defines 6 significant digits, range of 10^-37 to 10^37\n  integer, parameter :: sp = selected_real_kind(6, 37)\n  ! Compliant: dp defines 15 significant digits, range of 10^307 to 10^307\n  integer, parameter :: dp = selected_real_kind(15, 307)\nend module precision_mod\n\nprogram test_precision\n  use precision_mod, only: sp, dp\n  implicit none\n\n  real(kind=sp) :: x\n  real(kind=dp) :: y\n  real(kind=dp) :: z\n\n  x = 0.123456_sp\n  y = 0.123456789012345_dp\n  z = 1.0_dp\n\n  print *, x, y\nend program\n",[46,251,252,257,261,266,270,275,280,285,290,295,299,304,309,313,317,322,327,333,338,344,350,356,361,367],{"__ignoreMap":135},[139,253,254],{"class":141,"line":142},[139,255,256],{},"module precision_mod\n",[139,258,259],{"class":141,"line":148},[139,260,151],{},[139,262,263],{"class":141,"line":154},[139,264,265],{},"  public\n",[139,267,268],{"class":141,"line":160},[139,269,157],{"emptyLinePlaceholder":7},[139,271,272],{"class":141,"line":166},[139,273,274],{},"  ! Compliant: sp defines 6 significant digits, range of 10^-37 to 10^37\n",[139,276,277],{"class":141,"line":172},[139,278,279],{},"  integer, parameter :: sp = selected_real_kind(6, 37)\n",[139,281,282],{"class":141,"line":178},[139,283,284],{},"  ! Compliant: dp defines 15 significant digits, range of 10^307 to 10^307\n",[139,286,287],{"class":141,"line":184},[139,288,289],{},"  integer, parameter :: dp = selected_real_kind(15, 307)\n",[139,291,292],{"class":141,"line":190},[139,293,294],{},"end module precision_mod\n",[139,296,297],{"class":141,"line":196},[139,298,157],{"emptyLinePlaceholder":7},[139,300,301],{"class":141,"line":201},[139,302,303],{},"program test_precision\n",[139,305,306],{"class":141,"line":207},[139,307,308],{},"  use precision_mod, only: sp, dp\n",[139,310,311],{"class":141,"line":213},[139,312,151],{},[139,314,315],{"class":141,"line":219},[139,316,157],{"emptyLinePlaceholder":7},[139,318,319],{"class":141,"line":224},[139,320,321],{},"  real(kind=sp) :: x\n",[139,323,324],{"class":141,"line":230},[139,325,326],{},"  real(kind=dp) :: y\n",[139,328,330],{"class":141,"line":329},17,[139,331,332],{},"  real(kind=dp) :: z\n",[139,334,336],{"class":141,"line":335},18,[139,337,157],{"emptyLinePlaceholder":7},[139,339,341],{"class":141,"line":340},19,[139,342,343],{},"  x = 0.123456_sp\n",[139,345,347],{"class":141,"line":346},20,[139,348,349],{},"  y = 0.123456789012345_dp\n",[139,351,353],{"class":141,"line":352},21,[139,354,355],{},"  z = 1.0_dp\n",[139,357,359],{"class":141,"line":358},22,[139,360,157],{"emptyLinePlaceholder":7},[139,362,364],{"class":141,"line":363},23,[139,365,366],{},"  print *, x, y\n",[139,368,370],{"class":141,"line":369},24,[139,371,233],{},[95,373,237],{"id":374},"compliant-solution-1",[42,376,377,378,380],{},"For applications requiring specific storage sizes, ",[46,379,52],{}," provides consistent bit-width kinds (e.g., 32-bit and 64-bit reals), ensuring portability across platforms and compatibility with binary formats or C interoperability.",[126,382,383],{"quality":246},[130,384,386],{"className":132,"code":385,"language":134,"meta":135,"style":135},"module precision_mod\n  use iso_fortran_env, only: real32, real64\n  implicit none\n  public\n\n  integer, parameter :: f32 = real32\n  integer, parameter :: f64 = real64\nend module precision_mod\n\nprogram test_precision\n  use precision_mod, only: f32, f64\n  implicit none\n\n  real(kind=f32) :: val_a \n  real(kind=f64) :: val_b\n\n  val_a = 1.0_f32\n  val_b = 1.0_f64\nend program\n",[46,387,388,392,397,401,405,409,414,419,423,427,431,436,440,444,449,454,458,463,468],{"__ignoreMap":135},[139,389,390],{"class":141,"line":142},[139,391,256],{},[139,393,394],{"class":141,"line":148},[139,395,396],{},"  use iso_fortran_env, only: real32, real64\n",[139,398,399],{"class":141,"line":154},[139,400,151],{},[139,402,403],{"class":141,"line":160},[139,404,265],{},[139,406,407],{"class":141,"line":166},[139,408,157],{"emptyLinePlaceholder":7},[139,410,411],{"class":141,"line":172},[139,412,413],{},"  integer, parameter :: f32 = real32\n",[139,415,416],{"class":141,"line":178},[139,417,418],{},"  integer, parameter :: f64 = real64\n",[139,420,421],{"class":141,"line":184},[139,422,294],{},[139,424,425],{"class":141,"line":190},[139,426,157],{"emptyLinePlaceholder":7},[139,428,429],{"class":141,"line":196},[139,430,303],{},[139,432,433],{"class":141,"line":201},[139,434,435],{},"  use precision_mod, only: f32, f64\n",[139,437,438],{"class":141,"line":207},[139,439,151],{},[139,441,442],{"class":141,"line":213},[139,443,157],{"emptyLinePlaceholder":7},[139,445,446],{"class":141,"line":219},[139,447,448],{},"  real(kind=f32) :: val_a \n",[139,450,451],{"class":141,"line":224},[139,452,453],{},"  real(kind=f64) :: val_b\n",[139,455,456],{"class":141,"line":230},[139,457,157],{"emptyLinePlaceholder":7},[139,459,460],{"class":141,"line":329},[139,461,462],{},"  val_a = 1.0_f32\n",[139,464,465],{"class":141,"line":335},[139,466,467],{},"  val_b = 1.0_f64\n",[139,469,470],{"class":141,"line":340},[139,471,233],{},[95,473,475],{"id":474},"risk-assessment","Risk Assessment",[42,477,478],{},"Not centralizing and explicitly defining numeric kinds can lead to precision drift, where different components of an application use inconsistent floating-point widths. This may cause unexpected numerical results, compromise data integrity, and create portability issues across compilers or hardware platforms.",[480,481,482,503],"table",{},[483,484,485],"thead",{},[486,487,488,491,493,495,497,499,501],"tr",{},[489,490],"th",{},[489,492],{},[489,494],{},[489,496],{},[489,498],{},[489,500],{},[489,502],{},[504,505,506,530],"tbody",{},[486,507,508,512,515,518,521,524,527],{},[509,510,511],"td",{},"Recommendation",[509,513,514],{},"Severity",[509,516,517],{},"Likelihood",[509,519,520],{},"Detectable",[509,522,523],{},"Repairable",[509,525,526],{},"Priority",[509,528,529],{},"Level",[486,531,532,535,538,541,544,547,553],{},[509,533,534],{},"TYP04-F",[509,536,537],{},"High",[509,539,540],{},"Unlikely",[509,542,543],{},"Yes",[509,545,546],{},"No",[509,548,549],{},[550,551,552],"strong",{},"P6",[509,554,555],{},[550,556,557],{},"L2",[95,559,561],{"id":560},"bibliography","Bibliography",[480,563,564,572],{},[483,565,566],{},[486,567,568,570],{},[489,569],{},[489,571],{},[504,573,574],{},[486,575,576,587],{},[509,577,578,579,586],{},"[ ",[580,581,585],"a",{"href":582,"rel":583},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[584],"nofollow","Fortran 2023 Interpretation Document"," ]",[509,588,589],{},"Section 16.10.2.27",[591,592],"hr",{},[42,594,595,602,603,602,609],{},[580,596,598],{"href":597},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[599,600],"img",{"src":601},"attachments\u002F629047328\u002F638779499.png"," ",[580,604,606],{"href":605},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[599,607],{"src":608},"attachments\u002F629047328\u002F638779500.png",[580,610,612],{"href":611},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[599,613],{"src":614},"attachments\u002F629047328\u002F638779501.png",[95,616,618],{"id":617},"attachments","Attachments:",[620,621,625],"div",{"className":622,"align":624},[623],"greybox","left",[42,626,627,602,630,633,634,637,602,639,633,642,644,602,646,633],{},[599,628],{"alt":135,"src":629},"images\u002Ficons\u002Fbullet_blue.gif",[580,631,632],{"href":601},"button_arrow_left.png"," (image\u002Fpng)",[635,636],"br",{},[599,638],{"alt":135,"src":629},[580,640,641],{"href":608},"button_arrow_up.png",[635,643],{},[599,645],{"alt":135,"src":629},[580,647,648],{"href":614},"button_arrow_right.png",[650,651,652],"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":135,"searchDepth":148,"depth":148,"links":654},[655,656,657,658,659,660],{"id":97,"depth":148,"text":98},{"id":236,"depth":148,"text":237},{"id":374,"depth":148,"text":237},{"id":474,"depth":148,"text":475},{"id":560,"depth":148,"text":561},{"id":617,"depth":148,"text":618},"Programmers should define numeric kind parameters in a centralized module using standard-compliant mechanisms, such as selected_real_kind or iso_fortran_env , to ensure consistent and portable precision throughout the codebase.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp04-f",{"title":33,"description":661},"9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F5.typ04-f","9q0V9bvk0I7oN6i0ODeNcuEe1cIW5uw79Z-bfH-h_JE",[669,673],{"title":670,"path":671,"stem":672,"children":-1},"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":674,"path":675,"stem":676,"children":-1},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",[678],{"title":679,"path":680,"stem":681,"children":682},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[683,686,708,722,748,758,762,772,776,780,784,788,806,824,828,846,861],{"title":684,"path":680,"stem":685},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":687,"path":688,"stem":689,"children":690},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[691,692,696,700,704],{"title":687,"path":688,"stem":689},{"title":693,"path":694,"stem":695},"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":697,"path":698,"stem":699},"ARR02-F. Declare array dummy arguments as assumed-shape","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr02-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F3.arr02-f",{"title":701,"path":702,"stem":703},"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",{"title":705,"path":706,"stem":707},"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":709,"path":710,"stem":711,"children":712},"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",[713,714,718],{"title":709,"path":710,"stem":711},{"title":715,"path":716,"stem":717},"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":719,"path":720,"stem":721},"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":723,"path":724,"stem":725,"children":726},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[727,728,732,736,740,744],{"title":723,"path":724,"stem":725},{"title":729,"path":730,"stem":731},"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":733,"path":734,"stem":735},"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":737,"path":738,"stem":739},"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":741,"path":742,"stem":743},"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":745,"path":746,"stem":747},"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":749,"path":750,"stem":751,"children":752},"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",[753,754],{"title":749,"path":750,"stem":751},{"title":755,"path":756,"stem":757},"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":759,"path":760,"stem":761},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":763,"path":764,"stem":765,"children":766},"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",[767,768],{"title":763,"path":764,"stem":765},{"title":769,"path":770,"stem":771},"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":773,"path":774,"stem":775},"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":777,"path":778,"stem":779},"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":781,"path":782,"stem":783},"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":785,"path":786,"stem":787},"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":789,"path":790,"stem":791,"children":792},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[793,794,798,802],{"title":789,"path":790,"stem":791},{"title":795,"path":796,"stem":797},"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":799,"path":800,"stem":801},"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":803,"path":804,"stem":805},"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":807,"path":808,"stem":809,"children":810},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[811,812,816,820],{"title":807,"path":808,"stem":809},{"title":813,"path":814,"stem":815},"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":817,"path":818,"stem":819},"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":821,"path":822,"stem":823},"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":825,"path":826,"stem":827},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":829,"path":830,"stem":831,"children":832},"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",[833,834,838,842],{"title":829,"path":830,"stem":831},{"title":835,"path":836,"stem":837},"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":839,"path":840,"stem":841},"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":843,"path":844,"stem":845},"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":847,"path":848,"stem":849,"children":850},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[851,852,855,859,860],{"title":847,"path":848,"stem":849},{"title":853,"path":611,"stem":854},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":856,"path":857,"stem":858},"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":670,"path":671,"stem":672},{"title":33,"path":664,"stem":666},{"title":674,"path":675,"stem":676},1780320166965]