Return to floating_integer_convertors.adb CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Root_Counts / Stalift

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Stalift/floating_integer_convertors.adb, Revision 1.1

1.1     ! maekawa     1: with Standard_Floating_Numbers;          use Standard_Floating_Numbers;
        !             2:
        !             3: package body Floating_Integer_Convertors is
        !             4:
        !             5:   function Convert ( v : Standard_Integer_Vectors.Vector )
        !             6:                    return Standard_Floating_Vectors.Vector is
        !             7:
        !             8:     res : Standard_Floating_Vectors.Vector(v'range);
        !             9:
        !            10:   begin
        !            11:     for i in res'range loop
        !            12:       res(i) := double_float(v(i));
        !            13:     end loop;
        !            14:     return res;
        !            15:   end Convert;
        !            16:
        !            17:   function Convert ( v : Standard_Floating_Vectors.Vector )
        !            18:                    return Standard_Integer_Vectors.Vector is
        !            19:
        !            20:     res : Standard_Integer_Vectors.Vector(v'range);
        !            21:
        !            22:   begin
        !            23:     for i in res'range loop
        !            24:       res(i) := integer(v(i));
        !            25:     end loop;
        !            26:     return res;
        !            27:   end Convert;
        !            28:
        !            29:   function Convert ( l : Lists_of_Integer_Vectors.List )
        !            30:                    return Lists_of_Floating_Vectors.List is
        !            31:
        !            32:     res,res_last : Lists_of_Floating_Vectors.List;
        !            33:     tmp : Lists_of_Integer_Vectors.List := l;
        !            34:
        !            35:     use Lists_of_Integer_Vectors;
        !            36:
        !            37:   begin
        !            38:     while not Is_Null(tmp) loop
        !            39:       Lists_of_Floating_Vectors.Append(res,res_last,Convert(Head_Of(tmp).all));
        !            40:       tmp := Tail_Of(tmp);
        !            41:     end loop;
        !            42:     return res;
        !            43:   end Convert;
        !            44:
        !            45:   function Convert ( l : Lists_of_Floating_Vectors.List )
        !            46:                    return Lists_of_Integer_Vectors.List is
        !            47:
        !            48:     res,res_last : Lists_of_Integer_Vectors.List;
        !            49:     tmp : Lists_of_Floating_Vectors.List := l;
        !            50:
        !            51:     use Lists_of_Floating_Vectors;
        !            52:
        !            53:   begin
        !            54:     while not Is_Null(tmp) loop
        !            55:       Lists_of_Integer_Vectors.Append(res,res_last,Convert(Head_Of(tmp).all));
        !            56:       tmp := Tail_Of(tmp);
        !            57:     end loop;
        !            58:     return res;
        !            59:   end Convert;
        !            60:
        !            61:   function Convert ( l : Arrays_of_Integer_Vector_Lists.Array_of_Lists )
        !            62:                    return Arrays_of_Floating_Vector_Lists.Array_of_Lists is
        !            63:
        !            64:     res : Arrays_of_Floating_Vector_Lists.Array_of_Lists(l'range);
        !            65:
        !            66:   begin
        !            67:     for i in l'range loop
        !            68:       res(i) := Convert(l(i));
        !            69:     end loop;
        !            70:     return res;
        !            71:   end Convert;
        !            72:
        !            73:   function Convert ( l : Arrays_of_Floating_Vector_Lists.Array_of_Lists )
        !            74:                    return Arrays_of_Integer_Vector_Lists.Array_of_Lists is
        !            75:
        !            76:     res : Arrays_of_Integer_Vector_Lists.Array_of_Lists(l'range);
        !            77:
        !            78:   begin
        !            79:     for i in l'range loop
        !            80:       res(i) := Convert(l(i));
        !            81:     end loop;
        !            82:     return res;
        !            83:   end Convert;
        !            84:
        !            85:   function Convert ( m : Integer_Mixed_Subdivisions.Mixed_Cell )
        !            86:                    return Floating_Mixed_Subdivisions.Mixed_Cell is
        !            87:
        !            88:     res : Floating_Mixed_Subdivisions.Mixed_Cell;
        !            89:     use Integer_Mixed_Subdivisions;
        !            90:
        !            91:   begin
        !            92:     res.nor := new Standard_Floating_Vectors.Vector'(Convert(m.nor.all));
        !            93:     res.pts :=
        !            94:       new Arrays_of_Floating_Vector_Lists.Array_of_Lists'(Convert(m.pts.all));
        !            95:     if m.sub = null
        !            96:      then res.sub := null;
        !            97:      else res.sub :=
        !            98:       new Floating_Mixed_Subdivisions.Mixed_Subdivision'(Convert(m.sub.all));
        !            99:     end if;
        !           100:     return res;
        !           101:   end Convert;
        !           102:
        !           103:   function Convert ( m : Floating_Mixed_Subdivisions.Mixed_Cell )
        !           104:                    return Integer_Mixed_Subdivisions.Mixed_Cell is
        !           105:
        !           106:     res : Integer_Mixed_Subdivisions.Mixed_Cell;
        !           107:     use Floating_Mixed_Subdivisions;
        !           108:
        !           109:   begin
        !           110:     res.nor := new Standard_Integer_Vectors.Vector'(Convert(m.nor.all));
        !           111:     res.pts :=
        !           112:       new Arrays_of_Integer_Vector_Lists.Array_of_Lists'(Convert(m.pts.all));
        !           113:     if m.sub = null
        !           114:      then res.sub := null;
        !           115:      else res.sub :=
        !           116:        new Integer_Mixed_Subdivisions.Mixed_Subdivision'(Convert(m.sub.all));
        !           117:     end if;
        !           118:     return res;
        !           119:   end Convert;
        !           120:
        !           121:   function Convert ( s : Integer_Mixed_Subdivisions.Mixed_Subdivision )
        !           122:                    return Floating_Mixed_Subdivisions.Mixed_Subdivision is
        !           123:
        !           124:     res,res_last : Floating_Mixed_Subdivisions.Mixed_Subdivision;
        !           125:     tmp : Integer_Mixed_Subdivisions.Mixed_Subdivision := s;
        !           126:
        !           127:     use Integer_Mixed_Subdivisions;
        !           128:
        !           129:   begin
        !           130:     while not Is_Null(tmp) loop
        !           131:       Floating_Mixed_Subdivisions.Append(res,res_last,Convert(Head_Of(tmp)));
        !           132:       tmp := Tail_Of(tmp);
        !           133:     end loop;
        !           134:     return res;
        !           135:   end Convert;
        !           136:
        !           137:   function Convert ( s : Floating_Mixed_Subdivisions.Mixed_Subdivision )
        !           138:                    return Integer_Mixed_Subdivisions.Mixed_Subdivision is
        !           139:
        !           140:     res,res_last : Integer_Mixed_Subdivisions.Mixed_Subdivision;
        !           141:     tmp : Floating_Mixed_Subdivisions.Mixed_Subdivision := s;
        !           142:
        !           143:     use Floating_Mixed_Subdivisions;
        !           144:
        !           145:   begin
        !           146:     while not Is_Null(tmp) loop
        !           147:       Integer_Mixed_Subdivisions.Append(res,res_last,Convert(Head_Of(tmp)));
        !           148:       tmp := Tail_Of(tmp);
        !           149:     end loop;
        !           150:     return res;
        !           151:   end Convert;
        !           152:
        !           153: end Floating_Integer_Convertors;