separate( Test_Log_Family )

 procedure Test_LogB_Interval( N,
                               N_Arguments,
                               Base_Flag  : in Int_Type;
                               MRE_Base,
                               MRE_Mach,
                               Bad_Arg,
                               Bad_Base,
                               Bad_Val    : out Float_Type;
			       Outcome    : out Status ) is 

    NLog2_Pieces : array( Int_Type range 1..4 ) of Float_Type;
    Comp_Log_Arg : array( Int_Type range 1..Value_Table_Size ) 
                   of Float_Type;
    Two_to       : constant array ( Int_Type range -3..3 )
                   of Float_Type := ( 0.125, 0.25, 0.5, 1.0,
                                      2.0, 4.0, 8.0 );

    NLog2_Lead, NLog2_Trail, Error, Max_Error    : Float_Type;
    Tmp_Arg, Tmp_Base  : array(Int_Type range 1..Value_Table_Size) 
                         of Float_Type;
    Tmp_Arg2, Tmp_Base2 : Float_Type;

    Zero : constant Float_Type :=  0.0;
    Two  : constant Float_Type :=  2.0;
    Ten  : constant Float_Type := 10.0;

    N_Loops, M1, M2, J, K, L, M, I_Tmp2, I_Tmp3, Location : Int_Type;

    Arg, Log_of_Arg, ArgB, Log_of_ArgB, A, U, V, Buffer   : Value_Table;

 begin

    for Index in Int_Type(1)..4 loop
        NLog2_Pieces(Index) := Float_Type(N)*Log2_Pieces(Index);
    end loop;

    I_Tmp2 := Int_Type( NLog2_Pieces(2) * 2#1.0#E12 );
    I_Tmp3 := Int_Type( NLog2_Pieces(3) * 2#1.0#E12 );

    NLog2_Lead  := NLog2_Pieces(1) + Float_Type(I_Tmp2)*2#1.0#E-12;
    NLog2_Lead  := NLog2_Lead      + Float_Type(I_Tmp3)*2#1.0#E-12;

    NLog2_Trail := NLog2_Pieces(4) + 
                   (NLog2_Pieces(3) - Float_Type(I_Tmp3)*2#1.0#E-12);

    NLog2_Trail := NLog2_Trail +
                   (NLog2_Pieces(2) - Float_Type(I_Tmp2)*2#1.0#E-12);
    
    

    N_Loops := N_Arguments / Value_Table_Size;
    if N_Loops < 3 then
       N_Loops := 3;
    end if;

    Outcome   := OK;
    Error     := Zero;
    Max_Error := Zero;
    Bad_Arg   := Zero;
    Bad_Base  := Zero;
    Bad_Val   := Zero;

    case Base_Flag is
         when 2      =>  
              Log_of_ArgB := Log_of_Two;
              for Index in 1..Value_Table_Size loop
                  Tmp_Base(Index) := Two;
              end loop;

         when 10     =>  
              Log_of_ArgB := Log_of_Ten;
              for Index in 1..Value_Table_Size loop
                  Tmp_Base(Index) := Ten;
              end loop;

         when others => 
              Core_Test_Log(0, Zero, Zero,
                            0, K_Right-1, L_Right-1, M_Right-1,
                            ArgB, Log_of_ArgB);
              for Index in 1..Value_Table_Size loop
                  Tmp_Base(Index) := ArgB(Index,Lead)+ArgB(Index,Trail);
              end loop;
    end case;


    for Loop_Cnt in 1..N_Loops loop

        case Loop_Cnt is
             when 1       =>  J := Rand_Int(J_Left, J_Right);
                              K := 0; L := 0; M := 0;
             when 2       =>  J := 0;
                              K := K_Right; L := L_Right; M := M_Right;
             when others  =>  J := Rand_Int(J_Left, J_Right);
                              K := Rand_Int(K_Left, K_Right);
                              L := Rand_Int(L_Left, L_Right);
                              M := Rand_Int(M_Left, M_Right);
        end case;



        Core_Test_Log(N, NLog2_Lead, NLog2_Trail, 
                      J, K, L, M,
                      Arg, Log_of_Arg);


	begin
           for Index in 1..Value_Table_Size loop
               Tmp_Arg(Index) := Arg(Index, Lead) + Arg(Index, Trail);
	       Tmp_Arg2  := Tmp_Arg(Index);
	       Tmp_Base2 := Tmp_Base(Index);
               Buffer(Index, Lead ) := Test_Functions.Log(Tmp_Arg(Index),
                                                       Tmp_Base(Index));
               Buffer(Index, Trail) := Zero;
           end loop; --loop for invoking Log under test
        exception
	   when others =>
	        Bad_Arg  := Tmp_Arg2;
		Bad_Base := Tmp_Base2;
		Outcome  := Failed;
		return;
        end;

        Normalize( Val_In => Buffer, Val_Out => A );

        MRE_A_minus_UbyV( A => A, U => Log_of_Arg, V => Log_of_ArgB,
                          MRE => Error, Location => Location );


        if (Error > Max_Error) then
           Max_Error  :=  Error;
           Bad_Arg    :=  Tmp_Arg(Location);
           Bad_Base   :=  Tmp_Base(Location);
           Bad_Val    :=  A(Location,Lead) + A(Location,Trail);
        end if;

     
    end loop; --outermost loop

    begin
       MRE_Base := Base_Eps_Inv * Max_Error;
       MRE_Mach := Mach_Eps_Inv * Max_Error;
    exception
       when others =>
	  MRE_Base := Base_Eps_Inv * 500.0;
	  MRE_Mach := Mach_Eps_Inv * 500.0;
    end;

    return;

 end Test_LogB_Interval;