\hypertarget{interfacedc__test_1_1assertgreaterthan}{}\section{dc\+\_\+test\+:\+:assertgreaterthan Interface Reference}
\label{interfacedc__test_1_1assertgreaterthan}\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsection*{Private Member Functions}
\begin{DoxyCompactItemize}
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a3d1b676d667d18bf5f2df237453cddc2}{dctestassertgreaterthanint0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a85c6dd7c73450d7fd9a3adb692cf8c51}{dctestassertgreaterthanint1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a29a639704d70c5e3111179519d785bf0}{dctestassertgreaterthanint2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a42ff6cd6f5b0a8629bd16389bd6f378b}{dctestassertgreaterthanint3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a867d2980150ba0eed0d7b4afe05559a8}{dctestassertgreaterthanint4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a34b4bc8395835cbb59f9eacc43fe7b42}{dctestassertgreaterthanint5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a856a8de394a947d87063a27f068930a7}{dctestassertgreaterthanint6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_ab7868bb9ab57a71fe5c82b13e2f466bc}{dctestassertgreaterthanint7} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_aa5db8bd403922948e4707ebbdc5ed3a0}{dctestassertgreaterthanreal0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a8cf238a11b261ea9b5f8f336a8d73830}{dctestassertgreaterthanreal1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a0d4816ea184aede129e91fd1c3d21170}{dctestassertgreaterthanreal2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a2bd6382472a447d6886373c85cea750f}{dctestassertgreaterthanreal3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_af3a6a2eb12ebe8bfaada2c7e5858ead6}{dctestassertgreaterthanreal4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_acdef7c1be952f2cd986432b532df7d50}{dctestassertgreaterthanreal5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a6d2346ef375a443c63ac591e9261b1c0}{dctestassertgreaterthanreal6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a1d42a28d0e51ebb8e7fecdf6b0aa93c8}{dctestassertgreaterthanreal7} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a5881ffe655da540972941497fec67547}{dctestassertgreaterthandouble0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_abb21015b5d62836dbc24644dc4f69503}{dctestassertgreaterthandouble1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a4b25efc5b594c7dfc3c09f9578d2cee4}{dctestassertgreaterthandouble2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_adb9574c4fa5cdda4e2f825dedb0fa46e}{dctestassertgreaterthandouble3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a11fc6dd7ba5e572d6a97fdd80e7b7024}{dctestassertgreaterthandouble4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_ab9e36db7493c9ef33203558d55f057ca}{dctestassertgreaterthandouble5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_aa1d8cfb4e496de5da5225775afc4e829}{dctestassertgreaterthandouble6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertgreaterthan_a70c77b5dfd84b8376335e037fd602d5d}{dctestassertgreaterthandouble7} (message, answer, check, negative\+\_\+support)
\end{DoxyCompactItemize}


\subsection{Detailed Description}


Definition at line 419 of file dc\+\_\+test.\+f90.



