Update to Julienne 2.4.3 assert 3.0.2

example/learn-addition.F90

@@ -6,19 +6,24 @@
 module addition_m
   !! Define a function that produces the desired network output for a given network input
   use fiats_m, only : tensor_t
-  use julienne_m, only : call_julienne_assert_, operator(.isAtLeast.), operator(.isAtMost.), operator(.also.)
+  use julienne_m, only : &
+     call_julienne_assert_ &
+    ,operator(.also.) &
+    ,operator(.isAtLeast.) &
+    ,operator(.isAtMost.)
   implicit none
 
 contains
   elemental function y(x_tensor) result(a_tensor)
     type(tensor_t), intent(in) :: x_tensor
     type(tensor_t) a_tensor
     associate(x => x_tensor%values())
-      call_julienne_assert((ubound(x,1) .isAtLeast. 7) .also. (lbound(x,1) .isAtMost. 2))
-      a_tensor = tensor_t([x(1)+x(2), x(2)+x(3), x(3)+x(4), x(4)+x(5), x(5)+x(6), x(6)+x(8)])
+      associate(sufficient_input => (ubound(x,1) .isAtLeast. 7) .also. (lbound(x,1) .isAtMost. 2))
+        call_julienne_assert(sufficient_input)
+        a_tensor = tensor_t([x(1)+x(2), x(2)+x(3), x(3)+x(4), x(4)+x(5), x(5)+x(6), x(6)+x(8)])
+      end associate
     end associate
   end function
-
 end module
 
 program learn_addition
@@ -62,7 +67,7 @@ program learn_addition
         inputs = [(tensor_t(real([(j*i, j = 1,num_inputs)])/(num_inputs*num_pairs)), i = 1, num_pairs)]
         desired_outputs = y(inputs)
         output_sizes = [(size(desired_outputs(i)%values()),i=1,size(desired_outputs))]
-        call_julienne_assert(.all.(num_outputs .equalsExpected. output_sizes))
+        call_julienne_assert(.all. (num_outputs .equalsExpected. output_sizes))
       end block
       input_output_pairs = input_output_pair_t(inputs, desired_outputs)
       block 

example/learn-exponentiation.F90

@@ -6,19 +6,24 @@
 module exponentiation_m
   !! Define a function that produces the desired network output for a given network input
   use fiats_m, only : tensor_t
-  use julienne_m, only : call_julienne_assert_, operator(.isAtLeast.), operator(.isAtMost.), operator(.also.)
+  use julienne_m, only : &
+     call_julienne_assert_ &
+    ,operator(.also.) &
+    ,operator(.isAtMost.) &
+    ,operator(.isAtLeast.)
   implicit none
 
 contains
   elemental function y(x_tensor) result(a_tensor)
     type(tensor_t), intent(in) :: x_tensor
     type(tensor_t) a_tensor
     associate(x => x_tensor%values())
-      call_julienne_assert(ubound(x,1) .isAtLeast. 7 .also. lbound(x,1) .isAtMost. 2)
-      a_tensor = tensor_t([x(1)**2, x(2)**3, x(3)**4, x(4)**4, x(5)**3, x(6)**2])
+      associate(suffient_input => (ubound(x,1) .isAtLeast. 7) .also. (lbound(x,1) .isAtMost. 2))
+        call_julienne_assert(suffient_input)
+        a_tensor = tensor_t([x(1)**2, x(2)**3, x(3)**4, x(4)**4, x(5)**3, x(6)**2])
+      end associate
     end associate
   end function
-
 end module
 
 program learn_exponentiation

example/learn-multiplication.F90

@@ -6,16 +6,22 @@
 module multiply_inputs
   !! Define a function that produces the desired network output for a given network input
   use fiats_m, only : tensor_t
-  use julienne_m, only : call_julienne_assert_, operator(.isAtMost.), operator(.isAtLeast.), operator(.also.)
+  use julienne_m, only : &
+     call_julienne_assert_ &
+    ,operator(.also.) &
+    ,operator(.isAtLeast.) &
+    ,operator(.isAtMost.)
   implicit none
 
 contains
   elemental function y(x_tensor) result(a_tensor)
     type(tensor_t), intent(in) :: x_tensor
     type(tensor_t) a_tensor
     associate(x => x_tensor%values())
-      call_julienne_assert((ubound(x,1) .isAtMost. 7) .also. (lbound(x,1) .isAtMost. 2))
-      a_tensor = tensor_t([x(1)*x(2), x(2)*x(3), x(3)*x(4), x(4)*x(5), x(5)*x(6), x(6)*x(8)])
+      associate(sufficient_inputs => (ubound(x,1).isAtLeast. 7) .also. (lbound(x,1) .isAtMost. 2))
+        call_julienne_assert(sufficient_inputs)
+        a_tensor = tensor_t([x(1)*x(2), x(2)*x(3), x(3)*x(4), x(4)*x(5), x(5)*x(6), x(6)*x(8)])
+      end associate
     end associate
   end function
 
