File size: 4,013 Bytes
5070096 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 |
standard library package SampledFunctions {
doc
/*
* This package provides a library model of discretely sampled mathematical functions.
*/
private import Base::Anything;
private import ScalarValues::Positive;
private import Collections::KeyValuePair;
private import Collections::OrderedMap;
private import SequenceFunctions::size;
private import ControlFunctions::forAll;
private import ControlFunctions::collect;
private import ControlFunctions::select;
attribute def SamplePair :> KeyValuePair {
doc
/*
* SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
*/
attribute domainValue :>> key;
attribute rangeValue :>> val;
}
attribute def SampledFunction :> OrderedMap {
doc
/*
* SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled,
* uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
* decreasing.
*
* It maps discrete domain values to discrete range values.
* The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and
* the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
*/
attribute samples: SamplePair[0..*] ordered :>> elements;
assert constraint {
// Note: Assumes the functions '<' and '>' are defined for the domain type.
(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or // Strictly increasing
(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) } // Strictly decreasing
}
}
calc def Domain {
doc
/*
* Domain returns the sequence of the domainValues of all samples in a SampledFunction.
*/
in fn : SampledFunction;
return : Anything[0..*] = fn.samples.domainValue;
}
calc def Range {
doc
/*
* Range returns the sequence of the rangeValues of all samples in a SampledFunction.
*/
in fn : SampledFunction;
return : Anything[0..*] = fn.samples.rangeValue;
}
calc def Sample {
doc
/*
* Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
*/
in calc calculation { in x; }
in attribute domainValues [0..*];
return sampling = SampledFunction (
samples = domainValues->collect { in x; SamplePair(x, calculation(x)) }
);
}
calc def Interpolate {
doc
/*
* An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
* If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
*/
in attribute fn : SampledFunction;
in attribute value;
return attribute result;
}
calc interpolateLinear : Interpolate {
doc
/*
* interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
*/
in attribute fn : SampledFunction;
in attribute value;
private attribute domainValues = Domain(fn);
private attribute index : Positive[0..1] =
(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
private calc def Linear {
in attribute lowerSample : SamplePair;
in attribute upperSample : SamplePair;
in attribute value;
private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);
}
return result [0..1] =
if index == null or index == size(domainValues)? null
else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
else Linear(fn.samples#(index+1), fn.samples#(index), value);
}
} |