```Jeremy Hinegardner wrote:
> So the DSL generates a 'large' number of cases listing the input
> parameters and their associated values.  The list of input parameters
> static across all cases, or a set of cases?

The input parameter names are static across all cases, but
for each case, the parameter value will vary randomly according
to the tolerance DSL, e.g., 1.05+/-0.2.  Currently, I have all
these as a hash of arrays, e.g.,

{ 'F_x' => [ 1.23, 1.12, 0.92, 1.01, ... ],
'q_r' => [ 1.34e+9, 3.89e+8, 8.98e+8, 5.23e+9, ... ], ... }

where 1.23 is the sample for input parameter 'F_x' for the
first case, 1.12 is the sample for the second case, etc.,
and 1.34e+9 is the sample for input parameter 'q_r' for
the first case, and so forth.

> That is, for a given "experiment" you have the same set of parameters,
> just with a "large" numver of different values to put in those
> parameters.

Yes, if I understand you correctly.

>>  2) Run all the cases.
>>  3) Collect all the samples of all the outputs of interest.
>
> I'm also assuming that the output(s) for a given "experiment" would be
> consistent in their parameters?

Yes, the output parameter hash has the same structure as the input
hash, although it typically has fewer parameters.  The number
and sequence of values (realizations) for each output parameter,
however, corresponds exactly to the array of samples for each input
parameter.  For example, the outputs hash may look like,

{ 'heating' => [ 75.23, 76.54, ... ],
'stag_pr' => [ 102.13, 108.02, ... ], ... }

Here, the 2nd realization of the output, 'stag_pr', 108.02 corresponds
to the 2nd case and is associated with the 2nd entries in the 'F_x'
and 'q_r' arrays, 1.12 and 3.89e+8, respectively.

> So right now you are doing say for a given experiment f:
>
>     inputs  : i1,i2,i3,...,in
>     outputs : o1,o2,o3,...,0m
>
> run f(i1,i2,i3,...,in) -> [o1,...,on] where the values for i1,...,in are
> "jiggled"  And you have around 3,000 diferent sets of inputs.

Yes, where 'inputs' and 'outputs' are vectors m and k long,
respectively; so you have a matrix of values, e.g.,

input1  : i1_1, i1_2, i1_3, ..., i1_n
input2  : i2_1, i2_2, i2_3, ..., i2_n
.        .    .     .     .    .
.        [ m x n matrix ]      .
.        .    .     .     .    .
inputj  : im_1, im_2, im_3, ..., im_n

output1 : o1_1, o1_2, o1_3, ..., o1_n
output1 : o2_1, o2_2, o2_3, ..., o2_n
.        .    .     .     .    .
.        [ k x n matrix ]      .
.        .    .     .     .    .
output1 : ok_1, ok_2, ok_3, ..., ok_n

> Would you be willing to share these?

/I/ am willing, but unfortunately I'm also mired in red tape.

> I'm not sure if what I'm assuming
> about your problem is correct or not, but it intrigues me and I'd like
> to fiddle with the general problem :-).

The more I explain it, the more I learn about it; so thanks
for the interest.

Regards,
--
Bil Kleb
http://fun3d.larc.nasa.gov

```