-- получает двоичную степень числа, соответствующую 2**msb (most significant bit) входного параметра
-- (под диапазон значений 0 - 170141183460469231731687303715884105727 - power(2,127)-1 )
  function msb(px in Number) return number deterministic parallel_enable
  is
     offs Number;
     n_mask Number;
     x Number;
     x2 Number; 

     -- шаг вычисления, удваивающего число единиц от msb вправо
     Procedure step_mask 
     Is
     Begin      
      x := x2; n_mask := floor(x/offs);
      x2 := x - bitand(x, n_mask) + n_mask;   -- вычисляет битовый OR           
      offs := offs*offs;
     End;    
  begin

    if px = 0 Or px Is Null Then Return px; End if;
   
    offs := 2;
    x2 := floor(px); 
   
    Loop 
      -- 1 (2 соседних к msb bit-ов установлены в 1)
      step_mask;
      Exit When x=x2;
                
      -- 2 (4 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit When x=x2;
          
      -- 3 (8 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit When x=x2;
      
      -- 4 (16 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit When x=x2;

      -- 5 (32 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit When x=x2;      

      -- 6 (64 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit When x=x2;

      -- 7 (128 соседних к msb bit-ов установлены в 1)
      step_mask; 
      Exit;
    End Loop;    
    -- гарантированы все единицы, начиная с msb
    -- переходим в следующий разряд и возвращаем половину
    Return floor((x2+1)/2);
  end;  

create or replace package msb_pkg is

  -- Author  : booby
  -- Created : 2020-09-22 12:23:08
  -- Purpose : поддержка операций получения most significant bit 
  ----------------------------------------------------------------------


 -- инициализация внутреннего состояния пакета
 procedure init_msb; 
 ----------------------------------------------------------------
 -- вычисление msb (most significant bit), процедура
 -- проектировалось под диапазон значений 0 - 170141183460469231731687303715884105727 - power(2,127)-1 
 -- выбрасывает ошибку -20203 при потере состояния пакетом,
 -- или подаче на вход "слишком большого" числа ( > 128 разрядов) 
 -- msb_pkg.msb_2p(px in Number,msb Out nocopy Number,i_exponent Out Nocopy Pls_Integer);
 Procedure msb_2p(px in Number, -- входное значение
                  msb Out nocopy Number, -- значение степени для msb
                  i_exponent Out Nocopy Pls_Integer -- показатель степени
                  );  
 -----------------------------------------------------------------
-- вычисление msb (most significant bit)
-- проектировалось под диапазон значений 0 - 170141183460469231731687303715884105727 - power(2,127)-1 
-- получает двоичную степень числа, соответствующую 2**(старший_разряд)
-- msb_pkg.msb_t(px in Number)
  function msb_t(px in Number) return number deterministic parallel_enable;
 ------------------------------------------------------------------ 

end msb_pkg;
/

create or replace package body msb_pkg is
  
  TYPE T_MSB8_MAP Is Table Of pls_integer index by pls_integer;
  a_msb_val T_MSB8_MAP; -- для значений msb в интервале 1 - 255
  a_msb_exp T_MSB8_MAP; -- для значений показателя степени в интервале 1 - 255
  -----------------
 -- инициализация внутреннего состояния пакета
 procedure init_msb
 Is
 -- только для инициализации a_msb_val
 -- (возвращает 1 для x2=0)
   Function msb8(x2 in pls_integer) Return pls_integer
   Is     
   Begin   
     
     Return Case When x2 >= 16
                Then
                Case When x2 >= 128 Then 128
                     When x2 >= 64 Then 64
                     When x2 >= 32 Then 32
                Else 16
                End
              When x2 > 7 Then 8
              When x2 > 3 Then 4
              When x2 > 1 Then 2    
              Else 1
            End;            
    End;
 Begin
   
   For i in 0..255    
   Loop
     -- a_msb_val(0) = 1 -- в нулевом индексе единица,
     -- (не использовать массив вне контекста msb_inner)
     a_msb_val(i) := msb8(i);
     a_msb_exp(i) := Case 
                       When i Between 0 And 1 Then 0
                       When i Between 2 And 3 Then 1
                       When i Between 4 And 7 Then 2
                       When i Between 8 And 15 Then 3
                       When i Between 16 And 31 Then 4
                       When i Between 32 And 63 Then 5
                       When i Between 64 And 127 Then 6
                       When i Between 128 And 255 Then 7      
                     End;
   End Loop;    
 End;    
 -----------------------------------------------------------------
 -- msb_pkg.msb_2p(px in Number,msb Out nocopy Number,i_exponent Out Nocopy Pls_Integer); 
 Procedure msb_2p(px in Number, -- входное значение
                  msb Out nocopy Number, -- значение степени для msb
                  i_exponent Out Nocopy Pls_Integer -- показатель степени
                  )
 Is 
    i pls_integer := 0;
    k pls_integer := 0;
    
    x Number;
    x2 pls_integer;
    --
    m Number := 1.0;
    t Number := 1.0;
    
  begin  
      -- из агрегатной функции Null сюда не приедет.    
      -- оставлено на случай прямого использования. 
    If Coalesce(px, 0) = 0 Then      
      msb := 0; -- спорное место для (px Is Null), экономим if-ы в местах использования
      i_exponent := 0;
      Return;
    End If;  
    
    x := Floor(px);
    -- 
    Case 
      When x < 18446744073709551616 -- 2**64
          Then -- [0 -- 2**64) -- младшие разряды
         Case When x < 4294967296 -- 2**32, i := 32
             Then -- [0 - 2**32)
             Case When x < 65536 -- 2**16
                 Then -- [0 - 2**16)
               Case When x < 256 -- 2**8
                   Then
                 i:=0;
               Else  
                 i:= 8;
                 m:= 256;
               End Case;  
             When x < 16777216 -- 2**24 
                   Then -- [2**16 - 2**24) 
                   i := 16;
                   m := 65536;                 
             Else  -- [2**24 - 2**32)
                   i := 24;
                   m := 16777216;            
             End Case;
         Else 
           -- [2**32 - 2*64)
           Case 
         When x < 281474976710656 -- 2**48 
             Then -- [2**32 - 2**48)
             Case When x < 1099511627776 -- 2**40
               Then
                 i := 32;
                 m := 4294967296;
             Else
                 i := 40;
                 m := 1099511627776;
             End Case;      
             
         -- [2*48 - 2**64)
         When x < 72057594037927936 -- 2*56 
               Then -- [2**48 - 2**56)
                i := 48;
                m := 281474976710656; -- 2**48;  
         Else -- [2**56 - 2**64)
                i := 56;
                m := 72057594037927936; -- 2**56      
          End Case;  
         End Case;        

     -- старшие разряды - между [2**64 - 2**128)
     When x < 79228162514264337593543950336    -- 2**96
         Then -- [2**64 - 2**96)
           Case When x < 1208925819614629174706176  -- 2**80 
             Then -- [2**64 - 2**80)               
             Case When x <  4722366482869645213696  -- 2**72  
               Then -- [2**64 - 2**72)
                i := 64;
                m := 18446744073709551616;
             Else -- [2**72 - 2**80)
                i := 72;
                m := 4722366482869645213696;  
             End Case;    
           Else 
             -- [2**80 - 2**96)
             Case When x < 309485009821345068724781056   -- 2**88
               Then -- [2*80 - 2*88)
               i := 80;
               m := 1208925819614629174706176;  -- 2**80
             Else
               -- [2**88 - 2**96)
               i := 88;
               m := 309485009821345068724781056; -- 2**88
             End Case;       
           End Case;  -- 2**80 - 2*96    

     -- [2**96 - 2**128) 
     When x <  5192296858534827628530496329220096 -- 2**112
           Then -- [2**96 - 2**112)
           Case When x < 20282409603651670423947251286016  -- 2**104    
             Then -- [2**96 - 2**104)
               i := 96;
               m := 79228162514264337593543950336; -- 2**96 
           Else
             -- [2**104 - 2**112)
               i := 104;
               m := 20282409603651670423947251286016;
           End Case;      

     -- [2**112 - 2*128)         
     When x < 1329227995784915872903807060280344576   -- 2**120 
             Then -- [ 2**112 - 2**120)
               i := 112;
               m := 5192296858534827628530496329220096; 
           Else
                 -- [2**120 - 2**128)
               i := 120;
               m := 1329227995784915872903807060280344576;      
    End Case;  
    x2 := case when i > 0 Then floor(x/m ) else x End;
    --
    If x2 > 1 Then   
      Begin 
        t := a_msb_val(x2);
        k := a_msb_exp(x2);
      Exception
        When no_data_found Then
          -- ошибка программиста: потеряно состояние пакета или на входе число вне ожидаемого диапазона.
          Raise_Application_Error(-20203
                                 , 'msb_pkg.msb_inner.PE.1: index <'||x2        
                                 ||'> out of bounds (0-256) or array state lost, px='||px
                                 ||' .First='||a_msb_val.First
                                 ||' .Last='||a_msb_val.Last
                                 , True
                                 );
      End;
    End If;     
    
    msb := m*t; 
    i_exponent := (i+k);
    
 End;                         
                     
 ---------------------------------------------------------------
  function msb_t(px in Number) return number deterministic parallel_enable  
  is
  
    i pls_integer;
    m Number;
        
  begin 
    PRAGMA INLINE(msb_2p,'YES'); 
    msb_2p(px => px
          , msb => m
          , i_exponent => i
          );
    Return m;  

  End;    
 ---------------------------------------------------------------
begin
  -- Initialization
  init_msb;
end msb_pkg;
/

with 
  t(n) as (select level from dual connect by level<=5e3) 
 ,s0(x) as (select t1.n*1e6 + t2.n as x from t t1,t t2) -- 5e3^2 
select 
   -- count(*) as rn, to_char( max(x), 'TM9') ,
   to_char(sum(msb_pkg.msb_t(x)),'TM9') sum_msb
from s0 
;