minsky::anonymous_namespace{mdlReader.cc} Namespace Reference

Classes
struct	FunctionDef

Functions
string	readToken (istream &mdlFile, char delim, bool appendDelim=false)
bool	identifierChar (int c)
string	collapseWS (const string &x)
regex	identifier (R"([A-Za-z][A-Za-z0-9._]*[A-Za-z0-9_])")
void	addDefinitionToPort (Group &group, const shared_ptr< Port > &port, const string &name, const string &definition)
void	defineLookupFunction (Group &group, const std::string &name, const std::string &data)

Variables
map< string, FunctionDef >	venSimFunctions
set< string >	functionsAdded

Function Documentation

addDefinitionToPort()

void minsky::anonymous_namespace{mdlReader.cc}::addDefinitionToPort	(	Group &	group,
		const shared_ptr< Port > &	port,
		const string &	name,
		const string &	definition
	)

Definition at line 166 of file mdlReader.cc.

References f, functionsAdded, minsky::group, identifier(), and venSimFunctions.

Referenced by minsky::readMdl().

    {
      smatch match;
      if (regex_match(definition,match,identifier))
        {
          const VariablePtr rhs(VariableBase::flow, definition);
          group.addItem(rhs);
          if (port)
            group.addWire(rhs->ports(0).lock(), port);
          return;
        }
      
      auto function=new UserFunction(name,definition);
      group.addItem(function); //ownership passed
      for (auto& i: function->symbolNames())
        {
          auto f=venSimFunctions.find(i);
          if (f!=venSimFunctions.end())
            {
              if (functionsAdded.insert(f->first).second)
                addDefinitionToPort(group,nullptr,f->first+f->second.args,f->second.expression);
            }
       }
      if (port)
        group.addWire(function->ports(0), port);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

collapseWS()

string minsky::anonymous_namespace{mdlReader.cc}::collapseWS

(

const string &

x

)

Definition at line 69 of file mdlReader.cc.

References identifierChar().

Referenced by minsky::readMdl().

    {
      // work in UTF-32 to simplify string analysis
      auto xx=utf_to_utf<uint32_t>(x);
      basic_string<uint32_t> result;
      uint32_t lastNonWS=0;
      bool quoted=false, lastWS=false, inIdentifier=false;
      for (auto& i: xx)
        {
          if (i=='"' &&lastNonWS!='\\')
            {
              quoted=!quoted;
              inIdentifier=quoted;
              // identifiers not allowed to end in .
              if (!inIdentifier && result.back()=='.')
                result.erase(result.end()-1);
              continue; // strip quotes
            }
          
          if (!quoted && !inIdentifier && isalpha(i))
            inIdentifier=true;
          if (!quoted && inIdentifier && !identifierChar(i) && !isspace(i) && i!='_')
            {
              // identifiers not allowed to end in .
              if (result.back()=='.')
                result.erase(result.end()-1);
              inIdentifier=false;
            }
          
          if (!isspace(i) && i!='_')
            {
              // convert verboten characters into ones more friendly to exprtk
              // we use . as an escape into a numerical unicode code uXXXX, terminated by another .
              basic_string<uint32_t> exprTkGoodChar;
              if (inIdentifier)
                exprTkGoodChar=utf_to_utf<uint32_t>(".u"+to_string(i)+".");
              else
                exprTkGoodChar+=i;
              // camelcase if collapsing whitespace in an identifier, ' ' otherwise
              if (lastWS)
                if (quoted || (identifierChar(i) && identifierChar(lastNonWS)))
                  if (isalnum(i))
                    result+=toupper(i);
                  else
                    result+=exprTkGoodChar;
                else
                  {
                    result+=' ';
                    if (isalnum(i))
                      result+=tolower(i);
                    else
                      result+=exprTkGoodChar;
                  }
              else
                if (isalnum(i))
                  result+=tolower(i);
                else
                  result+=exprTkGoodChar;
              lastNonWS=i;
              lastWS=false;
            }
          else
            lastWS=true;
        }
      return utf_to_utf<char>(result);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

defineLookupFunction()

void minsky::anonymous_namespace{mdlReader.cc}::defineLookupFunction	(	Group &	group,
		const std::string &	name,
		const std::string &	data
	)

Definition at line 193 of file mdlReader.cc.

References f, minsky::group, and minsky::str().

Referenced by minsky::readMdl().

    {
      const regex lookupPairsPattern(R"((\[[^\]]*\],)?(\(.*\)))");
      smatch match; 
      map<double,double> xData;
      if (regex_match(data,match,lookupPairsPattern))
        {
          const regex extractHead(R"(\(([^,]*),([^)]*)\)(,(\(.*\)))*)");
          // note match[3] is the trailing data, match[4] strips the leading ,
          for (auto d=match[2].str(); regex_match(d, match, extractHead); d=match[4])
            xData[stod(match[1])]=stod(match[2]);
        }
      else
        {
          vector<double> xyData;
          for (size_t offs=0; offs<data.size(); ++offs)
            xyData.push_back(stod(data.substr(offs),&offs));
          if (xyData.size()%2!=0)
            throw runtime_error("Odd amount of data specified");
          for (size_t i=0; i<xyData.size()/2; ++i)
            xData[xyData[i]]=xyData[i+xyData.size()/2];
        }
      auto f=make_shared<Group>();
      f->self=f;
      f->title=name;
      group.addItem(f);
      const VariablePtr dataVar(VariableType::flow,"data");
      f->addItem(dataVar);
      dataVar->moveTo(f->x()-50,f->y()-20);
      const OperationPtr gather(OperationType::gather);
      f->addItem(gather);
      gather->moveTo(f->x()+30,f->y()-10);
      const VariablePtr inVar(VariableType::flow,"in"), outVar(VariableType::flow,"out");
      f->addItem(inVar);
      f->addItem(outVar);
      f->inVariables.push_back(inVar);
      f->outVariables.push_back(outVar);
      f->addWire(*dataVar, *gather, 1);
      f->addWire(*f->inVariables[0], *gather, 2);
      f->addWire(*gather, *f->outVariables[0], 1);
      
      XVector xVals("0",{Dimension::value,""});
      auto& tensorInit=dataVar->vValue()->tensorInit;
      for (auto& i: xData)
        xVals.push_back(i.first);
      Hypercube hc; hc.xvectors.push_back(std::move(xVals));
      tensorInit.hypercube(std::move(hc));

      assert(tensorInit.size()==xData.size());
      auto j=tensorInit.begin();
      for (auto& i: xData)
        *j++=i.second;

      *dataVar->vValue()=tensorInit;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

identifier()

regex minsky::anonymous_namespace{mdlReader.cc}::identifier

(

R"([A-Za-z][A-Za-z0-9._]*[A-Za-z0-9_])"

)

Referenced by addDefinitionToPort(), and minsky::readMdl().

Here is the caller graph for this function:

identifierChar()

bool minsky::anonymous_namespace{mdlReader.cc}::identifierChar

(

int

c

)

Definition at line 63 of file mdlReader.cc.

Referenced by collapseWS().

    {return c>0x7f || isalnum(c) || c=='\'' || c=='$';}

Here is the caller graph for this function:

readToken()

string minsky::anonymous_namespace{mdlReader.cc}::readToken	(	istream &	mdlFile,
		char	delim,
		bool	appendDelim = false
	)

Definition at line 35 of file mdlReader.cc.

Referenced by minsky::readMdl().

    {
      string r;
      string c;
      while (mdlFile>>GetUtf8Char(c))
        if (c[0]==delim || c[0]=='~' || c[0]=='|')
          {
            if (appendDelim)
              r+=c[0];
            break;
          }
        else if (c[0]=='{') /* inline comment - read up to close brace */
          {
            while (c[0]!='}' && mdlFile>>GetUtf8Char(c));
            continue;
          }
        else if (c[0]=='\\')
          // quoted end of line processing
          if (mdlFile>>GetUtf8Char(c) &&  (c[0]=='\n'||c[0]=='\r'))
            r+=c;
          else
            r+="\\"+c;
        else if (c[0]>=' ') // strip out control characters
          r+=c;
      
      return r;
    }

Here is the caller graph for this function:

Variable Documentation

functionsAdded

set<string> minsky::anonymous_namespace{mdlReader.cc}::functionsAdded

Definition at line 163 of file mdlReader.cc.

Referenced by addDefinitionToPort(), and minsky::readMdl().

venSimFunctions

map<string, FunctionDef> minsky::anonymous_namespace{mdlReader.cc}::venSimFunctions

Initial value:

={
      {"arccos",{"(x)","acos(x)"}},
      {"arcsin",{"(x)","asin(x)"}},
      {"arctan",{"(x)","atan(x)"}},
      {"gammaLn",{"(x)","gammaLn(x)"}},
      {"integer",{"(x)","floor(x)"}},
      {"ifThenElse",{"(x,y,z)","x? y: z"}},
      {"ln",{"(x)","log(x)"}},
      {"log",{"(x,y)","log(x)/log(y)"}},
      {"modulo",{"(x,y)","x%y"}},
      {"power",{"(x,y)","x^y"}},
      {"pulse",{"(x,y)","(time>=x)*(time<x+y)"}},
      {"pulseTrain",{"(s,b,r,e)","tm:=time%r; (time<e)*(time>=s)*(tm<((s+b)%r))*(tm>=(s%r))"}},
      {"quantum",{"(x,y)","floor(x/y)"}},
      {"ramp",{"(s,a,b)","var t1:=min(a,b); var t2:=max(a,b); (clamp(t1,time,t2)-t1)*s"}},
      {"step",{"(x,y)","y*(time>=x)"}},
      {"xidz",{"(x,y,z)","var r:=y/z; isfinite(r)? r: x"}},
      {"zidz",{"(x,y)","var r:=y/z; isfinite(r)? r:0"}}
    }

Definition at line 143 of file mdlReader.cc.

Referenced by addDefinitionToPort().