void DynProgProbLim::reserve (size_t arrayCapacity_) // new array capacity
// reduces capacity of and copies d_array_p from its begin
{
if (arrayCapacity_ == getArrayCapacity ()) return;
if (getArrayCapacity () < arrayCapacity_)
{
DynProgProb::reserve (arrayCapacity_);
return;
}
assert (arrayCapacity_ < getArrayCapacity ());
double *array = new double [getArrayCapacity ()];
for (size_t i = 0; i < 2; i++)
{
MemUtil::memCpy (array, getArray () [i], sizeof (double) * arrayCapacity_);
delete [] lgetArray () [i]; lgetArray () [i] = 0;
lgetArray () [i] = new double [arrayCapacity_];
MemUtil::memCpy (lgetArray () [i], array, sizeof (double) * arrayCapacity_);
}
lgetArrayCapacity () = arrayCapacity_;
delete [] array; array = 0;
}
void DynProgProb::copy (
size_t step_, // current index : starts at 0
const double *const *array_, // two corresponding arrays of probabilities
size_t arrayCapacity_, // present capacity of the array
Int4 valueBegin_, // lower limit for Int4 values in the array (an offset)
Int4 valueLower_, // present lower Int4 value in the array
Int4 valueUpper_, // one beyond present upper Int4 value in the array
ValueFct *newStateFct_, // function for updating dynamic programming values
size_t dimInputProb_,
const double *inputProb_) // array of input states : d_inputProb_p [0...dimStateProb - 1]
{
if (arrayCapacity_ != getArrayCapacity ())
{
free ();
init (arrayCapacity_);
}
d_step = step_;
for (size_t i = 0; i < 2; i++)
{
if (getArrayCapacity () > 0) MemUtil::memCpy (d_array_p [i], array_ [i], sizeof (double) * getArrayCapacity ());
}
d_valueBegin = valueBegin_;
d_valueLower = valueLower_;
d_valueUpper = valueUpper_;
setValueFct (newStateFct_);
setInput (dimInputProb_, inputProb_);
}
void DynProgProbLim::setValueBegin (Int4 valueBegin_)
// resets the offset d_valueBegin
// assert (offSet < getArrayCapacity ());
// if (getValueBegin () < valueBegin_) the caller must ensure consistency
{
if (valueBegin_ <= getValueBegin ())
{
DynProgProb::setValueBegin (valueBegin_);
return;
}
assert (getValueBegin () < valueBegin_);
size_t offSet = static_cast <size_t> (valueBegin_ - getValueBegin ());
double *array = new double [getArrayCapacity ()];
for (size_t i = 0; i < 2; i++)
{
MemUtil::memCpy (array, getArray () [i], sizeof (double) * getArrayCapacity ());
MemUtil::memZero (lgetArray () [i], sizeof (double) * getArrayCapacity ());
if (offSet < getArrayCapacity ())
{
MemUtil::memCpy (lgetArray () [i], array + offSet, sizeof (double) * (getArrayCapacity () - offSet));
}
}
delete [] array; array = 0;
lgetValueBegin () = valueBegin_;
}
void DynProgProb::update () // updates dynamic prog probs
{
assert (getValueFct ());
assert (getDimInputProb ());
assert (getInputProb ());
const size_t ARRAY_FAC = 2;
assert (1 < ARRAY_FAC);
Int4 i = 0;
size_t j = 0;
const double *oldArray = 0;
double *array = 0;
Int4 value = 0;
Int4 valueBegin = 0;
Int4 valueLower = 0;
Int4 valueUpper = 0;
size_t arrayPos = 0;
oldArray = d_array_p [d_step % 2];
array = d_array_p [(d_step + 1) % 2];
valueLower = kMax_I4;
valueUpper = kMin_I4;
MemUtil::memZero (array, sizeof (double) * getArrayCapacity ());
for (i = getValueLower (); i < getValueUpper (); i++)
{
if (oldArray [getArrayPos (i)] == 0.0) continue;
for (j = 0; j < getDimInputProb (); j++)
{
if (getInputProb () [j] == 0.0) continue;
// adjust the reserve, if necessary
value = getValueFct () (i, j);
while (value < getValueBegin () || getValueEnd () <= value) {
valueBegin = getValueBegin ();
if (value < getValueBegin ()) valueBegin -= (ARRAY_FAC - 1) * getArrayCapacity ();
reserve (ARRAY_FAC * getArrayCapacity ());
setValueBegin (valueBegin);
oldArray = d_array_p [d_step % 2];
array = d_array_p [(d_step + 1) % 2];
}
if (value < valueLower) valueLower = value;
if (valueUpper < value) valueUpper = value;
// add the probability
assert (getValueBegin () <= i);
assert (i < getValueEnd ());
array [getArrayPos (value)] += oldArray [getArrayPos (i)] * getInputProb () [j];
}
}
d_valueLower = valueLower;
d_valueUpper = valueUpper + 1;
d_step++;
}
void DynProgProbLim::update () // updates dynamic prog probs
{
assert (getValueFct ());
assert (getDimInputProb ());
assert (getInputProb ());
assert (0 < getArrayCapacity ());
Int4 i = 0;
size_t j = 0;
const double *oldArray = 0;
double *array = 0;
Int4 value = 0;
Int4 valueLower = 0;
Int4 valueUpper = 0;
size_t arrayPos = 0;
double prob = 0.0;
oldArray = getArray () [getStep () % 2];
array = lgetArray () [(getStep () + 1) % 2];
valueLower = kMax_I4;
valueUpper = kMin_I4;
MemUtil::memZero (array, sizeof (double) * getArrayCapacity ());
for (i = getValueLower (); i < getValueUpper (); i++)
{
if (oldArray [getArrayPos (i)] == 0.0) continue;
for (j = 0; j < getDimInputProb (); j++)
{
if (getInputProb () [j] == 0.0) continue;
value = getValueFct () (i, j);
prob = oldArray [getArrayPos (i)] * getInputProb () [j];
if (value < getValueBegin () || getValueEnd () <= value)
{
d_probLost += prob;
}
else
{
if (value < valueLower) valueLower = value;
if (valueUpper < value) valueUpper = value;
// add the probability
assert (getValueBegin () <= i);
assert (i < getValueEnd ());
array [getArrayPos (value)] += prob;
}
}
}
lgetValueLower () = valueLower;
lgetValueUpper () = valueUpper + 1;
lgetStep ()++;
}
void DynProgProbLim::setLimits (
Int4 valueBegin_, // range for values is [valueBegin_, valueEnd_).
Int4 valueEnd_) // range for values is [valueBegin_, valueEnd_).
// assert (valueBegin_ < valueEnd_);
{
assert (valueBegin_ < valueEnd_);
// take care of lost probability
Int4 value = 0;
for (value = getValueLower (); value < valueBegin_; value++)
{
d_probLost += getProb (value);
}
for (value = valueEnd_; value < getValueUpper (); value++)
{
d_probLost += getProb (value);
}
size_t arrayCapacity = static_cast <size_t> (valueEnd_ - valueBegin_);
if (getArrayCapacity () <= arrayCapacity)
{
reserve (arrayCapacity);
setValueBegin (valueBegin_);
}
else
{
setValueBegin (valueBegin_);
reserve (arrayCapacity);
}
}
void DynProgProb::reserve (size_t arrayCapacity_) // new array capacity
// increases capacity of and copies d_array_p, while updating other variables
{
assert (getArrayCapacity () < arrayCapacity_);
double *array = new double [getArrayCapacity ()];
for (size_t i = 0; i < 2; i++)
{
MemUtil::memCpy (array, d_array_p [i], sizeof (double) * getArrayCapacity ());
delete [] d_array_p [i]; d_array_p [i] = 0;
d_array_p [i] = new double [arrayCapacity_];
MemUtil::memZero (d_array_p [i], sizeof (double) * arrayCapacity_);
MemUtil::memCpy (d_array_p [i], array, sizeof (double) * getArrayCapacity ());
}
d_arrayCapacity = arrayCapacity_;
delete [] array; array = 0;
}
void DynProgProb::free ()
{
if (getArrayCapacity () > 0)
{
for (size_t i = 0; i < 2; i++)
{
delete [] d_array_p [i]; d_array_p [i] = 0;
}
}
d_arrayCapacity = 0;
}
void DynProgProb::setValueBegin (Int4 valueBegin_)
// resets the offset d_valueBegin
// assert (valueBegin_ <= getValueBegin ()) : enlarge the array only
// assert (offSet < getArrayCapacity ());
{
assert (valueBegin_ <= getValueBegin ());
size_t offSet = static_cast <size_t> (getValueBegin () - valueBegin_);
if (offSet == 0) return; // nothing to do
assert (offSet < getArrayCapacity ());
double *array = new double [getArrayCapacity ()];
for (size_t i = 0; i < 2; i++)
{
MemUtil::memCpy (array, d_array_p [i], sizeof (double) * getArrayCapacity ());
MemUtil::memZero (d_array_p [i], sizeof (double) * getArrayCapacity ());
MemUtil::memCpy (d_array_p [i] + offSet, array, sizeof (double) * (getArrayCapacity () - offSet));
}
delete [] array; array = 0;
d_valueBegin = valueBegin_;
}
void DynProgProb::clear ( // initializes the "probabilities" with non-negative weights
Int4 valueLower_, // lower Int4 value corresponding to the "probability" array
Int4 valueUpper_, // one beyond present upper Int4 value corresponding to the "probability" array
const double *prob_) // "probabilities" prob [valueLower_, valueUpper_) corresponding to the Int4s
{
assert ((! prob_ && valueLower_ <= 0 && 0 <= valueUpper_) ||
(prob_ && valueLower_ < valueUpper_));
if (prob_)
{
for (size_t i = 0; i < static_cast <size_t> (valueUpper_ - valueLower_); i++)
{
assert (0.0 <= prob_ [i]);
}
clear (valueLower_, static_cast <size_t> (valueUpper_ - valueLower_));
d_valueLower = valueLower_;
d_valueUpper = valueUpper_;
MemUtil::memCpy (d_array_p [0], prob_, sizeof (double) * getArrayCapacity ());
return;
}
if (valueLower_ == 0 && valueUpper_ == 0)
{
clear (-static_cast <Int4> (ARRAY_CAPACITY / 2) + 1, ARRAY_CAPACITY);
}
else
{
clear (valueLower_, static_cast <size_t> (valueUpper_ - valueLower_));
}
d_valueLower = 0;
d_valueUpper = 1;
d_array_p [0][getArrayPos (0)] = 1.0;
return;
}
