2-dimensional view on 1 dimensional array

2-dimensional view on 1 dimensional array

[Marek]

Hi.
Assume we have:

     generic
        type T is private;
        type T_Array is array (Natural range <>) of aliased T;
        type T_Array_Access is access all T_Array;
     package Buffers is

        type Row_Array is array (Natural range <>) of aliased 
T_Array_Access;

        type Row_Array_Access is access all Row_Array;

        type Buffer is tagged
           record
              Raw_Buffer : T_Array_Access   := null;
              Rows_Table : Row_Array_Access := null;
              Rows       : Natural          := 0;
              Columns    : Natural          := 0;
              Step       : Integer          := 0;
              Max_Rows   : Natural          := 0;
           end record;

        procedure Init
          (This    : in out Buffer;
           Buffer  :        T_Array_Access;
           Rows    :        Natural;
           Columns :        Natural;
           Step    :        Integer);

        procedure Set_Value
          (This  : in out Buffer;
           Value :        T);

     end Buffers;

..and:

     with Ada.Unchecked_Deallocation;

     package body Buffers is

        type T_Access is access all T;

        ------------
        --  Init  --
        ------------

        procedure Init
          (This    : in out Buffer;
           Buffer  :        T_Array_Access;
           Rows    :        Natural;
           Columns :        Natural;
           Step    :        Integer)
        is
           procedure Free is
             new Ada.Unchecked_Deallocation (Row_Array, Row_Array_Access);

           Row_Index : Integer := 0;
        begin
           This.Raw_Buffer := Buffer;
           This.Rows       := Rows;
           This.Columns    := Columns;
           This.Step       := Step;

           if Rows > This.Max_Rows then
              if This.Rows_Table /= null then
                 Free (This.Rows_Table);
              end if;

              declare
                 New_Rows : constant Row_Array_Access :=
                              new Row_Array (0 .. Rows - 1);
              begin
                 This.Rows_Table := New_Rows;
                 This.Max_Rows := Rows;
              end;
           end if;

           for H in 0 .. Rows - 1 loop
              declare
                 Row_Start : constant T_Access :=
                               This.Raw_Buffer (Row_Index * Step)'Access;
              begin
                 This.Rows_Table (H) := ...  -- What code here?

                 Row_Index := Row_Index + 1;
              end;
           end loop;

        end Init;

        -----------------
        --  Set_Value  --
        -----------------

        procedure Set_Value
          (This  : in out Buffer;
           Value :        T)
        is
        begin
           if This.Rows > 0 then
              for Y in 0 .. This.Rows - 1 loop
                 declare
                    Row : constant T_Array_Access := This.Rows_Table (Y);
                 begin
                    if This.Step > 0 then
                       for X in 0 .. This.Step - 1 loop
                          Row (X) := Value;
                       end loop;
                    end if;
                 end;
              end loop;
           end if;
        end Set_Value;

     end Buffers;

and finally:

     with Buffers;

     procedure Test is

        type Float_Array is array (Natural range <>) of aliased Float;

        type Float_Array_Access is access all Float_Array;

        package Buffer_Package is
          new Buffers (Float, Float_Array, Float_Array_Access);

        use Buffer_Package;

        A : aliased Float_Array := (0 .. 99 => 0.0);
        B : Buffer_Package.Buffer;
     begin

        B.Init (A'Access, 10, 10, 10);
        B.Set_Value (10.0);
     end Test;

Is there any possibilities to get this working?
Idea is to have another (2 dimensional) view on 1 dimensional array.
Unchecked_Conversion is not working (different sizes of objects).
Address_To_Access conversion also (unconstrained array);

Marek

Re: 2-dimensional view on 1 dimensional array

[AdaMagica]

Your code looks rather ununderstandable to me.
A quick attempt on what you claimed you are trying to do (no guarantee):

generic

  type T is private;

  type T_Array is array (Integer range <>) of T;

package Dim1_to_2 is

  -- type T_Array_2Dim is array (Integer range <>, Integer range <>) of T;

  procedure Set (TA: in T_Array; Row, Num_Row, Col, Num_Col: Positive; Value: T)
    with Pre => Row in 1 .. Num_Row and Col in 1 .. Num_Col and
                Num_Row * Num_col = TA'Length;

end Dim1_to_2;
package body Dim1_to_2 is

  type T_Array_2Dim is array (Integer range <>, Integer range <>) of T;

  procedure Set (TA: in T_Array; Row, Num_Row, Col, Num_Col: Positive; Value: T) is
    TA2: T_Array_2Dim (1 .. Num_Row, 1 .. Num_Col);
    for TA2'Address use TA'Address;
  begin
    if Num_Row * Num_Col /= TA'Length or
       Row not in 1 .. Num_Row or Col not in 1 .. Num_Col then
      raise Constraint_Error;
    end if;
    TA2 (Row, Col) := Value;
  end Set;

end Dim1_to_2;
with Dim1_to_2;

procedure Ausprobieren is

  type A is array (Integer range <>) of Integer;

  X: aliased A (-10 .. 10) := (others => 0);

  package To_2D is new Dim1_to_2 (Integer, A);

begin

  To_2D.Set (X, Row => 2, Num_Row => 7, Col => 1, Num_Col => 3, Value => -1);

  for V of X loop
    Put_Line (V'Image);
  end loop;

Re: 2-dimensional view on 1 dimensional array

[AdaMagica]

The object X must be aliased because of the address clauses.

Re: 2-dimensional view on 1 dimensional array

[AdaMagica]

Also interesting: The array is an in-parameter. You get a variable view with the overlay. Clever Gnat gives you a warning. Don't know what other cmpilers say.

Re: 2-dimensional view on 1 dimensional array

[J-P. Rosen]

Le 23/10/2022 à 14:31, Marek a écrit :
> generic
>         type T is private;
>         type T_Array is array (Natural range <>) of aliased T;
>         type T_Array_Access is access all T_Array;
>      package Buffers is
> 
>         type Row_Array is array (Natural range <>) of aliased 
> T_Array_Access;
> 
>         type Row_Array_Access is access all Row_Array;
Here I see a pointer to an array of pointers to an array whose 
components can pointed to...
That's too much for my small head ( (c) Hoare)
Can you explain what you try to accomplish?

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
https://www.adalog.fr https://www.adacontrol.fr

Re: 2-dimensional view on 1 dimensional array

[Jeffrey R.Carter]

On 2022-10-25 14:57, J-P. Rosen wrote:
> That's too much for my small head ( (c) Hoare)

I am familiar with the Dijkstra quote, "I have a very small head and I had 
better learn to live with it". Did Hoare say something along those lines, too?

-- 
Jeff Carter
"[Many] programmers do not use [languages with
automatic run-time checks] because 'They're not
efficient.' (Presumably this means that it is
vital to get the wrong answers quickly.)"
Elements of Programming Style
193