\subsection{Member Function/\+Subroutine Documentation}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a5881ffe655da540972941497fec67547}\label{interfacedc__test_1_1assertgreaterthan_a5881ffe655da540972941497fec67547}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble0@{dctestassertgreaterthandouble0}}
\index{dctestassertgreaterthandouble0@{dctestassertgreaterthandouble0}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble0()}{dctestassertgreaterthandouble0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble0 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), intent(in)}]{answer,  }\item[{real(dp), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12146 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12146     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12147     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12148     \textcolor{keywordtype}{implicit none}
12149     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12150     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer
12151     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check
12152     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12153     \textcolor{keywordtype}{logical}:: err\_flag
12154     \textcolor{keywordtype}{logical}:: negative\_support\_on
12155     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12156     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12157     \textcolor{keywordtype}{real(DP)}:: wrong, right
12158 
12159                                         
12160 
12161   \textcolor{keywordflow}{continue}
12162     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12163       negative\_support\_on = negative\_support
12164     \textcolor{keywordflow}{else}
12165       negative\_support\_on = .true.
12166 \textcolor{keywordflow}{    end if}
12167 
12168     err\_flag = .false.
12169 
12170                     
12171     err\_flag = .not. answer < check
12172     abs\_mes = \textcolor{stringliteral}{''}
12173 
12174     \textcolor{keywordflow}{if} ( answer < 0.0\_dp &
12175       &  .and. check < 0.0\_dp &
12176       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
12177 
12178       err\_flag = .not. err\_flag
12179       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12180 \textcolor{keywordflow}{    end if}
12181 
12182     wrong = check
12183     right = answer
12184     pos\_str = \textcolor{stringliteral}{''}
12185 
12186                     
12187 
12188 
12189     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12190       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12191       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12192       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12193         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12194       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12195       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12196         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12197 
12198       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12199     \textcolor{keywordflow}{else}
12200       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12201 \textcolor{keywordflow}{    end if}
12202 
12203 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_abb21015b5d62836dbc24644dc4f69503}\label{interfacedc__test_1_1assertgreaterthan_abb21015b5d62836dbc24644dc4f69503}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble1@{dctestassertgreaterthandouble1}}
\index{dctestassertgreaterthandouble1@{dctestassertgreaterthandouble1}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble1()}{dctestassertgreaterthandouble1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble1 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12209 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12209     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12210     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12211     \textcolor{keywordtype}{implicit none}
12212     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12213     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:)
12214     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:)
12215     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12216     \textcolor{keywordtype}{logical}:: err\_flag
12217     \textcolor{keywordtype}{logical}:: negative\_support\_on
12218     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12219     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12220     \textcolor{keywordtype}{real(DP)}:: wrong, right
12221 
12222                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
12223     \textcolor{keywordtype}{logical}:: consist\_shape(1)
12224     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
12225     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
12226     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
12227     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
12228     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
12229     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
12230     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
12231                     
12232 
12233   \textcolor{keywordflow}{continue}
12234     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12235       negative\_support\_on = negative\_support
12236     \textcolor{keywordflow}{else}
12237       negative\_support\_on = .true.
12238 \textcolor{keywordflow}{    end if}
12239 
12240     err\_flag = .false.
12241 
12242                     
12243     answer\_shape = shape(answer)
12244     check\_shape = shape(check)
12245 
12246     consist\_shape = answer\_shape == check\_shape
12247 
12248     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
12249       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12250       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12251       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
12252       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
12253       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
12254 
12255       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12256 \textcolor{keywordflow}{    end if}
12257 
12258 
12259     \textcolor{keyword}{allocate}( mask\_array( &
12260                       
12261       &    answer\_shape(1)  )  &
12262       &  )
12263 
12264     \textcolor{keyword}{allocate}( judge( &
12265                       
12266       &    answer\_shape(1)  )  &
12267       &  )
12268 
12269     \textcolor{keyword}{allocate}( judge\_rev( &
12270                       
12271       &    answer\_shape(1)  )  &
12272       &  )
12273 
12274     \textcolor{keyword}{allocate}( answer\_negative( &
12275                       
12276       &    answer\_shape(1)  )  &
12277       &  )
12278 
12279     \textcolor{keyword}{allocate}( check\_negative( &
12280                       
12281       &    answer\_shape(1)  )  &
12282       &  )
12283 
12284     \textcolor{keyword}{allocate}( both\_negative( &
12285                       
12286       &    answer\_shape(1)  )  &
12287       &  )
12288 
12289     answer\_negative = answer < 0.0\_dp
12290     check\_negative = check < 0.0\_dp
12291     both\_negative = answer\_negative .and. check\_negative
12292     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
12293 
12294     judge = answer < check
12295     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
12296 
12297     judge\_rev = .not. judge
12298     err\_flag = any(judge\_rev)
12299     mask\_array = 1
12300     pos = maxloc(mask\_array, judge\_rev)
12301 
12302     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12303 
12304       wrong = check( &
12305                       
12306         &    pos(1)  )
12307 
12308       right = answer( &
12309                       
12310         &    pos(1)  )
12311 
12312                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
12313                       
12314 
12315       pos\_str = \textcolor{stringliteral}{'('} // &
12316                       
12317         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
12318 
12319       \textcolor{keywordflow}{if} ( both\_negative( &
12320                       
12321         &    pos(1)  )  ) \textcolor{keywordflow}{then}
12322 
12323         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12324       \textcolor{keywordflow}{else}
12325         abs\_mes = \textcolor{stringliteral}{''}
12326 
12327 \textcolor{keywordflow}{      end if}
12328 
12329 \textcolor{keywordflow}{    end if}
12330     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
12331     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
12332 
12333                     
12334 
12335 
12336     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12337       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12338       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12339       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12340         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12341       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12342       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12343         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12344 
12345       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12346     \textcolor{keywordflow}{else}
12347       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12348 \textcolor{keywordflow}{    end if}
12349 
12350 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a4b25efc5b594c7dfc3c09f9578d2cee4}\label{interfacedc__test_1_1assertgreaterthan_a4b25efc5b594c7dfc3c09f9578d2cee4}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble2@{dctestassertgreaterthandouble2}}
\index{dctestassertgreaterthandouble2@{dctestassertgreaterthandouble2}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble2()}{dctestassertgreaterthandouble2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble2 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12356 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12356     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12357     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12358     \textcolor{keywordtype}{implicit none}
12359     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12360     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
12361     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
12362     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12363     \textcolor{keywordtype}{logical}:: err\_flag
12364     \textcolor{keywordtype}{logical}:: negative\_support\_on
12365     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12366     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12367     \textcolor{keywordtype}{real(DP)}:: wrong, right
12368 
12369                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
12370     \textcolor{keywordtype}{logical}:: consist\_shape(2)
12371     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
12372     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
12373     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
12374     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
12375     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
12376     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
12377     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
12378                     
12379 
12380   \textcolor{keywordflow}{continue}
12381     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12382       negative\_support\_on = negative\_support
12383     \textcolor{keywordflow}{else}
12384       negative\_support\_on = .true.
12385 \textcolor{keywordflow}{    end if}
12386 
12387     err\_flag = .false.
12388 
12389                     
12390     answer\_shape = shape(answer)
12391     check\_shape = shape(check)
12392 
12393     consist\_shape = answer\_shape == check\_shape
12394 
12395     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
12396       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12397       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12398       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
12399       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
12400       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
12401 
12402       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12403 \textcolor{keywordflow}{    end if}
12404 
12405 
12406     \textcolor{keyword}{allocate}( mask\_array( &
12407                             &    answer\_shape(1), &
12408                       
12409       &    answer\_shape(2)  )  &
12410       &  )
12411 
12412     \textcolor{keyword}{allocate}( judge( &
12413                             &    answer\_shape(1), &
12414                       
12415       &    answer\_shape(2)  )  &
12416       &  )
12417 
12418     \textcolor{keyword}{allocate}( judge\_rev( &
12419                             &    answer\_shape(1), &
12420                       
12421       &    answer\_shape(2)  )  &
12422       &  )
12423 
12424     \textcolor{keyword}{allocate}( answer\_negative( &
12425                             &    answer\_shape(1), &
12426                       
12427       &    answer\_shape(2)  )  &
12428       &  )
12429 
12430     \textcolor{keyword}{allocate}( check\_negative( &
12431                             &    answer\_shape(1), &
12432                       
12433       &    answer\_shape(2)  )  &
12434       &  )
12435 
12436     \textcolor{keyword}{allocate}( both\_negative( &
12437                             &    answer\_shape(1), &
12438                       
12439       &    answer\_shape(2)  )  &
12440       &  )
12441 
12442     answer\_negative = answer < 0.0\_dp
12443     check\_negative = check < 0.0\_dp
12444     both\_negative = answer\_negative .and. check\_negative
12445     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
12446 
12447     judge = answer < check
12448     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
12449 
12450     judge\_rev = .not. judge
12451     err\_flag = any(judge\_rev)
12452     mask\_array = 1
12453     pos = maxloc(mask\_array, judge\_rev)
12454 
12455     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12456 
12457       wrong = check( &
12458                               &    pos(1), &
12459                       
12460         &    pos(2)  )
12461 
12462       right = answer( &
12463                               &    pos(1), &
12464                       
12465         &    pos(2)  )
12466 
12467                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
12468                       
12469       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
12470                       
12471 
12472       pos\_str = \textcolor{stringliteral}{'('} // &
12473                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
12474                       
12475         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
12476 
12477       \textcolor{keywordflow}{if} ( both\_negative( &
12478                               &    pos(1), &
12479                       
12480         &    pos(2)  )  ) \textcolor{keywordflow}{then}
12481 
12482         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12483       \textcolor{keywordflow}{else}
12484         abs\_mes = \textcolor{stringliteral}{''}
12485 
12486 \textcolor{keywordflow}{      end if}
12487 
12488 \textcolor{keywordflow}{    end if}
12489     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
12490     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
12491 
12492                     
12493 
12494 
12495     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12496       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12497       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12498       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12499         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12500       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12501       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12502         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12503 
12504       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12505     \textcolor{keywordflow}{else}
12506       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12507 \textcolor{keywordflow}{    end if}
12508 
12509 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_adb9574c4fa5cdda4e2f825dedb0fa46e}\label{interfacedc__test_1_1assertgreaterthan_adb9574c4fa5cdda4e2f825dedb0fa46e}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble3@{dctestassertgreaterthandouble3}}
\index{dctestassertgreaterthandouble3@{dctestassertgreaterthandouble3}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble3()}{dctestassertgreaterthandouble3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble3 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12515 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12515     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12516     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12517     \textcolor{keywordtype}{implicit none}
12518     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12519     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
12520     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
12521     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12522     \textcolor{keywordtype}{logical}:: err\_flag
12523     \textcolor{keywordtype}{logical}:: negative\_support\_on
12524     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12525     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12526     \textcolor{keywordtype}{real(DP)}:: wrong, right
12527 
12528                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
12529     \textcolor{keywordtype}{logical}:: consist\_shape(3)
12530     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
12531     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
12532     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
12533     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
12534     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
12535     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
12536     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
12537                     
12538 
12539   \textcolor{keywordflow}{continue}
12540     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12541       negative\_support\_on = negative\_support
12542     \textcolor{keywordflow}{else}
12543       negative\_support\_on = .true.
12544 \textcolor{keywordflow}{    end if}
12545 
12546     err\_flag = .false.
12547 
12548                     
12549     answer\_shape = shape(answer)
12550     check\_shape = shape(check)
12551 
12552     consist\_shape = answer\_shape == check\_shape
12553 
12554     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
12555       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12556       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12557       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
12558       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
12559       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
12560 
12561       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12562 \textcolor{keywordflow}{    end if}
12563 
12564 
12565     \textcolor{keyword}{allocate}( mask\_array( &
12566                             &    answer\_shape(1), &
12567                       
12568       &    answer\_shape(2), &
12569                       
12570       &    answer\_shape(3)  )  &
12571       &  )
12572 
12573     \textcolor{keyword}{allocate}( judge( &
12574                             &    answer\_shape(1), &
12575                       
12576       &    answer\_shape(2), &
12577                       
12578       &    answer\_shape(3)  )  &
12579       &  )
12580 
12581     \textcolor{keyword}{allocate}( judge\_rev( &
12582                             &    answer\_shape(1), &
12583                       
12584       &    answer\_shape(2), &
12585                       
12586       &    answer\_shape(3)  )  &
12587       &  )
12588 
12589     \textcolor{keyword}{allocate}( answer\_negative( &
12590                             &    answer\_shape(1), &
12591                       
12592       &    answer\_shape(2), &
12593                       
12594       &    answer\_shape(3)  )  &
12595       &  )
12596 
12597     \textcolor{keyword}{allocate}( check\_negative( &
12598                             &    answer\_shape(1), &
12599                       
12600       &    answer\_shape(2), &
12601                       
12602       &    answer\_shape(3)  )  &
12603       &  )
12604 
12605     \textcolor{keyword}{allocate}( both\_negative( &
12606                             &    answer\_shape(1), &
12607                       
12608       &    answer\_shape(2), &
12609                       
12610       &    answer\_shape(3)  )  &
12611       &  )
12612 
12613     answer\_negative = answer < 0.0\_dp
12614     check\_negative = check < 0.0\_dp
12615     both\_negative = answer\_negative .and. check\_negative
12616     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
12617 
12618     judge = answer < check
12619     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
12620 
12621     judge\_rev = .not. judge
12622     err\_flag = any(judge\_rev)
12623     mask\_array = 1
12624     pos = maxloc(mask\_array, judge\_rev)
12625 
12626     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12627 
12628       wrong = check( &
12629                               &    pos(1), &
12630                       
12631         &    pos(2), &
12632                       
12633         &    pos(3)  )
12634 
12635       right = answer( &
12636                               &    pos(1), &
12637                       
12638         &    pos(2), &
12639                       
12640         &    pos(3)  )
12641 
12642                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
12643                       
12644       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
12645                       
12646       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
12647                       
12648 
12649       pos\_str = \textcolor{stringliteral}{'('} // &
12650                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
12651                       
12652         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
12653                       
12654         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
12655 
12656       \textcolor{keywordflow}{if} ( both\_negative( &
12657                               &    pos(1), &
12658                       
12659         &    pos(2), &
12660                       
12661         &    pos(3)  )  ) \textcolor{keywordflow}{then}
12662 
12663         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12664       \textcolor{keywordflow}{else}
12665         abs\_mes = \textcolor{stringliteral}{''}
12666 
12667 \textcolor{keywordflow}{      end if}
12668 
12669 \textcolor{keywordflow}{    end if}
12670     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
12671     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
12672 
12673                     
12674 
12675 
12676     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12677       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12678       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12679       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12680         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12681       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12682       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12683         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12684 
12685       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12686     \textcolor{keywordflow}{else}
12687       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12688 \textcolor{keywordflow}{    end if}
12689 
12690 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a11fc6dd7ba5e572d6a97fdd80e7b7024}\label{interfacedc__test_1_1assertgreaterthan_a11fc6dd7ba5e572d6a97fdd80e7b7024}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble4@{dctestassertgreaterthandouble4}}
\index{dctestassertgreaterthandouble4@{dctestassertgreaterthandouble4}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble4()}{dctestassertgreaterthandouble4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble4 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12696 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12696     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12697     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12698     \textcolor{keywordtype}{implicit none}
12699     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12700     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
12701     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
12702     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12703     \textcolor{keywordtype}{logical}:: err\_flag
12704     \textcolor{keywordtype}{logical}:: negative\_support\_on
12705     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12706     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12707     \textcolor{keywordtype}{real(DP)}:: wrong, right
12708 
12709                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
12710     \textcolor{keywordtype}{logical}:: consist\_shape(4)
12711     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
12712     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
12713     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
12714     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
12715     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
12716     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
12717     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
12718                     
12719 
12720   \textcolor{keywordflow}{continue}
12721     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12722       negative\_support\_on = negative\_support
12723     \textcolor{keywordflow}{else}
12724       negative\_support\_on = .true.
12725 \textcolor{keywordflow}{    end if}
12726 
12727     err\_flag = .false.
12728 
12729                     
12730     answer\_shape = shape(answer)
12731     check\_shape = shape(check)
12732 
12733     consist\_shape = answer\_shape == check\_shape
12734 
12735     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
12736       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12737       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12738       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
12739       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
12740       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
12741 
12742       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12743 \textcolor{keywordflow}{    end if}
12744 
12745 
12746     \textcolor{keyword}{allocate}( mask\_array( &
12747                             &    answer\_shape(1), &
12748                       
12749       &    answer\_shape(2), &
12750                       
12751       &    answer\_shape(3), &
12752                       
12753       &    answer\_shape(4)  )  &
12754       &  )
12755 
12756     \textcolor{keyword}{allocate}( judge( &
12757                             &    answer\_shape(1), &
12758                       
12759       &    answer\_shape(2), &
12760                       
12761       &    answer\_shape(3), &
12762                       
12763       &    answer\_shape(4)  )  &
12764       &  )
12765 
12766     \textcolor{keyword}{allocate}( judge\_rev( &
12767                             &    answer\_shape(1), &
12768                       
12769       &    answer\_shape(2), &
12770                       
12771       &    answer\_shape(3), &
12772                       
12773       &    answer\_shape(4)  )  &
12774       &  )
12775 
12776     \textcolor{keyword}{allocate}( answer\_negative( &
12777                             &    answer\_shape(1), &
12778                       
12779       &    answer\_shape(2), &
12780                       
12781       &    answer\_shape(3), &
12782                       
12783       &    answer\_shape(4)  )  &
12784       &  )
12785 
12786     \textcolor{keyword}{allocate}( check\_negative( &
12787                             &    answer\_shape(1), &
12788                       
12789       &    answer\_shape(2), &
12790                       
12791       &    answer\_shape(3), &
12792                       
12793       &    answer\_shape(4)  )  &
12794       &  )
12795 
12796     \textcolor{keyword}{allocate}( both\_negative( &
12797                             &    answer\_shape(1), &
12798                       
12799       &    answer\_shape(2), &
12800                       
12801       &    answer\_shape(3), &
12802                       
12803       &    answer\_shape(4)  )  &
12804       &  )
12805 
12806     answer\_negative = answer < 0.0\_dp
12807     check\_negative = check < 0.0\_dp
12808     both\_negative = answer\_negative .and. check\_negative
12809     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
12810 
12811     judge = answer < check
12812     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
12813 
12814     judge\_rev = .not. judge
12815     err\_flag = any(judge\_rev)
12816     mask\_array = 1
12817     pos = maxloc(mask\_array, judge\_rev)
12818 
12819     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12820 
12821       wrong = check( &
12822                               &    pos(1), &
12823                       
12824         &    pos(2), &
12825                       
12826         &    pos(3), &
12827                       
12828         &    pos(4)  )
12829 
12830       right = answer( &
12831                               &    pos(1), &
12832                       
12833         &    pos(2), &
12834                       
12835         &    pos(3), &
12836                       
12837         &    pos(4)  )
12838 
12839                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
12840                       
12841       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
12842                       
12843       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
12844                       
12845       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
12846                       
12847 
12848       pos\_str = \textcolor{stringliteral}{'('} // &
12849                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
12850                       
12851         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
12852                       
12853         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
12854                       
12855         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
12856 
12857       \textcolor{keywordflow}{if} ( both\_negative( &
12858                               &    pos(1), &
12859                       
12860         &    pos(2), &
12861                       
12862         &    pos(3), &
12863                       
12864         &    pos(4)  )  ) \textcolor{keywordflow}{then}
12865 
12866         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12867       \textcolor{keywordflow}{else}
12868         abs\_mes = \textcolor{stringliteral}{''}
12869 
12870 \textcolor{keywordflow}{      end if}
12871 
12872 \textcolor{keywordflow}{    end if}
12873     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
12874     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
12875 
12876                     
12877 
12878 
12879     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12880       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12881       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12882       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12883         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12884       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12885       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12886         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12887 
12888       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12889     \textcolor{keywordflow}{else}
12890       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12891 \textcolor{keywordflow}{    end if}
12892 
12893 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_ab9e36db7493c9ef33203558d55f057ca}\label{interfacedc__test_1_1assertgreaterthan_ab9e36db7493c9ef33203558d55f057ca}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble5@{dctestassertgreaterthandouble5}}
\index{dctestassertgreaterthandouble5@{dctestassertgreaterthandouble5}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble5()}{dctestassertgreaterthandouble5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble5 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 12899 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
12899     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
12900     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
12901     \textcolor{keywordtype}{implicit none}
12902     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
12903     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
12904     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
12905     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
12906     \textcolor{keywordtype}{logical}:: err\_flag
12907     \textcolor{keywordtype}{logical}:: negative\_support\_on
12908     \textcolor{keywordtype}{character(STRING)}:: pos\_str
12909     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
12910     \textcolor{keywordtype}{real(DP)}:: wrong, right
12911 
12912                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
12913     \textcolor{keywordtype}{logical}:: consist\_shape(5)
12914     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
12915     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
12916     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
12917     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
12918     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
12919     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
12920     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
12921                     
12922 
12923   \textcolor{keywordflow}{continue}
12924     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
12925       negative\_support\_on = negative\_support
12926     \textcolor{keywordflow}{else}
12927       negative\_support\_on = .true.
12928 \textcolor{keywordflow}{    end if}
12929 
12930     err\_flag = .false.
12931 
12932                     
12933     answer\_shape = shape(answer)
12934     check\_shape = shape(check)
12935 
12936     consist\_shape = answer\_shape == check\_shape
12937 
12938     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
12939       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12940       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12941       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
12942       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
12943       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
12944 
12945       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12946 \textcolor{keywordflow}{    end if}
12947 
12948 
12949     \textcolor{keyword}{allocate}( mask\_array( &
12950                             &    answer\_shape(1), &
12951                       
12952       &    answer\_shape(2), &
12953                       
12954       &    answer\_shape(3), &
12955                       
12956       &    answer\_shape(4), &
12957                       
12958       &    answer\_shape(5)  )  &
12959       &  )
12960 
12961     \textcolor{keyword}{allocate}( judge( &
12962                             &    answer\_shape(1), &
12963                       
12964       &    answer\_shape(2), &
12965                       
12966       &    answer\_shape(3), &
12967                       
12968       &    answer\_shape(4), &
12969                       
12970       &    answer\_shape(5)  )  &
12971       &  )
12972 
12973     \textcolor{keyword}{allocate}( judge\_rev( &
12974                             &    answer\_shape(1), &
12975                       
12976       &    answer\_shape(2), &
12977                       
12978       &    answer\_shape(3), &
12979                       
12980       &    answer\_shape(4), &
12981                       
12982       &    answer\_shape(5)  )  &
12983       &  )
12984 
12985     \textcolor{keyword}{allocate}( answer\_negative( &
12986                             &    answer\_shape(1), &
12987                       
12988       &    answer\_shape(2), &
12989                       
12990       &    answer\_shape(3), &
12991                       
12992       &    answer\_shape(4), &
12993                       
12994       &    answer\_shape(5)  )  &
12995       &  )
12996 
12997     \textcolor{keyword}{allocate}( check\_negative( &
12998                             &    answer\_shape(1), &
12999                       
13000       &    answer\_shape(2), &
13001                       
13002       &    answer\_shape(3), &
13003                       
13004       &    answer\_shape(4), &
13005                       
13006       &    answer\_shape(5)  )  &
13007       &  )
13008 
13009     \textcolor{keyword}{allocate}( both\_negative( &
13010                             &    answer\_shape(1), &
13011                       
13012       &    answer\_shape(2), &
13013                       
13014       &    answer\_shape(3), &
13015                       
13016       &    answer\_shape(4), &
13017                       
13018       &    answer\_shape(5)  )  &
13019       &  )
13020 
13021     answer\_negative = answer < 0.0\_dp
13022     check\_negative = check < 0.0\_dp
13023     both\_negative = answer\_negative .and. check\_negative
13024     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
13025 
13026     judge = answer < check
13027     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
13028 
13029     judge\_rev = .not. judge
13030     err\_flag = any(judge\_rev)
13031     mask\_array = 1
13032     pos = maxloc(mask\_array, judge\_rev)
13033 
13034     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13035 
13036       wrong = check( &
13037                               &    pos(1), &
13038                       
13039         &    pos(2), &
13040                       
13041         &    pos(3), &
13042                       
13043         &    pos(4), &
13044                       
13045         &    pos(5)  )
13046 
13047       right = answer( &
13048                               &    pos(1), &
13049                       
13050         &    pos(2), &
13051                       
13052         &    pos(3), &
13053                       
13054         &    pos(4), &
13055                       
13056         &    pos(5)  )
13057 
13058                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
13059                       
13060       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
13061                       
13062       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
13063                       
13064       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
13065                       
13066       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
13067                       
13068 
13069       pos\_str = \textcolor{stringliteral}{'('} // &
13070                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
13071                       
13072         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
13073                       
13074         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
13075                       
13076         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
13077                       
13078         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
13079 
13080       \textcolor{keywordflow}{if} ( both\_negative( &
13081                               &    pos(1), &
13082                       
13083         &    pos(2), &
13084                       
13085         &    pos(3), &
13086                       
13087         &    pos(4), &
13088                       
13089         &    pos(5)  )  ) \textcolor{keywordflow}{then}
13090 
13091         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13092       \textcolor{keywordflow}{else}
13093         abs\_mes = \textcolor{stringliteral}{''}
13094 
13095 \textcolor{keywordflow}{      end if}
13096 
13097 \textcolor{keywordflow}{    end if}
13098     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
13099     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
13100 
13101                     
13102 
13103 
13104     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13105       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13106       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13107       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13108         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13109       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
13110       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13111         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13112 
13113       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13114     \textcolor{keywordflow}{else}
13115       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
13116 \textcolor{keywordflow}{    end if}
13117 
13118 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_aa1d8cfb4e496de5da5225775afc4e829}\label{interfacedc__test_1_1assertgreaterthan_aa1d8cfb4e496de5da5225775afc4e829}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble6@{dctestassertgreaterthandouble6}}
\index{dctestassertgreaterthandouble6@{dctestassertgreaterthandouble6}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble6()}{dctestassertgreaterthandouble6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble6 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 13124 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
13124     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
13125     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
13126     \textcolor{keywordtype}{implicit none}
13127     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
13128     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
13129     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
13130     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
13131     \textcolor{keywordtype}{logical}:: err\_flag
13132     \textcolor{keywordtype}{logical}:: negative\_support\_on
13133     \textcolor{keywordtype}{character(STRING)}:: pos\_str
13134     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
13135     \textcolor{keywordtype}{real(DP)}:: wrong, right
13136 
13137                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
13138     \textcolor{keywordtype}{logical}:: consist\_shape(6)
13139     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
13140     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
13141     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
13142     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
13143     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
13144     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
13145     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
13146                     
13147 
13148   \textcolor{keywordflow}{continue}
13149     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
13150       negative\_support\_on = negative\_support
13151     \textcolor{keywordflow}{else}
13152       negative\_support\_on = .true.
13153 \textcolor{keywordflow}{    end if}
13154 
13155     err\_flag = .false.
13156 
13157                     
13158     answer\_shape = shape(answer)
13159     check\_shape = shape(check)
13160 
13161     consist\_shape = answer\_shape == check\_shape
13162 
13163     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
13164       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13165       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13166       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
13167       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
13168       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
13169 
13170       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13171 \textcolor{keywordflow}{    end if}
13172 
13173 
13174     \textcolor{keyword}{allocate}( mask\_array( &
13175                             &    answer\_shape(1), &
13176                       
13177       &    answer\_shape(2), &
13178                       
13179       &    answer\_shape(3), &
13180                       
13181       &    answer\_shape(4), &
13182                       
13183       &    answer\_shape(5), &
13184                       
13185       &    answer\_shape(6)  )  &
13186       &  )
13187 
13188     \textcolor{keyword}{allocate}( judge( &
13189                             &    answer\_shape(1), &
13190                       
13191       &    answer\_shape(2), &
13192                       
13193       &    answer\_shape(3), &
13194                       
13195       &    answer\_shape(4), &
13196                       
13197       &    answer\_shape(5), &
13198                       
13199       &    answer\_shape(6)  )  &
13200       &  )
13201 
13202     \textcolor{keyword}{allocate}( judge\_rev( &
13203                             &    answer\_shape(1), &
13204                       
13205       &    answer\_shape(2), &
13206                       
13207       &    answer\_shape(3), &
13208                       
13209       &    answer\_shape(4), &
13210                       
13211       &    answer\_shape(5), &
13212                       
13213       &    answer\_shape(6)  )  &
13214       &  )
13215 
13216     \textcolor{keyword}{allocate}( answer\_negative( &
13217                             &    answer\_shape(1), &
13218                       
13219       &    answer\_shape(2), &
13220                       
13221       &    answer\_shape(3), &
13222                       
13223       &    answer\_shape(4), &
13224                       
13225       &    answer\_shape(5), &
13226                       
13227       &    answer\_shape(6)  )  &
13228       &  )
13229 
13230     \textcolor{keyword}{allocate}( check\_negative( &
13231                             &    answer\_shape(1), &
13232                       
13233       &    answer\_shape(2), &
13234                       
13235       &    answer\_shape(3), &
13236                       
13237       &    answer\_shape(4), &
13238                       
13239       &    answer\_shape(5), &
13240                       
13241       &    answer\_shape(6)  )  &
13242       &  )
13243 
13244     \textcolor{keyword}{allocate}( both\_negative( &
13245                             &    answer\_shape(1), &
13246                       
13247       &    answer\_shape(2), &
13248                       
13249       &    answer\_shape(3), &
13250                       
13251       &    answer\_shape(4), &
13252                       
13253       &    answer\_shape(5), &
13254                       
13255       &    answer\_shape(6)  )  &
13256       &  )
13257 
13258     answer\_negative = answer < 0.0\_dp
13259     check\_negative = check < 0.0\_dp
13260     both\_negative = answer\_negative .and. check\_negative
13261     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
13262 
13263     judge = answer < check
13264     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
13265 
13266     judge\_rev = .not. judge
13267     err\_flag = any(judge\_rev)
13268     mask\_array = 1
13269     pos = maxloc(mask\_array, judge\_rev)
13270 
13271     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13272 
13273       wrong = check( &
13274                               &    pos(1), &
13275                       
13276         &    pos(2), &
13277                       
13278         &    pos(3), &
13279                       
13280         &    pos(4), &
13281                       
13282         &    pos(5), &
13283                       
13284         &    pos(6)  )
13285 
13286       right = answer( &
13287                               &    pos(1), &
13288                       
13289         &    pos(2), &
13290                       
13291         &    pos(3), &
13292                       
13293         &    pos(4), &
13294                       
13295         &    pos(5), &
13296                       
13297         &    pos(6)  )
13298 
13299                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
13300                       
13301       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
13302                       
13303       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
13304                       
13305       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
13306                       
13307       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
13308                       
13309       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
13310                       
13311 
13312       pos\_str = \textcolor{stringliteral}{'('} // &
13313                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
13314                       
13315         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
13316                       
13317         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
13318                       
13319         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
13320                       
13321         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
13322                       
13323         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
13324 
13325       \textcolor{keywordflow}{if} ( both\_negative( &
13326                               &    pos(1), &
13327                       
13328         &    pos(2), &
13329                       
13330         &    pos(3), &
13331                       
13332         &    pos(4), &
13333                       
13334         &    pos(5), &
13335                       
13336         &    pos(6)  )  ) \textcolor{keywordflow}{then}
13337 
13338         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13339       \textcolor{keywordflow}{else}
13340         abs\_mes = \textcolor{stringliteral}{''}
13341 
13342 \textcolor{keywordflow}{      end if}
13343 
13344 \textcolor{keywordflow}{    end if}
13345     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
13346     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
13347 
13348                     
13349 
13350 
13351     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13352       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13353       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13354       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13355         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13356       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
13357       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13358         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13359 
13360       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13361     \textcolor{keywordflow}{else}
13362       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
13363 \textcolor{keywordflow}{    end if}
13364 
13365 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a70c77b5dfd84b8376335e037fd602d5d}\label{interfacedc__test_1_1assertgreaterthan_a70c77b5dfd84b8376335e037fd602d5d}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthandouble7@{dctestassertgreaterthandouble7}}
\index{dctestassertgreaterthandouble7@{dctestassertgreaterthandouble7}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthandouble7()}{dctestassertgreaterthandouble7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthandouble7 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real(dp), dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 13371 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
13371     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
13372     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
13373     \textcolor{keywordtype}{implicit none}
13374     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
13375     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
13376     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
13377     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
13378     \textcolor{keywordtype}{logical}:: err\_flag
13379     \textcolor{keywordtype}{logical}:: negative\_support\_on
13380     \textcolor{keywordtype}{character(STRING)}:: pos\_str
13381     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
13382     \textcolor{keywordtype}{real(DP)}:: wrong, right
13383 
13384                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
13385     \textcolor{keywordtype}{logical}:: consist\_shape(7)
13386     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
13387     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
13388     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
13389     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
13390     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
13391     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
13392     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
13393                     
13394 
13395   \textcolor{keywordflow}{continue}
13396     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
13397       negative\_support\_on = negative\_support
13398     \textcolor{keywordflow}{else}
13399       negative\_support\_on = .true.
13400 \textcolor{keywordflow}{    end if}
13401 
13402     err\_flag = .false.
13403 
13404                     
13405     answer\_shape = shape(answer)
13406     check\_shape = shape(check)
13407 
13408     consist\_shape = answer\_shape == check\_shape
13409 
13410     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
13411       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13412       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13413       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
13414       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
13415       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
13416 
13417       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13418 \textcolor{keywordflow}{    end if}
13419 
13420 
13421     \textcolor{keyword}{allocate}( mask\_array( &
13422                             &    answer\_shape(1), &
13423                       
13424       &    answer\_shape(2), &
13425                       
13426       &    answer\_shape(3), &
13427                       
13428       &    answer\_shape(4), &
13429                       
13430       &    answer\_shape(5), &
13431                       
13432       &    answer\_shape(6), &
13433                       
13434       &    answer\_shape(7)  )  &
13435       &  )
13436 
13437     \textcolor{keyword}{allocate}( judge( &
13438                             &    answer\_shape(1), &
13439                       
13440       &    answer\_shape(2), &
13441                       
13442       &    answer\_shape(3), &
13443                       
13444       &    answer\_shape(4), &
13445                       
13446       &    answer\_shape(5), &
13447                       
13448       &    answer\_shape(6), &
13449                       
13450       &    answer\_shape(7)  )  &
13451       &  )
13452 
13453     \textcolor{keyword}{allocate}( judge\_rev( &
13454                             &    answer\_shape(1), &
13455                       
13456       &    answer\_shape(2), &
13457                       
13458       &    answer\_shape(3), &
13459                       
13460       &    answer\_shape(4), &
13461                       
13462       &    answer\_shape(5), &
13463                       
13464       &    answer\_shape(6), &
13465                       
13466       &    answer\_shape(7)  )  &
13467       &  )
13468 
13469     \textcolor{keyword}{allocate}( answer\_negative( &
13470                             &    answer\_shape(1), &
13471                       
13472       &    answer\_shape(2), &
13473                       
13474       &    answer\_shape(3), &
13475                       
13476       &    answer\_shape(4), &
13477                       
13478       &    answer\_shape(5), &
13479                       
13480       &    answer\_shape(6), &
13481                       
13482       &    answer\_shape(7)  )  &
13483       &  )
13484 
13485     \textcolor{keyword}{allocate}( check\_negative( &
13486                             &    answer\_shape(1), &
13487                       
13488       &    answer\_shape(2), &
13489                       
13490       &    answer\_shape(3), &
13491                       
13492       &    answer\_shape(4), &
13493                       
13494       &    answer\_shape(5), &
13495                       
13496       &    answer\_shape(6), &
13497                       
13498       &    answer\_shape(7)  )  &
13499       &  )
13500 
13501     \textcolor{keyword}{allocate}( both\_negative( &
13502                             &    answer\_shape(1), &
13503                       
13504       &    answer\_shape(2), &
13505                       
13506       &    answer\_shape(3), &
13507                       
13508       &    answer\_shape(4), &
13509                       
13510       &    answer\_shape(5), &
13511                       
13512       &    answer\_shape(6), &
13513                       
13514       &    answer\_shape(7)  )  &
13515       &  )
13516 
13517     answer\_negative = answer < 0.0\_dp
13518     check\_negative = check < 0.0\_dp
13519     both\_negative = answer\_negative .and. check\_negative
13520     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
13521 
13522     judge = answer < check
13523     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
13524 
13525     judge\_rev = .not. judge
13526     err\_flag = any(judge\_rev)
13527     mask\_array = 1
13528     pos = maxloc(mask\_array, judge\_rev)
13529 
13530     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13531 
13532       wrong = check( &
13533                               &    pos(1), &
13534                       
13535         &    pos(2), &
13536                       
13537         &    pos(3), &
13538                       
13539         &    pos(4), &
13540                       
13541         &    pos(5), &
13542                       
13543         &    pos(6), &
13544                       
13545         &    pos(7)  )
13546 
13547       right = answer( &
13548                               &    pos(1), &
13549                       
13550         &    pos(2), &
13551                       
13552         &    pos(3), &
13553                       
13554         &    pos(4), &
13555                       
13556         &    pos(5), &
13557                       
13558         &    pos(6), &
13559                       
13560         &    pos(7)  )
13561 
13562                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
13563                       
13564       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
13565                       
13566       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
13567                       
13568       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
13569                       
13570       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
13571                       
13572       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
13573                       
13574       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
13575                       
13576 
13577       pos\_str = \textcolor{stringliteral}{'('} // &
13578                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
13579                       
13580         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
13581                       
13582         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
13583                       
13584         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
13585                       
13586         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
13587                       
13588         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
13589                       
13590         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
13591 
13592       \textcolor{keywordflow}{if} ( both\_negative( &
13593                               &    pos(1), &
13594                       
13595         &    pos(2), &
13596                       
13597         &    pos(3), &
13598                       
13599         &    pos(4), &
13600                       
13601         &    pos(5), &
13602                       
13603         &    pos(6), &
13604                       
13605         &    pos(7)  )  ) \textcolor{keywordflow}{then}
13606 
13607         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13608       \textcolor{keywordflow}{else}
13609         abs\_mes = \textcolor{stringliteral}{''}
13610 
13611 \textcolor{keywordflow}{      end if}
13612 
13613 \textcolor{keywordflow}{    end if}
13614     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
13615     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
13616 
13617                     
13618 
13619 
13620     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13621       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13622       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13623       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13624         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13625       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
13626       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13627         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13628 
13629       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13630     \textcolor{keywordflow}{else}
13631       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
13632 \textcolor{keywordflow}{    end if}
13633 
13634 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a3d1b676d667d18bf5f2df237453cddc2}\label{interfacedc__test_1_1assertgreaterthan_a3d1b676d667d18bf5f2df237453cddc2}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint0@{dctestassertgreaterthanint0}}
\index{dctestassertgreaterthanint0@{dctestassertgreaterthanint0}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint0()}{dctestassertgreaterthanint0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint0 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, intent(in)}]{answer,  }\item[{integer, intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9158 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9158     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9159     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9160     \textcolor{keywordtype}{implicit none}
9161     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9162     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer
9163     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check
9164     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9165     \textcolor{keywordtype}{logical}:: err\_flag
9166     \textcolor{keywordtype}{logical}:: negative\_support\_on
9167     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9168     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9169     \textcolor{keywordtype}{integer}:: wrong, right
9170 
9171                                         
9172 
9173   \textcolor{keywordflow}{continue}
9174     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9175       negative\_support\_on = negative\_support
9176     \textcolor{keywordflow}{else}
9177       negative\_support\_on = .true.
9178 \textcolor{keywordflow}{    end if}
9179 
9180     err\_flag = .false.
9181 
9182                     
9183     err\_flag = .not. answer < check
9184     abs\_mes = \textcolor{stringliteral}{''}
9185 
9186     \textcolor{keywordflow}{if} ( answer < 0 &
9187       &  .and. check < 0 &
9188       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
9189 
9190       err\_flag = .not. err\_flag
9191       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
9192 \textcolor{keywordflow}{    end if}
9193 
9194     wrong = check
9195     right = answer
9196     pos\_str = \textcolor{stringliteral}{''}
9197 
9198                     
9199 
9200 
9201     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9202       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9203       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9204       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9205         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
9206       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
9207       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9208         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
9209 
9210       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9211     \textcolor{keywordflow}{else}
9212       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
9213 \textcolor{keywordflow}{    end if}
9214 
9215 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a85c6dd7c73450d7fd9a3adb692cf8c51}\label{interfacedc__test_1_1assertgreaterthan_a85c6dd7c73450d7fd9a3adb692cf8c51}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint1@{dctestassertgreaterthanint1}}
\index{dctestassertgreaterthanint1@{dctestassertgreaterthanint1}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint1()}{dctestassertgreaterthanint1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint1 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9221 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9221     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9222     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9223     \textcolor{keywordtype}{implicit none}
9224     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9225     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:)
9226     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:)
9227     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9228     \textcolor{keywordtype}{logical}:: err\_flag
9229     \textcolor{keywordtype}{logical}:: negative\_support\_on
9230     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9231     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9232     \textcolor{keywordtype}{integer}:: wrong, right
9233 
9234                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
9235     \textcolor{keywordtype}{logical}:: consist\_shape(1)
9236     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
9237     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
9238     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
9239     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
9240     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
9241     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
9242     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
9243                     
9244 
9245   \textcolor{keywordflow}{continue}
9246     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9247       negative\_support\_on = negative\_support
9248     \textcolor{keywordflow}{else}
9249       negative\_support\_on = .true.
9250 \textcolor{keywordflow}{    end if}
9251 
9252     err\_flag = .false.
9253 
9254                     
9255     answer\_shape = shape(answer)
9256     check\_shape = shape(check)
9257 
9258     consist\_shape = answer\_shape == check\_shape
9259 
9260     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
9261       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9262       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9263       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
9264       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
9265       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
9266 
9267       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9268 \textcolor{keywordflow}{    end if}
9269 
9270 
9271     \textcolor{keyword}{allocate}( mask\_array( &
9272                       
9273       &    answer\_shape(1)  )  &
9274       &  )
9275 
9276     \textcolor{keyword}{allocate}( judge( &
9277                       
9278       &    answer\_shape(1)  )  &
9279       &  )
9280 
9281     \textcolor{keyword}{allocate}( judge\_rev( &
9282                       
9283       &    answer\_shape(1)  )  &
9284       &  )
9285 
9286     \textcolor{keyword}{allocate}( answer\_negative( &
9287                       
9288       &    answer\_shape(1)  )  &
9289       &  )
9290 
9291     \textcolor{keyword}{allocate}( check\_negative( &
9292                       
9293       &    answer\_shape(1)  )  &
9294       &  )
9295 
9296     \textcolor{keyword}{allocate}( both\_negative( &
9297                       
9298       &    answer\_shape(1)  )  &
9299       &  )
9300 
9301     answer\_negative = answer < 0
9302     check\_negative = check < 0
9303     both\_negative = answer\_negative .and. check\_negative
9304     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
9305 
9306     judge = answer < check
9307     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
9308 
9309     judge\_rev = .not. judge
9310     err\_flag = any(judge\_rev)
9311     mask\_array = 1
9312     pos = maxloc(mask\_array, judge\_rev)
9313 
9314     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9315 
9316       wrong = check( &
9317                       
9318         &    pos(1)  )
9319 
9320       right = answer( &
9321                       
9322         &    pos(1)  )
9323 
9324                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
9325                       
9326 
9327       pos\_str = \textcolor{stringliteral}{'('} // &
9328                       
9329         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
9330 
9331       \textcolor{keywordflow}{if} ( both\_negative( &
9332                       
9333         &    pos(1)  )  ) \textcolor{keywordflow}{then}
9334 
9335         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
9336       \textcolor{keywordflow}{else}
9337         abs\_mes = \textcolor{stringliteral}{''}
9338 
9339 \textcolor{keywordflow}{      end if}
9340 
9341 \textcolor{keywordflow}{    end if}
9342     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
9343     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
9344 
9345                     
9346 
9347 
9348     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9349       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9350       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9351       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9352         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
9353       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
9354       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9355         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
9356 
9357       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9358     \textcolor{keywordflow}{else}
9359       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
9360 \textcolor{keywordflow}{    end if}
9361 
9362 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a29a639704d70c5e3111179519d785bf0}\label{interfacedc__test_1_1assertgreaterthan_a29a639704d70c5e3111179519d785bf0}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint2@{dctestassertgreaterthanint2}}
\index{dctestassertgreaterthanint2@{dctestassertgreaterthanint2}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint2()}{dctestassertgreaterthanint2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint2 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9368 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9368     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9369     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9370     \textcolor{keywordtype}{implicit none}
9371     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9372     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
9373     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
9374     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9375     \textcolor{keywordtype}{logical}:: err\_flag
9376     \textcolor{keywordtype}{logical}:: negative\_support\_on
9377     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9378     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9379     \textcolor{keywordtype}{integer}:: wrong, right
9380 
9381                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
9382     \textcolor{keywordtype}{logical}:: consist\_shape(2)
9383     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
9384     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
9385     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
9386     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
9387     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
9388     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
9389     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
9390                     
9391 
9392   \textcolor{keywordflow}{continue}
9393     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9394       negative\_support\_on = negative\_support
9395     \textcolor{keywordflow}{else}
9396       negative\_support\_on = .true.
9397 \textcolor{keywordflow}{    end if}
9398 
9399     err\_flag = .false.
9400 
9401                     
9402     answer\_shape = shape(answer)
9403     check\_shape = shape(check)
9404 
9405     consist\_shape = answer\_shape == check\_shape
9406 
9407     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
9408       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9409       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9410       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
9411       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
9412       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
9413 
9414       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9415 \textcolor{keywordflow}{    end if}
9416 
9417 
9418     \textcolor{keyword}{allocate}( mask\_array( &
9419                             &    answer\_shape(1), &
9420                       
9421       &    answer\_shape(2)  )  &
9422       &  )
9423 
9424     \textcolor{keyword}{allocate}( judge( &
9425                             &    answer\_shape(1), &
9426                       
9427       &    answer\_shape(2)  )  &
9428       &  )
9429 
9430     \textcolor{keyword}{allocate}( judge\_rev( &
9431                             &    answer\_shape(1), &
9432                       
9433       &    answer\_shape(2)  )  &
9434       &  )
9435 
9436     \textcolor{keyword}{allocate}( answer\_negative( &
9437                             &    answer\_shape(1), &
9438                       
9439       &    answer\_shape(2)  )  &
9440       &  )
9441 
9442     \textcolor{keyword}{allocate}( check\_negative( &
9443                             &    answer\_shape(1), &
9444                       
9445       &    answer\_shape(2)  )  &
9446       &  )
9447 
9448     \textcolor{keyword}{allocate}( both\_negative( &
9449                             &    answer\_shape(1), &
9450                       
9451       &    answer\_shape(2)  )  &
9452       &  )
9453 
9454     answer\_negative = answer < 0
9455     check\_negative = check < 0
9456     both\_negative = answer\_negative .and. check\_negative
9457     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
9458 
9459     judge = answer < check
9460     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
9461 
9462     judge\_rev = .not. judge
9463     err\_flag = any(judge\_rev)
9464     mask\_array = 1
9465     pos = maxloc(mask\_array, judge\_rev)
9466 
9467     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9468 
9469       wrong = check( &
9470                               &    pos(1), &
9471                       
9472         &    pos(2)  )
9473 
9474       right = answer( &
9475                               &    pos(1), &
9476                       
9477         &    pos(2)  )
9478 
9479                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
9480                       
9481       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
9482                       
9483 
9484       pos\_str = \textcolor{stringliteral}{'('} // &
9485                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
9486                       
9487         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
9488 
9489       \textcolor{keywordflow}{if} ( both\_negative( &
9490                               &    pos(1), &
9491                       
9492         &    pos(2)  )  ) \textcolor{keywordflow}{then}
9493 
9494         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
9495       \textcolor{keywordflow}{else}
9496         abs\_mes = \textcolor{stringliteral}{''}
9497 
9498 \textcolor{keywordflow}{      end if}
9499 
9500 \textcolor{keywordflow}{    end if}
9501     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
9502     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
9503 
9504                     
9505 
9506 
9507     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9508       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9509       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9510       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9511         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
9512       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
9513       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9514         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
9515 
9516       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9517     \textcolor{keywordflow}{else}
9518       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
9519 \textcolor{keywordflow}{    end if}
9520 
9521 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a42ff6cd6f5b0a8629bd16389bd6f378b}\label{interfacedc__test_1_1assertgreaterthan_a42ff6cd6f5b0a8629bd16389bd6f378b}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint3@{dctestassertgreaterthanint3}}
\index{dctestassertgreaterthanint3@{dctestassertgreaterthanint3}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint3()}{dctestassertgreaterthanint3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint3 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9527 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9527     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9528     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9529     \textcolor{keywordtype}{implicit none}
9530     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9531     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
9532     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
9533     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9534     \textcolor{keywordtype}{logical}:: err\_flag
9535     \textcolor{keywordtype}{logical}:: negative\_support\_on
9536     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9537     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9538     \textcolor{keywordtype}{integer}:: wrong, right
9539 
9540                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
9541     \textcolor{keywordtype}{logical}:: consist\_shape(3)
9542     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
9543     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
9544     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
9545     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
9546     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
9547     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
9548     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
9549                     
9550 
9551   \textcolor{keywordflow}{continue}
9552     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9553       negative\_support\_on = negative\_support
9554     \textcolor{keywordflow}{else}
9555       negative\_support\_on = .true.
9556 \textcolor{keywordflow}{    end if}
9557 
9558     err\_flag = .false.
9559 
9560                     
9561     answer\_shape = shape(answer)
9562     check\_shape = shape(check)
9563 
9564     consist\_shape = answer\_shape == check\_shape
9565 
9566     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
9567       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9568       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9569       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
9570       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
9571       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
9572 
9573       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9574 \textcolor{keywordflow}{    end if}
9575 
9576 
9577     \textcolor{keyword}{allocate}( mask\_array( &
9578                             &    answer\_shape(1), &
9579                       
9580       &    answer\_shape(2), &
9581                       
9582       &    answer\_shape(3)  )  &
9583       &  )
9584 
9585     \textcolor{keyword}{allocate}( judge( &
9586                             &    answer\_shape(1), &
9587                       
9588       &    answer\_shape(2), &
9589                       
9590       &    answer\_shape(3)  )  &
9591       &  )
9592 
9593     \textcolor{keyword}{allocate}( judge\_rev( &
9594                             &    answer\_shape(1), &
9595                       
9596       &    answer\_shape(2), &
9597                       
9598       &    answer\_shape(3)  )  &
9599       &  )
9600 
9601     \textcolor{keyword}{allocate}( answer\_negative( &
9602                             &    answer\_shape(1), &
9603                       
9604       &    answer\_shape(2), &
9605                       
9606       &    answer\_shape(3)  )  &
9607       &  )
9608 
9609     \textcolor{keyword}{allocate}( check\_negative( &
9610                             &    answer\_shape(1), &
9611                       
9612       &    answer\_shape(2), &
9613                       
9614       &    answer\_shape(3)  )  &
9615       &  )
9616 
9617     \textcolor{keyword}{allocate}( both\_negative( &
9618                             &    answer\_shape(1), &
9619                       
9620       &    answer\_shape(2), &
9621                       
9622       &    answer\_shape(3)  )  &
9623       &  )
9624 
9625     answer\_negative = answer < 0
9626     check\_negative = check < 0
9627     both\_negative = answer\_negative .and. check\_negative
9628     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
9629 
9630     judge = answer < check
9631     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
9632 
9633     judge\_rev = .not. judge
9634     err\_flag = any(judge\_rev)
9635     mask\_array = 1
9636     pos = maxloc(mask\_array, judge\_rev)
9637 
9638     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9639 
9640       wrong = check( &
9641                               &    pos(1), &
9642                       
9643         &    pos(2), &
9644                       
9645         &    pos(3)  )
9646 
9647       right = answer( &
9648                               &    pos(1), &
9649                       
9650         &    pos(2), &
9651                       
9652         &    pos(3)  )
9653 
9654                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
9655                       
9656       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
9657                       
9658       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
9659                       
9660 
9661       pos\_str = \textcolor{stringliteral}{'('} // &
9662                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
9663                       
9664         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
9665                       
9666         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
9667 
9668       \textcolor{keywordflow}{if} ( both\_negative( &
9669                               &    pos(1), &
9670                       
9671         &    pos(2), &
9672                       
9673         &    pos(3)  )  ) \textcolor{keywordflow}{then}
9674 
9675         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
9676       \textcolor{keywordflow}{else}
9677         abs\_mes = \textcolor{stringliteral}{''}
9678 
9679 \textcolor{keywordflow}{      end if}
9680 
9681 \textcolor{keywordflow}{    end if}
9682     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
9683     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
9684 
9685                     
9686 
9687 
9688     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9689       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9690       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9691       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9692         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
9693       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
9694       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9695         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
9696 
9697       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9698     \textcolor{keywordflow}{else}
9699       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
9700 \textcolor{keywordflow}{    end if}
9701 
9702 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a867d2980150ba0eed0d7b4afe05559a8}\label{interfacedc__test_1_1assertgreaterthan_a867d2980150ba0eed0d7b4afe05559a8}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint4@{dctestassertgreaterthanint4}}
\index{dctestassertgreaterthanint4@{dctestassertgreaterthanint4}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint4()}{dctestassertgreaterthanint4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint4 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9708 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9708     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9709     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9710     \textcolor{keywordtype}{implicit none}
9711     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9712     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
9713     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
9714     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9715     \textcolor{keywordtype}{logical}:: err\_flag
9716     \textcolor{keywordtype}{logical}:: negative\_support\_on
9717     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9718     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9719     \textcolor{keywordtype}{integer}:: wrong, right
9720 
9721                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
9722     \textcolor{keywordtype}{logical}:: consist\_shape(4)
9723     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
9724     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
9725     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
9726     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
9727     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
9728     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
9729     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
9730                     
9731 
9732   \textcolor{keywordflow}{continue}
9733     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9734       negative\_support\_on = negative\_support
9735     \textcolor{keywordflow}{else}
9736       negative\_support\_on = .true.
9737 \textcolor{keywordflow}{    end if}
9738 
9739     err\_flag = .false.
9740 
9741                     
9742     answer\_shape = shape(answer)
9743     check\_shape = shape(check)
9744 
9745     consist\_shape = answer\_shape == check\_shape
9746 
9747     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
9748       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9749       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9750       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
9751       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
9752       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
9753 
9754       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9755 \textcolor{keywordflow}{    end if}
9756 
9757 
9758     \textcolor{keyword}{allocate}( mask\_array( &
9759                             &    answer\_shape(1), &
9760                       
9761       &    answer\_shape(2), &
9762                       
9763       &    answer\_shape(3), &
9764                       
9765       &    answer\_shape(4)  )  &
9766       &  )
9767 
9768     \textcolor{keyword}{allocate}( judge( &
9769                             &    answer\_shape(1), &
9770                       
9771       &    answer\_shape(2), &
9772                       
9773       &    answer\_shape(3), &
9774                       
9775       &    answer\_shape(4)  )  &
9776       &  )
9777 
9778     \textcolor{keyword}{allocate}( judge\_rev( &
9779                             &    answer\_shape(1), &
9780                       
9781       &    answer\_shape(2), &
9782                       
9783       &    answer\_shape(3), &
9784                       
9785       &    answer\_shape(4)  )  &
9786       &  )
9787 
9788     \textcolor{keyword}{allocate}( answer\_negative( &
9789                             &    answer\_shape(1), &
9790                       
9791       &    answer\_shape(2), &
9792                       
9793       &    answer\_shape(3), &
9794                       
9795       &    answer\_shape(4)  )  &
9796       &  )
9797 
9798     \textcolor{keyword}{allocate}( check\_negative( &
9799                             &    answer\_shape(1), &
9800                       
9801       &    answer\_shape(2), &
9802                       
9803       &    answer\_shape(3), &
9804                       
9805       &    answer\_shape(4)  )  &
9806       &  )
9807 
9808     \textcolor{keyword}{allocate}( both\_negative( &
9809                             &    answer\_shape(1), &
9810                       
9811       &    answer\_shape(2), &
9812                       
9813       &    answer\_shape(3), &
9814                       
9815       &    answer\_shape(4)  )  &
9816       &  )
9817 
9818     answer\_negative = answer < 0
9819     check\_negative = check < 0
9820     both\_negative = answer\_negative .and. check\_negative
9821     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
9822 
9823     judge = answer < check
9824     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
9825 
9826     judge\_rev = .not. judge
9827     err\_flag = any(judge\_rev)
9828     mask\_array = 1
9829     pos = maxloc(mask\_array, judge\_rev)
9830 
9831     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9832 
9833       wrong = check( &
9834                               &    pos(1), &
9835                       
9836         &    pos(2), &
9837                       
9838         &    pos(3), &
9839                       
9840         &    pos(4)  )
9841 
9842       right = answer( &
9843                               &    pos(1), &
9844                       
9845         &    pos(2), &
9846                       
9847         &    pos(3), &
9848                       
9849         &    pos(4)  )
9850 
9851                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
9852                       
9853       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
9854                       
9855       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
9856                       
9857       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
9858                       
9859 
9860       pos\_str = \textcolor{stringliteral}{'('} // &
9861                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
9862                       
9863         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
9864                       
9865         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
9866                       
9867         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
9868 
9869       \textcolor{keywordflow}{if} ( both\_negative( &
9870                               &    pos(1), &
9871                       
9872         &    pos(2), &
9873                       
9874         &    pos(3), &
9875                       
9876         &    pos(4)  )  ) \textcolor{keywordflow}{then}
9877 
9878         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
9879       \textcolor{keywordflow}{else}
9880         abs\_mes = \textcolor{stringliteral}{''}
9881 
9882 \textcolor{keywordflow}{      end if}
9883 
9884 \textcolor{keywordflow}{    end if}
9885     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
9886     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
9887 
9888                     
9889 
9890 
9891     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
9892       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9893       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9894       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9895         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
9896       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
9897       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
9898         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
9899 
9900       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9901     \textcolor{keywordflow}{else}
9902       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
9903 \textcolor{keywordflow}{    end if}
9904 
9905 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a34b4bc8395835cbb59f9eacc43fe7b42}\label{interfacedc__test_1_1assertgreaterthan_a34b4bc8395835cbb59f9eacc43fe7b42}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint5@{dctestassertgreaterthanint5}}
\index{dctestassertgreaterthanint5@{dctestassertgreaterthanint5}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint5()}{dctestassertgreaterthanint5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint5 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 9911 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
9911     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
9912     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
9913     \textcolor{keywordtype}{implicit none}
9914     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
9915     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
9916     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
9917     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
9918     \textcolor{keywordtype}{logical}:: err\_flag
9919     \textcolor{keywordtype}{logical}:: negative\_support\_on
9920     \textcolor{keywordtype}{character(STRING)}:: pos\_str
9921     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
9922     \textcolor{keywordtype}{integer}:: wrong, right
9923 
9924                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
9925     \textcolor{keywordtype}{logical}:: consist\_shape(5)
9926     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
9927     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
9928     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
9929     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
9930     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
9931     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
9932     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
9933                     
9934 
9935   \textcolor{keywordflow}{continue}
9936     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
9937       negative\_support\_on = negative\_support
9938     \textcolor{keywordflow}{else}
9939       negative\_support\_on = .true.
9940 \textcolor{keywordflow}{    end if}
9941 
9942     err\_flag = .false.
9943 
9944                     
9945     answer\_shape = shape(answer)
9946     check\_shape = shape(check)
9947 
9948     consist\_shape = answer\_shape == check\_shape
9949 
9950     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
9951       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
9952       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
9953       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
9954       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
9955       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
9956 
9957       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
9958 \textcolor{keywordflow}{    end if}
9959 
9960 
9961     \textcolor{keyword}{allocate}( mask\_array( &
9962                             &    answer\_shape(1), &
9963                       
9964       &    answer\_shape(2), &
9965                       
9966       &    answer\_shape(3), &
9967                       
9968       &    answer\_shape(4), &
9969                       
9970       &    answer\_shape(5)  )  &
9971       &  )
9972 
9973     \textcolor{keyword}{allocate}( judge( &
9974                             &    answer\_shape(1), &
9975                       
9976       &    answer\_shape(2), &
9977                       
9978       &    answer\_shape(3), &
9979                       
9980       &    answer\_shape(4), &
9981                       
9982       &    answer\_shape(5)  )  &
9983       &  )
9984 
9985     \textcolor{keyword}{allocate}( judge\_rev( &
9986                             &    answer\_shape(1), &
9987                       
9988       &    answer\_shape(2), &
9989                       
9990       &    answer\_shape(3), &
9991                       
9992       &    answer\_shape(4), &
9993                       
9994       &    answer\_shape(5)  )  &
9995       &  )
9996 
9997     \textcolor{keyword}{allocate}( answer\_negative( &
9998                             &    answer\_shape(1), &
9999                       
10000       &    answer\_shape(2), &
10001                       
10002       &    answer\_shape(3), &
10003                       
10004       &    answer\_shape(4), &
10005                       
10006       &    answer\_shape(5)  )  &
10007       &  )
10008 
10009     \textcolor{keyword}{allocate}( check\_negative( &
10010                             &    answer\_shape(1), &
10011                       
10012       &    answer\_shape(2), &
10013                       
10014       &    answer\_shape(3), &
10015                       
10016       &    answer\_shape(4), &
10017                       
10018       &    answer\_shape(5)  )  &
10019       &  )
10020 
10021     \textcolor{keyword}{allocate}( both\_negative( &
10022                             &    answer\_shape(1), &
10023                       
10024       &    answer\_shape(2), &
10025                       
10026       &    answer\_shape(3), &
10027                       
10028       &    answer\_shape(4), &
10029                       
10030       &    answer\_shape(5)  )  &
10031       &  )
10032 
10033     answer\_negative = answer < 0
10034     check\_negative = check < 0
10035     both\_negative = answer\_negative .and. check\_negative
10036     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
10037 
10038     judge = answer < check
10039     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
10040 
10041     judge\_rev = .not. judge
10042     err\_flag = any(judge\_rev)
10043     mask\_array = 1
10044     pos = maxloc(mask\_array, judge\_rev)
10045 
10046     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10047 
10048       wrong = check( &
10049                               &    pos(1), &
10050                       
10051         &    pos(2), &
10052                       
10053         &    pos(3), &
10054                       
10055         &    pos(4), &
10056                       
10057         &    pos(5)  )
10058 
10059       right = answer( &
10060                               &    pos(1), &
10061                       
10062         &    pos(2), &
10063                       
10064         &    pos(3), &
10065                       
10066         &    pos(4), &
10067                       
10068         &    pos(5)  )
10069 
10070                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
10071                       
10072       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
10073                       
10074       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
10075                       
10076       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
10077                       
10078       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
10079                       
10080 
10081       pos\_str = \textcolor{stringliteral}{'('} // &
10082                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
10083                       
10084         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
10085                       
10086         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
10087                       
10088         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
10089                       
10090         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
10091 
10092       \textcolor{keywordflow}{if} ( both\_negative( &
10093                               &    pos(1), &
10094                       
10095         &    pos(2), &
10096                       
10097         &    pos(3), &
10098                       
10099         &    pos(4), &
10100                       
10101         &    pos(5)  )  ) \textcolor{keywordflow}{then}
10102 
10103         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10104       \textcolor{keywordflow}{else}
10105         abs\_mes = \textcolor{stringliteral}{''}
10106 
10107 \textcolor{keywordflow}{      end if}
10108 
10109 \textcolor{keywordflow}{    end if}
10110     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
10111     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
10112 
10113                     
10114 
10115 
10116     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10117       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10118       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10119       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10120         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
10121       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
10122       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10123         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
10124 
10125       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10126     \textcolor{keywordflow}{else}
10127       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
10128 \textcolor{keywordflow}{    end if}
10129 
10130 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a856a8de394a947d87063a27f068930a7}\label{interfacedc__test_1_1assertgreaterthan_a856a8de394a947d87063a27f068930a7}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint6@{dctestassertgreaterthanint6}}
\index{dctestassertgreaterthanint6@{dctestassertgreaterthanint6}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint6()}{dctestassertgreaterthanint6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint6 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 10136 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
10136     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
10137     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
10138     \textcolor{keywordtype}{implicit none}
10139     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
10140     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
10141     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
10142     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
10143     \textcolor{keywordtype}{logical}:: err\_flag
10144     \textcolor{keywordtype}{logical}:: negative\_support\_on
10145     \textcolor{keywordtype}{character(STRING)}:: pos\_str
10146     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
10147     \textcolor{keywordtype}{integer}:: wrong, right
10148 
10149                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
10150     \textcolor{keywordtype}{logical}:: consist\_shape(6)
10151     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
10152     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
10153     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
10154     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
10155     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
10156     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
10157     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
10158                     
10159 
10160   \textcolor{keywordflow}{continue}
10161     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
10162       negative\_support\_on = negative\_support
10163     \textcolor{keywordflow}{else}
10164       negative\_support\_on = .true.
10165 \textcolor{keywordflow}{    end if}
10166 
10167     err\_flag = .false.
10168 
10169                     
10170     answer\_shape = shape(answer)
10171     check\_shape = shape(check)
10172 
10173     consist\_shape = answer\_shape == check\_shape
10174 
10175     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
10176       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10177       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10178       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
10179       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
10180       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
10181 
10182       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10183 \textcolor{keywordflow}{    end if}
10184 
10185 
10186     \textcolor{keyword}{allocate}( mask\_array( &
10187                             &    answer\_shape(1), &
10188                       
10189       &    answer\_shape(2), &
10190                       
10191       &    answer\_shape(3), &
10192                       
10193       &    answer\_shape(4), &
10194                       
10195       &    answer\_shape(5), &
10196                       
10197       &    answer\_shape(6)  )  &
10198       &  )
10199 
10200     \textcolor{keyword}{allocate}( judge( &
10201                             &    answer\_shape(1), &
10202                       
10203       &    answer\_shape(2), &
10204                       
10205       &    answer\_shape(3), &
10206                       
10207       &    answer\_shape(4), &
10208                       
10209       &    answer\_shape(5), &
10210                       
10211       &    answer\_shape(6)  )  &
10212       &  )
10213 
10214     \textcolor{keyword}{allocate}( judge\_rev( &
10215                             &    answer\_shape(1), &
10216                       
10217       &    answer\_shape(2), &
10218                       
10219       &    answer\_shape(3), &
10220                       
10221       &    answer\_shape(4), &
10222                       
10223       &    answer\_shape(5), &
10224                       
10225       &    answer\_shape(6)  )  &
10226       &  )
10227 
10228     \textcolor{keyword}{allocate}( answer\_negative( &
10229                             &    answer\_shape(1), &
10230                       
10231       &    answer\_shape(2), &
10232                       
10233       &    answer\_shape(3), &
10234                       
10235       &    answer\_shape(4), &
10236                       
10237       &    answer\_shape(5), &
10238                       
10239       &    answer\_shape(6)  )  &
10240       &  )
10241 
10242     \textcolor{keyword}{allocate}( check\_negative( &
10243                             &    answer\_shape(1), &
10244                       
10245       &    answer\_shape(2), &
10246                       
10247       &    answer\_shape(3), &
10248                       
10249       &    answer\_shape(4), &
10250                       
10251       &    answer\_shape(5), &
10252                       
10253       &    answer\_shape(6)  )  &
10254       &  )
10255 
10256     \textcolor{keyword}{allocate}( both\_negative( &
10257                             &    answer\_shape(1), &
10258                       
10259       &    answer\_shape(2), &
10260                       
10261       &    answer\_shape(3), &
10262                       
10263       &    answer\_shape(4), &
10264                       
10265       &    answer\_shape(5), &
10266                       
10267       &    answer\_shape(6)  )  &
10268       &  )
10269 
10270     answer\_negative = answer < 0
10271     check\_negative = check < 0
10272     both\_negative = answer\_negative .and. check\_negative
10273     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
10274 
10275     judge = answer < check
10276     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
10277 
10278     judge\_rev = .not. judge
10279     err\_flag = any(judge\_rev)
10280     mask\_array = 1
10281     pos = maxloc(mask\_array, judge\_rev)
10282 
10283     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10284 
10285       wrong = check( &
10286                               &    pos(1), &
10287                       
10288         &    pos(2), &
10289                       
10290         &    pos(3), &
10291                       
10292         &    pos(4), &
10293                       
10294         &    pos(5), &
10295                       
10296         &    pos(6)  )
10297 
10298       right = answer( &
10299                               &    pos(1), &
10300                       
10301         &    pos(2), &
10302                       
10303         &    pos(3), &
10304                       
10305         &    pos(4), &
10306                       
10307         &    pos(5), &
10308                       
10309         &    pos(6)  )
10310 
10311                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
10312                       
10313       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
10314                       
10315       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
10316                       
10317       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
10318                       
10319       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
10320                       
10321       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
10322                       
10323 
10324       pos\_str = \textcolor{stringliteral}{'('} // &
10325                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
10326                       
10327         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
10328                       
10329         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
10330                       
10331         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
10332                       
10333         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
10334                       
10335         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
10336 
10337       \textcolor{keywordflow}{if} ( both\_negative( &
10338                               &    pos(1), &
10339                       
10340         &    pos(2), &
10341                       
10342         &    pos(3), &
10343                       
10344         &    pos(4), &
10345                       
10346         &    pos(5), &
10347                       
10348         &    pos(6)  )  ) \textcolor{keywordflow}{then}
10349 
10350         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10351       \textcolor{keywordflow}{else}
10352         abs\_mes = \textcolor{stringliteral}{''}
10353 
10354 \textcolor{keywordflow}{      end if}
10355 
10356 \textcolor{keywordflow}{    end if}
10357     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
10358     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
10359 
10360                     
10361 
10362 
10363     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10364       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10365       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10366       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10367         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
10368       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
10369       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10370         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
10371 
10372       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10373     \textcolor{keywordflow}{else}
10374       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
10375 \textcolor{keywordflow}{    end if}
10376 
10377 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_ab7868bb9ab57a71fe5c82b13e2f466bc}\label{interfacedc__test_1_1assertgreaterthan_ab7868bb9ab57a71fe5c82b13e2f466bc}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanint7@{dctestassertgreaterthanint7}}
\index{dctestassertgreaterthanint7@{dctestassertgreaterthanint7}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanint7()}{dctestassertgreaterthanint7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanint7 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{integer, dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 10383 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
10383     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
10384     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
10385     \textcolor{keywordtype}{implicit none}
10386     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
10387     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
10388     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
10389     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
10390     \textcolor{keywordtype}{logical}:: err\_flag
10391     \textcolor{keywordtype}{logical}:: negative\_support\_on
10392     \textcolor{keywordtype}{character(STRING)}:: pos\_str
10393     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
10394     \textcolor{keywordtype}{integer}:: wrong, right
10395 
10396                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
10397     \textcolor{keywordtype}{logical}:: consist\_shape(7)
10398     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
10399     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
10400     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
10401     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
10402     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
10403     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
10404     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
10405                     
10406 
10407   \textcolor{keywordflow}{continue}
10408     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
10409       negative\_support\_on = negative\_support
10410     \textcolor{keywordflow}{else}
10411       negative\_support\_on = .true.
10412 \textcolor{keywordflow}{    end if}
10413 
10414     err\_flag = .false.
10415 
10416                     
10417     answer\_shape = shape(answer)
10418     check\_shape = shape(check)
10419 
10420     consist\_shape = answer\_shape == check\_shape
10421 
10422     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
10423       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10424       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10425       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
10426       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
10427       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
10428 
10429       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10430 \textcolor{keywordflow}{    end if}
10431 
10432 
10433     \textcolor{keyword}{allocate}( mask\_array( &
10434                             &    answer\_shape(1), &
10435                       
10436       &    answer\_shape(2), &
10437                       
10438       &    answer\_shape(3), &
10439                       
10440       &    answer\_shape(4), &
10441                       
10442       &    answer\_shape(5), &
10443                       
10444       &    answer\_shape(6), &
10445                       
10446       &    answer\_shape(7)  )  &
10447       &  )
10448 
10449     \textcolor{keyword}{allocate}( judge( &
10450                             &    answer\_shape(1), &
10451                       
10452       &    answer\_shape(2), &
10453                       
10454       &    answer\_shape(3), &
10455                       
10456       &    answer\_shape(4), &
10457                       
10458       &    answer\_shape(5), &
10459                       
10460       &    answer\_shape(6), &
10461                       
10462       &    answer\_shape(7)  )  &
10463       &  )
10464 
10465     \textcolor{keyword}{allocate}( judge\_rev( &
10466                             &    answer\_shape(1), &
10467                       
10468       &    answer\_shape(2), &
10469                       
10470       &    answer\_shape(3), &
10471                       
10472       &    answer\_shape(4), &
10473                       
10474       &    answer\_shape(5), &
10475                       
10476       &    answer\_shape(6), &
10477                       
10478       &    answer\_shape(7)  )  &
10479       &  )
10480 
10481     \textcolor{keyword}{allocate}( answer\_negative( &
10482                             &    answer\_shape(1), &
10483                       
10484       &    answer\_shape(2), &
10485                       
10486       &    answer\_shape(3), &
10487                       
10488       &    answer\_shape(4), &
10489                       
10490       &    answer\_shape(5), &
10491                       
10492       &    answer\_shape(6), &
10493                       
10494       &    answer\_shape(7)  )  &
10495       &  )
10496 
10497     \textcolor{keyword}{allocate}( check\_negative( &
10498                             &    answer\_shape(1), &
10499                       
10500       &    answer\_shape(2), &
10501                       
10502       &    answer\_shape(3), &
10503                       
10504       &    answer\_shape(4), &
10505                       
10506       &    answer\_shape(5), &
10507                       
10508       &    answer\_shape(6), &
10509                       
10510       &    answer\_shape(7)  )  &
10511       &  )
10512 
10513     \textcolor{keyword}{allocate}( both\_negative( &
10514                             &    answer\_shape(1), &
10515                       
10516       &    answer\_shape(2), &
10517                       
10518       &    answer\_shape(3), &
10519                       
10520       &    answer\_shape(4), &
10521                       
10522       &    answer\_shape(5), &
10523                       
10524       &    answer\_shape(6), &
10525                       
10526       &    answer\_shape(7)  )  &
10527       &  )
10528 
10529     answer\_negative = answer < 0
10530     check\_negative = check < 0
10531     both\_negative = answer\_negative .and. check\_negative
10532     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
10533 
10534     judge = answer < check
10535     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
10536 
10537     judge\_rev = .not. judge
10538     err\_flag = any(judge\_rev)
10539     mask\_array = 1
10540     pos = maxloc(mask\_array, judge\_rev)
10541 
10542     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10543 
10544       wrong = check( &
10545                               &    pos(1), &
10546                       
10547         &    pos(2), &
10548                       
10549         &    pos(3), &
10550                       
10551         &    pos(4), &
10552                       
10553         &    pos(5), &
10554                       
10555         &    pos(6), &
10556                       
10557         &    pos(7)  )
10558 
10559       right = answer( &
10560                               &    pos(1), &
10561                       
10562         &    pos(2), &
10563                       
10564         &    pos(3), &
10565                       
10566         &    pos(4), &
10567                       
10568         &    pos(5), &
10569                       
10570         &    pos(6), &
10571                       
10572         &    pos(7)  )
10573 
10574                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
10575                       
10576       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
10577                       
10578       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
10579                       
10580       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
10581                       
10582       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
10583                       
10584       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
10585                       
10586       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
10587                       
10588 
10589       pos\_str = \textcolor{stringliteral}{'('} // &
10590                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
10591                       
10592         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
10593                       
10594         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
10595                       
10596         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
10597                       
10598         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
10599                       
10600         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
10601                       
10602         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
10603 
10604       \textcolor{keywordflow}{if} ( both\_negative( &
10605                               &    pos(1), &
10606                       
10607         &    pos(2), &
10608                       
10609         &    pos(3), &
10610                       
10611         &    pos(4), &
10612                       
10613         &    pos(5), &
10614                       
10615         &    pos(6), &
10616                       
10617         &    pos(7)  )  ) \textcolor{keywordflow}{then}
10618 
10619         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10620       \textcolor{keywordflow}{else}
10621         abs\_mes = \textcolor{stringliteral}{''}
10622 
10623 \textcolor{keywordflow}{      end if}
10624 
10625 \textcolor{keywordflow}{    end if}
10626     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
10627     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
10628 
10629                     
10630 
10631 
10632     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10633       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10634       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10635       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10636         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
10637       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
10638       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10639         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
10640 
10641       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10642     \textcolor{keywordflow}{else}
10643       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
10644 \textcolor{keywordflow}{    end if}
10645 
10646 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_aa5db8bd403922948e4707ebbdc5ed3a0}\label{interfacedc__test_1_1assertgreaterthan_aa5db8bd403922948e4707ebbdc5ed3a0}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal0@{dctestassertgreaterthanreal0}}
\index{dctestassertgreaterthanreal0@{dctestassertgreaterthanreal0}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal0()}{dctestassertgreaterthanreal0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal0 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, intent(in)}]{answer,  }\item[{real, intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 10652 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
10652     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
10653     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
10654     \textcolor{keywordtype}{implicit none}
10655     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
10656     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer
10657     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check
10658     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
10659     \textcolor{keywordtype}{logical}:: err\_flag
10660     \textcolor{keywordtype}{logical}:: negative\_support\_on
10661     \textcolor{keywordtype}{character(STRING)}:: pos\_str
10662     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
10663     \textcolor{keywordtype}{real}:: wrong, right
10664 
10665                                         
10666 
10667   \textcolor{keywordflow}{continue}
10668     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
10669       negative\_support\_on = negative\_support
10670     \textcolor{keywordflow}{else}
10671       negative\_support\_on = .true.
10672 \textcolor{keywordflow}{    end if}
10673 
10674     err\_flag = .false.
10675 
10676                     
10677     err\_flag = .not. answer < check
10678     abs\_mes = \textcolor{stringliteral}{''}
10679 
10680     \textcolor{keywordflow}{if} ( answer < 0.0 &
10681       &  .and. check < 0.0 &
10682       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
10683 
10684       err\_flag = .not. err\_flag
10685       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10686 \textcolor{keywordflow}{    end if}
10687 
10688     wrong = check
10689     right = answer
10690     pos\_str = \textcolor{stringliteral}{''}
10691 
10692                     
10693 
10694 
10695     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10696       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10697       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10698       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10699         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
10700       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
10701       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10702         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
10703 
10704       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10705     \textcolor{keywordflow}{else}
10706       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
10707 \textcolor{keywordflow}{    end if}
10708 
10709 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a8cf238a11b261ea9b5f8f336a8d73830}\label{interfacedc__test_1_1assertgreaterthan_a8cf238a11b261ea9b5f8f336a8d73830}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal1@{dctestassertgreaterthanreal1}}
\index{dctestassertgreaterthanreal1@{dctestassertgreaterthanreal1}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal1()}{dctestassertgreaterthanreal1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal1 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 10715 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
10715     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
10716     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
10717     \textcolor{keywordtype}{implicit none}
10718     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
10719     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:)
10720     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:)
10721     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
10722     \textcolor{keywordtype}{logical}:: err\_flag
10723     \textcolor{keywordtype}{logical}:: negative\_support\_on
10724     \textcolor{keywordtype}{character(STRING)}:: pos\_str
10725     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
10726     \textcolor{keywordtype}{real}:: wrong, right
10727 
10728                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
10729     \textcolor{keywordtype}{logical}:: consist\_shape(1)
10730     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
10731     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
10732     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
10733     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
10734     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
10735     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
10736     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
10737                     
10738 
10739   \textcolor{keywordflow}{continue}
10740     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
10741       negative\_support\_on = negative\_support
10742     \textcolor{keywordflow}{else}
10743       negative\_support\_on = .true.
10744 \textcolor{keywordflow}{    end if}
10745 
10746     err\_flag = .false.
10747 
10748                     
10749     answer\_shape = shape(answer)
10750     check\_shape = shape(check)
10751 
10752     consist\_shape = answer\_shape == check\_shape
10753 
10754     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
10755       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10756       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10757       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
10758       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
10759       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
10760 
10761       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10762 \textcolor{keywordflow}{    end if}
10763 
10764 
10765     \textcolor{keyword}{allocate}( mask\_array( &
10766                       
10767       &    answer\_shape(1)  )  &
10768       &  )
10769 
10770     \textcolor{keyword}{allocate}( judge( &
10771                       
10772       &    answer\_shape(1)  )  &
10773       &  )
10774 
10775     \textcolor{keyword}{allocate}( judge\_rev( &
10776                       
10777       &    answer\_shape(1)  )  &
10778       &  )
10779 
10780     \textcolor{keyword}{allocate}( answer\_negative( &
10781                       
10782       &    answer\_shape(1)  )  &
10783       &  )
10784 
10785     \textcolor{keyword}{allocate}( check\_negative( &
10786                       
10787       &    answer\_shape(1)  )  &
10788       &  )
10789 
10790     \textcolor{keyword}{allocate}( both\_negative( &
10791                       
10792       &    answer\_shape(1)  )  &
10793       &  )
10794 
10795     answer\_negative = answer < 0.0
10796     check\_negative = check < 0.0
10797     both\_negative = answer\_negative .and. check\_negative
10798     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
10799 
10800     judge = answer < check
10801     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
10802 
10803     judge\_rev = .not. judge
10804     err\_flag = any(judge\_rev)
10805     mask\_array = 1
10806     pos = maxloc(mask\_array, judge\_rev)
10807 
10808     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10809 
10810       wrong = check( &
10811                       
10812         &    pos(1)  )
10813 
10814       right = answer( &
10815                       
10816         &    pos(1)  )
10817 
10818                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
10819                       
10820 
10821       pos\_str = \textcolor{stringliteral}{'('} // &
10822                       
10823         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
10824 
10825       \textcolor{keywordflow}{if} ( both\_negative( &
10826                       
10827         &    pos(1)  )  ) \textcolor{keywordflow}{then}
10828 
10829         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10830       \textcolor{keywordflow}{else}
10831         abs\_mes = \textcolor{stringliteral}{''}
10832 
10833 \textcolor{keywordflow}{      end if}
10834 
10835 \textcolor{keywordflow}{    end if}
10836     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
10837     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
10838 
10839                     
10840 
10841 
10842     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10843       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10844       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10845       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10846         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
10847       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
10848       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
10849         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
10850 
10851       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10852     \textcolor{keywordflow}{else}
10853       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
10854 \textcolor{keywordflow}{    end if}
10855 
10856 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a0d4816ea184aede129e91fd1c3d21170}\label{interfacedc__test_1_1assertgreaterthan_a0d4816ea184aede129e91fd1c3d21170}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal2@{dctestassertgreaterthanreal2}}
\index{dctestassertgreaterthanreal2@{dctestassertgreaterthanreal2}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal2()}{dctestassertgreaterthanreal2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal2 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 10862 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
10862     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
10863     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
10864     \textcolor{keywordtype}{implicit none}
10865     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
10866     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
10867     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
10868     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
10869     \textcolor{keywordtype}{logical}:: err\_flag
10870     \textcolor{keywordtype}{logical}:: negative\_support\_on
10871     \textcolor{keywordtype}{character(STRING)}:: pos\_str
10872     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
10873     \textcolor{keywordtype}{real}:: wrong, right
10874 
10875                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
10876     \textcolor{keywordtype}{logical}:: consist\_shape(2)
10877     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
10878     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
10879     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
10880     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
10881     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
10882     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
10883     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
10884                     
10885 
10886   \textcolor{keywordflow}{continue}
10887     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
10888       negative\_support\_on = negative\_support
10889     \textcolor{keywordflow}{else}
10890       negative\_support\_on = .true.
10891 \textcolor{keywordflow}{    end if}
10892 
10893     err\_flag = .false.
10894 
10895                     
10896     answer\_shape = shape(answer)
10897     check\_shape = shape(check)
10898 
10899     consist\_shape = answer\_shape == check\_shape
10900 
10901     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
10902       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
10903       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
10904       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
10905       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
10906       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
10907 
10908       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
10909 \textcolor{keywordflow}{    end if}
10910 
10911 
10912     \textcolor{keyword}{allocate}( mask\_array( &
10913                             &    answer\_shape(1), &
10914                       
10915       &    answer\_shape(2)  )  &
10916       &  )
10917 
10918     \textcolor{keyword}{allocate}( judge( &
10919                             &    answer\_shape(1), &
10920                       
10921       &    answer\_shape(2)  )  &
10922       &  )
10923 
10924     \textcolor{keyword}{allocate}( judge\_rev( &
10925                             &    answer\_shape(1), &
10926                       
10927       &    answer\_shape(2)  )  &
10928       &  )
10929 
10930     \textcolor{keyword}{allocate}( answer\_negative( &
10931                             &    answer\_shape(1), &
10932                       
10933       &    answer\_shape(2)  )  &
10934       &  )
10935 
10936     \textcolor{keyword}{allocate}( check\_negative( &
10937                             &    answer\_shape(1), &
10938                       
10939       &    answer\_shape(2)  )  &
10940       &  )
10941 
10942     \textcolor{keyword}{allocate}( both\_negative( &
10943                             &    answer\_shape(1), &
10944                       
10945       &    answer\_shape(2)  )  &
10946       &  )
10947 
10948     answer\_negative = answer < 0.0
10949     check\_negative = check < 0.0
10950     both\_negative = answer\_negative .and. check\_negative
10951     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
10952 
10953     judge = answer < check
10954     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
10955 
10956     judge\_rev = .not. judge
10957     err\_flag = any(judge\_rev)
10958     mask\_array = 1
10959     pos = maxloc(mask\_array, judge\_rev)
10960 
10961     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
10962 
10963       wrong = check( &
10964                               &    pos(1), &
10965                       
10966         &    pos(2)  )
10967 
10968       right = answer( &
10969                               &    pos(1), &
10970                       
10971         &    pos(2)  )
10972 
10973                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
10974                       
10975       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
10976                       
10977 
10978       pos\_str = \textcolor{stringliteral}{'('} // &
10979                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
10980                       
10981         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
10982 
10983       \textcolor{keywordflow}{if} ( both\_negative( &
10984                               &    pos(1), &
10985                       
10986         &    pos(2)  )  ) \textcolor{keywordflow}{then}
10987 
10988         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
10989       \textcolor{keywordflow}{else}
10990         abs\_mes = \textcolor{stringliteral}{''}
10991 
10992 \textcolor{keywordflow}{      end if}
10993 
10994 \textcolor{keywordflow}{    end if}
10995     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
10996     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
10997 
10998                     
10999 
11000 
11001     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11002       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11003       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11004       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11005         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
11006       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
11007       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11008         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
11009 
11010       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11011     \textcolor{keywordflow}{else}
11012       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
11013 \textcolor{keywordflow}{    end if}
11014 
11015 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a2bd6382472a447d6886373c85cea750f}\label{interfacedc__test_1_1assertgreaterthan_a2bd6382472a447d6886373c85cea750f}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal3@{dctestassertgreaterthanreal3}}
\index{dctestassertgreaterthanreal3@{dctestassertgreaterthanreal3}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal3()}{dctestassertgreaterthanreal3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal3 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 11021 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
11021     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
11022     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
11023     \textcolor{keywordtype}{implicit none}
11024     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
11025     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
11026     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
11027     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
11028     \textcolor{keywordtype}{logical}:: err\_flag
11029     \textcolor{keywordtype}{logical}:: negative\_support\_on
11030     \textcolor{keywordtype}{character(STRING)}:: pos\_str
11031     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
11032     \textcolor{keywordtype}{real}:: wrong, right
11033 
11034                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
11035     \textcolor{keywordtype}{logical}:: consist\_shape(3)
11036     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
11037     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
11038     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
11039     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
11040     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
11041     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
11042     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
11043                     
11044 
11045   \textcolor{keywordflow}{continue}
11046     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
11047       negative\_support\_on = negative\_support
11048     \textcolor{keywordflow}{else}
11049       negative\_support\_on = .true.
11050 \textcolor{keywordflow}{    end if}
11051 
11052     err\_flag = .false.
11053 
11054                     
11055     answer\_shape = shape(answer)
11056     check\_shape = shape(check)
11057 
11058     consist\_shape = answer\_shape == check\_shape
11059 
11060     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
11061       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11062       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11063       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
11064       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
11065       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
11066 
11067       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11068 \textcolor{keywordflow}{    end if}
11069 
11070 
11071     \textcolor{keyword}{allocate}( mask\_array( &
11072                             &    answer\_shape(1), &
11073                       
11074       &    answer\_shape(2), &
11075                       
11076       &    answer\_shape(3)  )  &
11077       &  )
11078 
11079     \textcolor{keyword}{allocate}( judge( &
11080                             &    answer\_shape(1), &
11081                       
11082       &    answer\_shape(2), &
11083                       
11084       &    answer\_shape(3)  )  &
11085       &  )
11086 
11087     \textcolor{keyword}{allocate}( judge\_rev( &
11088                             &    answer\_shape(1), &
11089                       
11090       &    answer\_shape(2), &
11091                       
11092       &    answer\_shape(3)  )  &
11093       &  )
11094 
11095     \textcolor{keyword}{allocate}( answer\_negative( &
11096                             &    answer\_shape(1), &
11097                       
11098       &    answer\_shape(2), &
11099                       
11100       &    answer\_shape(3)  )  &
11101       &  )
11102 
11103     \textcolor{keyword}{allocate}( check\_negative( &
11104                             &    answer\_shape(1), &
11105                       
11106       &    answer\_shape(2), &
11107                       
11108       &    answer\_shape(3)  )  &
11109       &  )
11110 
11111     \textcolor{keyword}{allocate}( both\_negative( &
11112                             &    answer\_shape(1), &
11113                       
11114       &    answer\_shape(2), &
11115                       
11116       &    answer\_shape(3)  )  &
11117       &  )
11118 
11119     answer\_negative = answer < 0.0
11120     check\_negative = check < 0.0
11121     both\_negative = answer\_negative .and. check\_negative
11122     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
11123 
11124     judge = answer < check
11125     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
11126 
11127     judge\_rev = .not. judge
11128     err\_flag = any(judge\_rev)
11129     mask\_array = 1
11130     pos = maxloc(mask\_array, judge\_rev)
11131 
11132     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11133 
11134       wrong = check( &
11135                               &    pos(1), &
11136                       
11137         &    pos(2), &
11138                       
11139         &    pos(3)  )
11140 
11141       right = answer( &
11142                               &    pos(1), &
11143                       
11144         &    pos(2), &
11145                       
11146         &    pos(3)  )
11147 
11148                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
11149                       
11150       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
11151                       
11152       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
11153                       
11154 
11155       pos\_str = \textcolor{stringliteral}{'('} // &
11156                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
11157                       
11158         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
11159                       
11160         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
11161 
11162       \textcolor{keywordflow}{if} ( both\_negative( &
11163                               &    pos(1), &
11164                       
11165         &    pos(2), &
11166                       
11167         &    pos(3)  )  ) \textcolor{keywordflow}{then}
11168 
11169         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
11170       \textcolor{keywordflow}{else}
11171         abs\_mes = \textcolor{stringliteral}{''}
11172 
11173 \textcolor{keywordflow}{      end if}
11174 
11175 \textcolor{keywordflow}{    end if}
11176     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
11177     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
11178 
11179                     
11180 
11181 
11182     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11183       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11184       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11185       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11186         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
11187       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
11188       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11189         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
11190 
11191       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11192     \textcolor{keywordflow}{else}
11193       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
11194 \textcolor{keywordflow}{    end if}
11195 
11196 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_af3a6a2eb12ebe8bfaada2c7e5858ead6}\label{interfacedc__test_1_1assertgreaterthan_af3a6a2eb12ebe8bfaada2c7e5858ead6}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal4@{dctestassertgreaterthanreal4}}
\index{dctestassertgreaterthanreal4@{dctestassertgreaterthanreal4}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal4()}{dctestassertgreaterthanreal4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal4 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 11202 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
11202     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
11203     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
11204     \textcolor{keywordtype}{implicit none}
11205     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
11206     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
11207     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
11208     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
11209     \textcolor{keywordtype}{logical}:: err\_flag
11210     \textcolor{keywordtype}{logical}:: negative\_support\_on
11211     \textcolor{keywordtype}{character(STRING)}:: pos\_str
11212     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
11213     \textcolor{keywordtype}{real}:: wrong, right
11214 
11215                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
11216     \textcolor{keywordtype}{logical}:: consist\_shape(4)
11217     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
11218     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
11219     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
11220     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
11221     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
11222     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
11223     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
11224                     
11225 
11226   \textcolor{keywordflow}{continue}
11227     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
11228       negative\_support\_on = negative\_support
11229     \textcolor{keywordflow}{else}
11230       negative\_support\_on = .true.
11231 \textcolor{keywordflow}{    end if}
11232 
11233     err\_flag = .false.
11234 
11235                     
11236     answer\_shape = shape(answer)
11237     check\_shape = shape(check)
11238 
11239     consist\_shape = answer\_shape == check\_shape
11240 
11241     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
11242       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11243       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11244       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
11245       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
11246       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
11247 
11248       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11249 \textcolor{keywordflow}{    end if}
11250 
11251 
11252     \textcolor{keyword}{allocate}( mask\_array( &
11253                             &    answer\_shape(1), &
11254                       
11255       &    answer\_shape(2), &
11256                       
11257       &    answer\_shape(3), &
11258                       
11259       &    answer\_shape(4)  )  &
11260       &  )
11261 
11262     \textcolor{keyword}{allocate}( judge( &
11263                             &    answer\_shape(1), &
11264                       
11265       &    answer\_shape(2), &
11266                       
11267       &    answer\_shape(3), &
11268                       
11269       &    answer\_shape(4)  )  &
11270       &  )
11271 
11272     \textcolor{keyword}{allocate}( judge\_rev( &
11273                             &    answer\_shape(1), &
11274                       
11275       &    answer\_shape(2), &
11276                       
11277       &    answer\_shape(3), &
11278                       
11279       &    answer\_shape(4)  )  &
11280       &  )
11281 
11282     \textcolor{keyword}{allocate}( answer\_negative( &
11283                             &    answer\_shape(1), &
11284                       
11285       &    answer\_shape(2), &
11286                       
11287       &    answer\_shape(3), &
11288                       
11289       &    answer\_shape(4)  )  &
11290       &  )
11291 
11292     \textcolor{keyword}{allocate}( check\_negative( &
11293                             &    answer\_shape(1), &
11294                       
11295       &    answer\_shape(2), &
11296                       
11297       &    answer\_shape(3), &
11298                       
11299       &    answer\_shape(4)  )  &
11300       &  )
11301 
11302     \textcolor{keyword}{allocate}( both\_negative( &
11303                             &    answer\_shape(1), &
11304                       
11305       &    answer\_shape(2), &
11306                       
11307       &    answer\_shape(3), &
11308                       
11309       &    answer\_shape(4)  )  &
11310       &  )
11311 
11312     answer\_negative = answer < 0.0
11313     check\_negative = check < 0.0
11314     both\_negative = answer\_negative .and. check\_negative
11315     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
11316 
11317     judge = answer < check
11318     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
11319 
11320     judge\_rev = .not. judge
11321     err\_flag = any(judge\_rev)
11322     mask\_array = 1
11323     pos = maxloc(mask\_array, judge\_rev)
11324 
11325     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11326 
11327       wrong = check( &
11328                               &    pos(1), &
11329                       
11330         &    pos(2), &
11331                       
11332         &    pos(3), &
11333                       
11334         &    pos(4)  )
11335 
11336       right = answer( &
11337                               &    pos(1), &
11338                       
11339         &    pos(2), &
11340                       
11341         &    pos(3), &
11342                       
11343         &    pos(4)  )
11344 
11345                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
11346                       
11347       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
11348                       
11349       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
11350                       
11351       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
11352                       
11353 
11354       pos\_str = \textcolor{stringliteral}{'('} // &
11355                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
11356                       
11357         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
11358                       
11359         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
11360                       
11361         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
11362 
11363       \textcolor{keywordflow}{if} ( both\_negative( &
11364                               &    pos(1), &
11365                       
11366         &    pos(2), &
11367                       
11368         &    pos(3), &
11369                       
11370         &    pos(4)  )  ) \textcolor{keywordflow}{then}
11371 
11372         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
11373       \textcolor{keywordflow}{else}
11374         abs\_mes = \textcolor{stringliteral}{''}
11375 
11376 \textcolor{keywordflow}{      end if}
11377 
11378 \textcolor{keywordflow}{    end if}
11379     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
11380     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
11381 
11382                     
11383 
11384 
11385     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11386       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11387       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11388       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11389         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
11390       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
11391       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11392         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
11393 
11394       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11395     \textcolor{keywordflow}{else}
11396       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
11397 \textcolor{keywordflow}{    end if}
11398 
11399 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_acdef7c1be952f2cd986432b532df7d50}\label{interfacedc__test_1_1assertgreaterthan_acdef7c1be952f2cd986432b532df7d50}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal5@{dctestassertgreaterthanreal5}}
\index{dctestassertgreaterthanreal5@{dctestassertgreaterthanreal5}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal5()}{dctestassertgreaterthanreal5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal5 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 11405 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
11405     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
11406     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
11407     \textcolor{keywordtype}{implicit none}
11408     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
11409     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
11410     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
11411     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
11412     \textcolor{keywordtype}{logical}:: err\_flag
11413     \textcolor{keywordtype}{logical}:: negative\_support\_on
11414     \textcolor{keywordtype}{character(STRING)}:: pos\_str
11415     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
11416     \textcolor{keywordtype}{real}:: wrong, right
11417 
11418                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
11419     \textcolor{keywordtype}{logical}:: consist\_shape(5)
11420     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
11421     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
11422     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
11423     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
11424     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
11425     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
11426     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
11427                     
11428 
11429   \textcolor{keywordflow}{continue}
11430     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
11431       negative\_support\_on = negative\_support
11432     \textcolor{keywordflow}{else}
11433       negative\_support\_on = .true.
11434 \textcolor{keywordflow}{    end if}
11435 
11436     err\_flag = .false.
11437 
11438                     
11439     answer\_shape = shape(answer)
11440     check\_shape = shape(check)
11441 
11442     consist\_shape = answer\_shape == check\_shape
11443 
11444     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
11445       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11446       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11447       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
11448       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
11449       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
11450 
11451       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11452 \textcolor{keywordflow}{    end if}
11453 
11454 
11455     \textcolor{keyword}{allocate}( mask\_array( &
11456                             &    answer\_shape(1), &
11457                       
11458       &    answer\_shape(2), &
11459                       
11460       &    answer\_shape(3), &
11461                       
11462       &    answer\_shape(4), &
11463                       
11464       &    answer\_shape(5)  )  &
11465       &  )
11466 
11467     \textcolor{keyword}{allocate}( judge( &
11468                             &    answer\_shape(1), &
11469                       
11470       &    answer\_shape(2), &
11471                       
11472       &    answer\_shape(3), &
11473                       
11474       &    answer\_shape(4), &
11475                       
11476       &    answer\_shape(5)  )  &
11477       &  )
11478 
11479     \textcolor{keyword}{allocate}( judge\_rev( &
11480                             &    answer\_shape(1), &
11481                       
11482       &    answer\_shape(2), &
11483                       
11484       &    answer\_shape(3), &
11485                       
11486       &    answer\_shape(4), &
11487                       
11488       &    answer\_shape(5)  )  &
11489       &  )
11490 
11491     \textcolor{keyword}{allocate}( answer\_negative( &
11492                             &    answer\_shape(1), &
11493                       
11494       &    answer\_shape(2), &
11495                       
11496       &    answer\_shape(3), &
11497                       
11498       &    answer\_shape(4), &
11499                       
11500       &    answer\_shape(5)  )  &
11501       &  )
11502 
11503     \textcolor{keyword}{allocate}( check\_negative( &
11504                             &    answer\_shape(1), &
11505                       
11506       &    answer\_shape(2), &
11507                       
11508       &    answer\_shape(3), &
11509                       
11510       &    answer\_shape(4), &
11511                       
11512       &    answer\_shape(5)  )  &
11513       &  )
11514 
11515     \textcolor{keyword}{allocate}( both\_negative( &
11516                             &    answer\_shape(1), &
11517                       
11518       &    answer\_shape(2), &
11519                       
11520       &    answer\_shape(3), &
11521                       
11522       &    answer\_shape(4), &
11523                       
11524       &    answer\_shape(5)  )  &
11525       &  )
11526 
11527     answer\_negative = answer < 0.0
11528     check\_negative = check < 0.0
11529     both\_negative = answer\_negative .and. check\_negative
11530     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
11531 
11532     judge = answer < check
11533     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
11534 
11535     judge\_rev = .not. judge
11536     err\_flag = any(judge\_rev)
11537     mask\_array = 1
11538     pos = maxloc(mask\_array, judge\_rev)
11539 
11540     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11541 
11542       wrong = check( &
11543                               &    pos(1), &
11544                       
11545         &    pos(2), &
11546                       
11547         &    pos(3), &
11548                       
11549         &    pos(4), &
11550                       
11551         &    pos(5)  )
11552 
11553       right = answer( &
11554                               &    pos(1), &
11555                       
11556         &    pos(2), &
11557                       
11558         &    pos(3), &
11559                       
11560         &    pos(4), &
11561                       
11562         &    pos(5)  )
11563 
11564                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
11565                       
11566       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
11567                       
11568       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
11569                       
11570       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
11571                       
11572       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
11573                       
11574 
11575       pos\_str = \textcolor{stringliteral}{'('} // &
11576                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
11577                       
11578         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
11579                       
11580         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
11581                       
11582         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
11583                       
11584         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
11585 
11586       \textcolor{keywordflow}{if} ( both\_negative( &
11587                               &    pos(1), &
11588                       
11589         &    pos(2), &
11590                       
11591         &    pos(3), &
11592                       
11593         &    pos(4), &
11594                       
11595         &    pos(5)  )  ) \textcolor{keywordflow}{then}
11596 
11597         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
11598       \textcolor{keywordflow}{else}
11599         abs\_mes = \textcolor{stringliteral}{''}
11600 
11601 \textcolor{keywordflow}{      end if}
11602 
11603 \textcolor{keywordflow}{    end if}
11604     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
11605     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
11606 
11607                     
11608 
11609 
11610     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11611       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11612       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11613       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11614         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
11615       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
11616       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11617         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
11618 
11619       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11620     \textcolor{keywordflow}{else}
11621       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
11622 \textcolor{keywordflow}{    end if}
11623 
11624 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a6d2346ef375a443c63ac591e9261b1c0}\label{interfacedc__test_1_1assertgreaterthan_a6d2346ef375a443c63ac591e9261b1c0}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal6@{dctestassertgreaterthanreal6}}
\index{dctestassertgreaterthanreal6@{dctestassertgreaterthanreal6}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal6()}{dctestassertgreaterthanreal6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal6 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 11630 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
11630     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
11631     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
11632     \textcolor{keywordtype}{implicit none}
11633     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
11634     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
11635     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
11636     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
11637     \textcolor{keywordtype}{logical}:: err\_flag
11638     \textcolor{keywordtype}{logical}:: negative\_support\_on
11639     \textcolor{keywordtype}{character(STRING)}:: pos\_str
11640     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
11641     \textcolor{keywordtype}{real}:: wrong, right
11642 
11643                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
11644     \textcolor{keywordtype}{logical}:: consist\_shape(6)
11645     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
11646     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
11647     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
11648     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
11649     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
11650     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
11651     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
11652                     
11653 
11654   \textcolor{keywordflow}{continue}
11655     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
11656       negative\_support\_on = negative\_support
11657     \textcolor{keywordflow}{else}
11658       negative\_support\_on = .true.
11659 \textcolor{keywordflow}{    end if}
11660 
11661     err\_flag = .false.
11662 
11663                     
11664     answer\_shape = shape(answer)
11665     check\_shape = shape(check)
11666 
11667     consist\_shape = answer\_shape == check\_shape
11668 
11669     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
11670       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11671       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11672       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
11673       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
11674       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
11675 
11676       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11677 \textcolor{keywordflow}{    end if}
11678 
11679 
11680     \textcolor{keyword}{allocate}( mask\_array( &
11681                             &    answer\_shape(1), &
11682                       
11683       &    answer\_shape(2), &
11684                       
11685       &    answer\_shape(3), &
11686                       
11687       &    answer\_shape(4), &
11688                       
11689       &    answer\_shape(5), &
11690                       
11691       &    answer\_shape(6)  )  &
11692       &  )
11693 
11694     \textcolor{keyword}{allocate}( judge( &
11695                             &    answer\_shape(1), &
11696                       
11697       &    answer\_shape(2), &
11698                       
11699       &    answer\_shape(3), &
11700                       
11701       &    answer\_shape(4), &
11702                       
11703       &    answer\_shape(5), &
11704                       
11705       &    answer\_shape(6)  )  &
11706       &  )
11707 
11708     \textcolor{keyword}{allocate}( judge\_rev( &
11709                             &    answer\_shape(1), &
11710                       
11711       &    answer\_shape(2), &
11712                       
11713       &    answer\_shape(3), &
11714                       
11715       &    answer\_shape(4), &
11716                       
11717       &    answer\_shape(5), &
11718                       
11719       &    answer\_shape(6)  )  &
11720       &  )
11721 
11722     \textcolor{keyword}{allocate}( answer\_negative( &
11723                             &    answer\_shape(1), &
11724                       
11725       &    answer\_shape(2), &
11726                       
11727       &    answer\_shape(3), &
11728                       
11729       &    answer\_shape(4), &
11730                       
11731       &    answer\_shape(5), &
11732                       
11733       &    answer\_shape(6)  )  &
11734       &  )
11735 
11736     \textcolor{keyword}{allocate}( check\_negative( &
11737                             &    answer\_shape(1), &
11738                       
11739       &    answer\_shape(2), &
11740                       
11741       &    answer\_shape(3), &
11742                       
11743       &    answer\_shape(4), &
11744                       
11745       &    answer\_shape(5), &
11746                       
11747       &    answer\_shape(6)  )  &
11748       &  )
11749 
11750     \textcolor{keyword}{allocate}( both\_negative( &
11751                             &    answer\_shape(1), &
11752                       
11753       &    answer\_shape(2), &
11754                       
11755       &    answer\_shape(3), &
11756                       
11757       &    answer\_shape(4), &
11758                       
11759       &    answer\_shape(5), &
11760                       
11761       &    answer\_shape(6)  )  &
11762       &  )
11763 
11764     answer\_negative = answer < 0.0
11765     check\_negative = check < 0.0
11766     both\_negative = answer\_negative .and. check\_negative
11767     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
11768 
11769     judge = answer < check
11770     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
11771 
11772     judge\_rev = .not. judge
11773     err\_flag = any(judge\_rev)
11774     mask\_array = 1
11775     pos = maxloc(mask\_array, judge\_rev)
11776 
11777     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11778 
11779       wrong = check( &
11780                               &    pos(1), &
11781                       
11782         &    pos(2), &
11783                       
11784         &    pos(3), &
11785                       
11786         &    pos(4), &
11787                       
11788         &    pos(5), &
11789                       
11790         &    pos(6)  )
11791 
11792       right = answer( &
11793                               &    pos(1), &
11794                       
11795         &    pos(2), &
11796                       
11797         &    pos(3), &
11798                       
11799         &    pos(4), &
11800                       
11801         &    pos(5), &
11802                       
11803         &    pos(6)  )
11804 
11805                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
11806                       
11807       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
11808                       
11809       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
11810                       
11811       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
11812                       
11813       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
11814                       
11815       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
11816                       
11817 
11818       pos\_str = \textcolor{stringliteral}{'('} // &
11819                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
11820                       
11821         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
11822                       
11823         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
11824                       
11825         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
11826                       
11827         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
11828                       
11829         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
11830 
11831       \textcolor{keywordflow}{if} ( both\_negative( &
11832                               &    pos(1), &
11833                       
11834         &    pos(2), &
11835                       
11836         &    pos(3), &
11837                       
11838         &    pos(4), &
11839                       
11840         &    pos(5), &
11841                       
11842         &    pos(6)  )  ) \textcolor{keywordflow}{then}
11843 
11844         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
11845       \textcolor{keywordflow}{else}
11846         abs\_mes = \textcolor{stringliteral}{''}
11847 
11848 \textcolor{keywordflow}{      end if}
11849 
11850 \textcolor{keywordflow}{    end if}
11851     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
11852     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
11853 
11854                     
11855 
11856 
11857     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
11858       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11859       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11860       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11861         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
11862       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
11863       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
11864         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
11865 
11866       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11867     \textcolor{keywordflow}{else}
11868       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
11869 \textcolor{keywordflow}{    end if}
11870 
11871 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertgreaterthan_a1d42a28d0e51ebb8e7fecdf6b0aa93c8}\label{interfacedc__test_1_1assertgreaterthan_a1d42a28d0e51ebb8e7fecdf6b0aa93c8}} 
\index{dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}!dctestassertgreaterthanreal7@{dctestassertgreaterthanreal7}}
\index{dctestassertgreaterthanreal7@{dctestassertgreaterthanreal7}!dc\+\_\+test\+::assertgreaterthan@{dc\+\_\+test\+::assertgreaterthan}}
\subsubsection{\texorpdfstring{dctestassertgreaterthanreal7()}{dctestassertgreaterthanreal7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertgreaterthan\+::dctestassertgreaterthanreal7 (\begin{DoxyParamCaption}\item[{character($\ast$), intent(in)}]{message,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{answer,  }\item[{real, dimension(\+:,\+:,\+:,\+:,\+:,\+:,\+:), intent(in)}]{check,  }\item[{logical, intent(in), optional}]{negative\+\_\+support }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



Definition at line 11877 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
11877     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
11878     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
11879     \textcolor{keywordtype}{implicit none}
11880     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
11881     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
11882     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
11883     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
11884     \textcolor{keywordtype}{logical}:: err\_flag
11885     \textcolor{keywordtype}{logical}:: negative\_support\_on
11886     \textcolor{keywordtype}{character(STRING)}:: pos\_str
11887     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
11888     \textcolor{keywordtype}{real}:: wrong, right
11889 
11890                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
11891     \textcolor{keywordtype}{logical}:: consist\_shape(7)
11892     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
11893     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
11894     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
11895     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
11896     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
11897     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
11898     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
11899                     
11900 
11901   \textcolor{keywordflow}{continue}
11902     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
11903       negative\_support\_on = negative\_support
11904     \textcolor{keywordflow}{else}
11905       negative\_support\_on = .true.
11906 \textcolor{keywordflow}{    end if}
11907 
11908     err\_flag = .false.
11909 
11910                     
11911     answer\_shape = shape(answer)
11912     check\_shape = shape(check)
11913 
11914     consist\_shape = answer\_shape == check\_shape
11915 
11916     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
11917       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
11918       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
11919       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
11920       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
11921       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
11922 
11923       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
11924 \textcolor{keywordflow}{    end if}
11925 
11926 
11927     \textcolor{keyword}{allocate}( mask\_array( &
11928                             &    answer\_shape(1), &
11929                       
11930       &    answer\_shape(2), &
11931                       
11932       &    answer\_shape(3), &
11933                       
11934       &    answer\_shape(4), &
11935                       
11936       &    answer\_shape(5), &
11937                       
11938       &    answer\_shape(6), &
11939                       
11940       &    answer\_shape(7)  )  &
11941       &  )
11942 
11943     \textcolor{keyword}{allocate}( judge( &
11944                             &    answer\_shape(1), &
11945                       
11946       &    answer\_shape(2), &
11947                       
11948       &    answer\_shape(3), &
11949                       
11950       &    answer\_shape(4), &
11951                       
11952       &    answer\_shape(5), &
11953                       
11954       &    answer\_shape(6), &
11955                       
11956       &    answer\_shape(7)  )  &
11957       &  )
11958 
11959     \textcolor{keyword}{allocate}( judge\_rev( &
11960                             &    answer\_shape(1), &
11961                       
11962       &    answer\_shape(2), &
11963                       
11964       &    answer\_shape(3), &
11965                       
11966       &    answer\_shape(4), &
11967                       
11968       &    answer\_shape(5), &
11969                       
11970       &    answer\_shape(6), &
11971                       
11972       &    answer\_shape(7)  )  &
11973       &  )
11974 
11975     \textcolor{keyword}{allocate}( answer\_negative( &
11976                             &    answer\_shape(1), &
11977                       
11978       &    answer\_shape(2), &
11979                       
11980       &    answer\_shape(3), &
11981                       
11982       &    answer\_shape(4), &
11983                       
11984       &    answer\_shape(5), &
11985                       
11986       &    answer\_shape(6), &
11987                       
11988       &    answer\_shape(7)  )  &
11989       &  )
11990 
11991     \textcolor{keyword}{allocate}( check\_negative( &
11992                             &    answer\_shape(1), &
11993                       
11994       &    answer\_shape(2), &
11995                       
11996       &    answer\_shape(3), &
11997                       
11998       &    answer\_shape(4), &
11999                       
12000       &    answer\_shape(5), &
12001                       
12002       &    answer\_shape(6), &
12003                       
12004       &    answer\_shape(7)  )  &
12005       &  )
12006 
12007     \textcolor{keyword}{allocate}( both\_negative( &
12008                             &    answer\_shape(1), &
12009                       
12010       &    answer\_shape(2), &
12011                       
12012       &    answer\_shape(3), &
12013                       
12014       &    answer\_shape(4), &
12015                       
12016       &    answer\_shape(5), &
12017                       
12018       &    answer\_shape(6), &
12019                       
12020       &    answer\_shape(7)  )  &
12021       &  )
12022 
12023     answer\_negative = answer < 0.0
12024     check\_negative = check < 0.0
12025     both\_negative = answer\_negative .and. check\_negative
12026     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
12027 
12028     judge = answer < check
12029     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
12030 
12031     judge\_rev = .not. judge
12032     err\_flag = any(judge\_rev)
12033     mask\_array = 1
12034     pos = maxloc(mask\_array, judge\_rev)
12035 
12036     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12037 
12038       wrong = check( &
12039                               &    pos(1), &
12040                       
12041         &    pos(2), &
12042                       
12043         &    pos(3), &
12044                       
12045         &    pos(4), &
12046                       
12047         &    pos(5), &
12048                       
12049         &    pos(6), &
12050                       
12051         &    pos(7)  )
12052 
12053       right = answer( &
12054                               &    pos(1), &
12055                       
12056         &    pos(2), &
12057                       
12058         &    pos(3), &
12059                       
12060         &    pos(4), &
12061                       
12062         &    pos(5), &
12063                       
12064         &    pos(6), &
12065                       
12066         &    pos(7)  )
12067 
12068                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
12069                       
12070       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
12071                       
12072       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
12073                       
12074       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
12075                       
12076       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
12077                       
12078       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
12079                       
12080       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
12081                       
12082 
12083       pos\_str = \textcolor{stringliteral}{'('} // &
12084                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
12085                       
12086         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
12087                       
12088         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
12089                       
12090         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
12091                       
12092         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
12093                       
12094         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
12095                       
12096         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
12097 
12098       \textcolor{keywordflow}{if} ( both\_negative( &
12099                               &    pos(1), &
12100                       
12101         &    pos(2), &
12102                       
12103         &    pos(3), &
12104                       
12105         &    pos(4), &
12106                       
12107         &    pos(5), &
12108                       
12109         &    pos(6), &
12110                       
12111         &    pos(7)  )  ) \textcolor{keywordflow}{then}
12112 
12113         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
12114       \textcolor{keywordflow}{else}
12115         abs\_mes = \textcolor{stringliteral}{''}
12116 
12117 \textcolor{keywordflow}{      end if}
12118 
12119 \textcolor{keywordflow}{    end if}
12120     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
12121     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
12122 
12123                     
12124 
12125 
12126     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
12127       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
12128       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
12129       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12130         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
12131       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT GREATER THAN'}
12132       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
12133         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
12134 
12135       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
12136     \textcolor{keywordflow}{else}
12137       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertGT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
12138 \textcolor{keywordflow}{    end if}
12139 
12140 
\end{DoxyCode}


The documentation for this interface was generated from the following file\+:\begin{DoxyCompactItemize}
\item 
dc\+\_\+utils/\hyperlink{dc__test_8f90}{dc\+\_\+test.\+f90}\end{DoxyCompactItemize}
