Ada - Sensible code structure for SHA3 implementation - ada

Question

I'm using the SHA3 specification as a learning example for the Ada programming language.
The spec contains a family of data structures call Permutations, there are seven of these and they differ only by being able to handle different amounts of data. They contain a three-dimensional "State Array" where the first two dimensions are always mod 5 and the third dimension is mod N, where N is limited to these few values: 25, 50, 100, 200, 400, 800 and 1600.
I'd normally think to use generics to make the distinction between each package variation, but the difference is a number, and not a type.
How might I sensibly design my package / record types?
The only way I can think of doing this is to simply make a set of explicit types...
package Perm_25 is...
package Perm_50 is...
package Perm_100 is...
package Perm_200 is...
package Perm_400 is...
package Perm_800 is...
package Perm_1600 is...
Clearly that is nonsensical because it's laborious and requires me to duplicate a lot of code, which would invite inconsistencies.
Also I'm not convinced that OOP would help here because the types really aren't different apart from some array dimensions.
How should I approach this problem?
EDIT: Thanks to user #flyx for the tip to use a Static_Predicate subtype and a discriminated record type. Using that advice I have managed to get the following code to compile...
package body SHA3 is
subtype Perm_w_Coeff_Type is Positive
with Static_Predicate
=> Perm_w_Coeff_Type in 1 | 2 | 4 | 8 | 16 | 32 | 64;
subtype Perm_l_Coeff_Type is Natural range 0 .. 6;
type State_Array_Type is array (Natural range <>, Natural range <>, Natural range <>) of Boolean;
-- (see FIPS202 section 3)
type KECCAK_p_Permutation (bPW : b_Permutation_Width; numRounds : Positive; W_Coeff : Perm_w_Coeff_Type) is
record
b : b_Permutation_Width := bPW;
-- initialise w based on a lookup table using b as its index
-- (see FIPS202 section 3.1, table 1)
w : Perm_w_Coeff_Type := (
case bPW is
when 25 => 1,
when 50 => 2,
when 100 => 4,
when 200 => 8,
when 400 => 16,
when 800 => 32,
when 1600 => 64
);
-- initialise l based on a lookup table using b as its index
-- (see FIPS202 section 3.1, table 1)
l : Perm_l_Coeff_Type := (
case bPW is
when 25 => 0,
when 50 => 1,
when 100 => 2,
when 200 => 3,
when 400 => 4,
when 800 => 5,
when 1600 => 6
);
n_sub_r : Positive := numRounds;
State_Array : State_Array_Type (0 .. 4, 0 .. 4, 0 .. W_Coeff);
end record;
procedure Run is
begin
null;
end Run;
end SHA3;

Answer 1

subtype Third_Dimension_Type is Natural with
Static_Predicate => Third_Dimension_Type in 25 | 50 | 100 | 200 | 400 | 800 | 1600;
I don't know what you mean by „the first two dimensions are always mod 5“, but assuming you mean they have 5 entries, the resulting data type would the be something like:
type Permutation (Third_Dimension : Third_Dimension_Type) is record
State : array (1..5, 1..5, 1..Third_Dimension) of Item_Type;
end record;
Note that you cannot specify an array type that takes two discrete ranges and one indefinite range (e.g. Third_Dimension_Type range <>), so you need to use a discriminated record instead.

Answer 2

I haven't gone for the detail of your question, but I'm answering something that caught my eye: you say you can't use generics because the parameter that changes isn't a type. However, you can parameterize generics with values (not saying that's the best approach in this case, but that you can do it):
generic
Foo : Integer := 5; -- Or any other type.
package Bar is ...