Jeremy H. 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.

- Run all the cases.
- 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,