[{"data":1,"prerenderedAt":791},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp03-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp03-f":597,"sidebar-sei-cert-fortran-coding-standard":606},[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":590,"extension":591,"meta":592,"navigation":7,"path":593,"seo":594,"stem":595,"__hash__":596},"content\u002F9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F4.typ03-f.md","TYP03-F. Ensure intrinsic function arguments match intended precision",{"type":35,"value":36,"toc":581},"minimark",[37,41,50,53,100,105,118,193,197,204,255,258,267,332,335,344,401,405,408,486,490,518,521,543,547,577],[38,39,33],"h1",{"id":40},"typ03-f-ensure-intrinsic-function-arguments-match-intended-precision",[42,43,44,45,49],"p",{},"Programmers should use generic intrinsic procedure names and explicitly specify the ",[46,47,48],"code",{},"kind"," argument for type conversion functions to prevent unintended precision loss.",[42,51,52],{},"While modern Fortran provides generic interfaces for most intrinsic procedures, subtle naming conventions and default behaviors can lead to silent data narrowing and numeric errors. Two common mechanisms that cause precision loss are:",[54,55,56,71],"ul",{},[57,58,59,60,63,64,67,68,70],"li",{},"Usage of specific (legacy) intrinsic names. Legacy Fortran required specific function names for different data types (e.g., ",[46,61,62],{},"amod"," for real, ",[46,65,66],{},"dmod"," for double precision). Using a specific name like ",[46,69,62],{}," with double-precision arguments forces the compiler to convert the arguments to single precision before the operation, discarding significant digits. Calling a mathematical function intended for a smaller data type results in lower-precision operations and loss of information.",[57,72,73,74,77,78,81,82,85,86,89,90,93,94,96,97,99],{},"Implicit defaults in conversion functions. In Fortran, type conversion functions (specifically ",[46,75,76],{},"cmplx"," , ",[46,79,80],{},"real"," , and ",[46,83,84],{},"int"," ) default to the processor-dependent default kind (usually single precision) regardless of the input precision. This differs from mathematical intrinsics (like ",[46,87,88],{},"sqrt"," or ",[46,91,92],{},"sin"," ) which automatically inherit the precision of their arguments. If a programmer passes double-precision variables to ",[46,95,76],{}," without a ",[46,98,48],{}," argument, the data is silently demoted to single precision.",[101,102,104],"h2",{"id":103},"noncompliant-code-example","Noncompliant Code Example",[42,106,107,108,110,111,114,115,117],{},"In this noncompliant example, the legacy specific intrinsic ",[46,109,62],{}," (intended for default real) is used on double-precision variables. The compiler demotes ",[46,112,113],{},"d_val"," to single precision to satisfy ",[46,116,62],{}," , resulting in data loss.",[119,120,122],"code-block",{"quality":121},"bad",[123,124,129],"pre",{"className":125,"code":126,"language":127,"meta":128,"style":128},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program specific_intrinsic\n  use iso_fortran_env, only: real64\n  implicit none\n  real(real64) :: d_val = 1.23456789012345_real64\n  real(real64) :: res\n\n  ! Noncompliant: amod is specific to default real (single precision)\n  res = amod(d_val, 2.0_real64)\n  print *, res\nend program\n","fortran","",[46,130,131,139,145,151,157,163,169,175,181,187],{"__ignoreMap":128},[132,133,136],"span",{"class":134,"line":135},"line",1,[132,137,138],{},"program specific_intrinsic\n",[132,140,142],{"class":134,"line":141},2,[132,143,144],{},"  use iso_fortran_env, only: real64\n",[132,146,148],{"class":134,"line":147},3,[132,149,150],{},"  implicit none\n",[132,152,154],{"class":134,"line":153},4,[132,155,156],{},"  real(real64) :: d_val = 1.23456789012345_real64\n",[132,158,160],{"class":134,"line":159},5,[132,161,162],{},"  real(real64) :: res\n",[132,164,166],{"class":134,"line":165},6,[132,167,168],{"emptyLinePlaceholder":7},"\n",[132,170,172],{"class":134,"line":171},7,[132,173,174],{},"  ! Noncompliant: amod is specific to default real (single precision)\n",[132,176,178],{"class":134,"line":177},8,[132,179,180],{},"  res = amod(d_val, 2.0_real64)\n",[132,182,184],{"class":134,"line":183},9,[132,185,186],{},"  print *, res\n",[132,188,190],{"class":134,"line":189},10,[132,191,192],{},"end program\n",[101,194,196],{"id":195},"compliant-solution","Compliant Solution",[42,198,199,200,203],{},"Using the generic name ",[46,201,202],{},"mod"," allows the compiler to select the specific procedure that matches the argument's precision.",[119,205,207],{"quality":206},"good",[123,208,210],{"className":125,"code":209,"language":127,"meta":128,"style":128},"prprogram generic_intrinsic\n  use iso_fortran_env, only: real64\n  implicit none\n  real(real64) :: d_val = 1.23456789012345_real64\n  real(real64) :: res\n\n  ! Noncompliant: MOD is generic and maintains the precision of d_val\n  res = mod(d_val, 2.0_real64)\n  print *, res\nend program\n",[46,211,212,217,221,225,229,233,237,242,247,251],{"__ignoreMap":128},[132,213,214],{"class":134,"line":135},[132,215,216],{},"prprogram generic_intrinsic\n",[132,218,219],{"class":134,"line":141},[132,220,144],{},[132,222,223],{"class":134,"line":147},[132,224,150],{},[132,226,227],{"class":134,"line":153},[132,228,156],{},[132,230,231],{"class":134,"line":159},[132,232,162],{},[132,234,235],{"class":134,"line":165},[132,236,168],{"emptyLinePlaceholder":7},[132,238,239],{"class":134,"line":171},[132,240,241],{},"  ! Noncompliant: MOD is generic and maintains the precision of d_val\n",[132,243,244],{"class":134,"line":177},[132,245,246],{},"  res = mod(d_val, 2.0_real64)\n",[132,248,249],{"class":134,"line":183},[132,250,186],{},[132,252,253],{"class":134,"line":189},[132,254,192],{},[101,256,104],{"id":257},"noncompliant-code-example-1",[42,259,260,261,263,264,266],{},"In this noncompliant example, ",[46,262,76],{}," is called without a ",[46,265,48],{}," argument. Even though the inputs are double-precision, the result may be single-precision, leading to truncation and loss of accuracy.",[119,268,269],{"quality":121},[123,270,272],{"className":125,"code":271,"language":127,"meta":128,"style":128},"program complex\n  use iso_fortran_env, only: real64\n  implicit none\n  real(real64) :: d_real = 1.23456789012345_real64\n  real(real64) :: d_imag = 9.87654321098765_real64\n  complex(real64) :: z\n\n  ! Noncompliant: CMPLX defaults to single precision\n  z = cmplx(d_real, d_imag)\n\n  print *, z\nend program complex\n",[46,273,274,279,283,287,292,297,302,306,311,316,320,326],{"__ignoreMap":128},[132,275,276],{"class":134,"line":135},[132,277,278],{},"program complex\n",[132,280,281],{"class":134,"line":141},[132,282,144],{},[132,284,285],{"class":134,"line":147},[132,286,150],{},[132,288,289],{"class":134,"line":153},[132,290,291],{},"  real(real64) :: d_real = 1.23456789012345_real64\n",[132,293,294],{"class":134,"line":159},[132,295,296],{},"  real(real64) :: d_imag = 9.87654321098765_real64\n",[132,298,299],{"class":134,"line":165},[132,300,301],{},"  complex(real64) :: z\n",[132,303,304],{"class":134,"line":171},[132,305,168],{"emptyLinePlaceholder":7},[132,307,308],{"class":134,"line":177},[132,309,310],{},"  ! Noncompliant: CMPLX defaults to single precision\n",[132,312,313],{"class":134,"line":183},[132,314,315],{},"  z = cmplx(d_real, d_imag)\n",[132,317,318],{"class":134,"line":189},[132,319,168],{"emptyLinePlaceholder":7},[132,321,323],{"class":134,"line":322},11,[132,324,325],{},"  print *, z\n",[132,327,329],{"class":134,"line":328},12,[132,330,331],{},"end program complex\n",[101,333,196],{"id":334},"compliant-solution-1",[42,336,337,338,340,341,343],{},"By explicitly specifying the ",[46,339,48],{}," parameter, ",[46,342,76],{}," returns a double-precision complex number, preserving the precision of the inputs and preventing silent truncation.",[119,345,346],{"quality":206},[123,347,349],{"className":125,"code":348,"language":127,"meta":128,"style":128},"program complex\n  use iso_fortran_env, only: real64\n  implicit none\n  real(real64) :: d_real = 1.23456789012345_real64\n  real(real64) :: d_imag = 9.87654321098765_real64\n  complex(real64) :: z\n\n  ! Compliant: Explicitly specify KIND to preserve double precision\n  z = cmplx(d_real, d_imag, kind=real64)\n\n  print *, z\nend program complex\n",[46,350,351,355,359,363,367,371,375,379,384,389,393,397],{"__ignoreMap":128},[132,352,353],{"class":134,"line":135},[132,354,278],{},[132,356,357],{"class":134,"line":141},[132,358,144],{},[132,360,361],{"class":134,"line":147},[132,362,150],{},[132,364,365],{"class":134,"line":153},[132,366,291],{},[132,368,369],{"class":134,"line":159},[132,370,296],{},[132,372,373],{"class":134,"line":165},[132,374,301],{},[132,376,377],{"class":134,"line":171},[132,378,168],{"emptyLinePlaceholder":7},[132,380,381],{"class":134,"line":177},[132,382,383],{},"  ! Compliant: Explicitly specify KIND to preserve double precision\n",[132,385,386],{"class":134,"line":183},[132,387,388],{},"  z = cmplx(d_real, d_imag, kind=real64)\n",[132,390,391],{"class":134,"line":189},[132,392,168],{"emptyLinePlaceholder":7},[132,394,395],{"class":134,"line":322},[132,396,325],{},[132,398,399],{"class":134,"line":328},[132,400,331],{},[101,402,404],{"id":403},"risk-assessment","Risk Assessment",[42,406,407],{},"Implicit narrowing of function arguments can result in loss of significant digits, which may compound over subsequent calculations and produce numerically incorrect results.",[409,410,411,432],"table",{},[412,413,414],"thead",{},[415,416,417,420,422,424,426,428,430],"tr",{},[418,419],"th",{},[418,421],{},[418,423],{},[418,425],{},[418,427],{},[418,429],{},[418,431],{},[433,434,435,459],"tbody",{},[415,436,437,441,444,447,450,453,456],{},[438,439,440],"td",{},"Recommendation",[438,442,443],{},"Severity",[438,445,446],{},"Likelihood",[438,448,449],{},"Detectable",[438,451,452],{},"Repairable",[438,454,455],{},"Priority",[438,457,458],{},"Level",[415,460,461,464,467,470,473,475,481],{},[438,462,463],{},"TYP03-F",[438,465,466],{},"Low",[438,468,469],{},"Probable",[438,471,472],{},"Yes",[438,474,472],{},[438,476,477],{},[478,479,480],"strong",{},"P6",[438,482,483],{},[478,484,485],{},"L2",[101,487,489],{"id":488},"bibliography","Bibliography",[409,491,492,500],{},[412,493,494],{},[415,495,496,498],{},[418,497],{},[418,499],{},[433,501,502],{},[415,503,504,515],{},[438,505,506,507,514],{},"[ ",[508,509,513],"a",{"href":510,"rel":511},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[512],"nofollow","Fortran 2023 Interpretation Document"," ]",[438,516,517],{},"Section 16.9.53 and 16.9.199",[519,520],"hr",{},[42,522,523,530,531,530,537],{},[508,524,526],{"href":525},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[527,528],"img",{"src":529},"attachments\u002F629047316\u002F638779495.png"," ",[508,532,534],{"href":533},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[527,535],{"src":536},"attachments\u002F629047316\u002F638779496.png",[508,538,540],{"href":539},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[527,541],{"src":542},"attachments\u002F629047316\u002F638779497.png",[101,544,546],{"id":545},"attachments","Attachments:",[548,549,553],"div",{"className":550,"align":552},[551],"greybox","left",[42,554,555,530,558,561,562,565,530,567,561,570,572,530,574,561],{},[527,556],{"alt":128,"src":557},"images\u002Ficons\u002Fbullet_blue.gif",[508,559,560],{"href":529},"button_arrow_left.png"," (image\u002Fpng)",[563,564],"br",{},[527,566],{"alt":128,"src":557},[508,568,569],{"href":536},"button_arrow_up.png",[563,571],{},[527,573],{"alt":128,"src":557},[508,575,576],{"href":542},"button_arrow_right.png",[578,579,580],"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":128,"searchDepth":141,"depth":141,"links":582},[583,584,585,586,587,588,589],{"id":103,"depth":141,"text":104},{"id":195,"depth":141,"text":196},{"id":257,"depth":141,"text":104},{"id":334,"depth":141,"text":196},{"id":403,"depth":141,"text":404},{"id":488,"depth":141,"text":489},{"id":545,"depth":141,"text":546},"Programmers should use generic intrinsic procedure names and explicitly specify the kind argument for type conversion functions to prevent unintended precision loss.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp03-f",{"title":33,"description":590},"9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F4.typ03-f","3_AHRHkxswRDHvYV4HDuL0FxhUYMdZufYzgvaVFV2F0",[598,602],{"title":599,"path":600,"stem":601,"children":-1},"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":603,"path":604,"stem":605,"children":-1},"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",[607],{"title":608,"path":609,"stem":610,"children":611},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[612,615,637,651,677,687,691,701,705,709,713,717,735,753,757,775,787],{"title":613,"path":609,"stem":614},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":616,"path":617,"stem":618,"children":619},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[620,621,625,629,633],{"title":616,"path":617,"stem":618},{"title":622,"path":623,"stem":624},"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":626,"path":627,"stem":628},"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":630,"path":631,"stem":632},"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":634,"path":635,"stem":636},"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":638,"path":639,"stem":640,"children":641},"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",[642,643,647],{"title":638,"path":639,"stem":640},{"title":644,"path":645,"stem":646},"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":648,"path":649,"stem":650},"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":652,"path":653,"stem":654,"children":655},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[656,657,661,665,669,673],{"title":652,"path":653,"stem":654},{"title":658,"path":659,"stem":660},"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":662,"path":663,"stem":664},"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":666,"path":667,"stem":668},"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":670,"path":671,"stem":672},"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":674,"path":675,"stem":676},"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":678,"path":679,"stem":680,"children":681},"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",[682,683],{"title":678,"path":679,"stem":680},{"title":684,"path":685,"stem":686},"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":688,"path":689,"stem":690},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":692,"path":693,"stem":694,"children":695},"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",[696,697],{"title":692,"path":693,"stem":694},{"title":698,"path":699,"stem":700},"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":702,"path":703,"stem":704},"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":706,"path":707,"stem":708},"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":710,"path":711,"stem":712},"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":714,"path":715,"stem":716},"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":718,"path":719,"stem":720,"children":721},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[722,723,727,731],{"title":718,"path":719,"stem":720},{"title":724,"path":725,"stem":726},"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":728,"path":729,"stem":730},"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":732,"path":733,"stem":734},"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":736,"path":737,"stem":738,"children":739},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[740,741,745,749],{"title":736,"path":737,"stem":738},{"title":742,"path":743,"stem":744},"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":746,"path":747,"stem":748},"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":750,"path":751,"stem":752},"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":754,"path":755,"stem":756},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":758,"path":759,"stem":760,"children":761},"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",[762,763,767,771],{"title":758,"path":759,"stem":760},{"title":764,"path":765,"stem":766},"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":768,"path":769,"stem":770},"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":772,"path":773,"stem":774},"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":776,"path":777,"stem":778,"children":779},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[780,781,784,785,786],{"title":776,"path":777,"stem":778},{"title":782,"path":539,"stem":783},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":599,"path":600,"stem":601},{"title":33,"path":593,"stem":595},{"title":603,"path":604,"stem":605},{"title":788,"path":789,"stem":790},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320166964]