Return to integer_support_functions.adb CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Math_Lib / Supports

Annotation of OpenXM_contrib/PHC/Ada/Math_Lib/Supports/integer_support_functions.adb, Revision 1.1.1.1

1.1       maekawa     1: with Graded_Lexicographic_Order;         use Graded_Lexicographic_Order;
                      2:
                      3: package body Integer_Support_Functions is
                      4:
                      5:   function Maximal_Support ( l : List; v : Vector ) return integer is
                      6:
                      7:     sp,max : integer;
                      8:     tmp : List;
                      9:
                     10:   begin
                     11:     if not Is_Null(l)
                     12:      then max := Head_Of(l).all*v;
                     13:           tmp := Tail_Of(l);
                     14:           while not Is_Null(tmp) loop
                     15:             sp := Head_Of(tmp).all*v;
                     16:             if sp > max
                     17:              then max := sp;
                     18:             end if;
                     19:             tmp := Tail_Of(tmp);
                     20:           end loop;
                     21:           return max;
                     22:      else return 0;
                     23:     end if;
                     24:   end Maximal_Support;
                     25:
                     26:   function Minimal_Support ( l : List; v : Vector ) return integer is
                     27:
                     28:     sp,min : integer;
                     29:     tmp : List;
                     30:
                     31:   begin
                     32:     if not Is_Null(l)
                     33:      then min := Head_Of(l).all*v;
                     34:           tmp := Tail_Of(l);
                     35:           while not Is_Null(tmp) loop
                     36:             sp := Head_Of(tmp).all*v;
                     37:             if sp < min
                     38:              then min := sp;
                     39:             end if;
                     40:             tmp := Tail_Of(tmp);
                     41:           end loop;
                     42:           return min;
                     43:      else return 0;
                     44:     end if;
                     45:   end Minimal_Support;
                     46:
                     47:   procedure Min_Max ( l : in List; k : in integer;
                     48:                       min,max : in out integer ) is
                     49:
                     50:     tmp : List;
                     51:     v : Link_to_Vector;
                     52:
                     53:   begin
                     54:     if not Is_Null(l)
                     55:      then tmp := l;
                     56:           v := Head_Of(tmp);
                     57:           min := v(k);  max := min;
                     58:           tmp := Tail_Of(tmp);
                     59:           while not Is_Null(tmp) loop
                     60:             v := Head_Of(tmp);
                     61:             if v(k) < min
                     62:              then min := v(k);
                     63:              elsif v(k) > max
                     64:                  then max := v(k);
                     65:             end if;
                     66:             tmp := Tail_Of(tmp);
                     67:           end loop;
                     68:     end if;
                     69:   end Min_Max;
                     70:
                     71:   function Graded_Max ( l : List ) return Link_to_Vector is
                     72:
                     73:     res : Link_to_Vector := new Vector'(Head_Of(l).all);
                     74:     tmp : List := Tail_Of(l);
                     75:     ele : Link_to_Vector;
                     76:
                     77:   begin
                     78:     while not Is_Null(tmp) loop
                     79:       ele := Head_Of(tmp);
                     80:       if ele > res
                     81:        then res.all := ele.all;
                     82:       end if;
                     83:       tmp := Tail_Of(tmp);
                     84:     end loop;
                     85:     return res;
                     86:   end Graded_Max;
                     87:
                     88:   function Face ( l : List; v : Vector; m : integer ) return List is
                     89:
                     90:     res,tmp,res_last : List;
                     91:     d : Vector(v'range);
                     92:
                     93:   begin
                     94:     tmp := l;
                     95:     while not Is_Null(tmp) loop
                     96:       d := Head_Of(tmp).all;
                     97:       if d*v = m
                     98:        then Append(res,res_last,d);
                     99:       end if;
                    100:       tmp := Tail_Of(tmp);
                    101:     end loop;
                    102:     return res;
                    103:   end Face;
                    104:
                    105:   function Inner_Face ( l : List; v : Vector ) return List is
                    106:   begin
                    107:     return Face(l,v,Minimal_Support(l,v));
                    108:   end Inner_Face;
                    109:
                    110:   function Outer_Face ( l : List; v : Vector ) return List is
                    111:   begin
                    112:     return Face(l,v,Maximal_Support(l,v));
                    113:   end Outer_Face;
                    114:
                    115: end Integer_Support_Functions;