@@ -60,7 +66,7 @@ program learn_multiplication
         inputs = [(tensor_t(real([(j*i, j = 1,num_inputs)])/(num_inputs*num_pairs)), i = 1, num_pairs)]
         desired_outputs = y(inputs)
         output_sizes = [(size(desired_outputs(i)%values()),i=1,size(desired_outputs))]
-        call_julienne_assert(num_outputs .equalsExpected. output_sizes)
+        call_julienne_assert(.all. (num_outputs .equalsExpectd. output_sizes))
       end block
       input_output_pairs = input_output_pair_t(inputs, desired_outputs)
       block 

example/learn-power-series.F90

@@ -6,16 +6,22 @@
 module power_series
   !! Define a function that produces the desired network output for a given network input
   use fiats_m, only : tensor_t
-  use julienne_m, only : call_julienne_assert_, operator(.isAtMost.), operator(.isAtLeast.), operator(.also.)
+  use julienne_m, only : &
+     call_julienne_assert_ &
+    ,operator(.also.) &
+    ,operator(.isAtLeast.) &
+    ,operator(.isAtMost.)
   implicit none
 
 contains
   elemental function y(x_in) result(a)
     type(tensor_t), intent(in) :: x_in
     type(tensor_t) a
     associate(x => x_in%values())
-      call_julienne_assert((ubound(x,1) .isAtMost. 7) .also. (lbound(x,1) .isAtMost. 2))
-      a = tensor_t([1 + x(1) + (x(1)**2)/2 + (x(1)**3)/6, x(2), x(3), x(4), x(5), x(6)])
+      associate(sufficient_input => (ubound(x,1) .isAtLeast. 7) .also. (lbound(x,1) .isAtMost. 2))
+        call_julienne_assert(sufficient_input)
+        a = tensor_t([1 + x(1) + (x(1)**2)/2 + (x(1)**3)/6, x(2), x(3), x(4), x(5), x(6)])
+      end associate
     end associate
   end function
 

example/learn-saturated-mixing-ratio.F90

@@ -7,9 +7,9 @@ program train_saturated_mixture_ratio
   !! This program trains a neural network to learn the saturated mixing ratio function of ICAR.
   use fiats_m, only : trainable_network_t, mini_batch_t, tensor_t, input_output_pair_t, shuffle
   use julienne_m, only : &
-     command_line_t &
+     call_julienne_assert_ &
+    ,command_line_t &
     ,bin_t &
-    ,call_julienne_assert_ &
     ,csv &
     ,file_t &
     ,operator(.all.) &
@@ -73,7 +73,9 @@ program train_saturated_mixture_ratio
         integer, allocatable :: output_sizes(:)
         inputs = [( [(tensor_t([T(i), p(j)]), j=1,size(p))], i = 1,size(T))]
         num_pairs = size(inputs)
-        call_julienne_assert(num_pairs .equalsExpected. size(T)*size(p))
+        associate(inputs_tensor_array_complete => num_pairs .equalsExpected. size(T)*size(p))
+          call_julienne_assert(inputs_tensor_array_complete)
+        end associate
         desired_outputs = y(inputs)
         output_sizes = [(size(desired_outputs(i)%values()),i=1,size(desired_outputs))]
         call_julienne_assert(.all. (num_outputs .equalsExpected. output_sizes))

example/train-and-write.F90

@@ -13,7 +13,7 @@ program train_and_write
   !! that is uniformly distributed on the range [0,0.1].
   use fiats_m, only : &
     neural_network_t, trainable_network_t, mini_batch_t, tensor_t, input_output_pair_t, shuffle
-  use julienne_m, only : string_t, file_t, command_line_t, bin_t, operator(.equalsExpected.)
+  use julienne_m, only : string_t, file_t, command_line_t, bin_t, call_julienne_assert_, operator(.equalsExpected.)
   implicit none
 
   type(string_t) final_network_file
@@ -42,7 +42,7 @@ program train_and_write
 
     associate(num_inputs => trainable_network%num_inputs(), num_outputs => trainable_network%num_outputs())
 
-      call_julienne_assert(num_inputs .equalsExepcted. num_outputs)
+      call_julienne_assert(num_inputs .equalsExpected. num_outputs)
       block
         integer i, j
         inputs = [(tensor_t(real([(j*i, j = 1,num_inputs)])/(num_inputs*num_pairs)), i = 1, num_pairs)]

src/fiats/layer_s.F90

@@ -36,7 +36,9 @@
     end do
 
     line = trim(adjustl(layer_lines(start+4*neurons_in_layer+1)%string()))