Re: 2-dimensional view on 1 dimensional array

[Marek]

I want just to know if it is possible to make different "view" on 1 
dimensional array. And of course I meant not 2-dimensional array but 
array of arrays. Reason for that is that I want to use slicing on that view.

Ok, here is full specification:

     generic
        type T is private;
        type T_Array is array (Natural range <>) of aliased T;
        type T_Array_Access is access all T_Array;
     package Buffers is

        type Row_Array is array (Natural range <>) of aliased 
T_Array_Access;

        type Row_Array_Access is access all Row_Array;

        type Buffer is tagged
           record
              Raw_Buffer : T_Array_Access   := null;
              Rows_Table : Row_Array_Access := null;
              Rows       : Natural          := 0;
              Columns    : Natural          := 0;
              Step       : Integer          := 0;
              Max_Rows   : Natural          := 0;
           end record;

        procedure Init
          (This    : in out Buffer;
           Buffer  :        T_Array_Access;
           Rows    :        Natural;
           Columns :        Natural;
           Step    :        Integer);

        procedure Set_Value
          (This  : in out Buffer;
           Value :        T);

       function Get_Buffer
         (This : Rendering_Buffer)
          return T_Array_Access
       is (This.Buffer);

       function Get_Rows_Table
         (This : Rendering_Buffer)
          return Row_Array_Access
       is (This.Rows);

       function Get_Columns
         (This : Rendering_Buffer)
          return Natural
       is (This.Columns);

       function Get_Rows
         (This : Rendering_Buffer)
          return Natural
       is (This.Rows);

       function Get_Step
         (This : Rendering_Buffer)
          return Integer
       is (This.Step);

       function Move_Start
         (This       : Rendering_Buffer;
          Col_Offset : Natural;
          Row_Offset : Natural)
          return T_Array_Access;

       function Row
         (This   : Rendering_Buffer;
          R      : Natural)
          return T_Array_Access;

       procedure Copy_From
         (This   : in out Rendering_Buffer;
          Source :        Rendering_Buffer);

     end Buffers;

I consider this package to be a kind of template that I can apply to the 
raw data and get what it expects. That is why I am using access types.
I know this is very C-ish but...

thank you for your answers everybody
Marek
p.s. Be aware that this group is read not only by software engineers. 
Carpenters may also happen ... :)

Re: 2-dimensional view on 1 dimensional array

[J-P. Rosen]

Le 25/10/2022 à 17:53, Jeffrey R.Carter a écrit :
> I am familiar with the Dijkstra quote, "I have a very small head and I 
> had better learn to live with it". Did Hoare say something along those 
> lines, too?
My confusion, must be Dijkstra. But that's the quote I wanted...

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
https://www.adalog.fr https://www.adacontrol.fr

Re: 2-dimensional view on 1 dimensional array

[J-P. Rosen]

Le 25/10/2022 à 18:59, Marek a écrit :
> I want just to know if it is possible to make different "view" on 1 
> dimensional array. And of course I meant not 2-dimensional array but 
> array of arrays. Reason for that is that I want to use slicing on that 
> view.
Any one dimensional array can be sliced. If you have an (1 dimensional) 
array of arrays, it can be sliced, as well as any of its components. 
Still puzzled about what you want to achieve (and the depth of your 
pointers-to-pointers-to-pointers....)

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
https://www.adalog.fr https://www.adacontrol.fr

Re: 2-dimensional view on 1 dimensional array

[AdaMagica]

ficorax@gmail.com schrieb am Dienstag, 25. Oktober 2022 um 18:59:15 UTC+2:
> I want just to know if it is possible to make different "view" on 1 
> dimensional array. And of course I meant not 2-dimensional array but 
> array of arrays. Reason for that is that I want to use slicing on that view. 
> 
> Ok, here is full specification:
> generic 
> type T is private; 
> type T_Array is array (Natural range <>) of aliased T; 
> type T_Array_Access is access all T_Array; 
> package Buffers is 

and so on ununderstandably.
Have you ever heard of something like comments? Or more fundamentally, of design? This is just a lump of code fragments hurting my brain.