bool Object_mpq::DoDirProp(Environment &env, SymbolSet &symbols)
{
Signal &sig = GetSignal();
if (!Object::DoDirProp(env, symbols)) return false;
symbols.insert(Gura_Symbol(numer));
symbols.insert(Gura_Symbol(denom));
return true;
}
bool Object_Vector::DoDirProp(Environment &env, SymbolSet &symbols)
{
Signal &sig = GetSignal();
if (!Object::DoDirProp(env, symbols)) return false;
symbols.insert(Gura_Symbol(x));
symbols.insert(Gura_Symbol(y));
return true;
}
bool Object_FTC_Manager::DoDirProp(Environment &env, SymbolSet &symbols)
{
Signal &sig = GetSignal();
if (!Object::DoDirProp(env, symbols)) return false;
#if 0
symbols.insert(Gura_Symbol(x));
symbols.insert(Gura_Symbol(y));
#endif
return true;
}
Value Object_Vector::DoGetProp(Environment &env, const Symbol *pSymbol,
const SymbolSet &attrs, bool &evaluatedFlag)
{
evaluatedFlag = true;
if (pSymbol->IsIdentical(Gura_Symbol(x))) {
return Value(_pVector->x);
} else if (pSymbol->IsIdentical(Gura_Symbol(y))) {
return Value(_pVector->y);
}
evaluatedFlag = false;
return Value::Nil;
}
Value Object_mpq::DoGetProp(Environment &env, const Symbol *pSymbol,
const SymbolSet &attrs, bool &evaluatedFlag)
{
evaluatedFlag = true;
if (pSymbol->IsIdentical(Gura_Symbol(numer))) {
return Value(new Object_mpz(_num.get_num_mpz_t()));
} else if (pSymbol->IsIdentical(Gura_Symbol(denom))) {
return Value(new Object_mpz(_num.get_den_mpz_t()));
}
evaluatedFlag = false;
return Value::Nil;
}
Value Object_FTC_Manager::DoGetProp(Environment &env, const Symbol *pSymbol,
const SymbolSet &attrs, bool &evaluatedFlag)
{
evaluatedFlag = true;
#if 0
if (pSymbol->IsIdentical(Gura_Symbol(x))) {
return Value(_vector.x);
} else if (pSymbol->IsIdentical(Gura_Symbol(y))) {
return Value(_vector.y);
}
#endif
evaluatedFlag = false;
return Value::Nil;
}
Gura_ImplementPropertyGetter(Solver_Summary, nonlinear_conjugate_gradient_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::NonlinearConjugateGradientTypeToString(summary.nonlinear_conjugate_gradient_type)) :
Value(summary.nonlinear_conjugate_gradient_type);
}
Gura_ImplementPropertyGetter(Solver_Summary, line_search_interpolation_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::LineSearchInterpolationTypeToString(summary.line_search_interpolation_type)) :
Value(summary.line_search_interpolation_type);
}
Gura_ImplementPropertyGetter(Solver_Summary, sparse_linear_algebra_library_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::SparseLinearAlgebraLibraryTypeToString(summary.sparse_linear_algebra_library_type)) :
Value(summary.sparse_linear_algebra_library_type);
}
Gura_ImplementPropertyGetter(Solver_Summary, trust_region_strategy_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::TrustRegionStrategyTypeToString(summary.trust_region_strategy_type)) :
Value(summary.trust_region_strategy_type);
}
Gura_ImplementPropertyGetter(Solver_Summary, visibility_clustering_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::VisibilityClusteringTypeToString(summary.visibility_clustering_type)) :
Value(summary.visibility_clustering_type);
}
//-----------------------------------------------------------------------------
// Implementation of class methods
//-----------------------------------------------------------------------------
// gmp.mpf.get_defaul_prec()
Gura_DeclareClassMethod(mpf, get_default_prec)
{
SetFuncAttr(VTYPE_any, RSLTMODE_Normal, FLAG_None);
AddHelp(
Gura_Symbol(en),
"Gets the default precision for `gmp.mpf`.\n");
}
Func_BezierPrototype::Func_BezierPrototype(Environment &env, const ValueList &nums) :
Function(env, Gura_Symbol(_anonymous_), FUNCTYPE_Function, FLAG_None)
{
_nums.reserve(nums.size());
if (nums.size() == 3) {
Number num0 = nums[0].GetNumber();
Number num1 = nums[1].GetNumber();
Number num2 = nums[2].GetNumber();
_nums.push_back(num0);
_nums.push_back(2 * num1 - 2 * num0);
_nums.push_back(num2 - 2 * num1 + num0);
} else if (nums.size() == 4) {
Number num0 = nums[0].GetNumber();
Number num1 = nums[1].GetNumber();
Number num2 = nums[2].GetNumber();
Number num3 = nums[3].GetNumber();
_nums.push_back(num0);
_nums.push_back(3 * num1 - 3 * num0);
_nums.push_back(3 * num2 - 6 * num1 + 3 * num0);
_nums.push_back(num3 - 3 * num2 + 3 * num1 - num0);
} else {
foreach_const (ValueList, pValue, nums) {
_nums.push_back(pValue->GetNumber());
}
}
bool Formatter::PutInvalid(Signal &sig, const Flags &flags)
{
if (!_nilVisibleFlag) return true;
std::string str;
str += Gura_Symbol(nil)->GetName();
return PutAlignedString(sig, flags, str.c_str());
}
Gura_ImplementPropertyGetter(Solver_Summary, termination_type)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::TerminationTypeToString(summary.termination_type)) :
Value(summary.termination_type);
}
Gura_ImplementPropertyGetter(Solver_Summary, preconditioner_type_given)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::PreconditionerTypeToString(summary.preconditioner_type_given)) :
Value(summary.preconditioner_type_given);
}
// ml.linear.model.get_nr_class()
Gura_DeclareMethod(model, get_nr_class)
{
SetFuncAttr(VTYPE_any, RSLTMODE_Normal, FLAG_None);
AddHelp(
Gura_Symbol(en),
"");
}
Gura_ImplementPropertyGetter(Solver_Summary, linear_solver_type_used)
{
const ceres::Solver::Summary &summary = Object_Solver_Summary::GetObject(valueThis)->GetSummary();
return attrs.IsSet(Gura_Symbol(name))?
Value(ceres::LinearSolverTypeToString(summary.linear_solver_type_used)) :
Value(summary.linear_solver_type_used);
}
// fs.Stat#issock
Gura_DeclareProperty_R(Stat, issock)
{
SetPropAttr(VTYPE_boolean);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#preconditioner_type_used
Gura_DeclareProperty_RW(Solver_Summary, preconditioner_type_used)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#inner_iterations_used
Gura_DeclareProperty_RW(Solver_Summary, inner_iterations_used)
{
SetPropAttr(VTYPE_boolean);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#initial_cost
Gura_DeclareProperty_RW(Solver_Summary, initial_cost)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#linear_solver_type_given
Gura_DeclareProperty_RW(Solver_Summary, linear_solver_type_given)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#num_linear_solver_threads_used
Gura_DeclareProperty_RW(Solver_Summary, num_linear_solver_threads_used)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#is_constrained
Gura_DeclareProperty_RW(Solver_Summary, is_constrained)
{
SetPropAttr(VTYPE_boolean);
AddHelp(
Gura_Symbol(en),
""
);
}
// fs.Stat#ctime
Gura_DeclareProperty_R(Stat, ctime)
{
SetPropAttr(VTYPE_datetime);
AddHelp(
Gura_Symbol(en),
""
);
}
// fs.Stat#uid
Gura_DeclareProperty_R(Stat, uid)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#message
Gura_DeclareProperty_RW(Solver_Summary, message)
{
SetPropAttr(VTYPE_string);
AddHelp(
Gura_Symbol(en),
""
);
}
// fs.Stat#dirname
Gura_DeclareProperty_R(Stat, dirname)
{
SetPropAttr(VTYPE_string);
AddHelp(
Gura_Symbol(en),
""
);
}
// ceres.Solver$Summary#num_residuals_reduced
Gura_DeclareProperty_RW(Solver_Summary, num_residuals_reduced)
{
SetPropAttr(VTYPE_number);
AddHelp(
Gura_Symbol(en),
""
);
}