-    call_julienne_assert(line(1:1) .equalsExpected. ']')
+    associate(hidden_layer_end => ']')
+      call_julienne_assert(line(1:1) .equalsExpected. hidden_layer_end)
+    end associate
 
     if (line(len(line):len(line)) == ",") layer%next = layer_t(layer_lines, start+4*neurons_in_layer+2)
 
@@ -67,7 +69,9 @@
     end do
 
     line = trim(adjustl(layer_lines(start+4*neurons_in_layer+1)%string()))
-    call_julienne_assert(line(1:1) .equalsExpected. ']')
+    associate(hidden_layer_end => ']')
+      call_julienne_assert(line(1:1) .equalsExpected. ']')
+    end associate
 
     if (line(len(line):len(line)) == ",") layer%next = layer_t(layer_lines, start+4*neurons_in_layer+2)
 
@@ -82,7 +86,7 @@
       num_hidden_layers =>  hidden_layers%count_layers(), &
       num_output_layers => output_layer%count_layers() &
     )   
-      call_assert(num_output_layers==1)
+      call_julienne_assert(num_output_layers .equalsExpected. 1)
 
       associate(nodes => [num_inputs, neurons_per_hidden_layer, num_outputs])
         associate(n_max => maxval(nodes))
@@ -154,7 +158,7 @@
       num_hidden_layers =>  hidden_layers%count_layers(), &
       num_output_layers => output_layer%count_layers() &
     )   
-      call_assert(num_output_layers==1)
+      call_julienne_assert(num_output_layers .equalsExpected. 1)
 
       associate(nodes => [num_inputs, neurons_per_hidden_layer, num_outputs])
         associate(n_max => maxval(nodes))

src/fiats/neural_network_s.F90

@@ -7,7 +7,7 @@
 
 submodule(neural_network_m) neural_network_s
   use assert_m
-  use julienne_m, only : call_julienne_assert_, operator(.equalsExpected.)
+  use julienne_m, only : call_julienne_assert_ , operator(.all.), operator(.equalsExpected.)
   use double_precision_string_m, only : double_precision_string_t
   use kind_parameters_m, only : double_precision
   use layer_m, only : layer_t
@@ -152,7 +152,7 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
     call_assert(allocated(self%nodes_))
 
     associate(max_width=>maxval(self%nodes_), component_sizes=>[size(self%biases_,1), size(self%weights_,1), size(self%weights_,2)])
-      call_julienne_assert(component_sizes .equalsExpected. max_width)
+      call_julienne_assert(.all. (component_sizes .equalsExpected. max_width))
     end associate
 
     associate(input_subscript => lbound(self%nodes_,1))
@@ -171,7 +171,9 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
       call_julienne_assert(all(component_sizes .equalsExpected. max_width))
     end associate
 
-    call_julienne_assert(lbound(self%nodes_,1) .equalsExpected. input_layer)
+    associate(input_subscript => lbound(self%nodes_,1))
+      call_julienne_assert(input_subscript .equalsExpected. input_layer)
+    end associate
 
   end procedure
 
@@ -492,15 +494,10 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
     type(layer_t) hidden_layers, output_layer
 
     lines = file_%lines()
-    call_julienne_assert(adjustl(lines(1)%string()) .equalsExpected. "{")
-
-    check_git_tag: &
-    block 
-      character(len=:), allocatable :: tag
-
-      tag = lines(2)%get_json_value("minimum_acceptable_tag", mold="")
-      call_julienne_assert(tag .equalsExpected. minimum_acceptable_tag)
-    end block check_git_tag
+    associate(outermost_object => '{')
+      call_julienne_assert(adjustl(lines(1)%string()) .equalsExpected. outermost_object)
+    end associate
+    call_julienne_assert(lines(2)%get_json_value("minimum_acceptable_tag", mold="") .equalsExpected. minimum_acceptable_tag)
 
     num_file_lines = size(lines)
 
@@ -585,15 +582,10 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
     type(layer_t(double_precision)) hidden_layers, output_layer
 
     lines = file%double_precision_lines()
-    call_julienne_assert(adjustl(lines(1)%string()) .equalsExpected.  "{")
-
-    check_git_tag: &
-    block
-      character(len=:), allocatable :: tag
-
-      tag = lines(2)%get_json_value("minimum_acceptable_tag", mold="")
-      call_julienne_assert(tag .equalsExpected. minimum_acceptable_tag)
-    end block check_git_tag
+    associate(outermost_object => '{')
+      call_julienne_assert(adjustl(lines(1)%string()) .equalsExpected. outermost_object) 
+    end associate
+    call_julienne_assert(lines(2)%get_json_value("minimum_acceptable_tag", mold="") .equalsExpected. minimum_acceptable_tag)
 
     num_file_lines = size(lines)
 
@@ -671,9 +663,9 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
 
     call_assert_consistency(self)
 
