\hypertarget{interfacedc__test_1_1assertlessthan}{}\section{dc\+\_\+test\+:\+:assertlessthan Interface Reference}
\label{interfacedc__test_1_1assertlessthan}\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsection*{Private Member Functions}
\begin{DoxyCompactItemize}
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_ab76f704d907223e1bb4d61e23a7e258f}{dctestassertlessthanint0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_adfd66fdb4aa74fae4041fc6a266f783e}{dctestassertlessthanint1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_ae3fdfcfca9a7fb92019860f304ea4d50}{dctestassertlessthanint2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_af85d159c444c72f5900e9871a40e044a}{dctestassertlessthanint3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a02885d499f9b9eff71931da9bcd27075}{dctestassertlessthanint4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_aafdd46cc0163daffe7f1f827c204aa17}{dctestassertlessthanint5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a15ee372c39f1cfb6e89ec2da849b15f3}{dctestassertlessthanint6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a28e394c78a099c83f8b59aa85df81f9c}{dctestassertlessthanint7} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a5ecdb315f909c53421295eb4b4d041f5}{dctestassertlessthanreal0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_ae8efff2c6e06a7734d01e16c91a932b6}{dctestassertlessthanreal1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a2684338cf7d47baf4f08a0e2219a9b3a}{dctestassertlessthanreal2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a6e8bcff0d59f1ceb616158d3e1865db5}{dctestassertlessthanreal3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_acf1c4e3aba060ffba4093d17b72a4a8a}{dctestassertlessthanreal4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a9ad1d93294719fafaa64bb4a48bedc70}{dctestassertlessthanreal5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a3d0396421684d7c05414e601c6726078}{dctestassertlessthanreal6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a9604c13f01b2ebfa83c24e6af281b1de}{dctestassertlessthanreal7} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a9d9e206eea41e69c9dad3010ce226062}{dctestassertlessthandouble0} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a3d40d2696b5de44677da1f0aca072b43}{dctestassertlessthandouble1} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a66742ca30373bce5ae10e6deac9955f2}{dctestassertlessthandouble2} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a5340aca9b236c059f01d0bede65d4c02}{dctestassertlessthandouble3} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_ae6db6828458e0f8035cead6e908d2326}{dctestassertlessthandouble4} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a21089b24d8b8a919481304c8d470eb9d}{dctestassertlessthandouble5} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a1c7abaf25e854c5588a4cc8ceaa3b42c}{dctestassertlessthandouble6} (message, answer, check, negative\+\_\+support)
\item 
subroutine \hyperlink{interfacedc__test_1_1assertlessthan_a2993b3dfe9cb48702c5422d1a26f7aa4}{dctestassertlessthandouble7} (message, answer, check, negative\+\_\+support)
\end{DoxyCompactItemize}


\subsection{Detailed Description}


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



