// returns pattern #i // StringP StringSet::get_pat(LINT i) { if (!tax) return pat[i]; else return specialize(i); };
// if no taxonomy, returns itm // Item ItemSet::specialize(Item itm) { FLOAT r; LINT i, nchildren; Item first, last; if (!tax) // no taxonomy return itm; nchildren = tax->num_children(itm); if (nchildren == 0) // no children return itm; first = tax->child(itm, 0); last = tax->child(itm, nchildren-1); // find the desired pattern using cum_prob table r = rand(); i = first + r * nchildren; if (i == last) i--; while ( i < last && r > tax_prob[i] ) i++; while ( i > first && r < tax_prob[i-1] ) i--; return specialize(i); }
SLEvaluator* SLEvaluatorConcrete<RT>::specialize(const MutableMatrix* parameters) const { auto p = dynamic_cast<const MutableMat< DMat<RT> >*>(parameters); if (p == nullptr) { ERROR("specialize: expected a dense mutable matrix"); return nullptr; } return specialize(p); }
TEST(Type, SpecializedObjects) { auto const A = SystemLib::s_IteratorClass; auto const B = SystemLib::s_TraversableClass; EXPECT_TRUE(A->classof(B)); auto const obj = Type::Obj; auto const exactA = obj.specializeExact(A); auto const exactB = obj.specializeExact(B); auto const subA = obj.specialize(A); auto const subB = obj.specialize(B); EXPECT_EQ(exactA.getClass(), A); EXPECT_EQ(subA.getClass(), A); EXPECT_EQ(exactA.getExactClass(), A); EXPECT_EQ(subA.getExactClass(), nullptr); EXPECT_LE(exactA, exactA); EXPECT_LE(subA, subA); EXPECT_LT(exactA, obj); EXPECT_LT(subA, obj); EXPECT_LE(Type::Bottom, subA); EXPECT_LE(Type::Bottom, exactA); EXPECT_LT(exactA, subA); EXPECT_LT(exactA, subB); EXPECT_LT(subA, subB); EXPECT_FALSE(exactA <= exactB); EXPECT_FALSE(subA <= exactB); EXPECT_EQ(exactA & subA, exactA); EXPECT_EQ(subA & exactA, exactA); EXPECT_EQ(exactB & subB, exactB); EXPECT_EQ(subB & exactB, exactB); EXPECT_EQ(Type::Obj, Type::Obj - subA); // conservative EXPECT_EQ(subA, subA - exactA); // conservative }
Type convertToType(RepoAuthType ty) { using T = RepoAuthType::Tag; switch (ty.tag()) { case T::OptBool: return Type::Bool | Type::InitNull; case T::OptInt: return Type::Int | Type::InitNull; case T::OptSStr: return Type::StaticStr | Type::InitNull; case T::OptStr: return Type::Str | Type::InitNull; case T::OptDbl: return Type::Dbl | Type::InitNull; case T::OptRes: return Type::Res | Type::InitNull; case T::OptObj: return Type::Obj | Type::InitNull; case T::Uninit: return Type::Uninit; case T::InitNull: return Type::InitNull; case T::Null: return Type::Null; case T::Bool: return Type::Bool; case T::Int: return Type::Int; case T::Dbl: return Type::Dbl; case T::Res: return Type::Res; case T::SStr: return Type::StaticStr; case T::Str: return Type::Str; case T::Obj: return Type::Obj; case T::Cell: return Type::Cell; case T::Ref: return Type::BoxedCell; case T::InitUnc: return Type::UncountedInit; case T::Unc: return Type::Uncounted; case T::InitCell: return Type::InitCell; case T::InitGen: return Type::Init; case T::Gen: return Type::Gen; // TODO(#4205897): option specialized array types case T::OptArr: return Type::Arr | Type::InitNull; case T::OptSArr: return Type::StaticArr | Type::InitNull; case T::SArr: if (auto const ar = ty.array()) return Type::StaticArr.specialize(ar); return Type::StaticArr; case T::Arr: if (auto const ar = ty.array()) return Type::Arr.specialize(ar); return Type::Arr; case T::SubObj: case T::ExactObj: { auto const base = Type::Obj; if (auto const cls = Unit::lookupUniqueClass(ty.clsName())) { return ty.tag() == T::ExactObj ? base.specializeExact(cls) : base.specialize(cls); } return base; } case T::OptSubObj: case T::OptExactObj: { auto const base = Type::Obj | Type::InitNull; if (auto const cls = Unit::lookupUniqueClass(ty.clsName())) { return ty.tag() == T::OptExactObj ? base.specializeExact(cls) : base.specialize(cls); } return base; } } not_reached(); }
const callable &specialize(const ndt::type &ret_tp, const std::initializer_list<ndt::type> &arg_tp) const { return specialize(ret_tp, arg_tp.size(), arg_tp.begin()); }