Sanitize math with derived-type-operators

Sanitize math with derived-type-operators.

Why:

Derived type operators does not respect intrinsic operators precedence,
e.g. in `a + b * c` is not ensured that `d= b * c` is computed first and
only then `a + d` is done.

This change addresses the need by:

Adding parenthesis when necessary.

Side effects:

Nothing.

Author: szaghi

src/lib/foodie_integrator_adams_bashforth.f90

@@ -351,7 +351,7 @@ subroutine integrate(self, U, previous, Dt, t, autoupdate)
 
   autoupdate_ = .true. ; if (present(autoupdate)) autoupdate_ = autoupdate
   do s=1, self%steps
-    U = U + previous(s)%t(t=t(s)) * (Dt * self%b(s))
+    U = U + (previous(s)%t(t=t(s)) * (Dt * self%b(s)))
   enddo
   if (autoupdate_) call self%update_previous(U=U, previous=previous)
   endsubroutine integrate

src/lib/foodie_integrator_adams_moulton.f90

@@ -355,20 +355,20 @@ subroutine integrate(self, U, previous, Dt, t, iterations, autoupdate)
       allocate(delta, mold=U)
       delta = previous(self%steps)
       do s=0, self%steps - 1
-        delta = delta + previous(s+1)%t(t=t(s+1)) * (Dt * self%b(s))
+        delta = delta + (previous(s+1)%t(t=t(s+1)) * (Dt * self%b(s)))
       enddo
       do s=1, iterations
-        U = delta + U%t(t=t(self%steps) + Dt) * (Dt * self%b(self%steps))
+        U = delta + (U%t(t=t(self%steps) + Dt) * (Dt * self%b(self%steps)))
       enddo
     else
-      U = previous(self%steps) + U%t(t=t(self%steps) + Dt) * (Dt * self%b(self%steps))
+      U = previous(self%steps) + (U%t(t=t(self%steps) + Dt) * (Dt * self%b(self%steps)))
       do s=0, self%steps - 1
-        U = U + previous(s+1)%t(t=t(s+1)) * (Dt * self%b(s))
+        U = U + (previous(s+1)%t(t=t(s+1)) * (Dt * self%b(s)))
       enddo
     endif
     if (autoupdate_) call self%update_previous(U=U, previous=previous)
   else
-    U = U + U%t(t=t(1)) * (Dt * self%b(0))
+    U = U + (U%t(t=t(1)) * (Dt * self%b(0)))
   endif
   endsubroutine integrate
 

src/lib/foodie_integrator_backward_differentiation_formula.f90

@@ -227,10 +227,10 @@ subroutine integrate(self, U, previous, Dt, t, iterations, autoupdate)
   allocate(delta, mold=U)
   delta = previous(self%steps) * (-self%a(self%steps))
   do s=1, self%steps - 1
-    delta = delta + previous(s) * (-self%a(s))
+    delta = delta + (previous(s) * (-self%a(s)))
   enddo
   do s=1, iterations
-    U = delta + U%t(t=t(self%steps) + Dt) * (Dt * self%b)
+    U = delta + (U%t(t=t(self%steps) + Dt) * (Dt * self%b))
   enddo
   if (autoupdate_) call self%update_previous(U=U, previous=previous)
   endsubroutine integrate

src/lib/foodie_integrator_euler_explicit.f90

@@ -108,6 +108,6 @@ subroutine integrate(U, Dt, t)
   real(R_P),               intent(in)    :: Dt !< Time step.
   real(R_P), optional,     intent(in)    :: t  !< Time.
 
-  U = U + U%t(t=t) * Dt
+  U = U + (U%t(t=t) * Dt)
   endsubroutine integrate
 endmodule foodie_integrator_euler_explicit

src/lib/foodie_integrator_leapfrog.f90

@@ -169,11 +169,11 @@ subroutine integrate(self, U, previous, Dt, t, filter)
   real(R_P),                         intent(in)    :: t             !< Time.
   class(integrand_object), optional, intent(inout) :: filter        !< Filter field displacement.
 
-  U = previous(1) + previous(2)%t(t=t) * (Dt * 2._R_P)
+  U = previous(1) + (previous(2)%t(t=t) * (Dt * 2._R_P))
   if (present(filter)) then
