TVP vdmSeqInEqual(TVP seq,TVP seq2)
{
ASSERT_CHECK(seq);
ASSERT_CHECK(seq2);
return newBool(!collectionEqual(seq,seq2));
}
TVP vdmSeqConc(TVP seq,TVP seq2)
{
ASSERT_CHECK(seq);
ASSERT_CHECK(seq2);
UNWRAP_COLLECTION(col,seq);
UNWRAP_COLLECTION(col2,seq2);
//malloc
TVP concVal = newSeq(col->size+col2->size);
UNWRAP_COLLECTION(concSeq,concVal);
//copy list
for (int i = 0; i < col->size; i++)
{
concSeq->value[i] = vdmClone(col->value[i]);
}
int offset = col->size;
for (int i = 0; i < col2->size; i++)
{
concSeq->value[i+offset] = vdmClone(col2->value[i]);
}
return concVal;
}
void IOracle::extractAndAddSolution(DoubleVector const & x, Double rd) {
Column column(_input);
extract(x, column);
column.reducedCost() = rd;
ASSERT_CHECK(column.check(*_dual));ASSERT_CHECK(column.violation(*_decisions) == 0);
_columns.insert(column);
}
TVP vdmSeqElems(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
TVP elemsVal = newSetWithValues(col->size, col->value);
return elemsVal;
}
void IOracle::sortedColumns(
std::multimap<Double, Column const *, std::greater<Double>> & result) const {
result.clear();
// MY_PRINT(_columns.size());
for (auto const & column : _columns) {
// column.print();
ASSERT_CHECK(column.check(*_dual));
result.insert(std::make_pair(column.reducedCost(), &column));
}
}
void vdmSeqUpdate(TVP seq, TVP indexVal, TVP newValue)
{
ASSERT_CHECK(seq);
assert((indexVal->type == VDM_INT||indexVal->type == VDM_NAT||indexVal->type == VDM_NAT1) && "index is not a int");
int index = indexVal->value.intVal;
UNWRAP_COLLECTION(col,seq);
assert(index-1>=0 && index-1<col->size && "invalid index");
col->value[index-1] = vdmClone(newValue);
}
TVP vdmSeqIndex(TVP seq,TVP indexVal) //VDM uses 1 based index
{
ASSERT_CHECK(seq);
assert((indexVal->type == VDM_INT||indexVal->type == VDM_NAT||indexVal->type == VDM_NAT1) && "index is not a int");
int index = indexVal->value.intVal;
UNWRAP_COLLECTION(col,seq);
assert(index-1>=0 && index-1<col->size && "invalid index");
return vdmClone(col->value[index-1]);
}
void CliquePartitionProblem::gradient(IndexedList const & v,
DoubleVector & result) const {
ASSERT_CHECK(v.max_size()==nV());
result.assign(v.max_size(), 0);
for (auto const & e : _costs) {
if (v.contains(e._j)) {
result[e._i] += e._v;
}
if (v.contains(e._i)) {
result[e._j] += e._v;
}
}
}
TVP vdmSeqInds(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
struct TypedValue** value = (struct TypedValue**) calloc(col->size, sizeof(struct TypedValue*));
//copy list
for (int i = 0; i < col->size; i++)
{
value[i] = newInt(i+1);
}
TVP indsVal = newSetWithValues(col->size, value);
return indsVal;
}
TVP vdmSeqTl(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
//malloc
TVP tailVal = newSeq(col->size-1);
UNWRAP_COLLECTION(tail,tailVal);
//copy tail list
for (int i = 1; i < col->size; i++)
{
tail->value[i-1] = vdmClone(col->value[i]);
}
return tailVal;
}
TVP vdmSeqReverse(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
//malloc
TVP elemsVal = newSeq(col->size);
UNWRAP_COLLECTION(elems,elemsVal);
int offset = col->size-1;
//copy list
for (int i = 0; i < col->size; i++)
{
elems->value[i] = vdmClone(col->value[offset-i]);
}
return elemsVal;
}
TVP vdmSeqLen(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
return newInt(col->size);
}
TVP vdmSeqHd(TVP seq)
{
ASSERT_CHECK(seq);
UNWRAP_COLLECTION(col,seq);
return vdmClone(col->value[0]);
}
