VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1240 Commits
4 Branches
541MB
Tree: a4898ff3ec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a4898ff3ec'
${ noResults }
Rack/plugins/community/repos/squinkylabs-plug1/sqsrc/grammar/StochasticGrammar.cpp

645 lines
17KB
Raw Blame History 

  1. 

  2. #include "StochasticGrammar.h"

  3. #include <random>

  4. 

  5. #if 0

  6. // eventually get rid of this global random generator

  7. std::default_random_engine generator{57};

  8. std::uniform_real_distribution<float> distribution{0, 1.0};

  9. float Random::get()

  10. {

  11.     return  distribution(generator);

  12. }

  13. #endif

  14. 

  15. 

  16. /***************************************************************************************************************

  17.  *

  18.  * ProductionRuleKeys

  19.  *

  20.  ***************************************************************************************************************/

  21. 

  22. void ProductionRuleKeys::breakDown(GKEY key, GKEY * outKeys)

  23. {

  24.     switch (key) {

  25.         // terminal keys expand to themselves

  26.         case sg_w2:

  27.         case sg_w:

  28.         case sg_h:

  29.         case sg_q:

  30.         case sg_e:

  31.         case sg_e3:

  32.         case sg_sx:

  33.         case sg_68:

  34.         case sg_78:

  35.         case sg_98:

  36.         case sg_dq:

  37.         case sg_dh:

  38.         case sg_de:

  39.             //case sg_hdq:

  40.             //case sg_qhe:

  41.             *outKeys++ = key;

  42.             *outKeys++ = sg_invalid;

  43.             break;

  44.         case sg_798:

  45.             *outKeys++ = sg_78;

  46.             *outKeys++ = sg_98;

  47.             *outKeys++ = sg_invalid;

  48.             break;

  49.         case sg_ww:

  50.             *outKeys++ = sg_w;

  51.             *outKeys++ = sg_w;

  52.             *outKeys++ = sg_invalid;

  53.             break;

  54.         case sg_hh:

  55.             *outKeys++ = sg_h;

  56.             *outKeys++ = sg_h;

  57.             *outKeys++ = sg_invalid;

  58.             break;

  59.         case sg_qq:

  60.             *outKeys++ = sg_q;

  61.             *outKeys++ = sg_q;

  62.             *outKeys++ = sg_invalid;

  63.             break;

  64.         case sg_sxsx:

  65.             *outKeys++ = sg_sx;

  66.             *outKeys++ = sg_sx;

  67.             *outKeys++ = sg_invalid;

  68.             break;

  69.         case sg_ee:

  70.             *outKeys++ = sg_e;

  71.             *outKeys++ = sg_e;

  72.             *outKeys++ = sg_invalid;

  73.             break;

  74.         case sg_e3e3e3:

  75.             *outKeys++ = sg_e3;

  76.             *outKeys++ = sg_e3;

  77.             *outKeys++ = sg_e3;

  78.             *outKeys++ = sg_invalid;

  79.             break;

  80.         case sg_hdq:

  81.             *outKeys++ = sg_h;

  82.             *outKeys++ = sg_dq;

  83.             *outKeys++ = sg_invalid;

  84.             break;

  85.         case sg_hq:

  86.             *outKeys++ = sg_h;

  87.             *outKeys++ = sg_q;

  88.             *outKeys++ = sg_invalid;

  89.             break;

  90.         case sg_qh:

  91.             *outKeys++ = sg_q;

  92.             *outKeys++ = sg_h;

  93.             *outKeys++ = sg_invalid;

  94.             break;

  95. 

  96.         case sg_qhe:

  97.             *outKeys++ = sg_q;

  98.             *outKeys++ = sg_h;

  99.             *outKeys++ = sg_e;

  100.             *outKeys++ = sg_invalid;

  101.             break;

  102.         case sg_q78:

  103.             *outKeys++ = sg_q;

  104.             *outKeys++ = sg_78;

  105.             *outKeys++ = sg_invalid;

  106.             break;

  107.         case sg_qe68:

  108.             *outKeys++ = sg_q;

  109.             *outKeys++ = sg_e;

  110.             *outKeys++ = sg_68;

  111.             *outKeys++ = sg_invalid;

  112.             break;

  113.         default:

  114.             assert(false);

  115.     }

  116. }

  117. 

  118. 

  119. const char * ProductionRuleKeys::toString(GKEY key)

  120. {

  121.     const char * ret;

  122.     switch (key) {

  123.         case sg_w2: ret = "2xw"; break;

  124.         case sg_ww: ret = "w,w"; break;

  125.         case sg_w: ret = "w"; break;

  126.         case sg_h: ret = "h"; break;

  127.         case sg_hh: ret = "h,h"; break;

  128.         case sg_q: ret = "q"; break;

  129.         case sg_qq: ret = "q,q"; break;

  130.         case sg_e: ret = "e"; break;

  131.         case sg_ee: ret = "e,e"; break;

  132. 

  133.         case sg_e3e3e3: ret = "3e,3e,3e"; break;

  134.         case sg_e3: ret = "3e"; break;

  135. 

  136.         case sg_sx: ret = "sx"; break;

  137.         case sg_sxsx: ret = "sx, sx"; break;

  138.         case sg_68: ret = "<6/8>"; break;

  139.         case sg_78: ret = "<7/8>"; break;

  140.         case sg_98: ret = "<9/8>"; break;

  141.         case sg_798: ret = "7+9/8"; break;

  142. 

  143.         case sg_dq: ret = "q."; break;

  144.         case sg_dh: ret = "h."; break;

  145.         case sg_de: ret = "e."; break;

  146. 

  147.         case sg_hdq: ret = "h,q."; break;

  148.         case sg_qhe: ret = "q,h,e"; break;

  149.         case sg_qh: ret = "q,h"; break;

  150.         case sg_hq: ret = "h,q"; break;

  151.         case sg_q78: ret = "q,<7/8>"; break;

  152.         case sg_qe68: ret = "q,e,<6/8>"; break;

  153. 

  154. 

  155.         default:

  156.             printf("can't print key %d\n", key);

  157.             assert(false);

  158.             ret = "error";

  159.     }

  160.     return ret;

  161. }

  162. 

  163. int ProductionRuleKeys::getDuration(GKEY key)

  164. {

  165.     int ret;

  166. 

  167.     assert((PPQ % 3) == 0);

  168.     switch (key) {

  169.         case sg_798:

  170.         case sg_w2: ret = 2 * 4 * PPQ; 	break;

  171.         case sg_ww: ret = 2 * 4 * PPQ; 	break;

  172.         case sg_w: ret = 4 * PPQ; 	break;

  173.         case sg_h: ret = 2 * PPQ; 	break;

  174.         case sg_hh: ret = 2 * 2 * PPQ; 	break;

  175.         case sg_q: ret = 1 * PPQ; 	break;

  176.         case sg_qq: ret = 2 * PPQ; 	break;

  177.         case sg_e:

  178.             assert((PPQ % 2) == 0);

  179.             ret = PPQ / 2;

  180.             break;

  181.         case sg_ee: ret = PPQ; 	break;

  182.         case sg_sxsx: ret = PPQ / 2; break;

  183.         case sg_sx:

  184.             assert((PPQ % 4) == 0);

  185.             ret = PPQ / 4;

  186.             break;

  187.         case sg_e3e3e3: ret = PPQ; break;

  188.         case sg_e3:

  189.             assert(PPQ % 3 == 0);

  190.             ret = PPQ / 3;

  191.             break;

  192.         case sg_68: ret = 6 * (PPQ / 2); break;

  193.         case sg_78: ret = 7 * (PPQ / 2); break;

  194. 

  195.         case sg_q78:

  196.         case sg_qe68:

  197.         case sg_98:

  198.             ret = 9 * (PPQ / 2); break;

  199. 

  200.         case sg_dq: ret = 3 * PPQ / 2; break;

  201.         case sg_dh: ret = 3 * PPQ; break;

  202.         case sg_de: ret = 3 * PPQ / 4; break;

  203. 

  204.         case sg_hdq: ret = 2 * PPQ + 3 * PPQ / 2; break;

  205.         case sg_qhe: ret = PPQ * 3 + PPQ / 2; break;

  206. 

  207. 

  208. 

  209.         case sg_hq:

  210.         case sg_qh: ret = PPQ * 3; break;

  211. 

  212. 

  213.         default:

  214. #ifdef _MSC_VER

  215.             printf("can't get dur key %d\n", key);

  216. #endif

  217.             assert(false);

  218.             ret = 0;

  219.     }

  220.     return ret;

  221. 

  222. }

  223. 

  224. 

  225. /***************************************************************************************************************

  226. *

  227. * ProductionRule

  228. *

  229. ***************************************************************************************************************/

  230. 

  231. 

  232. // generate production, return code for what happened

  233. int ProductionRule::_evaluateRule(const ProductionRule& rule, float random)

  234. {

  235.     assert(random >= 0 && random <= 1);

  236. 

  237.     int i = 0;

  238.     for (bool done2 = false; !done2; ++i) {

  239.         assert(i < numEntries);

  240.         //printf("prob[%d] is %d\n", i,  rule.entries[i].probability);

  241.         if (rule.entries[i].probability >= random) {

  242.             GKEY code = rule.entries[i].code;

  243.             //printf("rule fired on code abs val=%d\n", code);

  244.             return code;

  245.         }

  246.     }

  247.     assert(false);	// no rule fired

  248.     return 0;

  249. }

  250. 

  251. void ProductionRule::evaluate(EvaluationState& es, int ruleToEval)

  252. {

  253.     //printf("\n evaluate called on rule #%d\n", ruleToEval);

  254.     const ProductionRule& rule = es.rules[ruleToEval];

  255. 

  256. #ifdef _MSC_VER

  257.     assert(rule._isValid(ruleToEval));

  258. #endif

  259.     GKEY result = _evaluateRule(rule, es.r());

  260.     if (result == sg_invalid)		// request to terminate recursion

  261.     {

  262.         GKEY code = ruleToEval;		// our "real" terminal code is our table index

  263.                                     //printf("production rule #%d terminated\n", ruleToEval);

  264.                                     //printf("rule terminated! execute code %s\n",  ProductionRuleKeys::toString(code));

  265.         es.writeSymbol(code);

  266.     } else {

  267.         //printf("production rule #%d expanded to %d\n", ruleToEval, result);

  268. 

  269.         // need to expand,then eval all of the expanded codes

  270. 

  271.         GKEY buffer[ProductionRuleKeys::bufferSize];

  272.         ProductionRuleKeys::breakDown(result, buffer);

  273.         for (GKEY * p = buffer; *p != sg_invalid; ++p) {

  274.             //printf("expanding rule #%d with %d\n", ruleToEval, *p);

  275.             evaluate(es, *p);

  276.         }

  277.         //printf("done expanding %d\n", ruleToEval);

  278.     }

  279. }

  280. 

  281. // is the data self consistent, and appropriate for index

  282. #if defined(_MSC_VER) && defined(_DEBUG)

  283. bool ProductionRule::_isValid(int index) const

  284. {

  285.     if (index == sg_invalid) {

  286.         printf("rule not allowed in first slot\n");

  287.         return false;

  288.     }

  289. 

  290. 

  291.     if (entries[0] == ProductionRuleEntry()) {

  292.         printf("rule at index %d is ininitizlied. bad graph (%s)\n",

  293.             index,

  294.             ProductionRuleKeys::toString(index));

  295.         return false;

  296.     }

  297. 

  298.     float last = -1;

  299.     bool foundTerminator = false;

  300.     for (int i = 0; !foundTerminator; ++i) {

  301.         if (i >= numEntries) {

  302.             printf("entries not terminated index=%d 'i' is too big: %d\n", index, i);

  303.             return false;

  304.         }

  305.         const ProductionRuleEntry& e = entries[i];

  306.         if (e.probability > 1.0f) {

  307.             printf("probability %f > 1 \n", e.probability);

  308.             return false;

  309.         }

  310.         if (e.probability == 0.f) {

  311.             printf("zero probability in rule\n");

  312.             return false;

  313.         }

  314.         if (e.probability <= last)			// probabilities grow

  315.         {

  316.             printf("probability not growing is %f was %f\n", e.probability, last);

  317.             return false;

  318.         }

  319.         if (e.probability == 1.0f) {

  320.             foundTerminator = true;					// must have a 255 to end it

  321.             if (e.code == index) {

  322.                 printf("rule terminates on self: recursion not allowed\n");

  323.                 return false;

  324.             }

  325.         }

  326. 

  327.         if (e.code < sg_invalid || e.code > sg_last) {

  328.             printf("rule[%d] entry[%d] had invalid code: %d\n", index, i, e.code);

  329.             return false;

  330.         }

  331. 

  332.         // if we are terminating recursion, then by definition our duration is correct

  333.         if (e.code != sg_invalid) {

  334.             // otherwise, make sure the entry has the right duration

  335.             int entryDuration = ProductionRuleKeys::getDuration(e.code);

  336.             int ruleDuration = ProductionRuleKeys::getDuration(index);

  337.             if (entryDuration != ruleDuration) {

  338.                 printf("production rule[%d] (name %s) duration mismatch (time not conserved) rule dur = %d entry dur %d\n",

  339.                     index, ProductionRuleKeys::toString(index), ruleDuration, entryDuration);

  340.                 return false;

  341.             }

  342.         }

  343.         last = e.probability;

  344.     }

  345.     return true;

  346. }

  347. #endif

  348. 

  349. #ifdef _DEBUG

  350. bool ProductionRule::isGrammarValid(const ProductionRule * rules, int numRules, GKEY firstRule)

  351. {

  352.     //printf("is grammar valid, numRules = %d first = %d\n", numRules, firstRule);

  353.     if (firstRule < sg_first) {

  354.         printf("first rule index (%d) bad\n", firstRule);

  355.         return false;

  356.     }

  357.     if (numRules != (sg_last + 1)) {

  358.         printf("bad number of rules\n");

  359.         return false;

  360.     }

  361. 

  362.     const ProductionRule& r = rules[firstRule];

  363. 

  364.     if (!r._isValid(firstRule)) {

  365.         return false;

  366.     }

  367. 

  368.     // now, make sure every entry goes to something real

  369.     bool foundTerminator = false;

  370.     for (int i = 0; !foundTerminator; ++i) {

  371.         const ProductionRuleEntry& e = r.entries[i];

  372.         if (e.probability == 1.0f)

  373.             foundTerminator = true;					// must have a 255 to end it	

  374.         GKEY _newKey = e.code;

  375.         if (_newKey != sg_invalid) {

  376.             GKEY outKeys[4];

  377.             ProductionRuleKeys::breakDown(_newKey, outKeys);

  378.             for (GKEY * p = outKeys; *p != sg_invalid; ++p) {

  379.                 if (!isGrammarValid(rules, numRules, *p)) {

  380.                     printf("followed rules to bad one\n");

  381.                     return false;

  382.                 }

  383.             }

  384.         }

  385.     }

  386. 

  387.     return true;

  388. }

  389. #endif

  390. 

  391. 

  392. 

  393. /*

  394. 

  395. StochasticGrammarDictionary

  396. 

  397. maybe move this to a test file?

  398. **/

  399. 

  400. static ProductionRule _rules0[fullRuleTableSize];

  401. static ProductionRule _rules1[fullRuleTableSize];

  402. static ProductionRule _rules2[fullRuleTableSize];

  403. static ProductionRule _rules3[fullRuleTableSize];

  404. 

  405. bool StochasticGrammarDictionary::_didInitRules = false;

  406. 

  407. void StochasticGrammarDictionary::initRules()

  408. {

  409.     initRule0(_rules0);

  410.     initRule1(_rules1);

  411.     initRule2(_rules2);

  412.     initRule3(_rules3);

  413. }

  414. 

  415. 

  416. 

  417. 

  418. // super dumb one - makes quarter notes

  419. void StochasticGrammarDictionary::initRule0(ProductionRule * rules)

  420. {

  421.     // break w2 into w,w prob 100

  422.     {

  423.         ProductionRule& r = rules[sg_w2];

  424.         r.entries[0].probability = 1.0f;

  425.         r.entries[0].code = sg_ww;

  426.     }

  427. 

  428.     // break w into h, h

  429.     {

  430.         ProductionRule& r = rules[sg_w];

  431.         r.entries[0].probability = 1.0f;

  432.         r.entries[0].code = sg_hh;

  433.     }

  434. 

  435.     // break h into q,q

  436.     {

  437.         ProductionRule&r = rules[sg_h];

  438.         r.entries[0].probability = 1.0f;

  439.         r.entries[0].code = sg_qq;

  440.     }

  441.     // stop on q

  442.     rules[sg_q].makeTerminal();

  443. 

  444. }

  445. 

  446. void StochasticGrammarDictionary::initRule1(ProductionRule * rules)

  447. {

  448. 

  449.     // break w2 into w,w prob 100

  450.     {

  451.         ProductionRule& r = rules[sg_w2];

  452.         r.entries[0].probability = 1.0f;

  453.         r.entries[0].code = sg_ww;

  454.     }

  455. 

  456.     // break w into h, h

  457.     {

  458.         ProductionRule& r = rules[sg_w];

  459.         r.entries[0].probability = 1.0f;

  460.         r.entries[0].code = sg_hh;

  461.     }

  462. 

  463.     // break h into q,q, or h

  464.     {

  465.         ProductionRule&r = rules[sg_h];

  466.         r.entries[0].probability = .75f;

  467.         r.entries[0].code = sg_qq;

  468. 

  469.         r.entries[1].probability = 1.0f;

  470.         r.entries[1].code = sg_invalid;

  471.     }

  472. 

  473.     // stop on q, or make e

  474.     {

  475. 

  476.         ProductionRule&r = rules[sg_q];

  477.         r.entries[0].probability = .3f;

  478.         r.entries[0].code = sg_ee;

  479. 

  480.         r.entries[1].probability = 1.0f;

  481.         r.entries[1].code = sg_invalid;

  482.     }

  483. 

  484.     // stop on e, or make sx

  485.     {

  486. 

  487.         ProductionRule&r = rules[sg_e];

  488.         r.entries[0].probability = .3f;

  489.         r.entries[0].code = sg_sxsx;

  490. 

  491.         r.entries[1].probability = 1.0f;

  492.         r.entries[1].code = sg_invalid;

  493.     }

  494. 

  495.     rules[sg_sx].makeTerminal();

  496. }

  497. 

  498. void StochasticGrammarDictionary::initRule2(ProductionRule * rules)

  499. {

  500.     // break w2 into 7+9/8 prob 100

  501.     {

  502.         ProductionRule& r = rules[sg_w2];

  503.         r.entries[0].probability = 1.0f;

  504.         r.entries[0].code = sg_798;

  505.     }

  506. 

  507.     // 9/8 -> different combos

  508.     {

  509.         ProductionRule& r = rules[sg_98];

  510.         r.entries[0].probability = .5f;

  511.         r.entries[0].code = sg_q78;

  512.         r.entries[1].probability = 1.0f;

  513.         r.entries[1].code = sg_qe68;

  514.     }

  515. 

  516.     // 6/8 ->

  517.     {

  518.         ProductionRule& r = rules[sg_68];

  519.         r.entries[0].probability = .5f;

  520.         r.entries[0].code = sg_hq;

  521.         r.entries[1].probability = 1.0f;

  522.         r.entries[1].code = sg_qh;

  523.     }

  524. 

  525. 

  526.     //78 -> different combos

  527.     {

  528.         ProductionRule& r = rules[sg_78];

  529.         r.entries[0].probability = .5f;

  530.         r.entries[0].code = sg_qhe;

  531.         r.entries[1].probability = 1.0f;

  532.         r.entries[1].code = sg_hdq;

  533.     }

  534. 

  535. 

  536. 

  537.     // terminate on these

  538.     rules[sg_hdq].makeTerminal();

  539.     rules[sg_qhe].makeTerminal();

  540.     rules[sg_q].makeTerminal();

  541.     rules[sg_dq].makeTerminal();

  542.     rules[sg_h].makeTerminal();

  543.     rules[sg_e].makeTerminal();

  544. }

  545. 

  546. // 3 is like 1, but with some trips

  547. void StochasticGrammarDictionary::initRule3(ProductionRule * rules)

  548. {

  549. 

  550.     // break w2 into w,w prob 100

  551.     {

  552.         ProductionRule& r = rules[sg_w2];

  553.         r.entries[0].probability = 1.0f;

  554.         r.entries[0].code = sg_ww;

  555.     }

  556. 

  557.     // break w into h, h

  558.     {

  559.         ProductionRule& r = rules[sg_w];

  560.         r.entries[0].probability = 1.0f;

  561.         r.entries[0].code = sg_hh;

  562.     }

  563. 

  564.     // break h into q,q, or h

  565.     {

  566.         ProductionRule&r = rules[sg_h];

  567.         r.entries[0].probability = .75f;

  568.         r.entries[0].code = sg_qq;

  569. 

  570.         r.entries[1].probability = 1.0f;

  571.         r.entries[1].code = sg_invalid;

  572.     }

  573. 

  574.     // stop on q, or make e, or make trips

  575.     {

  576. 

  577.         ProductionRule&r = rules[sg_q];

  578.         r.entries[0].probability = .3f;

  579.         r.entries[0].code = sg_ee;

  580. 

  581.         r.entries[1].probability = .7f;

  582.         r.entries[1].code = sg_e3e3e3;

  583. 

  584.         r.entries[2].probability = 1.0f;

  585.         r.entries[2].code = sg_invalid;

  586.     }

  587. 

  588.     // expand trip 8ths

  589.     rules[sg_e3].makeTerminal();

  590. 

  591. 

  592.     // stop on e, or make sx,

  593.     {

  594. 

  595.         ProductionRule&r = rules[sg_e];

  596.         r.entries[0].probability = .3f;

  597.         r.entries[0].code = sg_sxsx;

  598. 

  599.         r.entries[1].probability = 1.0f;

  600.         r.entries[1].code = sg_invalid;

  601.     }

  602. 

  603.     rules[sg_sx].makeTerminal();

  604. }

  605. 

  606. 

  607. int StochasticGrammarDictionary::getNumGrammars()

  608. {

  609.     return 4;

  610. }

  611. 

  612. StochasticGrammarDictionary::Grammar StochasticGrammarDictionary::getGrammar(int index)

  613. {

  614.     if (!_didInitRules)

  615.         initRules();

  616. 

  617.     assert(index >= 0 && index < getNumGrammars());

  618. 

  619. 

  620.     Grammar ret;

  621.     ret.firstRule = sg_w2;

  622.     ret.numRules = fullRuleTableSize;

  623. 

  624.     switch (index) {

  625.         case 0:

  626.             ret.rules = _rules0;

  627.             break;

  628.         case 1:

  629.             ret.rules = _rules1;

  630.             break;

  631.         case 2:

  632.             ret.rules = _rules2;

  633.             break;

  634.         case 3:

  635.             ret.rules = _rules3;

  636.             break;

  637.         default:

  638.             assert(false);

  639.     }

  640.     return ret;

  641. }

  642. 

  643.