So maybe use DataFrames and crossjoin?

[dmbates]

I know - I am the one who is always advocating using Tables.jl rather than DataFrames but I think a good case can be made in this package for preferring DataFrames. There are various kinds of joins (in the relational database sense) defined in DataFrames, and a lot of work went into making the joins faster in v1.0.0

It occurs to me that a good way of starting a design with crossed subj and item blocking factors and possible between subject and between item experimental factors is to create a subject table and an item table and to take the crossjoin of those two tables.

julia> using DataFrames, MixedModelsSim

julia> subject = DataFrame(subj = nlevels(40), age = repeat(["young", "old"], outer=20));

julia> describe(subject)
2×7 DataFrame
 Row │ variable  mean     min     median   max     nmissing  eltype   
     │ Symbol    Nothing  String  Nothing  String  Int64     DataType 
─────┼────────────────────────────────────────────────────────────────
   1 │ subj               S01              S40            0  String
   2 │ age                old              young          0  String

julia> item = DataFrame(item = nlevels(24, 'I'), itype = repeat(["easy", "hard"], inner=12))
24×2 DataFrame
 Row │ item    itype  
     │ String  String 
─────┼────────────────
   1 │ I01     easy
   2 │ I02     easy
   3 │ I03     easy
   4 │ I04     easy
   5 │ I05     easy
   6 │ I06     easy
   7 │ I07     easy
   8 │ I08     easy
   9 │ I09     easy
  10 │ I10     easy
  11 │ I11     easy
  12 │ I12     easy
  13 │ I13     hard
  14 │ I14     hard
  15 │ I15     hard
  16 │ I16     hard
  17 │ I17     hard
  18 │ I18     hard
  19 │ I19     hard
  20 │ I20     hard
  21 │ I21     hard
  22 │ I22     hard
  23 │ I23     hard
  24 │ I24     hard

julia> df = pooled!(crossjoin(subject, item))
960×4 DataFrame
 Row │ subj    age     item    itype  
     │ String  String  String  String 
─────┼────────────────────────────────
   1 │ S01     young   I01     easy
   2 │ S01     young   I02     easy
   3 │ S01     young   I03     easy
   4 │ S01     young   I04     easy
   5 │ S01     young   I05     easy
   6 │ S01     young   I06     easy
   7 │ S01     young   I07     easy
   8 │ S01     young   I08     easy
   9 │ S01     young   I09     easy
  10 │ S01     young   I10     easy
  ⋮  │   ⋮       ⋮       ⋮       ⋮
 952 │ S40     old     I16     hard
 953 │ S40     old     I17     hard
 954 │ S40     old     I18     hard
 955 │ S40     old     I19     hard
 956 │ S40     old     I20     hard
 957 │ S40     old     I21     hard
 958 │ S40     old     I22     hard
 959 │ S40     old     I23     hard
 960 │ S40     old     I24     hard
                      941 rows omitted

We can, of course, clean this up. I like @palday 's idea passing a dictionary or even just a tuple of pairs for the between-subject or between-item specifications (e.g. :age => ["young", "old"]) and let the function creating the data frame figure out what repetition pattern is to be used.

[palday]

I'm not adverse to DataFrames, if for no other reason than those are easier for target audience of this package. That will be another breaking release though (we're still well pre-1.0, so that's fine, but something to keep in mind). It was an ... interesting exercise to rewrite all the package internals to avoid dataframes. 😉

It might be interesting add (and expose) functions that do pieces of the assembly, e.g. separating out the "create between-G dataframe" into an exported function. Then we could allow creating designs with arbitrary crossings or nestings (as compared to our current requirement for two blocking variables).