-    call_assert(all(shape(self%weights_) == shape(neural_network%weights_)))
-    call_assert(all(shape(self%biases_) == shape(neural_network%biases_)))
-    call_assert(all(shape(self%nodes_) == shape(neural_network%nodes_)))
+    call_julienne_assert(.all. (shape(self%weights_) .equalsExpected. shape(neural_network%weights_)))
+    call_julienne_assert(.all. (shape(self%biases_) .equalsExpected. shape(neural_network%biases_)))
+    call_julienne_assert(.all. (shape(self%nodes_) .equalsExpected. shape(neural_network%nodes_)))
     call_assert(self%activation_ == neural_network%activation_)
 
   end procedure
@@ -682,10 +674,10 @@ elemental module subroutine double_precision_assert_conformable_with(self, neura
 
     call_assert_consistency(self)
 
-    call_assert(all(shape(self%weights_) == shape(neural_network%weights_)))
-    call_assert(all(shape(self%biases_) == shape(neural_network%biases_)))
-    call_assert(all(shape(self%nodes_) == shape(neural_network%nodes_)))
-    call_assert(self%activation_ == neural_network%activation_)
+    call_julienne_assert(.all. (shape(self%weights_) .equalsExpected. shape(neural_network%weights_)))
+    call_julienne_assert(.all. (shape(self%biases_) .equalsExpected. shape(neural_network%biases_)))
+    call_julienne_assert(.all. (shape(self%nodes_) .equalsExpected. shape(neural_network%nodes_)))
+    call_julienne_assert(self%activation_ == neural_network%activation_)
 
   end procedure
 

src/fiats/neuron_s.F90

@@ -6,8 +6,7 @@
 
 submodule(neuron_m) neuron_s
   use assert_m
-  use julienne_formats_m, only : separated_values
-  use julienne_m, only : operator(.equalsExpected.), call_julienne_assert_
+  use julienne_m, only : operator(.equalsExpected.), call_julienne_assert_, separated_values
   implicit none
 
 contains

src/fiats/tensor_map_s.F90

@@ -1,18 +1,19 @@
 ! Copyright (c) 2023-2025, The Regents of the University of California
 ! Terms of use are as specified in LICENSE.txt
 
+#include "julienne-assert-macros.h"
 #include "assert_macros.h"
 
 submodule(tensor_map_m) tensor_map_s
-  use assert_m
+  use julienne_m, only : call_julienne_assert_, operator(.equalsExpected.)
   use julienne_m, only : separated_values
   use kind_parameters_m, only : default_real
   implicit none
 
 contains
 
   module procedure construct_default_real
-    call_assert(size(minima)==size(maxima))
+    call_julienne_assert(size(minima) .equalsExpected. size(maxima))
     tensor_map%layer_ = layer
     tensor_map%intercept_ = minima
     tensor_map%slope_ = maxima - minima
@@ -35,7 +36,7 @@
   end procedure
 
   module procedure construct_double_precision
-    call_assert(size(minima)==size(maxima))
+    call_julienne_assert(size(minima) .equalsExpected. size(maxima))
     tensor_map%layer_ = layer
     tensor_map%intercept_ = minima
     tensor_map%slope_ = maxima - minima
@@ -85,8 +86,8 @@
     call_assert(allocated(lhs%layer_    ) .and. allocated(rhs%layer_    ))
     call_assert(allocated(lhs%intercept_) .and. allocated(rhs%intercept_))
     call_assert(allocated(lhs%slope_    ) .and. allocated(rhs%slope_    ))
-    call_assert(size(lhs%intercept_) == size(rhs%intercept_))
-    call_assert(size(lhs%slope_    ) == size(rhs%slope_    ))
+    call_julienne_assert(size(lhs%intercept_) .equalsExpected. size(rhs%intercept_))
+    call_julienne_assert(size(lhs%slope_    ) .equalsExpected. size(rhs%slope_    ))
 
     lhs_equals_rhs = &
       lhs%layer_ == rhs%layer_ .and. &
@@ -100,8 +101,8 @@
     call_assert(allocated(lhs%layer_    ) .and. allocated(rhs%layer_    ))
     call_assert(allocated(lhs%intercept_) .and. allocated(rhs%intercept_))
     call_assert(allocated(lhs%slope_    ) .and. allocated(rhs%slope_    ))
-    call_assert(size(lhs%intercept_) == size(rhs%intercept_))
-    call_assert(size(lhs%slope_    ) == size(rhs%slope_    ))
+    call_julienne_assert(size(lhs%intercept_) .equalsExpected. size(rhs%intercept_))
+    call_julienne_assert(size(lhs%slope_    ) .equalsExpected. size(rhs%slope_    ))
 
     lhs_equals_rhs = &
       lhs%layer_ == rhs%layer_ .and. &