\subsection{Member Function/\+Subroutine Documentation}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a9d9e206eea41e69c9dad3010ce226062}\label{interfacedc__test_1_1assertlessthan_a9d9e206eea41e69c9dad3010ce226062}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble0@{dctestassertlessthandouble0}}
\index{dctestassertlessthandouble0@{dctestassertlessthandouble0}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble0()}{dctestassertlessthandouble0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble0 (\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 16632 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
16632     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
16633     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
16634     \textcolor{keywordtype}{implicit none}
16635     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
16636     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer
16637     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check
16638     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
16639     \textcolor{keywordtype}{logical}:: err\_flag
16640     \textcolor{keywordtype}{logical}:: negative\_support\_on
16641     \textcolor{keywordtype}{character(STRING)}:: pos\_str
16642     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
16643     \textcolor{keywordtype}{real(DP)}:: wrong, right
16644 
16645                                         
16646 
16647   \textcolor{keywordflow}{continue}
16648     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
16649       negative\_support\_on = negative\_support
16650     \textcolor{keywordflow}{else}
16651       negative\_support\_on = .true.
16652 \textcolor{keywordflow}{    end if}
16653 
16654     err\_flag = .false.
16655 
16656                     
16657 
16658 
16659     err\_flag = .not. answer > check
16660     abs\_mes = \textcolor{stringliteral}{''}
16661 
16662     \textcolor{keywordflow}{if} ( answer < 0.0\_dp &
16663       &  .and. check < 0.0\_dp &
16664       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
16665 
16666       err\_flag = .not. err\_flag
16667       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16668 \textcolor{keywordflow}{    end if}
16669 
16670     wrong = check
16671     right = answer
16672     pos\_str = \textcolor{stringliteral}{''}
16673 
16674                     
16675 
16676 
16677     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16678       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16679       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16680       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16681         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16682       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16683       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16684         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16685 
16686       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16687     \textcolor{keywordflow}{else}
16688       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16689 \textcolor{keywordflow}{    end if}
16690 
16691 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a3d40d2696b5de44677da1f0aca072b43}\label{interfacedc__test_1_1assertlessthan_a3d40d2696b5de44677da1f0aca072b43}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble1@{dctestassertlessthandouble1}}
\index{dctestassertlessthandouble1@{dctestassertlessthandouble1}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble1()}{dctestassertlessthandouble1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble1 (\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 16697 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
16697     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
16698     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
16699     \textcolor{keywordtype}{implicit none}
16700     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
16701     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:)
16702     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:)
16703     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
16704     \textcolor{keywordtype}{logical}:: err\_flag
16705     \textcolor{keywordtype}{logical}:: negative\_support\_on
16706     \textcolor{keywordtype}{character(STRING)}:: pos\_str
16707     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
16708     \textcolor{keywordtype}{real(DP)}:: wrong, right
16709 
16710                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
16711     \textcolor{keywordtype}{logical}:: consist\_shape(1)
16712     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
16713     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
16714     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
16715     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
16716     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
16717     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
16718     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
16719                     
16720 
16721   \textcolor{keywordflow}{continue}
16722     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
16723       negative\_support\_on = negative\_support
16724     \textcolor{keywordflow}{else}
16725       negative\_support\_on = .true.
16726 \textcolor{keywordflow}{    end if}
16727 
16728     err\_flag = .false.
16729 
16730                     
16731     answer\_shape = shape(answer)
16732     check\_shape = shape(check)
16733 
16734     consist\_shape = answer\_shape == check\_shape
16735 
16736     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
16737       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16738       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16739       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
16740       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
16741       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
16742 
16743       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16744 \textcolor{keywordflow}{    end if}
16745 
16746 
16747     \textcolor{keyword}{allocate}( mask\_array( &
16748                       
16749       &    answer\_shape(1)  )  &
16750       &  )
16751 
16752     \textcolor{keyword}{allocate}( judge( &
16753                       
16754       &    answer\_shape(1)  )  &
16755       &  )
16756 
16757     \textcolor{keyword}{allocate}( judge\_rev( &
16758                       
16759       &    answer\_shape(1)  )  &
16760       &  )
16761 
16762     \textcolor{keyword}{allocate}( answer\_negative( &
16763                       
16764       &    answer\_shape(1)  )  &
16765       &  )
16766 
16767     \textcolor{keyword}{allocate}( check\_negative( &
16768                       
16769       &    answer\_shape(1)  )  &
16770       &  )
16771 
16772     \textcolor{keyword}{allocate}( both\_negative( &
16773                       
16774       &    answer\_shape(1)  )  &
16775       &  )
16776 
16777     answer\_negative = answer < 0.0\_dp
16778     check\_negative = check < 0.0\_dp
16779     both\_negative = answer\_negative .and. check\_negative
16780     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
16781 
16782     judge = answer > check
16783     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
16784 
16785     judge\_rev = .not. judge
16786     err\_flag = any(judge\_rev)
16787     mask\_array = 1
16788     pos = maxloc(mask\_array, judge\_rev)
16789 
16790     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16791 
16792       wrong = check( &
16793                       
16794         &    pos(1)  )
16795 
16796       right = answer( &
16797                       
16798         &    pos(1)  )
16799 
16800                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
16801                       
16802 
16803       pos\_str = \textcolor{stringliteral}{'('} // &
16804                       
16805         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
16806 
16807       \textcolor{keywordflow}{if} ( both\_negative( &
16808                       
16809         &    pos(1)  )  ) \textcolor{keywordflow}{then}
16810 
16811         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16812       \textcolor{keywordflow}{else}
16813         abs\_mes = \textcolor{stringliteral}{''}
16814 
16815 \textcolor{keywordflow}{      end if}
16816 
16817 \textcolor{keywordflow}{    end if}
16818     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
16819     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
16820 
16821                     
16822 
16823 
16824     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16825       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16826       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16827       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16828         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16829       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16830       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16831         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16832 
16833       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16834     \textcolor{keywordflow}{else}
16835       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16836 \textcolor{keywordflow}{    end if}
16837 
16838 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a66742ca30373bce5ae10e6deac9955f2}\label{interfacedc__test_1_1assertlessthan_a66742ca30373bce5ae10e6deac9955f2}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble2@{dctestassertlessthandouble2}}
\index{dctestassertlessthandouble2@{dctestassertlessthandouble2}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble2()}{dctestassertlessthandouble2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble2 (\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 16844 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
16844     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
16845     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
16846     \textcolor{keywordtype}{implicit none}
16847     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
16848     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
16849     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
16850     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
16851     \textcolor{keywordtype}{logical}:: err\_flag
16852     \textcolor{keywordtype}{logical}:: negative\_support\_on
16853     \textcolor{keywordtype}{character(STRING)}:: pos\_str
16854     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
16855     \textcolor{keywordtype}{real(DP)}:: wrong, right
16856 
16857                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
16858     \textcolor{keywordtype}{logical}:: consist\_shape(2)
16859     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
16860     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
16861     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
16862     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
16863     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
16864     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
16865     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
16866                     
16867 
16868   \textcolor{keywordflow}{continue}
16869     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
16870       negative\_support\_on = negative\_support
16871     \textcolor{keywordflow}{else}
16872       negative\_support\_on = .true.
16873 \textcolor{keywordflow}{    end if}
16874 
16875     err\_flag = .false.
16876 
16877                     
16878     answer\_shape = shape(answer)
16879     check\_shape = shape(check)
16880 
16881     consist\_shape = answer\_shape == check\_shape
16882 
16883     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
16884       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16885       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16886       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
16887       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
16888       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
16889 
16890       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16891 \textcolor{keywordflow}{    end if}
16892 
16893 
16894     \textcolor{keyword}{allocate}( mask\_array( &
16895                             &    answer\_shape(1), &
16896                       
16897       &    answer\_shape(2)  )  &
16898       &  )
16899 
16900     \textcolor{keyword}{allocate}( judge( &
16901                             &    answer\_shape(1), &
16902                       
16903       &    answer\_shape(2)  )  &
16904       &  )
16905 
16906     \textcolor{keyword}{allocate}( judge\_rev( &
16907                             &    answer\_shape(1), &
16908                       
16909       &    answer\_shape(2)  )  &
16910       &  )
16911 
16912     \textcolor{keyword}{allocate}( answer\_negative( &
16913                             &    answer\_shape(1), &
16914                       
16915       &    answer\_shape(2)  )  &
16916       &  )
16917 
16918     \textcolor{keyword}{allocate}( check\_negative( &
16919                             &    answer\_shape(1), &
16920                       
16921       &    answer\_shape(2)  )  &
16922       &  )
16923 
16924     \textcolor{keyword}{allocate}( both\_negative( &
16925                             &    answer\_shape(1), &
16926                       
16927       &    answer\_shape(2)  )  &
16928       &  )
16929 
16930     answer\_negative = answer < 0.0\_dp
16931     check\_negative = check < 0.0\_dp
16932     both\_negative = answer\_negative .and. check\_negative
16933     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
16934 
16935     judge = answer > check
16936     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
16937 
16938     judge\_rev = .not. judge
16939     err\_flag = any(judge\_rev)
16940     mask\_array = 1
16941     pos = maxloc(mask\_array, judge\_rev)
16942 
16943     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16944 
16945       wrong = check( &
16946                               &    pos(1), &
16947                       
16948         &    pos(2)  )
16949 
16950       right = answer( &
16951                               &    pos(1), &
16952                       
16953         &    pos(2)  )
16954 
16955                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
16956                       
16957       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
16958                       
16959 
16960       pos\_str = \textcolor{stringliteral}{'('} // &
16961                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
16962                       
16963         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
16964 
16965       \textcolor{keywordflow}{if} ( both\_negative( &
16966                               &    pos(1), &
16967                       
16968         &    pos(2)  )  ) \textcolor{keywordflow}{then}
16969 
16970         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16971       \textcolor{keywordflow}{else}
16972         abs\_mes = \textcolor{stringliteral}{''}
16973 
16974 \textcolor{keywordflow}{      end if}
16975 
16976 \textcolor{keywordflow}{    end if}
16977     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
16978     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
16979 
16980                     
16981 
16982 
16983     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16984       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16985       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16986       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16987         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16988       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16989       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16990         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16991 
16992       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16993     \textcolor{keywordflow}{else}
16994       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16995 \textcolor{keywordflow}{    end if}
16996 
16997 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a5340aca9b236c059f01d0bede65d4c02}\label{interfacedc__test_1_1assertlessthan_a5340aca9b236c059f01d0bede65d4c02}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble3@{dctestassertlessthandouble3}}
\index{dctestassertlessthandouble3@{dctestassertlessthandouble3}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble3()}{dctestassertlessthandouble3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble3 (\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 17003 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
17003     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
17004     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
17005     \textcolor{keywordtype}{implicit none}
17006     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
17007     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
17008     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
17009     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
17010     \textcolor{keywordtype}{logical}:: err\_flag
17011     \textcolor{keywordtype}{logical}:: negative\_support\_on
17012     \textcolor{keywordtype}{character(STRING)}:: pos\_str
17013     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
17014     \textcolor{keywordtype}{real(DP)}:: wrong, right
17015 
17016                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
17017     \textcolor{keywordtype}{logical}:: consist\_shape(3)
17018     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
17019     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
17020     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
17021     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
17022     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
17023     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
17024     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
17025                     
17026 
17027   \textcolor{keywordflow}{continue}
17028     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
17029       negative\_support\_on = negative\_support
17030     \textcolor{keywordflow}{else}
17031       negative\_support\_on = .true.
17032 \textcolor{keywordflow}{    end if}
17033 
17034     err\_flag = .false.
17035 
17036                     
17037     answer\_shape = shape(answer)
17038     check\_shape = shape(check)
17039 
17040     consist\_shape = answer\_shape == check\_shape
17041 
17042     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
17043       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17044       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17045       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
17046       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
17047       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
17048 
17049       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17050 \textcolor{keywordflow}{    end if}
17051 
17052 
17053     \textcolor{keyword}{allocate}( mask\_array( &
17054                             &    answer\_shape(1), &
17055                       
17056       &    answer\_shape(2), &
17057                       
17058       &    answer\_shape(3)  )  &
17059       &  )
17060 
17061     \textcolor{keyword}{allocate}( judge( &
17062                             &    answer\_shape(1), &
17063                       
17064       &    answer\_shape(2), &
17065                       
17066       &    answer\_shape(3)  )  &
17067       &  )
17068 
17069     \textcolor{keyword}{allocate}( judge\_rev( &
17070                             &    answer\_shape(1), &
17071                       
17072       &    answer\_shape(2), &
17073                       
17074       &    answer\_shape(3)  )  &
17075       &  )
17076 
17077     \textcolor{keyword}{allocate}( answer\_negative( &
17078                             &    answer\_shape(1), &
17079                       
17080       &    answer\_shape(2), &
17081                       
17082       &    answer\_shape(3)  )  &
17083       &  )
17084 
17085     \textcolor{keyword}{allocate}( check\_negative( &
17086                             &    answer\_shape(1), &
17087                       
17088       &    answer\_shape(2), &
17089                       
17090       &    answer\_shape(3)  )  &
17091       &  )
17092 
17093     \textcolor{keyword}{allocate}( both\_negative( &
17094                             &    answer\_shape(1), &
17095                       
17096       &    answer\_shape(2), &
17097                       
17098       &    answer\_shape(3)  )  &
17099       &  )
17100 
17101     answer\_negative = answer < 0.0\_dp
17102     check\_negative = check < 0.0\_dp
17103     both\_negative = answer\_negative .and. check\_negative
17104     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
17105 
17106     judge = answer > check
17107     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
17108 
17109     judge\_rev = .not. judge
17110     err\_flag = any(judge\_rev)
17111     mask\_array = 1
17112     pos = maxloc(mask\_array, judge\_rev)
17113 
17114     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17115 
17116       wrong = check( &
17117                               &    pos(1), &
17118                       
17119         &    pos(2), &
17120                       
17121         &    pos(3)  )
17122 
17123       right = answer( &
17124                               &    pos(1), &
17125                       
17126         &    pos(2), &
17127                       
17128         &    pos(3)  )
17129 
17130                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
17131                       
17132       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
17133                       
17134       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
17135                       
17136 
17137       pos\_str = \textcolor{stringliteral}{'('} // &
17138                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
17139                       
17140         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
17141                       
17142         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
17143 
17144       \textcolor{keywordflow}{if} ( both\_negative( &
17145                               &    pos(1), &
17146                       
17147         &    pos(2), &
17148                       
17149         &    pos(3)  )  ) \textcolor{keywordflow}{then}
17150 
17151         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
17152       \textcolor{keywordflow}{else}
17153         abs\_mes = \textcolor{stringliteral}{''}
17154 
17155 \textcolor{keywordflow}{      end if}
17156 
17157 \textcolor{keywordflow}{    end if}
17158     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
17159     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
17160 
17161                     
17162 
17163 
17164     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17165       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17166       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17167       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17168         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
17169       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
17170       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17171         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
17172 
17173       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17174     \textcolor{keywordflow}{else}
17175       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
17176 \textcolor{keywordflow}{    end if}
17177 
17178 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_ae6db6828458e0f8035cead6e908d2326}\label{interfacedc__test_1_1assertlessthan_ae6db6828458e0f8035cead6e908d2326}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble4@{dctestassertlessthandouble4}}
\index{dctestassertlessthandouble4@{dctestassertlessthandouble4}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble4()}{dctestassertlessthandouble4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble4 (\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 17184 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
17184     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
17185     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
17186     \textcolor{keywordtype}{implicit none}
17187     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
17188     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
17189     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
17190     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
17191     \textcolor{keywordtype}{logical}:: err\_flag
17192     \textcolor{keywordtype}{logical}:: negative\_support\_on
17193     \textcolor{keywordtype}{character(STRING)}:: pos\_str
17194     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
17195     \textcolor{keywordtype}{real(DP)}:: wrong, right
17196 
17197                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
17198     \textcolor{keywordtype}{logical}:: consist\_shape(4)
17199     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
17200     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
17201     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
17202     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
17203     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
17204     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
17205     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
17206                     
17207 
17208   \textcolor{keywordflow}{continue}
17209     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
17210       negative\_support\_on = negative\_support
17211     \textcolor{keywordflow}{else}
17212       negative\_support\_on = .true.
17213 \textcolor{keywordflow}{    end if}
17214 
17215     err\_flag = .false.
17216 
17217                     
17218     answer\_shape = shape(answer)
17219     check\_shape = shape(check)
17220 
17221     consist\_shape = answer\_shape == check\_shape
17222 
17223     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
17224       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17225       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17226       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
17227       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
17228       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
17229 
17230       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17231 \textcolor{keywordflow}{    end if}
17232 
17233 
17234     \textcolor{keyword}{allocate}( mask\_array( &
17235                             &    answer\_shape(1), &
17236                       
17237       &    answer\_shape(2), &
17238                       
17239       &    answer\_shape(3), &
17240                       
17241       &    answer\_shape(4)  )  &
17242       &  )
17243 
17244     \textcolor{keyword}{allocate}( judge( &
17245                             &    answer\_shape(1), &
17246                       
17247       &    answer\_shape(2), &
17248                       
17249       &    answer\_shape(3), &
17250                       
17251       &    answer\_shape(4)  )  &
17252       &  )
17253 
17254     \textcolor{keyword}{allocate}( judge\_rev( &
17255                             &    answer\_shape(1), &
17256                       
17257       &    answer\_shape(2), &
17258                       
17259       &    answer\_shape(3), &
17260                       
17261       &    answer\_shape(4)  )  &
17262       &  )
17263 
17264     \textcolor{keyword}{allocate}( answer\_negative( &
17265                             &    answer\_shape(1), &
17266                       
17267       &    answer\_shape(2), &
17268                       
17269       &    answer\_shape(3), &
17270                       
17271       &    answer\_shape(4)  )  &
17272       &  )
17273 
17274     \textcolor{keyword}{allocate}( check\_negative( &
17275                             &    answer\_shape(1), &
17276                       
17277       &    answer\_shape(2), &
17278                       
17279       &    answer\_shape(3), &
17280                       
17281       &    answer\_shape(4)  )  &
17282       &  )
17283 
17284     \textcolor{keyword}{allocate}( both\_negative( &
17285                             &    answer\_shape(1), &
17286                       
17287       &    answer\_shape(2), &
17288                       
17289       &    answer\_shape(3), &
17290                       
17291       &    answer\_shape(4)  )  &
17292       &  )
17293 
17294     answer\_negative = answer < 0.0\_dp
17295     check\_negative = check < 0.0\_dp
17296     both\_negative = answer\_negative .and. check\_negative
17297     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
17298 
17299     judge = answer > check
17300     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
17301 
17302     judge\_rev = .not. judge
17303     err\_flag = any(judge\_rev)
17304     mask\_array = 1
17305     pos = maxloc(mask\_array, judge\_rev)
17306 
17307     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17308 
17309       wrong = check( &
17310                               &    pos(1), &
17311                       
17312         &    pos(2), &
17313                       
17314         &    pos(3), &
17315                       
17316         &    pos(4)  )
17317 
17318       right = answer( &
17319                               &    pos(1), &
17320                       
17321         &    pos(2), &
17322                       
17323         &    pos(3), &
17324                       
17325         &    pos(4)  )
17326 
17327                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
17328                       
17329       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
17330                       
17331       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
17332                       
17333       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
17334                       
17335 
17336       pos\_str = \textcolor{stringliteral}{'('} // &
17337                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
17338                       
17339         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
17340                       
17341         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
17342                       
17343         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
17344 
17345       \textcolor{keywordflow}{if} ( both\_negative( &
17346                               &    pos(1), &
17347                       
17348         &    pos(2), &
17349                       
17350         &    pos(3), &
17351                       
17352         &    pos(4)  )  ) \textcolor{keywordflow}{then}
17353 
17354         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
17355       \textcolor{keywordflow}{else}
17356         abs\_mes = \textcolor{stringliteral}{''}
17357 
17358 \textcolor{keywordflow}{      end if}
17359 
17360 \textcolor{keywordflow}{    end if}
17361     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
17362     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
17363 
17364                     
17365 
17366 
17367     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17368       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17369       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17370       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17371         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
17372       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
17373       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17374         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
17375 
17376       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17377     \textcolor{keywordflow}{else}
17378       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
17379 \textcolor{keywordflow}{    end if}
17380 
17381 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a21089b24d8b8a919481304c8d470eb9d}\label{interfacedc__test_1_1assertlessthan_a21089b24d8b8a919481304c8d470eb9d}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble5@{dctestassertlessthandouble5}}
\index{dctestassertlessthandouble5@{dctestassertlessthandouble5}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble5()}{dctestassertlessthandouble5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble5 (\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 17387 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
17387     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
17388     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
17389     \textcolor{keywordtype}{implicit none}
17390     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
17391     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
17392     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
17393     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
17394     \textcolor{keywordtype}{logical}:: err\_flag
17395     \textcolor{keywordtype}{logical}:: negative\_support\_on
17396     \textcolor{keywordtype}{character(STRING)}:: pos\_str
17397     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
17398     \textcolor{keywordtype}{real(DP)}:: wrong, right
17399 
17400                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
17401     \textcolor{keywordtype}{logical}:: consist\_shape(5)
17402     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
17403     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
17404     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
17405     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
17406     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
17407     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
17408     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
17409                     
17410 
17411   \textcolor{keywordflow}{continue}
17412     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
17413       negative\_support\_on = negative\_support
17414     \textcolor{keywordflow}{else}
17415       negative\_support\_on = .true.
17416 \textcolor{keywordflow}{    end if}
17417 
17418     err\_flag = .false.
17419 
17420                     
17421     answer\_shape = shape(answer)
17422     check\_shape = shape(check)
17423 
17424     consist\_shape = answer\_shape == check\_shape
17425 
17426     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
17427       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17428       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17429       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
17430       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
17431       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
17432 
17433       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17434 \textcolor{keywordflow}{    end if}
17435 
17436 
17437     \textcolor{keyword}{allocate}( mask\_array( &
17438                             &    answer\_shape(1), &
17439                       
17440       &    answer\_shape(2), &
17441                       
17442       &    answer\_shape(3), &
17443                       
17444       &    answer\_shape(4), &
17445                       
17446       &    answer\_shape(5)  )  &
17447       &  )
17448 
17449     \textcolor{keyword}{allocate}( judge( &
17450                             &    answer\_shape(1), &
17451                       
17452       &    answer\_shape(2), &
17453                       
17454       &    answer\_shape(3), &
17455                       
17456       &    answer\_shape(4), &
17457                       
17458       &    answer\_shape(5)  )  &
17459       &  )
17460 
17461     \textcolor{keyword}{allocate}( judge\_rev( &
17462                             &    answer\_shape(1), &
17463                       
17464       &    answer\_shape(2), &
17465                       
17466       &    answer\_shape(3), &
17467                       
17468       &    answer\_shape(4), &
17469                       
17470       &    answer\_shape(5)  )  &
17471       &  )
17472 
17473     \textcolor{keyword}{allocate}( answer\_negative( &
17474                             &    answer\_shape(1), &
17475                       
17476       &    answer\_shape(2), &
17477                       
17478       &    answer\_shape(3), &
17479                       
17480       &    answer\_shape(4), &
17481                       
17482       &    answer\_shape(5)  )  &
17483       &  )
17484 
17485     \textcolor{keyword}{allocate}( check\_negative( &
17486                             &    answer\_shape(1), &
17487                       
17488       &    answer\_shape(2), &
17489                       
17490       &    answer\_shape(3), &
17491                       
17492       &    answer\_shape(4), &
17493                       
17494       &    answer\_shape(5)  )  &
17495       &  )
17496 
17497     \textcolor{keyword}{allocate}( both\_negative( &
17498                             &    answer\_shape(1), &
17499                       
17500       &    answer\_shape(2), &
17501                       
17502       &    answer\_shape(3), &
17503                       
17504       &    answer\_shape(4), &
17505                       
17506       &    answer\_shape(5)  )  &
17507       &  )
17508 
17509     answer\_negative = answer < 0.0\_dp
17510     check\_negative = check < 0.0\_dp
17511     both\_negative = answer\_negative .and. check\_negative
17512     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
17513 
17514     judge = answer > check
17515     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
17516 
17517     judge\_rev = .not. judge
17518     err\_flag = any(judge\_rev)
17519     mask\_array = 1
17520     pos = maxloc(mask\_array, judge\_rev)
17521 
17522     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17523 
17524       wrong = check( &
17525                               &    pos(1), &
17526                       
17527         &    pos(2), &
17528                       
17529         &    pos(3), &
17530                       
17531         &    pos(4), &
17532                       
17533         &    pos(5)  )
17534 
17535       right = answer( &
17536                               &    pos(1), &
17537                       
17538         &    pos(2), &
17539                       
17540         &    pos(3), &
17541                       
17542         &    pos(4), &
17543                       
17544         &    pos(5)  )
17545 
17546                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
17547                       
17548       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
17549                       
17550       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
17551                       
17552       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
17553                       
17554       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
17555                       
17556 
17557       pos\_str = \textcolor{stringliteral}{'('} // &
17558                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
17559                       
17560         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
17561                       
17562         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
17563                       
17564         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
17565                       
17566         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
17567 
17568       \textcolor{keywordflow}{if} ( both\_negative( &
17569                               &    pos(1), &
17570                       
17571         &    pos(2), &
17572                       
17573         &    pos(3), &
17574                       
17575         &    pos(4), &
17576                       
17577         &    pos(5)  )  ) \textcolor{keywordflow}{then}
17578 
17579         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
17580       \textcolor{keywordflow}{else}
17581         abs\_mes = \textcolor{stringliteral}{''}
17582 
17583 \textcolor{keywordflow}{      end if}
17584 
17585 \textcolor{keywordflow}{    end if}
17586     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
17587     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
17588 
17589                     
17590 
17591 
17592     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17593       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17594       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17595       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17596         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
17597       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
17598       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17599         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
17600 
17601       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17602     \textcolor{keywordflow}{else}
17603       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
17604 \textcolor{keywordflow}{    end if}
17605 
17606 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a1c7abaf25e854c5588a4cc8ceaa3b42c}\label{interfacedc__test_1_1assertlessthan_a1c7abaf25e854c5588a4cc8ceaa3b42c}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble6@{dctestassertlessthandouble6}}
\index{dctestassertlessthandouble6@{dctestassertlessthandouble6}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble6()}{dctestassertlessthandouble6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble6 (\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 17612 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
17612     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
17613     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
17614     \textcolor{keywordtype}{implicit none}
17615     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
17616     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
17617     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
17618     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
17619     \textcolor{keywordtype}{logical}:: err\_flag
17620     \textcolor{keywordtype}{logical}:: negative\_support\_on
17621     \textcolor{keywordtype}{character(STRING)}:: pos\_str
17622     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
17623     \textcolor{keywordtype}{real(DP)}:: wrong, right
17624 
17625                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
17626     \textcolor{keywordtype}{logical}:: consist\_shape(6)
17627     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
17628     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
17629     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
17630     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
17631     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
17632     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
17633     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
17634                     
17635 
17636   \textcolor{keywordflow}{continue}
17637     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
17638       negative\_support\_on = negative\_support
17639     \textcolor{keywordflow}{else}
17640       negative\_support\_on = .true.
17641 \textcolor{keywordflow}{    end if}
17642 
17643     err\_flag = .false.
17644 
17645                     
17646     answer\_shape = shape(answer)
17647     check\_shape = shape(check)
17648 
17649     consist\_shape = answer\_shape == check\_shape
17650 
17651     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
17652       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17653       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17654       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
17655       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
17656       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
17657 
17658       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17659 \textcolor{keywordflow}{    end if}
17660 
17661 
17662     \textcolor{keyword}{allocate}( mask\_array( &
17663                             &    answer\_shape(1), &
17664                       
17665       &    answer\_shape(2), &
17666                       
17667       &    answer\_shape(3), &
17668                       
17669       &    answer\_shape(4), &
17670                       
17671       &    answer\_shape(5), &
17672                       
17673       &    answer\_shape(6)  )  &
17674       &  )
17675 
17676     \textcolor{keyword}{allocate}( judge( &
17677                             &    answer\_shape(1), &
17678                       
17679       &    answer\_shape(2), &
17680                       
17681       &    answer\_shape(3), &
17682                       
17683       &    answer\_shape(4), &
17684                       
17685       &    answer\_shape(5), &
17686                       
17687       &    answer\_shape(6)  )  &
17688       &  )
17689 
17690     \textcolor{keyword}{allocate}( judge\_rev( &
17691                             &    answer\_shape(1), &
17692                       
17693       &    answer\_shape(2), &
17694                       
17695       &    answer\_shape(3), &
17696                       
17697       &    answer\_shape(4), &
17698                       
17699       &    answer\_shape(5), &
17700                       
17701       &    answer\_shape(6)  )  &
17702       &  )
17703 
17704     \textcolor{keyword}{allocate}( answer\_negative( &
17705                             &    answer\_shape(1), &
17706                       
17707       &    answer\_shape(2), &
17708                       
17709       &    answer\_shape(3), &
17710                       
17711       &    answer\_shape(4), &
17712                       
17713       &    answer\_shape(5), &
17714                       
17715       &    answer\_shape(6)  )  &
17716       &  )
17717 
17718     \textcolor{keyword}{allocate}( check\_negative( &
17719                             &    answer\_shape(1), &
17720                       
17721       &    answer\_shape(2), &
17722                       
17723       &    answer\_shape(3), &
17724                       
17725       &    answer\_shape(4), &
17726                       
17727       &    answer\_shape(5), &
17728                       
17729       &    answer\_shape(6)  )  &
17730       &  )
17731 
17732     \textcolor{keyword}{allocate}( both\_negative( &
17733                             &    answer\_shape(1), &
17734                       
17735       &    answer\_shape(2), &
17736                       
17737       &    answer\_shape(3), &
17738                       
17739       &    answer\_shape(4), &
17740                       
17741       &    answer\_shape(5), &
17742                       
17743       &    answer\_shape(6)  )  &
17744       &  )
17745 
17746     answer\_negative = answer < 0.0\_dp
17747     check\_negative = check < 0.0\_dp
17748     both\_negative = answer\_negative .and. check\_negative
17749     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
17750 
17751     judge = answer > check
17752     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
17753 
17754     judge\_rev = .not. judge
17755     err\_flag = any(judge\_rev)
17756     mask\_array = 1
17757     pos = maxloc(mask\_array, judge\_rev)
17758 
17759     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17760 
17761       wrong = check( &
17762                               &    pos(1), &
17763                       
17764         &    pos(2), &
17765                       
17766         &    pos(3), &
17767                       
17768         &    pos(4), &
17769                       
17770         &    pos(5), &
17771                       
17772         &    pos(6)  )
17773 
17774       right = answer( &
17775                               &    pos(1), &
17776                       
17777         &    pos(2), &
17778                       
17779         &    pos(3), &
17780                       
17781         &    pos(4), &
17782                       
17783         &    pos(5), &
17784                       
17785         &    pos(6)  )
17786 
17787                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
17788                       
17789       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
17790                       
17791       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
17792                       
17793       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
17794                       
17795       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
17796                       
17797       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
17798                       
17799 
17800       pos\_str = \textcolor{stringliteral}{'('} // &
17801                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
17802                       
17803         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
17804                       
17805         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
17806                       
17807         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
17808                       
17809         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
17810                       
17811         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
17812 
17813       \textcolor{keywordflow}{if} ( both\_negative( &
17814                               &    pos(1), &
17815                       
17816         &    pos(2), &
17817                       
17818         &    pos(3), &
17819                       
17820         &    pos(4), &
17821                       
17822         &    pos(5), &
17823                       
17824         &    pos(6)  )  ) \textcolor{keywordflow}{then}
17825 
17826         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
17827       \textcolor{keywordflow}{else}
17828         abs\_mes = \textcolor{stringliteral}{''}
17829 
17830 \textcolor{keywordflow}{      end if}
17831 
17832 \textcolor{keywordflow}{    end if}
17833     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
17834     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
17835 
17836                     
17837 
17838 
17839     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
17840       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17841       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17842       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17843         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
17844       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
17845       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
17846         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
17847 
17848       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17849     \textcolor{keywordflow}{else}
17850       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
17851 \textcolor{keywordflow}{    end if}
17852 
17853 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a2993b3dfe9cb48702c5422d1a26f7aa4}\label{interfacedc__test_1_1assertlessthan_a2993b3dfe9cb48702c5422d1a26f7aa4}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthandouble7@{dctestassertlessthandouble7}}
\index{dctestassertlessthandouble7@{dctestassertlessthandouble7}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthandouble7()}{dctestassertlessthandouble7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthandouble7 (\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 17859 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
17859     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
17860     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
17861     \textcolor{keywordtype}{implicit none}
17862     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
17863     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
17864     \textcolor{keywordtype}{real(DP)}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
17865     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
17866     \textcolor{keywordtype}{logical}:: err\_flag
17867     \textcolor{keywordtype}{logical}:: negative\_support\_on
17868     \textcolor{keywordtype}{character(STRING)}:: pos\_str
17869     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
17870     \textcolor{keywordtype}{real(DP)}:: wrong, right
17871 
17872                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
17873     \textcolor{keywordtype}{logical}:: consist\_shape(7)
17874     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
17875     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
17876     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
17877     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
17878     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
17879     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
17880     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
17881                     
17882 
17883   \textcolor{keywordflow}{continue}
17884     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
17885       negative\_support\_on = negative\_support
17886     \textcolor{keywordflow}{else}
17887       negative\_support\_on = .true.
17888 \textcolor{keywordflow}{    end if}
17889 
17890     err\_flag = .false.
17891 
17892                     
17893     answer\_shape = shape(answer)
17894     check\_shape = shape(check)
17895 
17896     consist\_shape = answer\_shape == check\_shape
17897 
17898     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
17899       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
17900       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
17901       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
17902       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
17903       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
17904 
17905       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
17906 \textcolor{keywordflow}{    end if}
17907 
17908 
17909     \textcolor{keyword}{allocate}( mask\_array( &
17910                             &    answer\_shape(1), &
17911                       
17912       &    answer\_shape(2), &
17913                       
17914       &    answer\_shape(3), &
17915                       
17916       &    answer\_shape(4), &
17917                       
17918       &    answer\_shape(5), &
17919                       
17920       &    answer\_shape(6), &
17921                       
17922       &    answer\_shape(7)  )  &
17923       &  )
17924 
17925     \textcolor{keyword}{allocate}( judge( &
17926                             &    answer\_shape(1), &
17927                       
17928       &    answer\_shape(2), &
17929                       
17930       &    answer\_shape(3), &
17931                       
17932       &    answer\_shape(4), &
17933                       
17934       &    answer\_shape(5), &
17935                       
17936       &    answer\_shape(6), &
17937                       
17938       &    answer\_shape(7)  )  &
17939       &  )
17940 
17941     \textcolor{keyword}{allocate}( judge\_rev( &
17942                             &    answer\_shape(1), &
17943                       
17944       &    answer\_shape(2), &
17945                       
17946       &    answer\_shape(3), &
17947                       
17948       &    answer\_shape(4), &
17949                       
17950       &    answer\_shape(5), &
17951                       
17952       &    answer\_shape(6), &
17953                       
17954       &    answer\_shape(7)  )  &
17955       &  )
17956 
17957     \textcolor{keyword}{allocate}( answer\_negative( &
17958                             &    answer\_shape(1), &
17959                       
17960       &    answer\_shape(2), &
17961                       
17962       &    answer\_shape(3), &
17963                       
17964       &    answer\_shape(4), &
17965                       
17966       &    answer\_shape(5), &
17967                       
17968       &    answer\_shape(6), &
17969                       
17970       &    answer\_shape(7)  )  &
17971       &  )
17972 
17973     \textcolor{keyword}{allocate}( check\_negative( &
17974                             &    answer\_shape(1), &
17975                       
17976       &    answer\_shape(2), &
17977                       
17978       &    answer\_shape(3), &
17979                       
17980       &    answer\_shape(4), &
17981                       
17982       &    answer\_shape(5), &
17983                       
17984       &    answer\_shape(6), &
17985                       
17986       &    answer\_shape(7)  )  &
17987       &  )
17988 
17989     \textcolor{keyword}{allocate}( both\_negative( &
17990                             &    answer\_shape(1), &
17991                       
17992       &    answer\_shape(2), &
17993                       
17994       &    answer\_shape(3), &
17995                       
17996       &    answer\_shape(4), &
17997                       
17998       &    answer\_shape(5), &
17999                       
18000       &    answer\_shape(6), &
18001                       
18002       &    answer\_shape(7)  )  &
18003       &  )
18004 
18005     answer\_negative = answer < 0.0\_dp
18006     check\_negative = check < 0.0\_dp
18007     both\_negative = answer\_negative .and. check\_negative
18008     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
18009 
18010     judge = answer > check
18011     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
18012 
18013     judge\_rev = .not. judge
18014     err\_flag = any(judge\_rev)
18015     mask\_array = 1
18016     pos = maxloc(mask\_array, judge\_rev)
18017 
18018     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
18019 
18020       wrong = check( &
18021                               &    pos(1), &
18022                       
18023         &    pos(2), &
18024                       
18025         &    pos(3), &
18026                       
18027         &    pos(4), &
18028                       
18029         &    pos(5), &
18030                       
18031         &    pos(6), &
18032                       
18033         &    pos(7)  )
18034 
18035       right = answer( &
18036                               &    pos(1), &
18037                       
18038         &    pos(2), &
18039                       
18040         &    pos(3), &
18041                       
18042         &    pos(4), &
18043                       
18044         &    pos(5), &
18045                       
18046         &    pos(6), &
18047                       
18048         &    pos(7)  )
18049 
18050                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
18051                       
18052       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
18053                       
18054       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
18055                       
18056       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
18057                       
18058       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
18059                       
18060       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
18061                       
18062       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
18063                       
18064 
18065       pos\_str = \textcolor{stringliteral}{'('} // &
18066                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
18067                       
18068         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
18069                       
18070         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
18071                       
18072         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
18073                       
18074         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
18075                       
18076         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
18077                       
18078         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
18079 
18080       \textcolor{keywordflow}{if} ( both\_negative( &
18081                               &    pos(1), &
18082                       
18083         &    pos(2), &
18084                       
18085         &    pos(3), &
18086                       
18087         &    pos(4), &
18088                       
18089         &    pos(5), &
18090                       
18091         &    pos(6), &
18092                       
18093         &    pos(7)  )  ) \textcolor{keywordflow}{then}
18094 
18095         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
18096       \textcolor{keywordflow}{else}
18097         abs\_mes = \textcolor{stringliteral}{''}
18098 
18099 \textcolor{keywordflow}{      end if}
18100 
18101 \textcolor{keywordflow}{    end if}
18102     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
18103     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
18104 
18105                     
18106 
18107 
18108     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
18109       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
18110       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
18111       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
18112         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
18113       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
18114       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
18115         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
18116 
18117       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
18118     \textcolor{keywordflow}{else}
18119       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
18120 \textcolor{keywordflow}{    end if}
18121 
18122 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_ab76f704d907223e1bb4d61e23a7e258f}\label{interfacedc__test_1_1assertlessthan_ab76f704d907223e1bb4d61e23a7e258f}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint0@{dctestassertlessthanint0}}
\index{dctestassertlessthanint0@{dctestassertlessthanint0}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint0()}{dctestassertlessthanint0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint0 (\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 13640 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
13640     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
13641     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
13642     \textcolor{keywordtype}{implicit none}
13643     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
13644     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer
13645     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check
13646     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
13647     \textcolor{keywordtype}{logical}:: err\_flag
13648     \textcolor{keywordtype}{logical}:: negative\_support\_on
13649     \textcolor{keywordtype}{character(STRING)}:: pos\_str
13650     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
13651     \textcolor{keywordtype}{integer}:: wrong, right
13652 
13653                                         
13654 
13655   \textcolor{keywordflow}{continue}
13656     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
13657       negative\_support\_on = negative\_support
13658     \textcolor{keywordflow}{else}
13659       negative\_support\_on = .true.
13660 \textcolor{keywordflow}{    end if}
13661 
13662     err\_flag = .false.
13663 
13664                     
13665 
13666 
13667     err\_flag = .not. answer > check
13668     abs\_mes = \textcolor{stringliteral}{''}
13669 
13670     \textcolor{keywordflow}{if} ( answer < 0 &
13671       &  .and. check < 0 &
13672       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
13673 
13674       err\_flag = .not. err\_flag
13675       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13676 \textcolor{keywordflow}{    end if}
13677 
13678     wrong = check
13679     right = answer
13680     pos\_str = \textcolor{stringliteral}{''}
13681 
13682                     
13683 
13684 
13685     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13686       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13687       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13688       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13689         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13690       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
13691       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13692         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13693 
13694       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13695     \textcolor{keywordflow}{else}
13696       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
13697 \textcolor{keywordflow}{    end if}
13698 
13699 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_adfd66fdb4aa74fae4041fc6a266f783e}\label{interfacedc__test_1_1assertlessthan_adfd66fdb4aa74fae4041fc6a266f783e}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint1@{dctestassertlessthanint1}}
\index{dctestassertlessthanint1@{dctestassertlessthanint1}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint1()}{dctestassertlessthanint1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint1 (\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 13705 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
13705     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
13706     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
13707     \textcolor{keywordtype}{implicit none}
13708     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
13709     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:)
13710     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:)
13711     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
13712     \textcolor{keywordtype}{logical}:: err\_flag
13713     \textcolor{keywordtype}{logical}:: negative\_support\_on
13714     \textcolor{keywordtype}{character(STRING)}:: pos\_str
13715     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
13716     \textcolor{keywordtype}{integer}:: wrong, right
13717 
13718                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
13719     \textcolor{keywordtype}{logical}:: consist\_shape(1)
13720     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
13721     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
13722     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
13723     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
13724     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
13725     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
13726     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
13727                     
13728 
13729   \textcolor{keywordflow}{continue}
13730     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
13731       negative\_support\_on = negative\_support
13732     \textcolor{keywordflow}{else}
13733       negative\_support\_on = .true.
13734 \textcolor{keywordflow}{    end if}
13735 
13736     err\_flag = .false.
13737 
13738                     
13739     answer\_shape = shape(answer)
13740     check\_shape = shape(check)
13741 
13742     consist\_shape = answer\_shape == check\_shape
13743 
13744     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
13745       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13746       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13747       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
13748       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
13749       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
13750 
13751       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13752 \textcolor{keywordflow}{    end if}
13753 
13754 
13755     \textcolor{keyword}{allocate}( mask\_array( &
13756                       
13757       &    answer\_shape(1)  )  &
13758       &  )
13759 
13760     \textcolor{keyword}{allocate}( judge( &
13761                       
13762       &    answer\_shape(1)  )  &
13763       &  )
13764 
13765     \textcolor{keyword}{allocate}( judge\_rev( &
13766                       
13767       &    answer\_shape(1)  )  &
13768       &  )
13769 
13770     \textcolor{keyword}{allocate}( answer\_negative( &
13771                       
13772       &    answer\_shape(1)  )  &
13773       &  )
13774 
13775     \textcolor{keyword}{allocate}( check\_negative( &
13776                       
13777       &    answer\_shape(1)  )  &
13778       &  )
13779 
13780     \textcolor{keyword}{allocate}( both\_negative( &
13781                       
13782       &    answer\_shape(1)  )  &
13783       &  )
13784 
13785     answer\_negative = answer < 0
13786     check\_negative = check < 0
13787     both\_negative = answer\_negative .and. check\_negative
13788     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
13789 
13790     judge = answer > check
13791     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
13792 
13793     judge\_rev = .not. judge
13794     err\_flag = any(judge\_rev)
13795     mask\_array = 1
13796     pos = maxloc(mask\_array, judge\_rev)
13797 
13798     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13799 
13800       wrong = check( &
13801                       
13802         &    pos(1)  )
13803 
13804       right = answer( &
13805                       
13806         &    pos(1)  )
13807 
13808                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
13809                       
13810 
13811       pos\_str = \textcolor{stringliteral}{'('} // &
13812                       
13813         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
13814 
13815       \textcolor{keywordflow}{if} ( both\_negative( &
13816                       
13817         &    pos(1)  )  ) \textcolor{keywordflow}{then}
13818 
13819         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13820       \textcolor{keywordflow}{else}
13821         abs\_mes = \textcolor{stringliteral}{''}
13822 
13823 \textcolor{keywordflow}{      end if}
13824 
13825 \textcolor{keywordflow}{    end if}
13826     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
13827     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
13828 
13829                     
13830 
13831 
13832     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13833       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13834       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13835       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13836         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13837       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
13838       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13839         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13840 
13841       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13842     \textcolor{keywordflow}{else}
13843       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
13844 \textcolor{keywordflow}{    end if}
13845 
13846 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_ae3fdfcfca9a7fb92019860f304ea4d50}\label{interfacedc__test_1_1assertlessthan_ae3fdfcfca9a7fb92019860f304ea4d50}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint2@{dctestassertlessthanint2}}
\index{dctestassertlessthanint2@{dctestassertlessthanint2}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint2()}{dctestassertlessthanint2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint2 (\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 13852 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
13852     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
13853     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
13854     \textcolor{keywordtype}{implicit none}
13855     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
13856     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
13857     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
13858     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
13859     \textcolor{keywordtype}{logical}:: err\_flag
13860     \textcolor{keywordtype}{logical}:: negative\_support\_on
13861     \textcolor{keywordtype}{character(STRING)}:: pos\_str
13862     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
13863     \textcolor{keywordtype}{integer}:: wrong, right
13864 
13865                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
13866     \textcolor{keywordtype}{logical}:: consist\_shape(2)
13867     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
13868     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
13869     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
13870     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
13871     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
13872     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
13873     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
13874                     
13875 
13876   \textcolor{keywordflow}{continue}
13877     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
13878       negative\_support\_on = negative\_support
13879     \textcolor{keywordflow}{else}
13880       negative\_support\_on = .true.
13881 \textcolor{keywordflow}{    end if}
13882 
13883     err\_flag = .false.
13884 
13885                     
13886     answer\_shape = shape(answer)
13887     check\_shape = shape(check)
13888 
13889     consist\_shape = answer\_shape == check\_shape
13890 
13891     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
13892       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13893       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13894       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
13895       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
13896       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
13897 
13898       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
13899 \textcolor{keywordflow}{    end if}
13900 
13901 
13902     \textcolor{keyword}{allocate}( mask\_array( &
13903                             &    answer\_shape(1), &
13904                       
13905       &    answer\_shape(2)  )  &
13906       &  )
13907 
13908     \textcolor{keyword}{allocate}( judge( &
13909                             &    answer\_shape(1), &
13910                       
13911       &    answer\_shape(2)  )  &
13912       &  )
13913 
13914     \textcolor{keyword}{allocate}( judge\_rev( &
13915                             &    answer\_shape(1), &
13916                       
13917       &    answer\_shape(2)  )  &
13918       &  )
13919 
13920     \textcolor{keyword}{allocate}( answer\_negative( &
13921                             &    answer\_shape(1), &
13922                       
13923       &    answer\_shape(2)  )  &
13924       &  )
13925 
13926     \textcolor{keyword}{allocate}( check\_negative( &
13927                             &    answer\_shape(1), &
13928                       
13929       &    answer\_shape(2)  )  &
13930       &  )
13931 
13932     \textcolor{keyword}{allocate}( both\_negative( &
13933                             &    answer\_shape(1), &
13934                       
13935       &    answer\_shape(2)  )  &
13936       &  )
13937 
13938     answer\_negative = answer < 0
13939     check\_negative = check < 0
13940     both\_negative = answer\_negative .and. check\_negative
13941     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
13942 
13943     judge = answer > check
13944     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
13945 
13946     judge\_rev = .not. judge
13947     err\_flag = any(judge\_rev)
13948     mask\_array = 1
13949     pos = maxloc(mask\_array, judge\_rev)
13950 
13951     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13952 
13953       wrong = check( &
13954                               &    pos(1), &
13955                       
13956         &    pos(2)  )
13957 
13958       right = answer( &
13959                               &    pos(1), &
13960                       
13961         &    pos(2)  )
13962 
13963                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
13964                       
13965       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
13966                       
13967 
13968       pos\_str = \textcolor{stringliteral}{'('} // &
13969                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
13970                       
13971         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
13972 
13973       \textcolor{keywordflow}{if} ( both\_negative( &
13974                               &    pos(1), &
13975                       
13976         &    pos(2)  )  ) \textcolor{keywordflow}{then}
13977 
13978         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
13979       \textcolor{keywordflow}{else}
13980         abs\_mes = \textcolor{stringliteral}{''}
13981 
13982 \textcolor{keywordflow}{      end if}
13983 
13984 \textcolor{keywordflow}{    end if}
13985     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
13986     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
13987 
13988                     
13989 
13990 
13991     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
13992       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
13993       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
13994       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13995         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
13996       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
13997       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
13998         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
13999 
14000       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14001     \textcolor{keywordflow}{else}
14002       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
14003 \textcolor{keywordflow}{    end if}
14004 
14005 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_af85d159c444c72f5900e9871a40e044a}\label{interfacedc__test_1_1assertlessthan_af85d159c444c72f5900e9871a40e044a}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint3@{dctestassertlessthanint3}}
\index{dctestassertlessthanint3@{dctestassertlessthanint3}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint3()}{dctestassertlessthanint3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint3 (\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 14011 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
14011     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
14012     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
14013     \textcolor{keywordtype}{implicit none}
14014     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
14015     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
14016     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
14017     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
14018     \textcolor{keywordtype}{logical}:: err\_flag
14019     \textcolor{keywordtype}{logical}:: negative\_support\_on
14020     \textcolor{keywordtype}{character(STRING)}:: pos\_str
14021     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
14022     \textcolor{keywordtype}{integer}:: wrong, right
14023 
14024                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
14025     \textcolor{keywordtype}{logical}:: consist\_shape(3)
14026     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
14027     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
14028     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
14029     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
14030     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
14031     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
14032     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
14033                     
14034 
14035   \textcolor{keywordflow}{continue}
14036     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
14037       negative\_support\_on = negative\_support
14038     \textcolor{keywordflow}{else}
14039       negative\_support\_on = .true.
14040 \textcolor{keywordflow}{    end if}
14041 
14042     err\_flag = .false.
14043 
14044                     
14045     answer\_shape = shape(answer)
14046     check\_shape = shape(check)
14047 
14048     consist\_shape = answer\_shape == check\_shape
14049 
14050     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
14051       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14052       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14053       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
14054       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
14055       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
14056 
14057       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14058 \textcolor{keywordflow}{    end if}
14059 
14060 
14061     \textcolor{keyword}{allocate}( mask\_array( &
14062                             &    answer\_shape(1), &
14063                       
14064       &    answer\_shape(2), &
14065                       
14066       &    answer\_shape(3)  )  &
14067       &  )
14068 
14069     \textcolor{keyword}{allocate}( judge( &
14070                             &    answer\_shape(1), &
14071                       
14072       &    answer\_shape(2), &
14073                       
14074       &    answer\_shape(3)  )  &
14075       &  )
14076 
14077     \textcolor{keyword}{allocate}( judge\_rev( &
14078                             &    answer\_shape(1), &
14079                       
14080       &    answer\_shape(2), &
14081                       
14082       &    answer\_shape(3)  )  &
14083       &  )
14084 
14085     \textcolor{keyword}{allocate}( answer\_negative( &
14086                             &    answer\_shape(1), &
14087                       
14088       &    answer\_shape(2), &
14089                       
14090       &    answer\_shape(3)  )  &
14091       &  )
14092 
14093     \textcolor{keyword}{allocate}( check\_negative( &
14094                             &    answer\_shape(1), &
14095                       
14096       &    answer\_shape(2), &
14097                       
14098       &    answer\_shape(3)  )  &
14099       &  )
14100 
14101     \textcolor{keyword}{allocate}( both\_negative( &
14102                             &    answer\_shape(1), &
14103                       
14104       &    answer\_shape(2), &
14105                       
14106       &    answer\_shape(3)  )  &
14107       &  )
14108 
14109     answer\_negative = answer < 0
14110     check\_negative = check < 0
14111     both\_negative = answer\_negative .and. check\_negative
14112     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
14113 
14114     judge = answer > check
14115     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
14116 
14117     judge\_rev = .not. judge
14118     err\_flag = any(judge\_rev)
14119     mask\_array = 1
14120     pos = maxloc(mask\_array, judge\_rev)
14121 
14122     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14123 
14124       wrong = check( &
14125                               &    pos(1), &
14126                       
14127         &    pos(2), &
14128                       
14129         &    pos(3)  )
14130 
14131       right = answer( &
14132                               &    pos(1), &
14133                       
14134         &    pos(2), &
14135                       
14136         &    pos(3)  )
14137 
14138                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
14139                       
14140       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
14141                       
14142       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
14143                       
14144 
14145       pos\_str = \textcolor{stringliteral}{'('} // &
14146                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
14147                       
14148         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
14149                       
14150         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
14151 
14152       \textcolor{keywordflow}{if} ( both\_negative( &
14153                               &    pos(1), &
14154                       
14155         &    pos(2), &
14156                       
14157         &    pos(3)  )  ) \textcolor{keywordflow}{then}
14158 
14159         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
14160       \textcolor{keywordflow}{else}
14161         abs\_mes = \textcolor{stringliteral}{''}
14162 
14163 \textcolor{keywordflow}{      end if}
14164 
14165 \textcolor{keywordflow}{    end if}
14166     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
14167     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
14168 
14169                     
14170 
14171 
14172     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14173       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14174       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14175       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14176         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
14177       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
14178       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14179         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
14180 
14181       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14182     \textcolor{keywordflow}{else}
14183       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
14184 \textcolor{keywordflow}{    end if}
14185 
14186 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a02885d499f9b9eff71931da9bcd27075}\label{interfacedc__test_1_1assertlessthan_a02885d499f9b9eff71931da9bcd27075}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint4@{dctestassertlessthanint4}}
\index{dctestassertlessthanint4@{dctestassertlessthanint4}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint4()}{dctestassertlessthanint4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint4 (\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 14192 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
14192     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
14193     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
14194     \textcolor{keywordtype}{implicit none}
14195     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
14196     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
14197     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
14198     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
14199     \textcolor{keywordtype}{logical}:: err\_flag
14200     \textcolor{keywordtype}{logical}:: negative\_support\_on
14201     \textcolor{keywordtype}{character(STRING)}:: pos\_str
14202     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
14203     \textcolor{keywordtype}{integer}:: wrong, right
14204 
14205                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
14206     \textcolor{keywordtype}{logical}:: consist\_shape(4)
14207     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
14208     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
14209     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
14210     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
14211     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
14212     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
14213     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
14214                     
14215 
14216   \textcolor{keywordflow}{continue}
14217     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
14218       negative\_support\_on = negative\_support
14219     \textcolor{keywordflow}{else}
14220       negative\_support\_on = .true.
14221 \textcolor{keywordflow}{    end if}
14222 
14223     err\_flag = .false.
14224 
14225                     
14226     answer\_shape = shape(answer)
14227     check\_shape = shape(check)
14228 
14229     consist\_shape = answer\_shape == check\_shape
14230 
14231     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
14232       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14233       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14234       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
14235       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
14236       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
14237 
14238       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14239 \textcolor{keywordflow}{    end if}
14240 
14241 
14242     \textcolor{keyword}{allocate}( mask\_array( &
14243                             &    answer\_shape(1), &
14244                       
14245       &    answer\_shape(2), &
14246                       
14247       &    answer\_shape(3), &
14248                       
14249       &    answer\_shape(4)  )  &
14250       &  )
14251 
14252     \textcolor{keyword}{allocate}( judge( &
14253                             &    answer\_shape(1), &
14254                       
14255       &    answer\_shape(2), &
14256                       
14257       &    answer\_shape(3), &
14258                       
14259       &    answer\_shape(4)  )  &
14260       &  )
14261 
14262     \textcolor{keyword}{allocate}( judge\_rev( &
14263                             &    answer\_shape(1), &
14264                       
14265       &    answer\_shape(2), &
14266                       
14267       &    answer\_shape(3), &
14268                       
14269       &    answer\_shape(4)  )  &
14270       &  )
14271 
14272     \textcolor{keyword}{allocate}( answer\_negative( &
14273                             &    answer\_shape(1), &
14274                       
14275       &    answer\_shape(2), &
14276                       
14277       &    answer\_shape(3), &
14278                       
14279       &    answer\_shape(4)  )  &
14280       &  )
14281 
14282     \textcolor{keyword}{allocate}( check\_negative( &
14283                             &    answer\_shape(1), &
14284                       
14285       &    answer\_shape(2), &
14286                       
14287       &    answer\_shape(3), &
14288                       
14289       &    answer\_shape(4)  )  &
14290       &  )
14291 
14292     \textcolor{keyword}{allocate}( both\_negative( &
14293                             &    answer\_shape(1), &
14294                       
14295       &    answer\_shape(2), &
14296                       
14297       &    answer\_shape(3), &
14298                       
14299       &    answer\_shape(4)  )  &
14300       &  )
14301 
14302     answer\_negative = answer < 0
14303     check\_negative = check < 0
14304     both\_negative = answer\_negative .and. check\_negative
14305     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
14306 
14307     judge = answer > check
14308     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
14309 
14310     judge\_rev = .not. judge
14311     err\_flag = any(judge\_rev)
14312     mask\_array = 1
14313     pos = maxloc(mask\_array, judge\_rev)
14314 
14315     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14316 
14317       wrong = check( &
14318                               &    pos(1), &
14319                       
14320         &    pos(2), &
14321                       
14322         &    pos(3), &
14323                       
14324         &    pos(4)  )
14325 
14326       right = answer( &
14327                               &    pos(1), &
14328                       
14329         &    pos(2), &
14330                       
14331         &    pos(3), &
14332                       
14333         &    pos(4)  )
14334 
14335                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
14336                       
14337       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
14338                       
14339       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
14340                       
14341       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
14342                       
14343 
14344       pos\_str = \textcolor{stringliteral}{'('} // &
14345                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
14346                       
14347         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
14348                       
14349         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
14350                       
14351         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
14352 
14353       \textcolor{keywordflow}{if} ( both\_negative( &
14354                               &    pos(1), &
14355                       
14356         &    pos(2), &
14357                       
14358         &    pos(3), &
14359                       
14360         &    pos(4)  )  ) \textcolor{keywordflow}{then}
14361 
14362         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
14363       \textcolor{keywordflow}{else}
14364         abs\_mes = \textcolor{stringliteral}{''}
14365 
14366 \textcolor{keywordflow}{      end if}
14367 
14368 \textcolor{keywordflow}{    end if}
14369     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
14370     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
14371 
14372                     
14373 
14374 
14375     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14376       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14377       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14378       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14379         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
14380       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
14381       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14382         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
14383 
14384       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14385     \textcolor{keywordflow}{else}
14386       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
14387 \textcolor{keywordflow}{    end if}
14388 
14389 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_aafdd46cc0163daffe7f1f827c204aa17}\label{interfacedc__test_1_1assertlessthan_aafdd46cc0163daffe7f1f827c204aa17}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint5@{dctestassertlessthanint5}}
\index{dctestassertlessthanint5@{dctestassertlessthanint5}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint5()}{dctestassertlessthanint5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint5 (\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 14395 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
14395     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
14396     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
14397     \textcolor{keywordtype}{implicit none}
14398     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
14399     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
14400     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
14401     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
14402     \textcolor{keywordtype}{logical}:: err\_flag
14403     \textcolor{keywordtype}{logical}:: negative\_support\_on
14404     \textcolor{keywordtype}{character(STRING)}:: pos\_str
14405     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
14406     \textcolor{keywordtype}{integer}:: wrong, right
14407 
14408                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
14409     \textcolor{keywordtype}{logical}:: consist\_shape(5)
14410     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
14411     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
14412     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
14413     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
14414     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
14415     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
14416     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
14417                     
14418 
14419   \textcolor{keywordflow}{continue}
14420     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
14421       negative\_support\_on = negative\_support
14422     \textcolor{keywordflow}{else}
14423       negative\_support\_on = .true.
14424 \textcolor{keywordflow}{    end if}
14425 
14426     err\_flag = .false.
14427 
14428                     
14429     answer\_shape = shape(answer)
14430     check\_shape = shape(check)
14431 
14432     consist\_shape = answer\_shape == check\_shape
14433 
14434     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
14435       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14436       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14437       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
14438       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
14439       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
14440 
14441       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14442 \textcolor{keywordflow}{    end if}
14443 
14444 
14445     \textcolor{keyword}{allocate}( mask\_array( &
14446                             &    answer\_shape(1), &
14447                       
14448       &    answer\_shape(2), &
14449                       
14450       &    answer\_shape(3), &
14451                       
14452       &    answer\_shape(4), &
14453                       
14454       &    answer\_shape(5)  )  &
14455       &  )
14456 
14457     \textcolor{keyword}{allocate}( judge( &
14458                             &    answer\_shape(1), &
14459                       
14460       &    answer\_shape(2), &
14461                       
14462       &    answer\_shape(3), &
14463                       
14464       &    answer\_shape(4), &
14465                       
14466       &    answer\_shape(5)  )  &
14467       &  )
14468 
14469     \textcolor{keyword}{allocate}( judge\_rev( &
14470                             &    answer\_shape(1), &
14471                       
14472       &    answer\_shape(2), &
14473                       
14474       &    answer\_shape(3), &
14475                       
14476       &    answer\_shape(4), &
14477                       
14478       &    answer\_shape(5)  )  &
14479       &  )
14480 
14481     \textcolor{keyword}{allocate}( answer\_negative( &
14482                             &    answer\_shape(1), &
14483                       
14484       &    answer\_shape(2), &
14485                       
14486       &    answer\_shape(3), &
14487                       
14488       &    answer\_shape(4), &
14489                       
14490       &    answer\_shape(5)  )  &
14491       &  )
14492 
14493     \textcolor{keyword}{allocate}( check\_negative( &
14494                             &    answer\_shape(1), &
14495                       
14496       &    answer\_shape(2), &
14497                       
14498       &    answer\_shape(3), &
14499                       
14500       &    answer\_shape(4), &
14501                       
14502       &    answer\_shape(5)  )  &
14503       &  )
14504 
14505     \textcolor{keyword}{allocate}( both\_negative( &
14506                             &    answer\_shape(1), &
14507                       
14508       &    answer\_shape(2), &
14509                       
14510       &    answer\_shape(3), &
14511                       
14512       &    answer\_shape(4), &
14513                       
14514       &    answer\_shape(5)  )  &
14515       &  )
14516 
14517     answer\_negative = answer < 0
14518     check\_negative = check < 0
14519     both\_negative = answer\_negative .and. check\_negative
14520     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
14521 
14522     judge = answer > check
14523     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
14524 
14525     judge\_rev = .not. judge
14526     err\_flag = any(judge\_rev)
14527     mask\_array = 1
14528     pos = maxloc(mask\_array, judge\_rev)
14529 
14530     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14531 
14532       wrong = check( &
14533                               &    pos(1), &
14534                       
14535         &    pos(2), &
14536                       
14537         &    pos(3), &
14538                       
14539         &    pos(4), &
14540                       
14541         &    pos(5)  )
14542 
14543       right = answer( &
14544                               &    pos(1), &
14545                       
14546         &    pos(2), &
14547                       
14548         &    pos(3), &
14549                       
14550         &    pos(4), &
14551                       
14552         &    pos(5)  )
14553 
14554                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
14555                       
14556       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
14557                       
14558       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
14559                       
14560       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
14561                       
14562       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
14563                       
14564 
14565       pos\_str = \textcolor{stringliteral}{'('} // &
14566                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
14567                       
14568         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
14569                       
14570         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
14571                       
14572         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
14573                       
14574         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
14575 
14576       \textcolor{keywordflow}{if} ( both\_negative( &
14577                               &    pos(1), &
14578                       
14579         &    pos(2), &
14580                       
14581         &    pos(3), &
14582                       
14583         &    pos(4), &
14584                       
14585         &    pos(5)  )  ) \textcolor{keywordflow}{then}
14586 
14587         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
14588       \textcolor{keywordflow}{else}
14589         abs\_mes = \textcolor{stringliteral}{''}
14590 
14591 \textcolor{keywordflow}{      end if}
14592 
14593 \textcolor{keywordflow}{    end if}
14594     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
14595     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
14596 
14597                     
14598 
14599 
14600     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14601       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14602       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14603       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14604         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
14605       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
14606       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14607         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
14608 
14609       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14610     \textcolor{keywordflow}{else}
14611       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
14612 \textcolor{keywordflow}{    end if}
14613 
14614 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a15ee372c39f1cfb6e89ec2da849b15f3}\label{interfacedc__test_1_1assertlessthan_a15ee372c39f1cfb6e89ec2da849b15f3}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint6@{dctestassertlessthanint6}}
\index{dctestassertlessthanint6@{dctestassertlessthanint6}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint6()}{dctestassertlessthanint6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint6 (\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 14620 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
14620     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
14621     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
14622     \textcolor{keywordtype}{implicit none}
14623     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
14624     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
14625     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
14626     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
14627     \textcolor{keywordtype}{logical}:: err\_flag
14628     \textcolor{keywordtype}{logical}:: negative\_support\_on
14629     \textcolor{keywordtype}{character(STRING)}:: pos\_str
14630     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
14631     \textcolor{keywordtype}{integer}:: wrong, right
14632 
14633                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
14634     \textcolor{keywordtype}{logical}:: consist\_shape(6)
14635     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
14636     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
14637     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
14638     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
14639     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
14640     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
14641     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
14642                     
14643 
14644   \textcolor{keywordflow}{continue}
14645     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
14646       negative\_support\_on = negative\_support
14647     \textcolor{keywordflow}{else}
14648       negative\_support\_on = .true.
14649 \textcolor{keywordflow}{    end if}
14650 
14651     err\_flag = .false.
14652 
14653                     
14654     answer\_shape = shape(answer)
14655     check\_shape = shape(check)
14656 
14657     consist\_shape = answer\_shape == check\_shape
14658 
14659     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
14660       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14661       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14662       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
14663       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
14664       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
14665 
14666       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14667 \textcolor{keywordflow}{    end if}
14668 
14669 
14670     \textcolor{keyword}{allocate}( mask\_array( &
14671                             &    answer\_shape(1), &
14672                       
14673       &    answer\_shape(2), &
14674                       
14675       &    answer\_shape(3), &
14676                       
14677       &    answer\_shape(4), &
14678                       
14679       &    answer\_shape(5), &
14680                       
14681       &    answer\_shape(6)  )  &
14682       &  )
14683 
14684     \textcolor{keyword}{allocate}( judge( &
14685                             &    answer\_shape(1), &
14686                       
14687       &    answer\_shape(2), &
14688                       
14689       &    answer\_shape(3), &
14690                       
14691       &    answer\_shape(4), &
14692                       
14693       &    answer\_shape(5), &
14694                       
14695       &    answer\_shape(6)  )  &
14696       &  )
14697 
14698     \textcolor{keyword}{allocate}( judge\_rev( &
14699                             &    answer\_shape(1), &
14700                       
14701       &    answer\_shape(2), &
14702                       
14703       &    answer\_shape(3), &
14704                       
14705       &    answer\_shape(4), &
14706                       
14707       &    answer\_shape(5), &
14708                       
14709       &    answer\_shape(6)  )  &
14710       &  )
14711 
14712     \textcolor{keyword}{allocate}( answer\_negative( &
14713                             &    answer\_shape(1), &
14714                       
14715       &    answer\_shape(2), &
14716                       
14717       &    answer\_shape(3), &
14718                       
14719       &    answer\_shape(4), &
14720                       
14721       &    answer\_shape(5), &
14722                       
14723       &    answer\_shape(6)  )  &
14724       &  )
14725 
14726     \textcolor{keyword}{allocate}( check\_negative( &
14727                             &    answer\_shape(1), &
14728                       
14729       &    answer\_shape(2), &
14730                       
14731       &    answer\_shape(3), &
14732                       
14733       &    answer\_shape(4), &
14734                       
14735       &    answer\_shape(5), &
14736                       
14737       &    answer\_shape(6)  )  &
14738       &  )
14739 
14740     \textcolor{keyword}{allocate}( both\_negative( &
14741                             &    answer\_shape(1), &
14742                       
14743       &    answer\_shape(2), &
14744                       
14745       &    answer\_shape(3), &
14746                       
14747       &    answer\_shape(4), &
14748                       
14749       &    answer\_shape(5), &
14750                       
14751       &    answer\_shape(6)  )  &
14752       &  )
14753 
14754     answer\_negative = answer < 0
14755     check\_negative = check < 0
14756     both\_negative = answer\_negative .and. check\_negative
14757     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
14758 
14759     judge = answer > check
14760     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
14761 
14762     judge\_rev = .not. judge
14763     err\_flag = any(judge\_rev)
14764     mask\_array = 1
14765     pos = maxloc(mask\_array, judge\_rev)
14766 
14767     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14768 
14769       wrong = check( &
14770                               &    pos(1), &
14771                       
14772         &    pos(2), &
14773                       
14774         &    pos(3), &
14775                       
14776         &    pos(4), &
14777                       
14778         &    pos(5), &
14779                       
14780         &    pos(6)  )
14781 
14782       right = answer( &
14783                               &    pos(1), &
14784                       
14785         &    pos(2), &
14786                       
14787         &    pos(3), &
14788                       
14789         &    pos(4), &
14790                       
14791         &    pos(5), &
14792                       
14793         &    pos(6)  )
14794 
14795                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
14796                       
14797       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
14798                       
14799       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
14800                       
14801       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
14802                       
14803       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
14804                       
14805       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
14806                       
14807 
14808       pos\_str = \textcolor{stringliteral}{'('} // &
14809                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
14810                       
14811         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
14812                       
14813         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
14814                       
14815         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
14816                       
14817         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
14818                       
14819         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
14820 
14821       \textcolor{keywordflow}{if} ( both\_negative( &
14822                               &    pos(1), &
14823                       
14824         &    pos(2), &
14825                       
14826         &    pos(3), &
14827                       
14828         &    pos(4), &
14829                       
14830         &    pos(5), &
14831                       
14832         &    pos(6)  )  ) \textcolor{keywordflow}{then}
14833 
14834         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
14835       \textcolor{keywordflow}{else}
14836         abs\_mes = \textcolor{stringliteral}{''}
14837 
14838 \textcolor{keywordflow}{      end if}
14839 
14840 \textcolor{keywordflow}{    end if}
14841     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
14842     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
14843 
14844                     
14845 
14846 
14847     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
14848       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14849       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14850       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14851         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
14852       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
14853       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
14854         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
14855 
14856       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14857     \textcolor{keywordflow}{else}
14858       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
14859 \textcolor{keywordflow}{    end if}
14860 
14861 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a28e394c78a099c83f8b59aa85df81f9c}\label{interfacedc__test_1_1assertlessthan_a28e394c78a099c83f8b59aa85df81f9c}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanint7@{dctestassertlessthanint7}}
\index{dctestassertlessthanint7@{dctestassertlessthanint7}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanint7()}{dctestassertlessthanint7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanint7 (\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 14867 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
14867     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
14868     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
14869     \textcolor{keywordtype}{implicit none}
14870     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
14871     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
14872     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
14873     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
14874     \textcolor{keywordtype}{logical}:: err\_flag
14875     \textcolor{keywordtype}{logical}:: negative\_support\_on
14876     \textcolor{keywordtype}{character(STRING)}:: pos\_str
14877     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
14878     \textcolor{keywordtype}{integer}:: wrong, right
14879 
14880                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
14881     \textcolor{keywordtype}{logical}:: consist\_shape(7)
14882     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
14883     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
14884     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
14885     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
14886     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
14887     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
14888     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
14889                     
14890 
14891   \textcolor{keywordflow}{continue}
14892     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
14893       negative\_support\_on = negative\_support
14894     \textcolor{keywordflow}{else}
14895       negative\_support\_on = .true.
14896 \textcolor{keywordflow}{    end if}
14897 
14898     err\_flag = .false.
14899 
14900                     
14901     answer\_shape = shape(answer)
14902     check\_shape = shape(check)
14903 
14904     consist\_shape = answer\_shape == check\_shape
14905 
14906     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
14907       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
14908       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
14909       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
14910       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
14911       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
14912 
14913       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
14914 \textcolor{keywordflow}{    end if}
14915 
14916 
14917     \textcolor{keyword}{allocate}( mask\_array( &
14918                             &    answer\_shape(1), &
14919                       
14920       &    answer\_shape(2), &
14921                       
14922       &    answer\_shape(3), &
14923                       
14924       &    answer\_shape(4), &
14925                       
14926       &    answer\_shape(5), &
14927                       
14928       &    answer\_shape(6), &
14929                       
14930       &    answer\_shape(7)  )  &
14931       &  )
14932 
14933     \textcolor{keyword}{allocate}( judge( &
14934                             &    answer\_shape(1), &
14935                       
14936       &    answer\_shape(2), &
14937                       
14938       &    answer\_shape(3), &
14939                       
14940       &    answer\_shape(4), &
14941                       
14942       &    answer\_shape(5), &
14943                       
14944       &    answer\_shape(6), &
14945                       
14946       &    answer\_shape(7)  )  &
14947       &  )
14948 
14949     \textcolor{keyword}{allocate}( judge\_rev( &
14950                             &    answer\_shape(1), &
14951                       
14952       &    answer\_shape(2), &
14953                       
14954       &    answer\_shape(3), &
14955                       
14956       &    answer\_shape(4), &
14957                       
14958       &    answer\_shape(5), &
14959                       
14960       &    answer\_shape(6), &
14961                       
14962       &    answer\_shape(7)  )  &
14963       &  )
14964 
14965     \textcolor{keyword}{allocate}( answer\_negative( &
14966                             &    answer\_shape(1), &
14967                       
14968       &    answer\_shape(2), &
14969                       
14970       &    answer\_shape(3), &
14971                       
14972       &    answer\_shape(4), &
14973                       
14974       &    answer\_shape(5), &
14975                       
14976       &    answer\_shape(6), &
14977                       
14978       &    answer\_shape(7)  )  &
14979       &  )
14980 
14981     \textcolor{keyword}{allocate}( check\_negative( &
14982                             &    answer\_shape(1), &
14983                       
14984       &    answer\_shape(2), &
14985                       
14986       &    answer\_shape(3), &
14987                       
14988       &    answer\_shape(4), &
14989                       
14990       &    answer\_shape(5), &
14991                       
14992       &    answer\_shape(6), &
14993                       
14994       &    answer\_shape(7)  )  &
14995       &  )
14996 
14997     \textcolor{keyword}{allocate}( both\_negative( &
14998                             &    answer\_shape(1), &
14999                       
15000       &    answer\_shape(2), &
15001                       
15002       &    answer\_shape(3), &
15003                       
15004       &    answer\_shape(4), &
15005                       
15006       &    answer\_shape(5), &
15007                       
15008       &    answer\_shape(6), &
15009                       
15010       &    answer\_shape(7)  )  &
15011       &  )
15012 
15013     answer\_negative = answer < 0
15014     check\_negative = check < 0
15015     both\_negative = answer\_negative .and. check\_negative
15016     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
15017 
15018     judge = answer > check
15019     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
15020 
15021     judge\_rev = .not. judge
15022     err\_flag = any(judge\_rev)
15023     mask\_array = 1
15024     pos = maxloc(mask\_array, judge\_rev)
15025 
15026     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15027 
15028       wrong = check( &
15029                               &    pos(1), &
15030                       
15031         &    pos(2), &
15032                       
15033         &    pos(3), &
15034                       
15035         &    pos(4), &
15036                       
15037         &    pos(5), &
15038                       
15039         &    pos(6), &
15040                       
15041         &    pos(7)  )
15042 
15043       right = answer( &
15044                               &    pos(1), &
15045                       
15046         &    pos(2), &
15047                       
15048         &    pos(3), &
15049                       
15050         &    pos(4), &
15051                       
15052         &    pos(5), &
15053                       
15054         &    pos(6), &
15055                       
15056         &    pos(7)  )
15057 
15058                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
15059                       
15060       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
15061                       
15062       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
15063                       
15064       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
15065                       
15066       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
15067                       
15068       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
15069                       
15070       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
15071                       
15072 
15073       pos\_str = \textcolor{stringliteral}{'('} // &
15074                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
15075                       
15076         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
15077                       
15078         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
15079                       
15080         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
15081                       
15082         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
15083                       
15084         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
15085                       
15086         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
15087 
15088       \textcolor{keywordflow}{if} ( both\_negative( &
15089                               &    pos(1), &
15090                       
15091         &    pos(2), &
15092                       
15093         &    pos(3), &
15094                       
15095         &    pos(4), &
15096                       
15097         &    pos(5), &
15098                       
15099         &    pos(6), &
15100                       
15101         &    pos(7)  )  ) \textcolor{keywordflow}{then}
15102 
15103         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15104       \textcolor{keywordflow}{else}
15105         abs\_mes = \textcolor{stringliteral}{''}
15106 
15107 \textcolor{keywordflow}{      end if}
15108 
15109 \textcolor{keywordflow}{    end if}
15110     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
15111     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
15112 
15113                     
15114 
15115 
15116     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15117       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15118       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15119       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15120         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15121       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15122       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15123         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15124 
15125       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15126     \textcolor{keywordflow}{else}
15127       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15128 \textcolor{keywordflow}{    end if}
15129 
15130 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a5ecdb315f909c53421295eb4b4d041f5}\label{interfacedc__test_1_1assertlessthan_a5ecdb315f909c53421295eb4b4d041f5}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal0@{dctestassertlessthanreal0}}
\index{dctestassertlessthanreal0@{dctestassertlessthanreal0}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal0()}{dctestassertlessthanreal0()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal0 (\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 15136 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15136     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15137     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15138     \textcolor{keywordtype}{implicit none}
15139     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15140     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer
15141     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check
15142     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15143     \textcolor{keywordtype}{logical}:: err\_flag
15144     \textcolor{keywordtype}{logical}:: negative\_support\_on
15145     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15146     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15147     \textcolor{keywordtype}{real}:: wrong, right
15148 
15149                                         
15150 
15151   \textcolor{keywordflow}{continue}
15152     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15153       negative\_support\_on = negative\_support
15154     \textcolor{keywordflow}{else}
15155       negative\_support\_on = .true.
15156 \textcolor{keywordflow}{    end if}
15157 
15158     err\_flag = .false.
15159 
15160                     
15161 
15162 
15163     err\_flag = .not. answer > check
15164     abs\_mes = \textcolor{stringliteral}{''}
15165 
15166     \textcolor{keywordflow}{if} ( answer < 0.0 &
15167       &  .and. check < 0.0 &
15168       &  .and. negative\_support\_on ) \textcolor{keywordflow}{then}
15169 
15170       err\_flag = .not. err\_flag
15171       abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15172 \textcolor{keywordflow}{    end if}
15173 
15174     wrong = check
15175     right = answer
15176     pos\_str = \textcolor{stringliteral}{''}
15177 
15178                     
15179 
15180 
15181     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15182       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15183       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15184       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15185         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15186       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15187       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15188         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15189 
15190       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15191     \textcolor{keywordflow}{else}
15192       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15193 \textcolor{keywordflow}{    end if}
15194 
15195 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_ae8efff2c6e06a7734d01e16c91a932b6}\label{interfacedc__test_1_1assertlessthan_ae8efff2c6e06a7734d01e16c91a932b6}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal1@{dctestassertlessthanreal1}}
\index{dctestassertlessthanreal1@{dctestassertlessthanreal1}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal1()}{dctestassertlessthanreal1()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal1 (\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 15201 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15201     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15202     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15203     \textcolor{keywordtype}{implicit none}
15204     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15205     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:)
15206     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:)
15207     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15208     \textcolor{keywordtype}{logical}:: err\_flag
15209     \textcolor{keywordtype}{logical}:: negative\_support\_on
15210     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15211     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15212     \textcolor{keywordtype}{real}:: wrong, right
15213 
15214                         \textcolor{keywordtype}{integer}:: answer\_shape(1), check\_shape(1), pos(1)
15215     \textcolor{keywordtype}{logical}:: consist\_shape(1)
15216     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(1)
15217     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:)
15218     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:)
15219     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:)
15220     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:)
15221     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:)
15222     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:)
15223                     
15224 
15225   \textcolor{keywordflow}{continue}
15226     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15227       negative\_support\_on = negative\_support
15228     \textcolor{keywordflow}{else}
15229       negative\_support\_on = .true.
15230 \textcolor{keywordflow}{    end if}
15231 
15232     err\_flag = .false.
15233 
15234                     
15235     answer\_shape = shape(answer)
15236     check\_shape = shape(check)
15237 
15238     consist\_shape = answer\_shape == check\_shape
15239 
15240     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
15241       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15242       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15243       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
15244       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
15245       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
15246 
15247       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15248 \textcolor{keywordflow}{    end if}
15249 
15250 
15251     \textcolor{keyword}{allocate}( mask\_array( &
15252                       
15253       &    answer\_shape(1)  )  &
15254       &  )
15255 
15256     \textcolor{keyword}{allocate}( judge( &
15257                       
15258       &    answer\_shape(1)  )  &
15259       &  )
15260 
15261     \textcolor{keyword}{allocate}( judge\_rev( &
15262                       
15263       &    answer\_shape(1)  )  &
15264       &  )
15265 
15266     \textcolor{keyword}{allocate}( answer\_negative( &
15267                       
15268       &    answer\_shape(1)  )  &
15269       &  )
15270 
15271     \textcolor{keyword}{allocate}( check\_negative( &
15272                       
15273       &    answer\_shape(1)  )  &
15274       &  )
15275 
15276     \textcolor{keyword}{allocate}( both\_negative( &
15277                       
15278       &    answer\_shape(1)  )  &
15279       &  )
15280 
15281     answer\_negative = answer < 0.0
15282     check\_negative = check < 0.0
15283     both\_negative = answer\_negative .and. check\_negative
15284     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
15285 
15286     judge = answer > check
15287     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
15288 
15289     judge\_rev = .not. judge
15290     err\_flag = any(judge\_rev)
15291     mask\_array = 1
15292     pos = maxloc(mask\_array, judge\_rev)
15293 
15294     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15295 
15296       wrong = check( &
15297                       
15298         &    pos(1)  )
15299 
15300       right = answer( &
15301                       
15302         &    pos(1)  )
15303 
15304                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
15305                       
15306 
15307       pos\_str = \textcolor{stringliteral}{'('} // &
15308                       
15309         &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{')'}
15310 
15311       \textcolor{keywordflow}{if} ( both\_negative( &
15312                       
15313         &    pos(1)  )  ) \textcolor{keywordflow}{then}
15314 
15315         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15316       \textcolor{keywordflow}{else}
15317         abs\_mes = \textcolor{stringliteral}{''}
15318 
15319 \textcolor{keywordflow}{      end if}
15320 
15321 \textcolor{keywordflow}{    end if}
15322     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
15323     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
15324 
15325                     
15326 
15327 
15328     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15329       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15330       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15331       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15332         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15333       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15334       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15335         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15336 
15337       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15338     \textcolor{keywordflow}{else}
15339       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15340 \textcolor{keywordflow}{    end if}
15341 
15342 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a2684338cf7d47baf4f08a0e2219a9b3a}\label{interfacedc__test_1_1assertlessthan_a2684338cf7d47baf4f08a0e2219a9b3a}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal2@{dctestassertlessthanreal2}}
\index{dctestassertlessthanreal2@{dctestassertlessthanreal2}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal2()}{dctestassertlessthanreal2()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal2 (\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 15348 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15348     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15349     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15350     \textcolor{keywordtype}{implicit none}
15351     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15352     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:)
15353     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:)
15354     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15355     \textcolor{keywordtype}{logical}:: err\_flag
15356     \textcolor{keywordtype}{logical}:: negative\_support\_on
15357     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15358     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15359     \textcolor{keywordtype}{real}:: wrong, right
15360 
15361                         \textcolor{keywordtype}{integer}:: answer\_shape(2), check\_shape(2), pos(2)
15362     \textcolor{keywordtype}{logical}:: consist\_shape(2)
15363     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(2)
15364     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:)
15365     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:)
15366     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:)
15367     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:)
15368     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:)
15369     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:)
15370                     
15371 
15372   \textcolor{keywordflow}{continue}
15373     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15374       negative\_support\_on = negative\_support
15375     \textcolor{keywordflow}{else}
15376       negative\_support\_on = .true.
15377 \textcolor{keywordflow}{    end if}
15378 
15379     err\_flag = .false.
15380 
15381                     
15382     answer\_shape = shape(answer)
15383     check\_shape = shape(check)
15384 
15385     consist\_shape = answer\_shape == check\_shape
15386 
15387     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
15388       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15389       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15390       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
15391       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
15392       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
15393 
15394       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15395 \textcolor{keywordflow}{    end if}
15396 
15397 
15398     \textcolor{keyword}{allocate}( mask\_array( &
15399                             &    answer\_shape(1), &
15400                       
15401       &    answer\_shape(2)  )  &
15402       &  )
15403 
15404     \textcolor{keyword}{allocate}( judge( &
15405                             &    answer\_shape(1), &
15406                       
15407       &    answer\_shape(2)  )  &
15408       &  )
15409 
15410     \textcolor{keyword}{allocate}( judge\_rev( &
15411                             &    answer\_shape(1), &
15412                       
15413       &    answer\_shape(2)  )  &
15414       &  )
15415 
15416     \textcolor{keyword}{allocate}( answer\_negative( &
15417                             &    answer\_shape(1), &
15418                       
15419       &    answer\_shape(2)  )  &
15420       &  )
15421 
15422     \textcolor{keyword}{allocate}( check\_negative( &
15423                             &    answer\_shape(1), &
15424                       
15425       &    answer\_shape(2)  )  &
15426       &  )
15427 
15428     \textcolor{keyword}{allocate}( both\_negative( &
15429                             &    answer\_shape(1), &
15430                       
15431       &    answer\_shape(2)  )  &
15432       &  )
15433 
15434     answer\_negative = answer < 0.0
15435     check\_negative = check < 0.0
15436     both\_negative = answer\_negative .and. check\_negative
15437     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
15438 
15439     judge = answer > check
15440     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
15441 
15442     judge\_rev = .not. judge
15443     err\_flag = any(judge\_rev)
15444     mask\_array = 1
15445     pos = maxloc(mask\_array, judge\_rev)
15446 
15447     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15448 
15449       wrong = check( &
15450                               &    pos(1), &
15451                       
15452         &    pos(2)  )
15453 
15454       right = answer( &
15455                               &    pos(1), &
15456                       
15457         &    pos(2)  )
15458 
15459                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
15460                       
15461       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
15462                       
15463 
15464       pos\_str = \textcolor{stringliteral}{'('} // &
15465                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
15466                       
15467         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{')'}
15468 
15469       \textcolor{keywordflow}{if} ( both\_negative( &
15470                               &    pos(1), &
15471                       
15472         &    pos(2)  )  ) \textcolor{keywordflow}{then}
15473 
15474         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15475       \textcolor{keywordflow}{else}
15476         abs\_mes = \textcolor{stringliteral}{''}
15477 
15478 \textcolor{keywordflow}{      end if}
15479 
15480 \textcolor{keywordflow}{    end if}
15481     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
15482     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
15483 
15484                     
15485 
15486 
15487     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15488       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15489       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15490       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15491         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15492       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15493       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15494         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15495 
15496       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15497     \textcolor{keywordflow}{else}
15498       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15499 \textcolor{keywordflow}{    end if}
15500 
15501 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a6e8bcff0d59f1ceb616158d3e1865db5}\label{interfacedc__test_1_1assertlessthan_a6e8bcff0d59f1ceb616158d3e1865db5}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal3@{dctestassertlessthanreal3}}
\index{dctestassertlessthanreal3@{dctestassertlessthanreal3}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal3()}{dctestassertlessthanreal3()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal3 (\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 15507 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15507     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15508     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15509     \textcolor{keywordtype}{implicit none}
15510     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15511     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:)
15512     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:)
15513     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15514     \textcolor{keywordtype}{logical}:: err\_flag
15515     \textcolor{keywordtype}{logical}:: negative\_support\_on
15516     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15517     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15518     \textcolor{keywordtype}{real}:: wrong, right
15519 
15520                         \textcolor{keywordtype}{integer}:: answer\_shape(3), check\_shape(3), pos(3)
15521     \textcolor{keywordtype}{logical}:: consist\_shape(3)
15522     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(3)
15523     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:)
15524     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:)
15525     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:)
15526     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:)
15527     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:)
15528     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:)
15529                     
15530 
15531   \textcolor{keywordflow}{continue}
15532     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15533       negative\_support\_on = negative\_support
15534     \textcolor{keywordflow}{else}
15535       negative\_support\_on = .true.
15536 \textcolor{keywordflow}{    end if}
15537 
15538     err\_flag = .false.
15539 
15540                     
15541     answer\_shape = shape(answer)
15542     check\_shape = shape(check)
15543 
15544     consist\_shape = answer\_shape == check\_shape
15545 
15546     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
15547       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15548       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15549       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
15550       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
15551       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
15552 
15553       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15554 \textcolor{keywordflow}{    end if}
15555 
15556 
15557     \textcolor{keyword}{allocate}( mask\_array( &
15558                             &    answer\_shape(1), &
15559                       
15560       &    answer\_shape(2), &
15561                       
15562       &    answer\_shape(3)  )  &
15563       &  )
15564 
15565     \textcolor{keyword}{allocate}( judge( &
15566                             &    answer\_shape(1), &
15567                       
15568       &    answer\_shape(2), &
15569                       
15570       &    answer\_shape(3)  )  &
15571       &  )
15572 
15573     \textcolor{keyword}{allocate}( judge\_rev( &
15574                             &    answer\_shape(1), &
15575                       
15576       &    answer\_shape(2), &
15577                       
15578       &    answer\_shape(3)  )  &
15579       &  )
15580 
15581     \textcolor{keyword}{allocate}( answer\_negative( &
15582                             &    answer\_shape(1), &
15583                       
15584       &    answer\_shape(2), &
15585                       
15586       &    answer\_shape(3)  )  &
15587       &  )
15588 
15589     \textcolor{keyword}{allocate}( check\_negative( &
15590                             &    answer\_shape(1), &
15591                       
15592       &    answer\_shape(2), &
15593                       
15594       &    answer\_shape(3)  )  &
15595       &  )
15596 
15597     \textcolor{keyword}{allocate}( both\_negative( &
15598                             &    answer\_shape(1), &
15599                       
15600       &    answer\_shape(2), &
15601                       
15602       &    answer\_shape(3)  )  &
15603       &  )
15604 
15605     answer\_negative = answer < 0.0
15606     check\_negative = check < 0.0
15607     both\_negative = answer\_negative .and. check\_negative
15608     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
15609 
15610     judge = answer > check
15611     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
15612 
15613     judge\_rev = .not. judge
15614     err\_flag = any(judge\_rev)
15615     mask\_array = 1
15616     pos = maxloc(mask\_array, judge\_rev)
15617 
15618     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15619 
15620       wrong = check( &
15621                               &    pos(1), &
15622                       
15623         &    pos(2), &
15624                       
15625         &    pos(3)  )
15626 
15627       right = answer( &
15628                               &    pos(1), &
15629                       
15630         &    pos(2), &
15631                       
15632         &    pos(3)  )
15633 
15634                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
15635                       
15636       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
15637                       
15638       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
15639                       
15640 
15641       pos\_str = \textcolor{stringliteral}{'('} // &
15642                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
15643                       
15644         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
15645                       
15646         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{')'}
15647 
15648       \textcolor{keywordflow}{if} ( both\_negative( &
15649                               &    pos(1), &
15650                       
15651         &    pos(2), &
15652                       
15653         &    pos(3)  )  ) \textcolor{keywordflow}{then}
15654 
15655         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15656       \textcolor{keywordflow}{else}
15657         abs\_mes = \textcolor{stringliteral}{''}
15658 
15659 \textcolor{keywordflow}{      end if}
15660 
15661 \textcolor{keywordflow}{    end if}
15662     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
15663     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
15664 
15665                     
15666 
15667 
15668     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15669       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15670       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15671       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15672         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15673       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15674       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15675         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15676 
15677       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15678     \textcolor{keywordflow}{else}
15679       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15680 \textcolor{keywordflow}{    end if}
15681 
15682 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_acf1c4e3aba060ffba4093d17b72a4a8a}\label{interfacedc__test_1_1assertlessthan_acf1c4e3aba060ffba4093d17b72a4a8a}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal4@{dctestassertlessthanreal4}}
\index{dctestassertlessthanreal4@{dctestassertlessthanreal4}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal4()}{dctestassertlessthanreal4()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal4 (\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 15688 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15688     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15689     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15690     \textcolor{keywordtype}{implicit none}
15691     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15692     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:)
15693     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:)
15694     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15695     \textcolor{keywordtype}{logical}:: err\_flag
15696     \textcolor{keywordtype}{logical}:: negative\_support\_on
15697     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15698     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15699     \textcolor{keywordtype}{real}:: wrong, right
15700 
15701                         \textcolor{keywordtype}{integer}:: answer\_shape(4), check\_shape(4), pos(4)
15702     \textcolor{keywordtype}{logical}:: consist\_shape(4)
15703     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(4)
15704     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:)
15705     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:)
15706     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:)
15707     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:)
15708     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:)
15709     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:)
15710                     
15711 
15712   \textcolor{keywordflow}{continue}
15713     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15714       negative\_support\_on = negative\_support
15715     \textcolor{keywordflow}{else}
15716       negative\_support\_on = .true.
15717 \textcolor{keywordflow}{    end if}
15718 
15719     err\_flag = .false.
15720 
15721                     
15722     answer\_shape = shape(answer)
15723     check\_shape = shape(check)
15724 
15725     consist\_shape = answer\_shape == check\_shape
15726 
15727     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
15728       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15729       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15730       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
15731       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
15732       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
15733 
15734       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15735 \textcolor{keywordflow}{    end if}
15736 
15737 
15738     \textcolor{keyword}{allocate}( mask\_array( &
15739                             &    answer\_shape(1), &
15740                       
15741       &    answer\_shape(2), &
15742                       
15743       &    answer\_shape(3), &
15744                       
15745       &    answer\_shape(4)  )  &
15746       &  )
15747 
15748     \textcolor{keyword}{allocate}( judge( &
15749                             &    answer\_shape(1), &
15750                       
15751       &    answer\_shape(2), &
15752                       
15753       &    answer\_shape(3), &
15754                       
15755       &    answer\_shape(4)  )  &
15756       &  )
15757 
15758     \textcolor{keyword}{allocate}( judge\_rev( &
15759                             &    answer\_shape(1), &
15760                       
15761       &    answer\_shape(2), &
15762                       
15763       &    answer\_shape(3), &
15764                       
15765       &    answer\_shape(4)  )  &
15766       &  )
15767 
15768     \textcolor{keyword}{allocate}( answer\_negative( &
15769                             &    answer\_shape(1), &
15770                       
15771       &    answer\_shape(2), &
15772                       
15773       &    answer\_shape(3), &
15774                       
15775       &    answer\_shape(4)  )  &
15776       &  )
15777 
15778     \textcolor{keyword}{allocate}( check\_negative( &
15779                             &    answer\_shape(1), &
15780                       
15781       &    answer\_shape(2), &
15782                       
15783       &    answer\_shape(3), &
15784                       
15785       &    answer\_shape(4)  )  &
15786       &  )
15787 
15788     \textcolor{keyword}{allocate}( both\_negative( &
15789                             &    answer\_shape(1), &
15790                       
15791       &    answer\_shape(2), &
15792                       
15793       &    answer\_shape(3), &
15794                       
15795       &    answer\_shape(4)  )  &
15796       &  )
15797 
15798     answer\_negative = answer < 0.0
15799     check\_negative = check < 0.0
15800     both\_negative = answer\_negative .and. check\_negative
15801     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
15802 
15803     judge = answer > check
15804     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
15805 
15806     judge\_rev = .not. judge
15807     err\_flag = any(judge\_rev)
15808     mask\_array = 1
15809     pos = maxloc(mask\_array, judge\_rev)
15810 
15811     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15812 
15813       wrong = check( &
15814                               &    pos(1), &
15815                       
15816         &    pos(2), &
15817                       
15818         &    pos(3), &
15819                       
15820         &    pos(4)  )
15821 
15822       right = answer( &
15823                               &    pos(1), &
15824                       
15825         &    pos(2), &
15826                       
15827         &    pos(3), &
15828                       
15829         &    pos(4)  )
15830 
15831                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
15832                       
15833       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
15834                       
15835       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
15836                       
15837       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
15838                       
15839 
15840       pos\_str = \textcolor{stringliteral}{'('} // &
15841                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
15842                       
15843         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
15844                       
15845         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
15846                       
15847         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{')'}
15848 
15849       \textcolor{keywordflow}{if} ( both\_negative( &
15850                               &    pos(1), &
15851                       
15852         &    pos(2), &
15853                       
15854         &    pos(3), &
15855                       
15856         &    pos(4)  )  ) \textcolor{keywordflow}{then}
15857 
15858         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
15859       \textcolor{keywordflow}{else}
15860         abs\_mes = \textcolor{stringliteral}{''}
15861 
15862 \textcolor{keywordflow}{      end if}
15863 
15864 \textcolor{keywordflow}{    end if}
15865     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
15866     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
15867 
15868                     
15869 
15870 
15871     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
15872       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15873       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15874       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15875         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
15876       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
15877       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
15878         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
15879 
15880       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15881     \textcolor{keywordflow}{else}
15882       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
15883 \textcolor{keywordflow}{    end if}
15884 
15885 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a9ad1d93294719fafaa64bb4a48bedc70}\label{interfacedc__test_1_1assertlessthan_a9ad1d93294719fafaa64bb4a48bedc70}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal5@{dctestassertlessthanreal5}}
\index{dctestassertlessthanreal5@{dctestassertlessthanreal5}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal5()}{dctestassertlessthanreal5()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal5 (\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 15891 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
15891     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
15892     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
15893     \textcolor{keywordtype}{implicit none}
15894     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
15895     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:)
15896     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:)
15897     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
15898     \textcolor{keywordtype}{logical}:: err\_flag
15899     \textcolor{keywordtype}{logical}:: negative\_support\_on
15900     \textcolor{keywordtype}{character(STRING)}:: pos\_str
15901     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
15902     \textcolor{keywordtype}{real}:: wrong, right
15903 
15904                         \textcolor{keywordtype}{integer}:: answer\_shape(5), check\_shape(5), pos(5)
15905     \textcolor{keywordtype}{logical}:: consist\_shape(5)
15906     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(5)
15907     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:)
15908     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:)
15909     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:)
15910     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:)
15911     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:)
15912     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:)
15913                     
15914 
15915   \textcolor{keywordflow}{continue}
15916     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
15917       negative\_support\_on = negative\_support
15918     \textcolor{keywordflow}{else}
15919       negative\_support\_on = .true.
15920 \textcolor{keywordflow}{    end if}
15921 
15922     err\_flag = .false.
15923 
15924                     
15925     answer\_shape = shape(answer)
15926     check\_shape = shape(check)
15927 
15928     consist\_shape = answer\_shape == check\_shape
15929 
15930     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
15931       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
15932       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
15933       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
15934       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
15935       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
15936 
15937       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
15938 \textcolor{keywordflow}{    end if}
15939 
15940 
15941     \textcolor{keyword}{allocate}( mask\_array( &
15942                             &    answer\_shape(1), &
15943                       
15944       &    answer\_shape(2), &
15945                       
15946       &    answer\_shape(3), &
15947                       
15948       &    answer\_shape(4), &
15949                       
15950       &    answer\_shape(5)  )  &
15951       &  )
15952 
15953     \textcolor{keyword}{allocate}( judge( &
15954                             &    answer\_shape(1), &
15955                       
15956       &    answer\_shape(2), &
15957                       
15958       &    answer\_shape(3), &
15959                       
15960       &    answer\_shape(4), &
15961                       
15962       &    answer\_shape(5)  )  &
15963       &  )
15964 
15965     \textcolor{keyword}{allocate}( judge\_rev( &
15966                             &    answer\_shape(1), &
15967                       
15968       &    answer\_shape(2), &
15969                       
15970       &    answer\_shape(3), &
15971                       
15972       &    answer\_shape(4), &
15973                       
15974       &    answer\_shape(5)  )  &
15975       &  )
15976 
15977     \textcolor{keyword}{allocate}( answer\_negative( &
15978                             &    answer\_shape(1), &
15979                       
15980       &    answer\_shape(2), &
15981                       
15982       &    answer\_shape(3), &
15983                       
15984       &    answer\_shape(4), &
15985                       
15986       &    answer\_shape(5)  )  &
15987       &  )
15988 
15989     \textcolor{keyword}{allocate}( check\_negative( &
15990                             &    answer\_shape(1), &
15991                       
15992       &    answer\_shape(2), &
15993                       
15994       &    answer\_shape(3), &
15995                       
15996       &    answer\_shape(4), &
15997                       
15998       &    answer\_shape(5)  )  &
15999       &  )
16000 
16001     \textcolor{keyword}{allocate}( both\_negative( &
16002                             &    answer\_shape(1), &
16003                       
16004       &    answer\_shape(2), &
16005                       
16006       &    answer\_shape(3), &
16007                       
16008       &    answer\_shape(4), &
16009                       
16010       &    answer\_shape(5)  )  &
16011       &  )
16012 
16013     answer\_negative = answer < 0.0
16014     check\_negative = check < 0.0
16015     both\_negative = answer\_negative .and. check\_negative
16016     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
16017 
16018     judge = answer > check
16019     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
16020 
16021     judge\_rev = .not. judge
16022     err\_flag = any(judge\_rev)
16023     mask\_array = 1
16024     pos = maxloc(mask\_array, judge\_rev)
16025 
16026     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16027 
16028       wrong = check( &
16029                               &    pos(1), &
16030                       
16031         &    pos(2), &
16032                       
16033         &    pos(3), &
16034                       
16035         &    pos(4), &
16036                       
16037         &    pos(5)  )
16038 
16039       right = answer( &
16040                               &    pos(1), &
16041                       
16042         &    pos(2), &
16043                       
16044         &    pos(3), &
16045                       
16046         &    pos(4), &
16047                       
16048         &    pos(5)  )
16049 
16050                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
16051                       
16052       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
16053                       
16054       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
16055                       
16056       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
16057                       
16058       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
16059                       
16060 
16061       pos\_str = \textcolor{stringliteral}{'('} // &
16062                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
16063                       
16064         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
16065                       
16066         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
16067                       
16068         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
16069                       
16070         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{')'}
16071 
16072       \textcolor{keywordflow}{if} ( both\_negative( &
16073                               &    pos(1), &
16074                       
16075         &    pos(2), &
16076                       
16077         &    pos(3), &
16078                       
16079         &    pos(4), &
16080                       
16081         &    pos(5)  )  ) \textcolor{keywordflow}{then}
16082 
16083         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16084       \textcolor{keywordflow}{else}
16085         abs\_mes = \textcolor{stringliteral}{''}
16086 
16087 \textcolor{keywordflow}{      end if}
16088 
16089 \textcolor{keywordflow}{    end if}
16090     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
16091     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
16092 
16093                     
16094 
16095 
16096     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16097       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16098       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16099       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16100         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16101       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16102       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16103         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16104 
16105       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16106     \textcolor{keywordflow}{else}
16107       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16108 \textcolor{keywordflow}{    end if}
16109 
16110 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a3d0396421684d7c05414e601c6726078}\label{interfacedc__test_1_1assertlessthan_a3d0396421684d7c05414e601c6726078}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal6@{dctestassertlessthanreal6}}
\index{dctestassertlessthanreal6@{dctestassertlessthanreal6}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal6()}{dctestassertlessthanreal6()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal6 (\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 16116 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
16116     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
16117     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
16118     \textcolor{keywordtype}{implicit none}
16119     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
16120     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:)
16121     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:)
16122     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
16123     \textcolor{keywordtype}{logical}:: err\_flag
16124     \textcolor{keywordtype}{logical}:: negative\_support\_on
16125     \textcolor{keywordtype}{character(STRING)}:: pos\_str
16126     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
16127     \textcolor{keywordtype}{real}:: wrong, right
16128 
16129                         \textcolor{keywordtype}{integer}:: answer\_shape(6), check\_shape(6), pos(6)
16130     \textcolor{keywordtype}{logical}:: consist\_shape(6)
16131     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(6)
16132     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:)
16133     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:)
16134     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:)
16135     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:)
16136     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:)
16137     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:)
16138                     
16139 
16140   \textcolor{keywordflow}{continue}
16141     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
16142       negative\_support\_on = negative\_support
16143     \textcolor{keywordflow}{else}
16144       negative\_support\_on = .true.
16145 \textcolor{keywordflow}{    end if}
16146 
16147     err\_flag = .false.
16148 
16149                     
16150     answer\_shape = shape(answer)
16151     check\_shape = shape(check)
16152 
16153     consist\_shape = answer\_shape == check\_shape
16154 
16155     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
16156       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16157       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16158       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
16159       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
16160       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
16161 
16162       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16163 \textcolor{keywordflow}{    end if}
16164 
16165 
16166     \textcolor{keyword}{allocate}( mask\_array( &
16167                             &    answer\_shape(1), &
16168                       
16169       &    answer\_shape(2), &
16170                       
16171       &    answer\_shape(3), &
16172                       
16173       &    answer\_shape(4), &
16174                       
16175       &    answer\_shape(5), &
16176                       
16177       &    answer\_shape(6)  )  &
16178       &  )
16179 
16180     \textcolor{keyword}{allocate}( judge( &
16181                             &    answer\_shape(1), &
16182                       
16183       &    answer\_shape(2), &
16184                       
16185       &    answer\_shape(3), &
16186                       
16187       &    answer\_shape(4), &
16188                       
16189       &    answer\_shape(5), &
16190                       
16191       &    answer\_shape(6)  )  &
16192       &  )
16193 
16194     \textcolor{keyword}{allocate}( judge\_rev( &
16195                             &    answer\_shape(1), &
16196                       
16197       &    answer\_shape(2), &
16198                       
16199       &    answer\_shape(3), &
16200                       
16201       &    answer\_shape(4), &
16202                       
16203       &    answer\_shape(5), &
16204                       
16205       &    answer\_shape(6)  )  &
16206       &  )
16207 
16208     \textcolor{keyword}{allocate}( answer\_negative( &
16209                             &    answer\_shape(1), &
16210                       
16211       &    answer\_shape(2), &
16212                       
16213       &    answer\_shape(3), &
16214                       
16215       &    answer\_shape(4), &
16216                       
16217       &    answer\_shape(5), &
16218                       
16219       &    answer\_shape(6)  )  &
16220       &  )
16221 
16222     \textcolor{keyword}{allocate}( check\_negative( &
16223                             &    answer\_shape(1), &
16224                       
16225       &    answer\_shape(2), &
16226                       
16227       &    answer\_shape(3), &
16228                       
16229       &    answer\_shape(4), &
16230                       
16231       &    answer\_shape(5), &
16232                       
16233       &    answer\_shape(6)  )  &
16234       &  )
16235 
16236     \textcolor{keyword}{allocate}( both\_negative( &
16237                             &    answer\_shape(1), &
16238                       
16239       &    answer\_shape(2), &
16240                       
16241       &    answer\_shape(3), &
16242                       
16243       &    answer\_shape(4), &
16244                       
16245       &    answer\_shape(5), &
16246                       
16247       &    answer\_shape(6)  )  &
16248       &  )
16249 
16250     answer\_negative = answer < 0.0
16251     check\_negative = check < 0.0
16252     both\_negative = answer\_negative .and. check\_negative
16253     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
16254 
16255     judge = answer > check
16256     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
16257 
16258     judge\_rev = .not. judge
16259     err\_flag = any(judge\_rev)
16260     mask\_array = 1
16261     pos = maxloc(mask\_array, judge\_rev)
16262 
16263     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16264 
16265       wrong = check( &
16266                               &    pos(1), &
16267                       
16268         &    pos(2), &
16269                       
16270         &    pos(3), &
16271                       
16272         &    pos(4), &
16273                       
16274         &    pos(5), &
16275                       
16276         &    pos(6)  )
16277 
16278       right = answer( &
16279                               &    pos(1), &
16280                       
16281         &    pos(2), &
16282                       
16283         &    pos(3), &
16284                       
16285         &    pos(4), &
16286                       
16287         &    pos(5), &
16288                       
16289         &    pos(6)  )
16290 
16291                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
16292                       
16293       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
16294                       
16295       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
16296                       
16297       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
16298                       
16299       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
16300                       
16301       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
16302                       
16303 
16304       pos\_str = \textcolor{stringliteral}{'('} // &
16305                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
16306                       
16307         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
16308                       
16309         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
16310                       
16311         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
16312                       
16313         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
16314                       
16315         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{')'}
16316 
16317       \textcolor{keywordflow}{if} ( both\_negative( &
16318                               &    pos(1), &
16319                       
16320         &    pos(2), &
16321                       
16322         &    pos(3), &
16323                       
16324         &    pos(4), &
16325                       
16326         &    pos(5), &
16327                       
16328         &    pos(6)  )  ) \textcolor{keywordflow}{then}
16329 
16330         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16331       \textcolor{keywordflow}{else}
16332         abs\_mes = \textcolor{stringliteral}{''}
16333 
16334 \textcolor{keywordflow}{      end if}
16335 
16336 \textcolor{keywordflow}{    end if}
16337     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
16338     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
16339 
16340                     
16341 
16342 
16343     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16344       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16345       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16346       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16347         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16348       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16349       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16350         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16351 
16352       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16353     \textcolor{keywordflow}{else}
16354       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16355 \textcolor{keywordflow}{    end if}
16356 
16357 
\end{DoxyCode}
\mbox{\Hypertarget{interfacedc__test_1_1assertlessthan_a9604c13f01b2ebfa83c24e6af281b1de}\label{interfacedc__test_1_1assertlessthan_a9604c13f01b2ebfa83c24e6af281b1de}} 
\index{dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}!dctestassertlessthanreal7@{dctestassertlessthanreal7}}
\index{dctestassertlessthanreal7@{dctestassertlessthanreal7}!dc\+\_\+test\+::assertlessthan@{dc\+\_\+test\+::assertlessthan}}
\subsubsection{\texorpdfstring{dctestassertlessthanreal7()}{dctestassertlessthanreal7()}}
{\footnotesize\ttfamily subroutine dc\+\_\+test\+::assertlessthan\+::dctestassertlessthanreal7 (\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 16363 of file dc\+\_\+test.\+f90.


\begin{DoxyCode}
16363     \textcolor{keywordtype}{use }\hyperlink{namespacesysdep}{sysdep}\textcolor{keywordtype}{, only}: \hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}
16364     \textcolor{keywordtype}{use }\hyperlink{namespacedc__types}{dc\_types}\textcolor{keywordtype}{, only}: \hyperlink{namespacedc__types_adb76910ff05e3b9fe3436567f8f8dac6}{string}, \hyperlink{namespacedc__types_a6d28eb015ba84292a06f4ff25165b376}{token}
16365     \textcolor{keywordtype}{implicit none}
16366     \textcolor{keywordtype}{character(*)}, \textcolor{keywordtype}{intent(in)}:: message
16367     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: answer(:,:,:,:,:,:,:)
16368     \textcolor{keywordtype}{real}, \textcolor{keywordtype}{intent(in)}:: check(:,:,:,:,:,:,:)
16369     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{intent(in)}, \textcolor{keywordtype}{optional}:: negative\_support
16370     \textcolor{keywordtype}{logical}:: err\_flag
16371     \textcolor{keywordtype}{logical}:: negative\_support\_on
16372     \textcolor{keywordtype}{character(STRING)}:: pos\_str
16373     \textcolor{keywordtype}{character(TOKEN)}:: abs\_mes
16374     \textcolor{keywordtype}{real}:: wrong, right
16375 
16376                         \textcolor{keywordtype}{integer}:: answer\_shape(7), check\_shape(7), pos(7)
16377     \textcolor{keywordtype}{logical}:: consist\_shape(7)
16378     \textcolor{keywordtype}{character(TOKEN)}:: pos\_array(7)
16379     \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{allocatable}:: mask\_array(:,:,:,:,:,:,:)
16380     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge(:,:,:,:,:,:,:)
16381     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: judge\_rev(:,:,:,:,:,:,:)
16382     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: answer\_negative(:,:,:,:,:,:,:)
16383     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: check\_negative(:,:,:,:,:,:,:)
16384     \textcolor{keywordtype}{logical}, \textcolor{keywordtype}{allocatable}:: both\_negative(:,:,:,:,:,:,:)
16385                     
16386 
16387   \textcolor{keywordflow}{continue}
16388     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(negative\_support)) \textcolor{keywordflow}{then}
16389       negative\_support\_on = negative\_support
16390     \textcolor{keywordflow}{else}
16391       negative\_support\_on = .true.
16392 \textcolor{keywordflow}{    end if}
16393 
16394     err\_flag = .false.
16395 
16396                     
16397     answer\_shape = shape(answer)
16398     check\_shape = shape(check)
16399 
16400     consist\_shape = answer\_shape == check\_shape
16401 
16402     \textcolor{keywordflow}{if} (.not. all(consist\_shape)) \textcolor{keywordflow}{then}
16403       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16404       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16405       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  shape of check is ('}, check\_shape, \textcolor{stringliteral}{')'}
16406       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is INCORRECT'}
16407       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'  Correct shape of answer is ('}, answer\_shape, \textcolor{stringliteral}{')'}
16408 
16409       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16410 \textcolor{keywordflow}{    end if}
16411 
16412 
16413     \textcolor{keyword}{allocate}( mask\_array( &
16414                             &    answer\_shape(1), &
16415                       
16416       &    answer\_shape(2), &
16417                       
16418       &    answer\_shape(3), &
16419                       
16420       &    answer\_shape(4), &
16421                       
16422       &    answer\_shape(5), &
16423                       
16424       &    answer\_shape(6), &
16425                       
16426       &    answer\_shape(7)  )  &
16427       &  )
16428 
16429     \textcolor{keyword}{allocate}( judge( &
16430                             &    answer\_shape(1), &
16431                       
16432       &    answer\_shape(2), &
16433                       
16434       &    answer\_shape(3), &
16435                       
16436       &    answer\_shape(4), &
16437                       
16438       &    answer\_shape(5), &
16439                       
16440       &    answer\_shape(6), &
16441                       
16442       &    answer\_shape(7)  )  &
16443       &  )
16444 
16445     \textcolor{keyword}{allocate}( judge\_rev( &
16446                             &    answer\_shape(1), &
16447                       
16448       &    answer\_shape(2), &
16449                       
16450       &    answer\_shape(3), &
16451                       
16452       &    answer\_shape(4), &
16453                       
16454       &    answer\_shape(5), &
16455                       
16456       &    answer\_shape(6), &
16457                       
16458       &    answer\_shape(7)  )  &
16459       &  )
16460 
16461     \textcolor{keyword}{allocate}( answer\_negative( &
16462                             &    answer\_shape(1), &
16463                       
16464       &    answer\_shape(2), &
16465                       
16466       &    answer\_shape(3), &
16467                       
16468       &    answer\_shape(4), &
16469                       
16470       &    answer\_shape(5), &
16471                       
16472       &    answer\_shape(6), &
16473                       
16474       &    answer\_shape(7)  )  &
16475       &  )
16476 
16477     \textcolor{keyword}{allocate}( check\_negative( &
16478                             &    answer\_shape(1), &
16479                       
16480       &    answer\_shape(2), &
16481                       
16482       &    answer\_shape(3), &
16483                       
16484       &    answer\_shape(4), &
16485                       
16486       &    answer\_shape(5), &
16487                       
16488       &    answer\_shape(6), &
16489                       
16490       &    answer\_shape(7)  )  &
16491       &  )
16492 
16493     \textcolor{keyword}{allocate}( both\_negative( &
16494                             &    answer\_shape(1), &
16495                       
16496       &    answer\_shape(2), &
16497                       
16498       &    answer\_shape(3), &
16499                       
16500       &    answer\_shape(4), &
16501                       
16502       &    answer\_shape(5), &
16503                       
16504       &    answer\_shape(6), &
16505                       
16506       &    answer\_shape(7)  )  &
16507       &  )
16508 
16509     answer\_negative = answer < 0.0
16510     check\_negative = check < 0.0
16511     both\_negative = answer\_negative .and. check\_negative
16512     \textcolor{keywordflow}{if} (.not. negative\_support\_on) both\_negative = .false.
16513 
16514     judge = answer > check
16515     \textcolor{keywordflow}{where} (both\_negative) judge = .not. judge
16516 
16517     judge\_rev = .not. judge
16518     err\_flag = any(judge\_rev)
16519     mask\_array = 1
16520     pos = maxloc(mask\_array, judge\_rev)
16521 
16522     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16523 
16524       wrong = check( &
16525                               &    pos(1), &
16526                       
16527         &    pos(2), &
16528                       
16529         &    pos(3), &
16530                       
16531         &    pos(4), &
16532                       
16533         &    pos(5), &
16534                       
16535         &    pos(6), &
16536                       
16537         &    pos(7)  )
16538 
16539       right = answer( &
16540                               &    pos(1), &
16541                       
16542         &    pos(2), &
16543                       
16544         &    pos(3), &
16545                       
16546         &    pos(4), &
16547                       
16548         &    pos(5), &
16549                       
16550         &    pos(6), &
16551                       
16552         &    pos(7)  )
16553 
16554                             \textcolor{keyword}{write}(unit=pos\_array(1), fmt=\textcolor{stringliteral}{"(i20)"}) pos(1)
16555                       
16556       \textcolor{keyword}{write}(unit=pos\_array(2), fmt=\textcolor{stringliteral}{"(i20)"}) pos(2)
16557                       
16558       \textcolor{keyword}{write}(unit=pos\_array(3), fmt=\textcolor{stringliteral}{"(i20)"}) pos(3)
16559                       
16560       \textcolor{keyword}{write}(unit=pos\_array(4), fmt=\textcolor{stringliteral}{"(i20)"}) pos(4)
16561                       
16562       \textcolor{keyword}{write}(unit=pos\_array(5), fmt=\textcolor{stringliteral}{"(i20)"}) pos(5)
16563                       
16564       \textcolor{keyword}{write}(unit=pos\_array(6), fmt=\textcolor{stringliteral}{"(i20)"}) pos(6)
16565                       
16566       \textcolor{keyword}{write}(unit=pos\_array(7), fmt=\textcolor{stringliteral}{"(i20)"}) pos(7)
16567                       
16568 
16569       pos\_str = \textcolor{stringliteral}{'('} // &
16570                               &    trim(adjustl(pos\_array(1))) // \textcolor{stringliteral}{','} // &
16571                       
16572         &    trim(adjustl(pos\_array(2))) // \textcolor{stringliteral}{','} // &
16573                       
16574         &    trim(adjustl(pos\_array(3))) // \textcolor{stringliteral}{','} // &
16575                       
16576         &    trim(adjustl(pos\_array(4))) // \textcolor{stringliteral}{','} // &
16577                       
16578         &    trim(adjustl(pos\_array(5))) // \textcolor{stringliteral}{','} // &
16579                       
16580         &    trim(adjustl(pos\_array(6))) // \textcolor{stringliteral}{','} // &
16581                       
16582         &    trim(adjustl(pos\_array(7))) // \textcolor{stringliteral}{')'}
16583 
16584       \textcolor{keywordflow}{if} ( both\_negative( &
16585                               &    pos(1), &
16586                       
16587         &    pos(2), &
16588                       
16589         &    pos(3), &
16590                       
16591         &    pos(4), &
16592                       
16593         &    pos(5), &
16594                       
16595         &    pos(6), &
16596                       
16597         &    pos(7)  )  ) \textcolor{keywordflow}{then}
16598 
16599         abs\_mes = \textcolor{stringliteral}{'ABSOLUTE value of'}
16600       \textcolor{keywordflow}{else}
16601         abs\_mes = \textcolor{stringliteral}{''}
16602 
16603 \textcolor{keywordflow}{      end if}
16604 
16605 \textcolor{keywordflow}{    end if}
16606     \textcolor{keyword}{deallocate}(mask\_array, judge, judge\_rev)
16607     \textcolor{keyword}{deallocate}(answer\_negative, check\_negative, both\_negative)
16608 
16609                     
16610 
16611 
16612     \textcolor{keywordflow}{if} (err\_flag) \textcolor{keywordflow}{then}
16613       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** Error [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' FAILURE'}
16614       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{''}
16615       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16616         &        \textcolor{stringliteral}{' check'} // trim(pos\_str) // \textcolor{stringliteral}{'  = '}, wrong
16617       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{'    is NOT LESS THAN'}
16618       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' '} // trim(abs\_mes) // &
16619         &        \textcolor{stringliteral}{' answer'} // trim(pos\_str) // \textcolor{stringliteral}{' = '}, right
16620 
16621       \textcolor{keyword}{call }\hyperlink{interfacesysdep_1_1abortprogram}{abortprogram}(\textcolor{stringliteral}{''})
16622     \textcolor{keywordflow}{else}
16623       \textcolor{keyword}{write}(*,*) \textcolor{stringliteral}{' *** MESSAGE [AssertLT] *** Checking '} // trim(message) // \textcolor{stringliteral}{' OK'}
16624 \textcolor{keywordflow}{    end if}
16625 
16626 
\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}
