SymbolTable* SymbolTable::clone(VM& vm)
{
SymbolTable* result = SymbolTable::create(vm);
result->m_parameterCountIncludingThis = m_parameterCountIncludingThis;
result->m_usesNonStrictEval = m_usesNonStrictEval;
result->m_captureStart = m_captureStart;
result->m_captureEnd = m_captureEnd;
Map::iterator iter = m_map.begin();
Map::iterator end = m_map.end();
for (; iter != end; ++iter) {
result->m_map.add(
iter->key,
SymbolTableEntry(iter->value.getIndex(), iter->value.getAttributes()));
}
if (m_slowArguments) {
result->m_slowArguments = std::make_unique<SlowArgument[]>(parameterCount());
for (unsigned i = parameterCount(); i--;)
result->m_slowArguments[i] = m_slowArguments[i];
}
return result;
}
ublas::matrix<double> dp2(const ublas::vector<double>& p) const
{
ublas::matrix<double> result(parameterCount(), parameterCount());
result.clear();
for (typename Data::const_iterator it=data_.begin(); it!=data_.end(); ++it)
{
std::complex<double> diffconj = conj(std::complex<double>(f_(it->x, p) - it->y));
ublas::vector<value_type> dp = f_.dp(it->x,p);
ublas::matrix<value_type> dp2 = f_.dp2(it->x,p);
result += 2 * real(diffconj*dp2 + outer_prod(conj(dp),dp));
}
return result;
}
SymbolTable* SymbolTable::cloneCapturedNames(VM& vm)
{
SymbolTable* result = SymbolTable::create(vm);
result->m_parameterCountIncludingThis = m_parameterCountIncludingThis;
result->m_usesNonStrictEval = m_usesNonStrictEval;
result->m_captureStart = m_captureStart;
result->m_captureEnd = m_captureEnd;
for (auto iter = m_map.begin(), end = m_map.end(); iter != end; ++iter) {
if (!isCaptured(iter->value.getIndex()))
continue;
result->m_map.add(
iter->key,
SymbolTableEntry(iter->value.getIndex(), iter->value.getAttributes()));
}
if (m_slowArguments) {
result->m_slowArguments = std::make_unique<SlowArgument[]>(parameterCount());
for (unsigned i = parameterCount(); i--;)
result->m_slowArguments[i] = m_slowArguments[i];
}
if (m_uniqueIDMap && result->m_uniqueIDMap) {
{
auto iter = m_uniqueIDMap->begin();
auto end = m_uniqueIDMap->end();
for (; iter != end; ++iter)
result->m_uniqueIDMap->set(iter->key, iter->value);
}
{
auto iter = m_registerToVariableMap->begin();
auto end = m_registerToVariableMap->end();
for (; iter != end; ++iter)
result->m_registerToVariableMap->set(iter->key, iter->value);
}
{
auto iter = m_uniqueTypeSetMap->begin();
auto end = m_uniqueTypeSetMap->end();
for (; iter != end; ++iter)
result->m_uniqueTypeSetMap->set(iter->key, iter->value);
}
}
return result;
}
factory_method make_factory_method(const types_by_name &known_types, const type &t, const type &f)
{
assert(!t.is_empty());
assert(!t.is_qobject());
assert(!f.is_empty());
assert(!f.is_qobject());
auto meta_object = f.meta_object();
auto method_count = meta_object->methodCount();
auto factory_methods = std::vector<factory_method>{};
for (decltype(method_count) i = 0; i < method_count; i++)
{
auto method = meta_object->method(i);
if (method.parameterCount() != 0)
continue;
auto return_type = type_by_pointer(known_types, method.typeName());
if (return_type.is_empty())
continue;
auto interfaces = extract_interfaces(return_type);
if (interfaces.contains(t))
factory_methods.emplace_back(return_type, method);
}
if (factory_methods.size() == 1)
return factory_methods.front();
else
return factory_method{};
}
std::string
Polynomial::toString() const
{
std::ostringstream stream;
stream << "[Polynomial][" << name() << "][" << equation() << "][" <<
parameterCount() << " parameters]";
return stream.str();
}
ublas::vector<double> dp(const ublas::vector<double>& p) const
{
ublas::vector<double> result(parameterCount());
result.clear();
for (typename Data::const_iterator it=data_.begin(); it!=data_.end(); ++it)
{
std::complex<double> diffconj = conj(std::complex<double>(f_(it->x,p) - it->y));
result += 2 * real(diffconj*f_.dp(it->x,p));
}
return result;
}
