PhpConst::PhpConst(const folly::dynamic& cns, fbstring cls /* = "" */) : m_constant(cns), m_name(cns["name"].asString()), m_className(cls) { if (!parseType(cns) && !inferType(cns)) { // Constant has neither explicit type nor implicit type from 'value' assert(false); m_kindOf = KindOfInvalid; m_cppType = "void"; } // Override typeString()'s selection for string values if (m_kindOf == KindOfString) { m_cppType = "HPHP::StaticString"; } }
scalar WeightedAverage::defuzzify(const Term* term, scalar minimum, scalar maximum) const { const Accumulated* fuzzyOutput = dynamic_cast<const Accumulated*> (term); if (not fuzzyOutput) { std::ostringstream ss; ss << "[defuzzification error]" << "expected an Accumulated term instead of" << "<" << term->toString() << ">"; throw fl::Exception(ss.str(), FL_AT); } minimum = fuzzyOutput->getMinimum(); maximum = fuzzyOutput->getMaximum(); scalar sum = 0.0; scalar weights = 0.0; if (not fuzzyOutput->getAccumulation()) { Type type = _type; for (int i = 0; i < fuzzyOutput->numberOfTerms(); ++i) { Activated* activated = fuzzyOutput->getTerm(i); scalar w = activated->getDegree(); if (type == Automatic) type = inferType(activated->getTerm()); scalar z = (type == TakagiSugeno) //? activated.getTerm()->membership(fl::nan) Would ensure no Tsukamoto applies, but Inverse Tsukamoto with Functions would not work. ? activated->getTerm()->membership(w) //Provides Takagi-Sugeno and Inverse Tsukamoto of Functions : tsukamoto(activated->getTerm(), w, minimum, maximum); sum += w * z; weights += w; } } else { typedef std::map<const Term*, std::vector<Activated*> > TermGroup; TermGroup groups; for (int i = 0; i < fuzzyOutput->numberOfTerms(); ++i) { Activated* value = fuzzyOutput->getTerm(i); const Term* key = value->getTerm(); groups[key].push_back(value); } TermGroup::const_iterator it = groups.begin(); Type type = _type; while (it != groups.end()) { const Term* activatedTerm = it->first; scalar accumulatedDegree = 0.0; for (std::size_t i = 0; i < it->second.size(); ++i) accumulatedDegree = fuzzyOutput->getAccumulation()->compute( accumulatedDegree, it->second.at(i)->getDegree()); if (type == Automatic) type = inferType(activatedTerm); scalar z = (type == TakagiSugeno) //? activated.getTerm()->membership(fl::nan) Would ensure no Tsukamoto applies, but Inverse Tsukamoto with Functions would not work. ? activatedTerm->membership(accumulatedDegree) //Provides Takagi-Sugeno and Inverse Tsukamoto of Functions : tsukamoto(activatedTerm, accumulatedDegree, minimum, maximum); sum += accumulatedDegree * z; weights += accumulatedDegree; ++it; } } return sum / weights; }
LEXEME *expression_lambda(LEXEME *lex, SYMBOL *funcsp, TYPE *atp, TYPE **tp, EXPRESSION **exp, int flags) { LAMBDA *self; SYMBOL *vpl, *ths; HASHREC *hrl; TYPE *ltp; STRUCTSYM ssl; if (funcsp) funcsp->noinline = TRUE; IncGlobalFlag(); self = Alloc(sizeof(LAMBDA)); ltp = Alloc(sizeof(TYPE)); ltp->type = bt_struct; ltp->syms = CreateHashTable(1); ltp->tags = CreateHashTable(1); ltp->size = 0; self->captured = CreateHashTable(1); self->oldSyms = localNameSpace->syms; self->oldTags = localNameSpace->tags; self->index = lambdaIndex; self->captureMode = cmNone; self->isMutable = FALSE; self->captureThis = FALSE; self->cls = makeID(sc_type, ltp, NULL, LambdaName()); ltp->sp = self->cls; SetLinkerNames(self->cls, lk_cdecl); self->cls->islambda = TRUE; self->cls->structAlign = getAlign(sc_global, &stdpointer); self->func = makeID(sc_member, ltp, NULL, "$internalFunc"); self->func->parentClass = self->cls; self->functp = &stdauto; self->enclosingFunc = theCurrentFunc; if (lambdas) lambdas->prev = self; self->next = lambdas; lambdas = self; localNameSpace->syms = CreateHashTable(1); localNameSpace->tags = CreateHashTable(1); if (lambdas->next) { self->lthis = lambdas->next->lthis; } else if (funcsp && funcsp->parentClass) { self->lthis = ((SYMBOL *)funcsp->tp->syms->table[0]->p); } lex = getsym(); // past [ if (funcsp) { // can have a capture list; if (MATCHKW(lex, assign)) { lex = getsym(); if (MATCHKW(lex, comma) || MATCHKW(lex, closebr)) { self->captureMode = cmValue; skip(&lex, comma); } else { lex = backupsym(); } } else if (MATCHKW(lex, and)) { lex = getsym(); if (MATCHKW(lex, comma) || MATCHKW(lex, closebr)) { self->captureMode = cmRef; skip(&lex, comma); } else { lex = backupsym(); } } if (!MATCHKW(lex, comma) && !MATCHKW(lex, closebr)) { do { enum e_cm localMode = self->captureMode; if (MATCHKW(lex, comma)) skip(&lex, comma); if (MATCHKW(lex, kw_this)) { lex = getsym(); if (localMode == cmValue || !self->lthis) { error(ERR_CANNOT_CAPTURE_THIS); } else { if (self->captureThis) { error(ERR_CAPTURE_ITEM_LISTED_MULTIPLE_TIMES); } self->captureThis = TRUE; lambda_capture(NULL, cmThis, TRUE); } continue; } else if (MATCHKW(lex, and)) { if (localMode == cmRef) { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } localMode = cmRef; lex = getsym(); } else { if (localMode == cmValue) { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } localMode = cmValue; } if (ISID(lex)) { SYMBOL *sp = search(lex->value.s.a, localNameSpace->syms); LAMBDA *current = lambdas; while (current && !sp) { sp = search(lex->value.s.a, current->oldSyms); current = current->next; } lex = getsym(); if (sp) { if (sp->packed) { if (!MATCHKW(lex, ellipse)) error(ERR_PACK_SPECIFIER_REQUIRED_HERE); else lex = getsym(); } if (sp->packed) { int n; TEMPLATEPARAMLIST * templateParam = sp->tp->templateParam->p->byPack.pack; HASHREC *hr; for (n=0; templateParam; templateParam = templateParam->next, n++); hr = funcsp->tp->syms->table[0]; while (hr && ((SYMBOL *)hr->p) != sp) hr = hr->next; while (hr && n) { lambda_capture((SYMBOL *)hr->p, localMode, TRUE); hr = hr->next; n--; } } else { lambda_capture(sp, localMode, TRUE); } } else errorstr(ERR_UNDEFINED_IDENTIFIER, lex->value.s.a); } else { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } } while (MATCHKW(lex, comma)); } needkw(&lex, closebr); } else { if (!MATCHKW(lex, closebr)) { error(ERR_LAMBDA_CANNOT_CAPTURE); } else { lex = getsym(); } } if (MATCHKW(lex, openpa)) { TYPE *tpx = &stdvoid; HASHREC *hr; lex = getFunctionParams(lex, NULL, &self->func, &tpx, FALSE, sc_auto); self->funcargs = self->func->tp->syms->table[0]; hr = self->func->tp->syms->table[0]; while (hr) { SYMBOL *sym = (SYMBOL *)hr->p; if (sym->init) { error(ERR_CANNOT_DEFAULT_PARAMETERS_WITH_LAMBDA); } hr = hr->next; } if (MATCHKW(lex, kw_mutable)) { HASHREC *hr = self->captured->table[0]; while (hr) { LAMBDASP *lsp = (LAMBDASP *)hr->p; if (lsp->sym->lambdaMode == cmValue) { lsp->sym->tp = basetype(lsp->sym->tp); } hr = hr->next; } self->isMutable = TRUE; lex = getsym(); } ParseAttributeSpecifiers(&lex, funcsp, TRUE); if (MATCHKW(lex, pointsto)) { lex = getsym(); lex = get_type_id(lex, &self->functp, funcsp, sc_cast, FALSE, TRUE); } } else { TYPE *tp1 = Alloc(sizeof(TYPE)); SYMBOL *spi; tp1->type = bt_func; tp1->size = getSize(bt_pointer); tp1->btp = &stdvoid; tp1->sp = self->func; self->func->tp = tp1; spi = makeID(sc_parameter, tp1, NULL, AnonymousName()); spi->anonymous = TRUE; spi->tp = Alloc(sizeof(TYPE)); spi->tp->type = bt_void; insert(spi, localNameSpace->syms); SetLinkerNames(spi, lk_cpp); self->func->tp->syms = localNameSpace->syms; self->funcargs = self->func->tp->syms->table[0]; self->func->tp->syms->table[0] = NULL; } vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName()); vpl->assigned = vpl->used = TRUE; SetLinkerNames(vpl, lk_cdecl); hrl = Alloc(sizeof(HASHREC)); hrl->p = (struct _hrintern_ *)vpl; hrl->next = lambdas->func->tp->syms->table[0]; lambdas->func->tp->syms->table[0] = hrl; vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName()); vpl->assigned = vpl->used = TRUE; SetLinkerNames(vpl, lk_cdecl); hrl = Alloc(sizeof(HASHREC)); hrl->p = (struct _hrintern_ *)vpl; hrl->next = lambdas->func->tp->syms->table[0]; lambdas->func->tp->syms->table[0] = hrl; SetLinkerNames(lambdas->func, lk_cdecl); injectThisPtr(lambdas->func, basetype(lambdas->func->tp)->syms); lambdas->func->tp->btp = self->functp; lambdas->func->linkage = lk_virtual; lambdas->func->isInline = TRUE; ssl.str = self->cls; ssl.tmpl = NULL; addStructureDeclaration(&ssl); ths = makeID(sc_member, &stdpointer, NULL, "$this"); lambda_insert(ths, lambdas); if (MATCHKW(lex, begin)) { lex = body(lex, self->func); } else { error(ERR_LAMBDA_FUNCTION_BODY_EXPECTED); } dropStructureDeclaration(); localNameSpace->syms = self->oldSyms; localNameSpace->tags = self->oldTags; inferType(); finishClass(); *exp = createLambda(0); *tp = lambdas->cls->tp; lambdas = lambdas->next; if (lambdas) lambdas->prev = NULL; DecGlobalFlag(); return lex; }