Disposable<Array> qrSolve(const Matrix& a, const Array& b,
bool pivot, const Array& d) {
const Size m = a.rows();
const Size n = a.columns();
QL_REQUIRE(b.size() == m, "dimensions of A and b don't match");
QL_REQUIRE(d.size() == n || d.empty(),
"dimensions of A and d don't match");
Matrix q(m, n), r(n, n);
std::vector<Size> lipvt = qrDecomposition(a, q, r, pivot);
boost::scoped_array<int> ipvt(new int[n]);
std::copy(lipvt.begin(), lipvt.end(), ipvt.get());
Matrix rT = transpose(r);
boost::scoped_array<Real> sdiag(new Real[n]);
boost::scoped_array<Real> wa(new Real[n]);
Array ld(n, 0.0);
if (!d.empty()) {
std::copy(d.begin(), d.end(), ld.begin());
}
Array x(n);
Array qtb = transpose(q)*b;
MINPACK::qrsolv(n, rT.begin(), n, ipvt.get(),
ld.begin(), qtb.begin(),
x.begin(), sdiag.get(), wa.get());
return x;
}
void CompositorLoader::ParseStageConnections(CompositeStageConnections& connections, const json::Value& stageJson)
{
if (stageJson.HasKey("input") && stageJson["input"].GetType() == ArrayVal)
{
Array inputArray = stageJson["input"].ToArray();
for (auto it = inputArray.begin(); it != inputArray.end(); ++it)
{
connections.AddRenderTargetInput(it->ToString(""));
}
}
if (stageJson.HasKey("output") && stageJson["output"].GetType() == ArrayVal)
{
Array inputArray = stageJson["output"].ToArray();
for (auto it = inputArray.begin(); it != inputArray.end(); ++it)
{
connections.AddRenderTarget(it->ToString(""));
}
}
if (stageJson.HasKey("depthBuffer") && stageJson["depthBuffer"].GetType() == StringVal)
{
connections.SetDepthBuffer(stageJson["depthBuffer"].ToString());
}
}
void ArrayTest::pointerConversion() {
Array a(2);
int* b = a;
CORRADE_COMPARE(b, a.begin());
const Array c(3);
const int* d = c;
CORRADE_COMPARE(d, c.begin());
/* Pointer arithmetic */
const Array e(3);
const int* f = e + 2;
CORRADE_COMPARE(f, &e[2]);
/* Verify that we can't convert rvalues */
CORRADE_VERIFY((std::is_convertible<Array&, int*>::value));
CORRADE_VERIFY((std::is_convertible<const Array&, const int*>::value));
{
#ifdef CORRADE_GCC47_COMPATIBILITY
CORRADE_EXPECT_FAIL("Rvalue references for *this are not supported in GCC < 4.8.1.");
#endif
CORRADE_VERIFY(!(std::is_convertible<Array, int*>::value));
CORRADE_VERIFY(!(std::is_convertible<Array&&, int*>::value));
}
/* Deleting const&& overload and leaving only const& one will not, in fact,
disable conversion of const Array&& to pointer, but rather make the
conversion ambiguous, which is not what we want, as it breaks e.g.
rvalueArrayAccess() test. */
{
CORRADE_EXPECT_FAIL("I don't know how to properly disable conversion of const Array&& to pointer.");
CORRADE_VERIFY(!(std::is_convertible<const Array, const int*>::value));
CORRADE_VERIFY(!(std::is_convertible<const Array&&, const int*>::value));
}
}
inline Disposable<Array> operator/(const Array& v1, const Array& v2) {
QL_REQUIRE(v1.size() == v2.size(),
"dividing arrays with different sizes");
Array result(v1.size());
std::transform(v1.begin(),v1.end(),v2.begin(),result.begin(),
std::divides<double>());
return result;
}
void ExtEngineManager::Trigger::execute(thread_db* tdbb, ExternalTrigger::Action action,
record_param* oldRpb, record_param* newRpb) const
{
EngineAttachmentInfo* attInfo = extManager->getEngineAttachment(tdbb, engine);
ContextManager<ExternalTrigger> ctxManager(tdbb, attInfo, trigger,
CallerName(obj_trigger, trg->name));
// ASF: Using Array instead of HalfStaticArray to not need to do alignment hacks here.
Array<UCHAR> oldMsg;
Array<UCHAR> newMsg;
if (oldRpb)
setValues(tdbb, oldMsg, oldRpb);
if (newRpb)
setValues(tdbb, newMsg, newRpb);
{ // scope
Attachment::Checkout attCout(tdbb->getAttachment(), FB_FUNCTION);
LocalStatus status;
trigger->execute(&status, attInfo->context, action,
(oldMsg.hasData() ? oldMsg.begin() : NULL), (newMsg.hasData() ? newMsg.begin() : NULL));
status.check();
}
if (newRpb)
{
// Move data back from the message to the record.
Record* record = newRpb->rpb_record;
UCHAR* p = newMsg.begin();
for (unsigned i = 0; i < format->fmt_count / 2u; ++i)
{
USHORT fieldPos = fieldsPos[i];
dsc target;
bool readonly = !EVL_field(newRpb->rpb_relation, record, fieldPos, &target) &&
target.dsc_address && !(target.dsc_flags & DSC_null);
if (!readonly)
{
SSHORT* nullSource = (SSHORT*) (p + (IPTR) format->fmt_desc[i * 2 + 1].dsc_address);
if (*nullSource == 0)
{
dsc source = format->fmt_desc[i * 2];
source.dsc_address += (IPTR) p;
MOV_move(tdbb, &source, &target);
record->clearNull(fieldPos);
}
else
record->setNull(fieldPos);
}
}
}
}
/**
* Remove the item at the given index.
*/
void remove(size_type i) {
assert(i < size());
std::move(std::next(data.begin(), i + 1),
std::next(data.begin(), size()),
std::next(data.begin(), i));
--the_size;
}
bool simpleInitTest(ofstream& fout, Solver& solver, const Array& a,
const Array& b, const Matrix& bin) {
PrintABbin(fout, a, b, bin);
fout << "-------------------------" << endl;
solver.Init(a.size(), b.size(), bin);
fout << "solver.Init(a.size(),b.size(),bin);" << endl;
solver.PrintTestData(fout);
fout << "-------------------------" << endl;
return simpleNoPrintABbinTest(fout, solver, a.begin(), b.begin());
}
inline std::size_t
forward_partial_product(const Array& in, Array& out)
{
using T = Value_type<Array>;
std::multiplies<T> mul;
auto f = in.begin();
auto l = --in.end();
auto o = out.begin();
*o++ = T(1);
std::partial_sum(f, l, o, mul);
return *(--o) * *l;
}
real
L::l2DiscrepancyHeinrich (const real* points, unsigned dim, Index n)
{
checkDimensionNotZero (dim);
// Term 2 and diagonal part of term 3
real term2 = 0;
real term3Diag = 0;
const real* const lastPoint = points + n * dim;
for (const real* point = points; point != lastPoint; )
{
const real* const lastCoord = point + dim;
real product2 = 1 - sqr (*point);
real product3 = 1 - *point;
while (++point != lastCoord)
{
product2 *= 1 - sqr (*point);
product3 *= 1 - *point;
}
// cout << "product2 = " << product2 << '\n';
term2 += product2;
term3Diag += product3;
}
// Calculate one triangle of term 3 using Heinrich's recursive method
Array<L2Data> list (n);
L2Data* dest = list.begin();
for (const real* src = points; src != lastPoint; src += dim, ++dest)
{
dest->point = src;
dest->weight = 1;
}
const real term3
= heinrichRecursionSymmetric (list.begin(), dest, dim - 1, 0.0, 1.0);
// return result
return HINTLIB_MN sqrt (
1 / HINTLIB_MN pow (real(3), int(dim))
- term2 / (HINTLIB_MN pow (real(2), int(dim) - 1) * n)
+ (2 * term3 + term3Diag) / sqr(real(n)));
}
/*
* Return string representation of filter state.
*/
std::string state() {
std::stringstream ss;
ss << "<IIR Filter; numerator: [";
std::for_each(numerator.begin(), numerator.end(), [&](T coeff) { ss << coeff << ", "; });
ss << "]; denominator: [";
std::for_each(denominator.begin(), denominator.end(), [&](T coeff) { ss << coeff << ", "; });
ss << "]; inputs: [";
std::for_each(inputs.begin(), inputs.end(), [&](T val) { ss << val << ", "; });
ss << "]; outputs: [";
std::for_each(outputs.begin(), outputs.end(), [&](T val) { ss << val << ", "; });
ss << "]>";
return ss.str();
}
static void set_slice( Array& arr, index_type from, index_type to, data_type const& v )
{
if( from > to ) {
return;
} else if( to > arr.size() ) {
::PyErr_SetString( ::PyExc_IndexError, "Index out of range" );
boost::python::throw_error_already_set();
} else {
std::fill( arr.begin() + from, arr.begin() + to, v );
}
}
TEST(RWMoleculeTest, setAtomPositions3d)
{
Molecule m;
RWMolecule mol(m);
mol.addAtom(1);
mol.addAtom(2);
mol.addAtom(3);
mol.addAtom(4);
mol.addAtom(5);
mol.undoStack().clear();
Array<Vector3> pos;
Real gen = 1;
pos.push_back(Vector3(gen, gen, gen)); gen++;
pos.push_back(Vector3(gen, gen, gen)); gen++;
pos.push_back(Vector3(gen, gen, gen)); gen++;
pos.push_back(Vector3(gen, gen, gen)); gen++;
pos.push_back(Vector3(gen, gen, gen)); gen++;
mol.setAtomPositions3d(pos);
EXPECT_TRUE(std::equal(mol.atomPositions3d().begin(),
mol.atomPositions3d().end(), pos.begin()));
mol.undoStack().undo();
EXPECT_TRUE(mol.atomPositions3d().empty());
mol.undoStack().redo();
EXPECT_TRUE(std::equal(mol.atomPositions3d().begin(),
mol.atomPositions3d().end(), pos.begin()));
mol.undoStack().undo();
// Test merging for interactive edits:
mol.setInteractive(true);
mol.setAtomPositions3d(pos);
for (Array<Vector3>::iterator it = pos.begin(), itEnd = pos.end();
it != itEnd; ++it) {
it->x() += static_cast<Real>(pos.size());
it->y() += static_cast<Real>(pos.size());
it->z() += static_cast<Real>(pos.size());
}
mol.setAtomPositions3d(pos);
mol.setInteractive(false);
EXPECT_TRUE(std::equal(mol.atomPositions3d().begin(),
mol.atomPositions3d().end(), pos.begin()));
EXPECT_EQ(1, mol.undoStack().count());
mol.undoStack().undo();
EXPECT_TRUE(mol.atomPositions3d().empty());
mol.undoStack().redo();
EXPECT_TRUE(std::equal(mol.atomPositions3d().begin(),
mol.atomPositions3d().end(), pos.begin()));
}
IIRFilter(IterType1 numerator_begin, IterType1 numerator_end,
IterType2 denominator_begin, IterType2 denominator_end) {
// set filter coefficients
std::copy(numerator_begin, numerator_end, std::back_inserter(numerator));
std::copy(denominator_begin, denominator_end, std::back_inserter(denominator));
// set inputs/outputs to zero
inputs.resize(numerator.size());
outputs.resize(denominator.size() - 1); // outputs size is one less than denominator--first term of denominator is scaling factor...
std::fill(inputs.begin(), inputs.end(), 0);
std::fill(outputs.begin(), outputs.end(), 0);
// set input/output iterators to some position
current_input = inputs.begin();
last_output = outputs.begin();
}
void ArrayTest::access() {
Array a(7);
for(std::size_t i = 0; i != 7; ++i)
a[i] = i;
CORRADE_COMPARE(a.data(), static_cast<int*>(a));
CORRADE_COMPARE(*(a.begin()+2), 2);
CORRADE_COMPARE(a[4], 4);
CORRADE_COMPARE(a.end()-a.begin(), a.size());
const auto b = Array::from(7, 3, 5, 4);
CORRADE_COMPARE(b.data(), static_cast<const int*>(b));
CORRADE_COMPARE(b[2], 5);
}
void ConnectionHandler::start(const FieldTable& /*serverProps*/, const Array& mechanisms, const Array& /*locales*/)
{
checkState(NOT_STARTED, INVALID_STATE_START);
setState(NEGOTIATING);
sasl = SaslFactory::getInstance().create( username,
password,
service,
host,
minSsf,
maxSsf
);
std::vector<std::string> mechlist;
mechlist.reserve(mechanisms.size());
if (mechanism.empty()) {
//mechlist is simply what the server offers
std::transform(mechanisms.begin(), mechanisms.end(), std::back_inserter(mechlist), Array::get<std::string, Array::ValuePtr>);
} else {
//mechlist is the intersection of those indicated by user and
//those supported by server, in the order listed by user
std::vector<std::string> allowed = split(mechanism, " ");
std::vector<std::string> supported(mechanisms.size());
std::transform(mechanisms.begin(), mechanisms.end(), std::back_inserter(supported), Array::get<std::string, Array::ValuePtr>);
intersection(allowed, supported, mechlist);
if (mechlist.empty()) {
throw Exception(QPID_MSG("Desired mechanism(s) not valid: " << mechanism << " (supported: " << join(supported) << ")"));
}
}
if (sasl.get()) {
std::string response;
if (sasl->start(join(mechlist), response, getSecuritySettings ? getSecuritySettings() : 0)) {
proxy.startOk(properties, sasl->getMechanism(), response, locale);
} else {
//response was null
ConnectionStartOkBody body;
body.setClientProperties(properties);
body.setMechanism(sasl->getMechanism());
//Don't set response, as none was given
body.setLocale(locale);
proxy.send(body);
}
} else {
//TODO: verify that desired mechanism and locale are supported
std::string response = ((char)0) + username + ((char)0) + password;
proxy.startOk(properties, mechanism, response, locale);
}
}
void f_debug_print_backtrace() {
if (RuntimeOption::InjectedStackTrace) {
Array bt = FrameInjection::GetBacktrace(true);
int i = 0;
for (ArrayIter it = bt.begin(); !it.end(); it.next(), i++) {
Array frame = it.second().toArray();
StringBuffer buf;
buf.append('#');
buf.append(i);
if (i < 10) buf.append(' ');
buf.append(' ');
if (frame.exists("class")) {
buf.append(frame->get("class").toString());
buf.append(frame->get("type").toString());
}
buf.append(frame->get("function").toString());
buf.append("()");
if (frame.exists("file")) {
buf.append(" called at [");
buf.append(frame->get("file").toString());
buf.append(':');
buf.append(frame->get("line").toString());
buf.append(']');
}
buf.append('\n');
echo(buf.detach());
}
} else {
StackTrace st;
echo(String(st.toString()));
}
}
void ExtEngineManager::closeAttachment(thread_db* tdbb, Attachment* attachment)
{
Array<ExternalEngine*> enginesCopy;
{ // scope
ReadLockGuard readGuard(enginesLock, FB_FUNCTION);
EnginesMap::Accessor accessor(&engines);
for (bool found = accessor.getFirst(); found; found = accessor.getNext())
enginesCopy.add(accessor.current()->second);
}
RefDeb(DEB_RLS_JATT, "ExtEngineManager::closeAttachment");
Attachment::Checkout attCout(attachment, FB_FUNCTION, true);
for (Array<ExternalEngine*>::iterator i = enginesCopy.begin(); i != enginesCopy.end(); ++i)
{
ExternalEngine* engine = *i;
EngineAttachmentInfo* attInfo = getEngineAttachment(tdbb, engine, true);
if (attInfo)
{
{ // scope
ContextManager<ExternalFunction> ctxManager(tdbb, attInfo, attInfo->adminCharSet);
LocalStatus status;
engine->closeAttachment(&status, attInfo->context); //// FIXME: log status
}
delete attInfo;
}
}
}
void CompositorLoader::ParseStage(ResourceManager& resourceManager, Compositor::Ptr& compositor, const json::Value& stageJson)
{
if (stageJson.HasKey("disabled") && stageJson["disabled"].ToBool(false))
{
return;
}
if (!stageJson.HasKey("stage") || stageJson["stage"].GetType() != StringVal)
{
throw FormatException("stages[].stage needs to be a string containing the relvative path to a CompositeStage");
}
CompositeStageConnections connections;
ParseStageConnections(connections, stageJson);
std::string stageFilename = stageJson["stage"].ToString();
CompositeStage::Ptr stage = resourceManager.LoadResource<CompositeStage>(stageFilename);
if (stageJson.HasKey("shaderValues"))
{
Array defaultValues = stageJson["shaderValues"].ToArray();
for (auto it = defaultValues.begin(); it != defaultValues.end(); ++it)
{
JsonTypeHelper::ParseValueIntoParameters(stage->GetStateParameters(), *it);
}
}
compositor->AddCompositeStage(stage, connections);
}
Array::Array(const Array& other)
: m_imp(0)
{
if (!other.valid())
return;
m_imp = new ArrayImp(other.get_heap(), other.get_ext_heap(), other.type());
if (other.empty())
return;
if (m_imp->type.isPod())
{
m_imp->data = other.m_imp->data;
}
else
{
m_imp->data.resize(other.m_imp->data.size());
byte *p = m_imp->data.data();
for (Array::const_iterator itr = other.begin(); itr != other.end(); ++itr)
{
//TODO: exception safe code
CommonObject obj(m_imp->type, p);
m_imp->type.methods().construct(obj, get_heap(), get_ext_heap());
m_imp->type.methods().assign(*itr, obj);
p += m_imp->type.payload();
}
}
}
TEST(UnitCellTest, wrapAtomsToUnitCell)
{
Molecule mol = createCrystal(static_cast<Real>(3.0),
static_cast<Real>(4.0),
static_cast<Real>(5.0),
static_cast<Real>(90.0),
static_cast<Real>(120.0),
static_cast<Real>(77.0));
for (int i = 0; i < 10; ++i)
mol.addAtom(1).setPosition3d(Vector3::Zero());
Array<Vector3> fcoords;
for (int i = 0; i < 10; ++i) {
fcoords.push_back(Vector3(static_cast<Real>(i + i / 10.),
static_cast<Real>(i + 2 * i / 10.),
static_cast<Real>(i + 3 * i / 10.)));
}
EXPECT_TRUE(CrystalTools::setFractionalCoordinates(mol, fcoords));
EXPECT_TRUE(CrystalTools::wrapAtomsToUnitCell(mol));
fcoords.clear();
EXPECT_TRUE(CrystalTools::fractionalCoordinates(mol, fcoords));
for (std::vector<Vector3>::const_iterator it = fcoords.begin(),
itEnd = fcoords.end(); it != itEnd; ++it) {
EXPECT_GE(it->x(), static_cast<Real>(0.0));
EXPECT_LE(it->x(), static_cast<Real>(1.0));
EXPECT_GE(it->y(), static_cast<Real>(0.0));
EXPECT_LE(it->y(), static_cast<Real>(1.0));
EXPECT_GE(it->z(), static_cast<Real>(0.0));
EXPECT_LE(it->z(), static_cast<Real>(1.0));
}
}
void binary_serialize_spec(const Object& zthis, PHPOutputTransport& transport,
const Array& spec) {
for (ArrayIter key_ptr = spec.begin(); !key_ptr.end(); ++key_ptr) {
Variant key = key_ptr.first();
if (!key.isInteger()) {
throw_tprotocolexception("Bad keytype in TSPEC (expected 'long')", INVALID_DATA);
return;
}
unsigned long fieldno = key.toInt64();
Array fieldspec = key_ptr.second().toArray();
// field name
String varname = fieldspec.rvalAt(PHPTransport::s_var,
AccessFlags::Error_Key).toString();
// thrift type
int8_t ttype = fieldspec.rvalAt(PHPTransport::s_type,
AccessFlags::Error_Key).toByte();
Variant prop = zthis->o_get(varname, true, zthis->getClassName());
if (!prop.isNull()) {
transport.writeI8(ttype);
transport.writeI16(fieldno);
binary_serialize(ttype, transport, prop, fieldspec);
}
}
transport.writeI8(T_STOP); // struct end
}
int Array::compare(const Array& rhs) const
{
AIO_PRE_CONDITION(type() == rhs.type());
if (!valid() && !rhs.valid())
return 0;
const MethodsExtension* pextern = type().methods().extension();
AIO_PRE_CONDITION(pextern && pextern->compare);
size_t min_size = std::min(size(), rhs.size());
Array::const_iterator last = begin() + min_size;
for (Array::const_iterator li = begin(), ri = rhs.begin(); li != last; ++li, ++ri)
{
int ret = pextern->compare(*li, *ri);
if (ret != 0)
return ret;
}
return min_size < size()
? 1
: min_size < rhs.size()
? -1
: 0;
}
void
InputDeltaState::NotifyListeners(Array<InputListener*>& listeners) const
{
for (Array<Change>::const_iterator it = changes_.begin();
it != changes_.end();
++it)
{
const Change& change = *it;
for (Array<InputListener*>::iterator it2 = listeners.begin();
it2 != listeners.end();
++it2)
{
if (change.type == BT_BOOL)
{
if (!(*it2)->OnDeviceButtonBool(change.device, change.deviceButton, change.oldValue.b, change.newValue.b))
{
break;
}
}
else if (change.type == BT_FLOAT)
{
if(!(*it2)->OnDeviceButtonFloat(change.device, change.deviceButton, change.oldValue.f, change.newValue.f))
{
break;
}
}
}
}
}
// implements FileDragAndDropTarget
bool TrackComponent::isInterestedInFileDrag(const StringArray & files)
{
bool accepted;
// file types accepted by target
Array<String> extensions;
extensions.add(".wav");
extensions.add(".aif");
extensions.add(".aiff");
extensions.add(".flac");
// checks the string array for the file extensions, return true if accepted and false if not
for (auto currentFile = files.begin(), end = files.end(); currentFile != end; ++currentFile) {
accepted = false;
for (auto extension = extensions.begin(), endExtensions = extensions.end(); extension != endExtensions; ++extension) {
if (currentFile->endsWith(*extension)) {
accepted = true;
break;
}
}
if (!accepted) {
return false;
}
}
return true;
}
Compositor::Ptr CompositorLoader::ParseCompositor(ResourceManager& resourceManager, const json::Value& root)
{
Compositor::Ptr result(new Compositor());
if (root["renderTargets"].GetType() != ObjectVal)
{
throw FormatException("renderTargets must be an object");
}
json::Object renderTargets = root["renderTargets"].ToObject();
ParseRenderTargets(result, renderTargets);
const Value& stages = root["stages"];
if (stages.GetType() != ArrayVal)
{
throw FormatException("stages must be an array");
}
Array arrayStages = stages.ToArray();
for (auto it = arrayStages.begin(); it != arrayStages.end(); ++it)
{
ParseStage(resourceManager, result, *it);
}
return result;
}
String FieldVisitorDump::operator() (const Array & x) const
{
String res;
WriteBufferFromString wb(res);
wb.write("Array_[", 7);
for (auto it = x.begin(); it != x.end(); ++it)
{
if (it != x.begin())
wb.write(", ", 2);
writeString(applyVisitor(*this, *it), wb);
}
writeChar(']', wb);
return res;
}
void MaxRectsBinPack::Insert(Array<Vector2i> &rectSizes, Array<Rectangle> &dst, FreeRectChoiceHeuristic method)
{
dst.clear();
while(rectSizes.size() > 0)
{
int bestScore1 = std::numeric_limits<int>::max();
int bestScore2 = std::numeric_limits<int>::max();
int bestRectIndex = -1;
Rectangle bestNode;
for(size_t i = 0; i < rectSizes.size(); ++i)
{
int score1;
int score2;
Rectangle newNode = ScoreRect(rectSizes[i].x, rectSizes[i].y, method, score1, score2);
if (score1 < bestScore1 || (score1 == bestScore1 && score2 < bestScore2))
{
bestScore1 = score1;
bestScore2 = score2;
bestNode = newNode;
bestRectIndex = i;
}
}
if (bestRectIndex == -1)
return;
PlaceRect(bestNode);
rectSizes.remove(rectSizes.begin() + bestRectIndex);
}
}
static void construct_random_bitmap(vector<dtype>& X, size_t edge_size,
const ImageOptions& opt, unsigned long seed) {
FastInt rng(seed);
// First build the correct array
Array<size_t, nd> dims;
fill(dims.begin(), dims.end(), edge_size);
Array<size_t, nd> dim_product(dim_vector_factors<nd>(dims));
// Construct the random points
vector< Array<size_t, nd> > points(opt.n_points);
vector< int > point_values(opt.n_points);
for(size_t i = 0; i < points.size(); ++i) {
for(size_t j = 0; j < nd; ++j)
points[i][j] = rng(edge_size);
point_values[i] = rng(opt.points_lb, opt.points_ub);
}
// Setup the random matrix
X.resize(prod<size_t, nd>(dims));
Array<size_t, nd> x;
for(IndexIterator<nd> idxit(dims); !idxit.done(); ++idxit) {
size_t pidx = argclosest<nd>(points, idxit.coords()).first;
X[idxit.index()] = point_values[pidx] + rng(opt.noise_lb, opt.noise_ub);
}
cout << "Image constructed; " << X.size() << " pixels." << endl;
}
String debug_string_backtrace(bool skip) {
if (RuntimeOption::InjectedStackTrace) {
Array bt;
StringBuffer buf;
bt = g_vmContext->debugBacktrace(skip);
int i = 0;
for (ArrayIter it = bt.begin(); !it.end(); it.next(), i++) {
Array frame = it.second().toArray();
buf.append('#');
buf.append(i);
if (i < 10) buf.append(' ');
buf.append(' ');
if (frame.exists(s_class)) {
buf.append(frame->get(s_class).toString());
buf.append(frame->get(s_type).toString());
}
buf.append(frame->get(s_function).toString());
buf.append("()");
if (frame.exists(s_file)) {
buf.append(" called at [");
buf.append(frame->get(s_file).toString());
buf.append(':');
buf.append(frame->get(s_line).toString());
buf.append(']');
}
buf.append('\n');
}
return buf.detach();
} else {
StackTrace st;
return String(st.toString());
}
}
void LoadSave::varToState(mopo::HelmEngine* synth,
const CriticalSection& critical_section,
var state) {
if (!state.isObject())
return;
mopo::control_map controls = synth->getControls();
DynamicObject* object_state = state.getDynamicObject();
ScopedLock lock(critical_section);
NamedValueSet properties = object_state->getProperties();
int size = properties.size();
for (int i = 0; i < size; ++i) {
Identifier id = properties.getName(i);
if (id.isValid()) {
std::string name = id.toString().toStdString();
if (controls.count(name)) {
mopo::mopo_float value = properties.getValueAt(i);
controls[name]->set(value);
}
}
}
synth->clearModulations();
Array<var>* modulations = object_state->getProperty("modulations").getArray();
var* modulation = modulations->begin();
for (; modulation != modulations->end(); ++modulation) {
DynamicObject* mod = modulation->getDynamicObject();
std::string source = mod->getProperty("source").toString().toStdString();
std::string destination = mod->getProperty("destination").toString().toStdString();
mopo::ModulationConnection* connection = new mopo::ModulationConnection(source, destination);
connection->amount.set(mod->getProperty("amount"));
synth->connectModulation(connection);
}
}