-    filter = (previous(1) - previous(2) * 2._R_P + U) * self%nu * 0.5_R_P
-    previous(2) = previous(2) + filter * self%alpha
-    U = U + filter * (self%alpha - 1._R_P)
+    filter = (previous(1) - (previous(2) * 2._R_P) + U) * self%nu * 0.5_R_P
+    previous(2) = previous(2) + (filter * self%alpha)
+    U = U + (filter * (self%alpha - 1._R_P))
   endif
   previous(1) = previous(2)
   previous(2) = U

src/lib/foodie_integrator_lmm_ssp.f90

@@ -214,8 +214,8 @@ subroutine integrate(self, U, previous, Dt, t, autoupdate)
   autoupdate_ = .true. ; if (present(autoupdate)) autoupdate_ = autoupdate
   U = U * 0._R_P
   do s=1, self%steps
-    if (self%a(s) /= 0._R_P) U = U + previous(s) * self%a(s)
-    if (self%b(s) /= 0._R_P) U = U + previous(s)%t(t=t(s)) * (Dt * self%b(s))
+    if (self%a(s) /= 0._R_P) U = U + (previous(s) * self%a(s))
+    if (self%b(s) /= 0._R_P) U = U + (previous(s)%t(t=t(s)) * (Dt * self%b(s)))
   enddo
   if (autoupdate_) call self%update_previous(U=U, previous=previous)
   endsubroutine integrate

src/lib/foodie_integrator_lmm_ssp_vss.f90

@@ -245,10 +245,10 @@ subroutine integrate_order_2(self, U, previous, Dt, t, autoupdate)
   real(R_P)                                    :: omega_sq      !< Square of omega coefficient.
 
   autoupdate_ = .true. ; if (present(autoupdate)) autoupdate_ = autoupdate
-  omega_= omega(Dt=Dt, s=self%steps-1)
+  omega_ = omega(Dt=Dt, s=self%steps-1)
   omega_sq = omega_ * omega_
-  U = previous(1) * (1._R_P / omega_sq) + previous(self%steps) * ((omega_sq - 1._R_P) / omega_sq) + &
-      previous(self%steps)%t(t=t(self%steps)) * (Dt(self%steps) * (omega_ + 1._R_P) / omega_)
+  U = (previous(1) * (1._R_P / omega_sq)) + (previous(self%steps) * ((omega_sq - 1._R_P) / omega_sq)) + &
+      (previous(self%steps)%t(t=t(self%steps)) * (Dt(self%steps) * (omega_ + 1._R_P) / omega_))
   if (autoupdate_) call self%update_previous(U=U, previous=previous, Dt=Dt)
   endsubroutine integrate_order_2
 
@@ -265,10 +265,10 @@ subroutine integrate_order_3(self, U, previous, Dt, t, autoupdate)
 
   autoupdate_ = .true. ; if (present(autoupdate)) autoupdate_ = autoupdate
   omega_= omega(Dt=Dt, s=self%steps-1)
-  U = previous(1) * ((3._R_P * omega_ + 2._R_P) / omega_ ** 3 ) +                           &
-      previous(self%steps) * (((omega_ + 1._R_P) ** 2) * (omega_ - 2._R_P) / omega_ ** 3) + &
-      previous(1)%t(t=t(1)) * (Dt(self%steps) * (omega_ + 1._R_P) / omega_ ** 2) +          &
-      previous(self%steps)%t(t=t(self%steps)) * (Dt(self%steps) * (omega_ + 1._R_P) ** 2 / omega_ ** 2)
+  U = (previous(1) * ((3._R_P * omega_ + 2._R_P) / omega_ ** 3 )) +                           &
+      (previous(self%steps) * (((omega_ + 1._R_P) ** 2) * (omega_ - 2._R_P) / omega_ ** 3)) + &
+      (previous(1)%t(t=t(1)) * (Dt(self%steps) * (omega_ + 1._R_P) / omega_ ** 2)) +          &
+      (previous(self%steps)%t(t=t(self%steps)) * (Dt(self%steps) * (omega_ + 1._R_P) ** 2 / omega_ ** 2))
   if (autoupdate_) call self%update_previous(U=U, previous=previous, Dt=Dt)
   endsubroutine integrate_order_3
 

src/lib/foodie_integrator_ms_runge_kutta_ssp.f90

@@ -327,25 +327,25 @@ subroutine integrate(self, U, previous, stage, Dt, t, autoupdate)
   do k=2, self%stages
     stage(k) = U * 0._R_P
     do s=1, self%steps
-      if (self%D(k, s) /= 0._R_P) stage(k) = stage(k) + previous(s) * self%D(k, s)
+      if (self%D(k, s) /= 0._R_P) stage(k) = stage(k) + (previous(s) * self%D(k, s))
     enddo
     do s=1, self%steps - 1
-      if (self%Ahat(k, s) /= 0._R_P) stage(k) = stage(k) + previous(s)%t(t=t(s)) * (Dt * self%Ahat(k, s))
+      if (self%Ahat(k, s) /= 0._R_P) stage(k) = stage(k) + (previous(s)%t(t=t(s)) * (Dt * self%Ahat(k, s)))
     enddo
     do kk=1, k - 1
-      if (self%A(k, kk) /= 0._R_P) stage(k) = stage(k) + stage(kk)%t(t=t(self%steps)) * (Dt * self%A(k, kk))
+      if (self%A(k, kk) /= 0._R_P) stage(k) = stage(k) + (stage(kk)%t(t=t(self%steps)) * (Dt * self%A(k, kk)))
     enddo
   enddo
   ! computing new time step
   U = U * 0._R_P
   do s=1, self%steps
-    if (self%T(s) /= 0._R_P) U = U + previous(s) * self%T(s)
+    if (self%T(s) /= 0._R_P) U = U + (previous(s) * self%T(s))
   enddo
   do s=1, self%steps - 1
-    if (self%Bhat(s) /= 0._R_P) U = U + previous(s)%t(t=t(s)) * (Dt * self%Bhat(s))
+    if (self%Bhat(s) /= 0._R_P) U = U + (previous(s)%t(t=t(s)) * (Dt * self%Bhat(s)))
   enddo
   do k=1, self%stages
-    if (self%B(k) /= 0._R_P) U = U + stage(k)%t(t=t(self%steps)) * (Dt * self%B(k))
+    if (self%B(k) /= 0._R_P) U = U + (stage(k)%t(t=t(self%steps)) * (Dt * self%B(k)))
   enddo
   if (autoupdate_) call self%update_previous(U=U, previous=previous)
   endsubroutine integrate

src/lib/foodie_integrator_runge_kutta_embedded.f90

@@ -687,16 +687,16 @@ subroutine integrate(self, U, stage, Dt, t)
     do s=1, self%stages
       stage(s) = U
       do ss=1, s - 1
-        stage(s) = stage(s) + stage(ss) * (Dt * self%alph(s, ss))
+        stage(s) = stage(s) + (stage(ss) * (Dt * self%alph(s, ss)))
       enddo
       stage(s) = stage(s)%t(t=t + self%gamm(s) * Dt)
     enddo
     ! compute new time step
     U1 = U
     U2 = U
     do s=1, self%stages
-      U1 = U1 +  stage(s) * (Dt * self%beta(s, 1))
-      U2 = U2 +  stage(s) * (Dt * self%beta(s, 2))
+      U1 = U1 + (stage(s) * (Dt * self%beta(s, 1)))
+      U2 = U2 + (stage(s) * (Dt * self%beta(s, 2)))
     enddo
     error = U2.lterror.U1
     call self%new_Dt(error=error, Dt=Dt)

src/lib/foodie_integrator_runge_kutta_low_storage.f90

@@ -414,8 +414,8 @@ subroutine integrate(self, U, stage, Dt, t)
   stage(1) = U
   stage(2) = U * 0._R_P
   do s=1, self%stages
-    stage(2) = stage(2) * self%A(s) + stage(1)%t(t=t + self%C(s) * Dt) * Dt
-    stage(1) = stage(1) + stage(2) * self%B(s)
+    stage(2) = (stage(2) * self%A(s)) + (stage(1)%t(t=t + self%C(s) * Dt) * Dt)
+    stage(1) = stage(1) + (stage(2) * self%B(s))
   enddo
   U = stage(1)
   endsubroutine integrate