void PorterStemmer::step3() {
   if (k == k0) return; /* For Bug 1 */
   switch (b[k-1]) {
   case 'a':
     if (ends(_T("ational"))) { r(_T("ate")); break; }
     if (ends(_T("tional"))) { r(_T("tion")); break; }
     break;
   case 'c':
     if (ends(_T("enci"))) { r(_T("ence")); break; }
     if (ends(_T("anci"))) { r(_T("ance")); break; }
     break;
   case 'e':
     if (ends(_T("izer"))) { r(_T("ize")); break; }
     break;
   case 'l':
     if (ends(_T("bli"))) { r(_T("ble")); break; }
     if (ends(_T("alli"))) { r(_T("al")); break; }
     if (ends(_T("entli"))) { r(_T("ent")); break; }
     if (ends(_T("eli"))) { r(_T("e")); break; }
     if (ends(_T("ousli"))) { r(_T("ous")); break; }
     break;
   case 'o':
     if (ends(_T("ization"))) { r(_T("ize")); break; }
     if (ends(_T("ation"))) { r(_T("ate")); break; }
     if (ends(_T("ator"))) { r(_T("ate")); break; }
     break;
   case 's':
     if (ends(_T("alism"))) { r(_T("al")); break; }
     if (ends(_T("iveness"))) { r(_T("ive")); break; }
     if (ends(_T("fulness"))) { r(_T("ful")); break; }
     if (ends(_T("ousness"))) { r(_T("ous")); break; }
     break;
   case 't':
     if (ends(_T("aliti"))) { r(_T("al")); break; }
     if (ends(_T("iviti"))) { r(_T("ive")); break; }
     if (ends(_T("biliti"))) { r(_T("ble")); break; }
     break;
   case 'g':
     if (ends(_T("logi"))) { r(_T("log")); break; }
   }
 }
static void step4(struct stemmer * z) {
	switch (z->b[z->k - 1]) {
	case 'a':
		if (ends(z, "\02" "al"))
			break;
		return;
	case 'c':
		if (ends(z, "\04" "ance"))
			break;
		if (ends(z, "\04" "ence"))
			break;
		return;
	case 'e':
		if (ends(z, "\02" "er"))
			break;
		return;
	case 'i':
		if (ends(z, "\02" "ic"))
			break;
		return;
	case 'l':
		if (ends(z, "\04" "able"))
			break;
		if (ends(z, "\04" "ible"))
			break;
		return;
	case 'n':
		if (ends(z, "\03" "ant"))
			break;
		if (ends(z, "\05" "ement"))
			break;
		if (ends(z, "\04" "ment"))
			break;
		if (ends(z, "\03" "ent"))
			break;
		return;
	case 'o':
		if (ends(z, "\03" "ion") && z->j >= 0
				&& (z->b[z->j] == 's' || z->b[z->j] == 't'))
			break;
		if (ends(z, "\02" "ou"))
			break;
		return;
		/* takes care of -ous */
	case 's':
		if (ends(z, "\03" "ism"))
			break;
		return;
	case 't':
		if (ends(z, "\03" "ate"))
			break;
		if (ends(z, "\03" "iti"))
			break;
		return;
	case 'u':
		if (ends(z, "\03" "ous"))
			break;
		return;
	case 'v':
		if (ends(z, "\03" "ive"))
			break;
		return;
	case 'z':
		if (ends(z, "\03" "ize"))
			break;
		return;
	default:
		return;
	}
	if (m(z) > 1)
		z->k = z->j;
}
 void PorterStemmer::step2() {
   if (ends(_T("y")) && vowelinstem()) {
     b[k] = 'i';
     dirty = true;
   }
 }
static void step1c(struct stemmer * z) {
	if (ends(z, "\01" "y") && vowelinstem(z))
		z->b[z->k] = 'i';
}
static void step2(struct stemmer * z) {
	switch (z->b[z->k - 1]) {
	case 'a':
		if (ends(z, "\07" "ational")) {
			r(z, "\03" "ate");
			break;
		}
		if (ends(z, "\06" "tional")) {
			r(z, "\04" "tion");
			break;
		}
		break;
	case 'c':
		if (ends(z, "\04" "enci")) {
			r(z, "\04" "ence");
			break;
		}
		if (ends(z, "\04" "anci")) {
			r(z, "\04" "ance");
			break;
		}
		break;
	case 'e':
		if (ends(z, "\04" "izer")) {
			r(z, "\03" "ize");
			break;
		}
		break;
	case 'l':
		if (ends(z, "\03" "bli")) {
			r(z, "\03" "ble");
			break;
		} /*-DEPARTURE-*/

		/* To match the published algorithm, replace this line with
		 case 'l': if (ends(z, "\04" "abli")) { r(z, "\04" "able"); break; } */

		if (ends(z, "\04" "alli")) {
			r(z, "\02" "al");
			break;
		}
		if (ends(z, "\05" "entli")) {
			r(z, "\03" "ent");
			break;
		}
		if (ends(z, "\03" "eli")) {
			r(z, "\01" "e");
			break;
		}
		if (ends(z, "\05" "ousli")) {
			r(z, "\03" "ous");
			break;
		}
		break;
	case 'o':
		if (ends(z, "\07" "ization")) {
			r(z, "\03" "ize");
			break;
		}
		if (ends(z, "\05" "ation")) {
			r(z, "\03" "ate");
			break;
		}
		if (ends(z, "\04" "ator")) {
			r(z, "\03" "ate");
			break;
		}
		break;
	case 's':
		if (ends(z, "\05" "alism")) {
			r(z, "\02" "al");
			break;
		}
		if (ends(z, "\07" "iveness")) {
			r(z, "\03" "ive");
			break;
		}
		if (ends(z, "\07" "fulness")) {
			r(z, "\03" "ful");
			break;
		}
		if (ends(z, "\07" "ousness")) {
			r(z, "\03" "ous");
			break;
		}
		break;
	case 't':
		if (ends(z, "\05" "aliti")) {
			r(z, "\02" "al");
			break;
		}
		if (ends(z, "\05" "iviti")) {
			r(z, "\03" "ive");
			break;
		}
		if (ends(z, "\06" "biliti")) {
			r(z, "\03" "ble");
			break;
		}
		break;
	case 'g':
		if (ends(z, "\04" "logi")) {
			r(z, "\03" "log");
			break;
		} /*-DEPARTURE-*/

		/* To match the published algorithm, delete this line */

	}
}
Exemple #6
0
int
poor_rubber_font_rep::search_font (string s, string& r) {
  if (starts (s, "<big-") && (ends (s, "-1>") || ends (s, "-2>"))) {
    r= s;
    return 2*MAGNIFIED_NUMBER + 4;
  }
  if (starts (s, "<mid-")) s= "<left-" * s (5, N(s));
  if (starts (s, "<right-")) s= "<left-" * s (7, N(s));
  if (starts (s, "<large-")) s= "<left-" * s (7, N(s));
  if (starts (s, "<left-")) {
    int pos= search_backwards ("-", N(s), s), num;
    if (pos > 6) { r= s (6, pos); num= as_int (s (pos+1, N(s)-1)); }
    else { r= s (6, N(s)-1); num= 0; }
    //cout << "Search " << base->res_name << ", " << s
    //     << ", " << r << ", " << num << LF;
    int nr= max (num - 5, 0);
    int thin= (is_thin (r)? 1: 0);
    int code;
    if (num <= MAGNIFIED_NUMBER ||
        r == "/" || r == "\\" || r == "langle" || r == "rangle") {
      num= min (num, MAGNIFIED_NUMBER);
      if (N(r) > 1) r= "<" * r * ">";
      if (N(r)>1 && !base->supports (r)) {
        if (r == "<||>") r= "<emu-dbar>";
        else if (r == "<interleave>") r= "<emu-tbar>";
        else if (r == "<llbracket>") r= "<emu-dlbracket>";
        else if (r == "<rrbracket>") r= "<emu-drbracket>";
        else r= "<emu-" * r (1, N(r)-1) * ">";
      }
      else if (r == "\\" && base->supports ("/")) {
        metric ex1, ex2;
        base -> get_extents ("/", ex1);
        base -> get_extents ("\\", ex2);
        double h1= ex1->y2 - ex1->y1;
        double h2= ex2->y2 - ex2->y1;
        if (fabs ((h2/h1) - 1.0) > 0.05) r= "<emu-backslash>";
      }
      return 2*num + thin;
    }
    else if (r == "(")
      code= virt->dict ["<rubber-lparenthesis-#>"];
    else if (r == ")")
      code= virt->dict ["<rubber-rparenthesis-#>"];
    else if (r == "[")
      code= virt->dict ["<rubber-lbracket-#>"];
    else if (r == "]")
      code= virt->dict ["<rubber-rbracket-#>"];
    else if (r == "{")
      code= virt->dict ["<rubber-lcurly-#>"];
    else if (r == "}")
      code= virt->dict ["<rubber-rcurly-#>"];
    else if (r == "|")
      code= virt->dict ["<rubber-bar-#>"];
    else if (r == "||") {
      if (base->supports ("<||>"))
        code= virt->dict ["<rubber-parallel-#>"];
      else code= virt->dict ["<rubber-parallel*-#>"];
    }
    else if (r == "interleave") {
      if (base->supports ("<interleave>"))
        code= virt->dict ["<rubber-interleave-#>"];
      else code= virt->dict ["<rubber-interleave*-#>"];
    }
    else if (r == "lfloor" || r == "rfloor" ||
             r == "lceil" || r == "rceil" ||
             r == "llbracket" || r == "rrbracket") {
      if (base->supports ("<" * r * ">"))
        code= virt->dict ["<rubber-" * r * "-#>"];
      else code= virt->dict ["<rubber-" * r * "*-#>"];
    }
    else if (r == "dlfloor" || r == "drfloor" ||
             r == "dlceil" || r == "drceil" ||
             r == "tlbracket" || r == "trbracket" ||
             r == "tlfloor" || r == "trfloor" ||
             r == "tlceil" || r == "trceil")
      code= virt->dict ["<rubber-" * r * "-#>"];
    else
      code= virt->dict ["<rubber-lparenthesis-#>"];
    
    r= string ((char) code) * as_string (nr + HUGE_ADJUST) * ">";
    return 2*MAGNIFIED_NUMBER + 2 + thin;
  }
  r= s;
  return 0;
}
Exemple #7
0
static void step4() {

    switch (b[k-1]) {

        case 'a':
            if (ends("\02" "al"))
                break;
            return;

        case 'c':
            if (ends("\04" "ance"))
                break;
            if (ends("\04" "ence"))
                break;
            return;

        case 'e':
            if (ends("\02" "er"))
                break;
            return;

        case 'i':
            if (ends("\02" "ic"))
                break;
            return;

        case 'l':
            if (ends("\04" "able"))
                break;
            if (ends("\04" "ible"))
                break;
            return;

        case 'n':
            if (ends("\03" "ant"))
                break;
            if (ends("\05" "ement"))
                break;
            if (ends("\04" "ment"))
                break;
            if (ends("\03" "ent"))
                break;
            return;

        case 'o':
            if (ends("\03" "ion") && j >= k0 && (b[j] == 's' || b[j] == 't'))
                break;
            if (ends("\02" "ou")) // Takes care of -ous
                break;
            return;

        case 's':
            if (ends("\03" "ism"))
                break;
            return;

        case 't':
            if (ends("\03" "ate"))
                break;
            if (ends("\03" "iti"))
                break;
            return;

        case 'u':
            if (ends("\03" "ous"))
                break;
            return;

        case 'v':
            if (ends("\03" "ive"))
                break;
            return;

        case 'z':
            if (ends("\03" "ize"))
                break;
            return;

        default:
            return;
    }

    if (m() > 1)
        k = j;
}
void CStemmer::step1c() { if (ends("\01" "y") && vowelinstem()) b[k] = 'i'; }
int main(int argc, const char* argv[]){
  IloEnv env;
  try {
    const char* filename = "../../../examples/data/learningeffect_default.data";
    IloInt failLimit = IloIntMax;
    if (argc > 1)
      filename = argv[1];
    if (argc > 2)
      failLimit = atoi(argv[2]);
    std::ifstream file(filename);
    if (!file){
      env.out() << "usage: " << argv[0] << " <file> <failLimit>" << std::endl;
      throw FileError();
    }

    IloModel model(env);
    IloInt nbJobs, nbMachines;
    file >> nbJobs;
    file >> nbMachines;
    IloIntervalVarArray2 machines(env, nbMachines);
    IloIntArray2 sizes(env, nbMachines);
    for (IloInt j = 0; j < nbMachines; j++) {
      machines[j] = IloIntervalVarArray(env);
      sizes[j] = IloIntArray(env);
    }
    IloIntExprArray ends(env);
    for (IloInt i = 0; i < nbJobs; i++) {
      IloIntervalVar prec;
      for (IloInt j = 0; j < nbMachines; j++) {
        IloInt m, d;
        file >> m;
        file >> d;
        IloIntervalVar ti(env);
        machines[m].add(ti);
        sizes[m].add(d);
        if (0 != prec.getImpl())
          model.add(IloEndBeforeStart(env, prec, ti));
        prec = ti;
      }
      ends.add(IloEndOf(prec));
    }
    for (IloInt j = 0; j < nbMachines; j++) {
      IloInt lef;
      file >> lef;
      IloNum alpha = lef/100.0;
      IloIntervalVarArray chain(env);
      IloIntVarArray indices(env);
      IloIntervalVar prec;
      for(IloInt i = 0; i < nbJobs; ++i) {
        IloIntervalVar ti = machines[j][i];
        IloInt d = sizes[j][i];
        ti.setSizeMax(d);
        // Building of the chain of intervals for the machine.
        IloIntervalVar syncti(env);
        if (prec.getImpl()) 
          model.add(IloEndBeforeStart(env, prec, syncti));
        prec = syncti;
        IloIntVar index(env, 0, nbJobs - 1);
        // Learning effect captured by the decreasing function
        // of the position (0 <= alpha <= 1).
        // At first position in the sequence index = 0; there is no
        // learning effect and duration of the task is its nominal duration
        model.add(IloSizeOf(ti) == IloFloor(IloNum(d)*IloPower(alpha, index)));
        chain.add(syncti);
        indices.add(index);
      }
      model.add(IloIsomorphism(env, chain, machines[j], indices, nbJobs));

      // The no-overlap is a redundant constraint in this quite simple
      // model - it is used only to provide stronger inference.
      model.add(IloNoOverlap(env, machines[j]));
    }
    IloObjective objective = IloMinimize(env,IloMax(ends));
    model.add(objective);
    
    IloCP cp(model);
    cp.setParameter(IloCP::FailLimit, failLimit);
    cp.setParameter(IloCP::LogPeriod, 10000);
    cp.out() << "Instance \t: " << filename << std::endl;
    if (cp.solve()) {
      cp.out() << "Makespan \t: " << cp.getObjValue() << std::endl;
    } else {
      cp.out() << "No solution found."  << std::endl;
    }
  } catch(IloException& e){
    env.out() << " ERROR: " << e << std::endl;
  }
  env.end();
  return 0;
}
Exemple #10
0
void SkTileGrid::search(const SkRect& originalQuery, SkTDArray<unsigned>* results) const {
    // The inset counteracts the outset that applied in 'insert', which optimizes
    // for lookups of size 'tileInterval + 2 * margin' (aligned with the tile grid).
    SkRect query = originalQuery;
    query.inset(fMarginWidth, fMarginHeight);
    this->commonAdjust(&query);

    // The inset may have inverted the rectangle, so sort().
    // TODO(mtklein): It looks like we only end up with inverted bounds in unit tests
    // that make explicitly inverted queries, not from insetting.  If we can drop support for
    // unsorted bounds (i.e. we don't see them outside unit tests), I think we can drop this.
    query.sort();

    // No intersection check.  We optimize for queries that are in bounds.
    // We're safe anyway: userToGrid() will clamp out-of-bounds queries to nearest tile.
    SkIRect grid;
    this->userToGrid(query, &grid);

    const int tilesHit = (grid.fRight - grid.fLeft + 1) * (grid.fBottom - grid.fTop + 1);
    SkASSERT(tilesHit > 0);

    if (tilesHit == 1) {
        // A performance shortcut.  The merging code below would work fine here too.
        *results = fTiles[grid.fTop * fXTiles + grid.fLeft];
        return;
    }

    // We've got to merge the data in many tiles into a single sorted and deduplicated stream.
    // We do a simple k-way merge based on the value of opIndex.

    // Gather pointers to the starts and ends of the tiles to merge.
    SkAutoSTArray<kStackAllocationTileCount, const unsigned*> starts(tilesHit), ends(tilesHit);
    int i = 0;
    for (int y = grid.fTop; y <= grid.fBottom; y++) {
        for (int x = grid.fLeft; x <= grid.fRight; x++) {
            starts[i] = fTiles[y * fXTiles + x].begin();
            ends[i]   = fTiles[y * fXTiles + x].end();
            i++;
        }
    }

    // Merge tiles into results until they're fully consumed.
    results->reset();
    while (true) {
        // The tiles themselves are already ordered, so the earliest op is at the front of some
        // tile. It may be at the front of several, even all, tiles.
        unsigned earliest = SK_MaxU32;
        for (int i = 0; i < starts.count(); i++) {
            if (starts[i] < ends[i]) {
                earliest = SkTMin(earliest, *starts[i]);
            }
        }

        // If we didn't find an earliest op, there isn't anything left to merge.
        if (SK_MaxU32 == earliest) {
            return;
        }

        // We did find an earliest op. Output it, and step forward every tile that contains it.
        results->push(earliest);
        for (int i = 0; i < starts.count(); i++) {
            if (starts[i] < ends[i] && *starts[i] == earliest) {
                starts[i]++;
            }
        }
    }
}
Exemple #11
0
static int equals(struct stemmer * z, char * s) {
    if (s[0] != z->k + 1) return FALSE;
    return ends(z, s);
}
Exemple #12
0
/* step2() maps double suffices to single ones. so -ization ( = -ize plus
   -ation) maps to -ize etc. note that the string before the suffix must give
   m() > 0. */
static void
step2(void)
{
	switch (b[k-1]) {
	case 'a':
		if (ends("\07" "ational")) {
			r("\03" "ate");
			break;
		}
		if (ends("\06" "tional")) {
			r("\04" "tion");
			break;
		}
		break;
	case 'c':
		if (ends("\04" "enci")) {
			r("\04" "ence");
			break;
		}
		if (ends("\04" "anci")) {
			r("\04" "ance");
			break;
		}
		break;
	case 'e':
		if (ends("\04" "izer")) {
			r("\03" "ize");
			break;
		}
		break;
	case 'l':
		if (ends("\03" "bli")) {
			r("\03" "ble");
			break;
		}
		/*-DEPARTURE-*/
 
		if (ends("\04" "alli")) {
			r("\02" "al");
			break;
		}
		if (ends("\05" "entli")) {
			r("\03" "ent");
			break;
		}
		if (ends("\03" "eli")) {
			r("\01" "e");
			break;
		}
		if (ends("\05" "ousli")) {
			r("\03" "ous");
			break;
		}
		break;
	case 'o':
		if (ends("\07" "ization")) {
			r("\03" "ize");
			break;
		}
		if (ends("\05" "ation")) {
			r("\03" "ate");
			break;
		}
		if (ends("\04" "ator")) {
			r("\03" "ate");
			break;
		}
		break;
	case 's':
		if (ends("\05" "alism")) {
			r("\02" "al");
			break;
		}
		if (ends("\07" "iveness")) {
			r("\03" "ive");
			break;
		}
		if (ends("\07" "fulness")) {
			r("\03" "ful");
			break;
		}
		if (ends("\07" "ousness")) {
			r("\03" "ous");
			break;
		}
		break;
	case 't':
		if (ends("\05" "aliti")) {
			r("\02" "al");
			break;
		}
		if (ends("\05" "iviti")) {
			r("\03" "ive");
			break;
		}
		if (ends("\06" "biliti")) {
			r("\03" "ble");
			break;
		}
		break;
	case 'g':
		if (ends("\04" "logi")) {
			r("\03" "log");
			break;
		}
		/*-DEPARTURE-*/

	default:
		break;
	}
	return;
}
Exemple #13
0
void SkTileGrid::search(const SkRect& query, SkTDArray<void*>* results) const {
    SkIRect adjusted;
    query.roundOut(&adjusted);

    // The inset is to counteract the outset that was applied in 'insert'
    // The outset/inset is to optimize for lookups of size
    // 'tileInterval + 2 * margin' that are aligned with the tile grid.
    adjusted.inset(fInfo.fMargin.width(), fInfo.fMargin.height());
    adjusted.offset(fInfo.fOffset);
    adjusted.sort();  // in case the inset inverted the rectangle

    // Convert the query rectangle from device coordinates to tile coordinates
    // by rounding outwards to the nearest tile boundary so that the resulting tile
    // region includes the query rectangle.
    int startX = adjusted.left() / fInfo.fTileInterval.width(),
        startY = adjusted.top()  / fInfo.fTileInterval.height();
    int endX = divide_ceil(adjusted.right(),  fInfo.fTileInterval.width()),
        endY = divide_ceil(adjusted.bottom(), fInfo.fTileInterval.height());

    // Logically, we could pin endX to [startX, fXTiles], but we force it
    // up to (startX, fXTiles] to make sure we hit at least one tile.
    // This snaps just-out-of-bounds queries to the neighboring border tile.
    // I don't know if this is an important feature outside of unit tests.
    startX = SkPin32(startX, 0, fXTiles - 1);
    startY = SkPin32(startY, 0, fYTiles - 1);
    endX   = SkPin32(endX, startX + 1, fXTiles);
    endY   = SkPin32(endY, startY + 1, fYTiles);

    const int tilesHit = (endX - startX) * (endY - startY);
    SkASSERT(tilesHit > 0);

    if (tilesHit == 1) {
        // A performance shortcut.  The merging code below would work fine here too.
        const SkTDArray<Entry>& tile = fTiles[startY * fXTiles + startX];
        results->setCount(tile.count());
        for (int i = 0; i < tile.count(); i++) {
            (*results)[i] = tile[i].data;
        }
        return;
    }

    // We've got to merge the data in many tiles into a single sorted and deduplicated stream.
    // We do a simple k-way merge based on the order the data was inserted.

    // Gather pointers to the starts and ends of the tiles to merge.
    SkAutoSTArray<kStackAllocationTileCount, const Entry*> starts(tilesHit), ends(tilesHit);
    int i = 0;
    for (int x = startX; x < endX; x++) {
        for (int y = startY; y < endY; y++) {
            starts[i] = fTiles[y * fXTiles + x].begin();
            ends[i]  = fTiles[y * fXTiles + x].end();
            i++;
        }
    }

    // Merge tiles into results until they're fully consumed.
    results->reset();
    while (true) {
        // The tiles themselves are already ordered, so the earliest is at the front of some tile.
        // It may be at the front of several, even all, tiles.
        const Entry* earliest = NULL;
        for (int i = 0; i < starts.count(); i++) {
            if (starts[i] < ends[i]) {
                if (NULL == earliest || starts[i]->order < earliest->order) {
                    earliest = starts[i];
                }
            }
        }

        // If we didn't find an earliest entry, there isn't anything left to merge.
        if (NULL == earliest) {
            return;
        }

        // We did find an earliest entry. Output it, and step forward every tile that contains it.
        results->push(earliest->data);
        for (int i = 0; i < starts.count(); i++) {
            if (starts[i] < ends[i] && starts[i]->order == earliest->order) {
                starts[i]++;
            }
        }
    }
}
Exemple #14
0
int
rubber_stix_font_rep::search_font_sub (string s, string& rew, string& ltype) {
  ltype= "";
  if (starts (s, "<big-") && ends (s, "-1>")) {
    string r= s (5, N(s) - 3);
    if (ends (r, "lim")) r= r (0, N(r) - 3);
    if (starts (r, "up") && ends (r, "int")) {
      rew= "<big-" * r (2, N(r)) * ">";
      return 4;
    }
    if (ends (r, "int") || r == "sum" || r == "prod" || r == "pluscup") {
      rew= s;
      return 0;
    }
    if (r == "box") s= "<big-square-1>";
    rew= s;
    return 1;
  }
  if (starts (s, "<big-") && ends (s, "-2>")) {
    string r= s (5, N(s) - 3);
    if (ends (r, "lim")) r= r (0, N(r) - 3);
    if (starts (r, "up") && ends (r, "int")) {
      rew= "<big-" * r (2, N(r)) * ">";
      return 5;
    }
    if (ends (r, "int")) {
      rew= "<big-" * r * ">";
      return 3;
    }
    if (r == "sum" || r == "prod" || r == "amalg" ||
        r == "cap" || r == "cup" || r == "vee" || r == "wedge") {
      rew= "<big-" * r * ">";
      return 6;
    }
    if (r == "pluscup") {
      rew= "<big-" * r * ">";
      return 1;
    }
    if (r == "box") s= "<big-square-2>";
    rew= s;
    return 2;
  }
  if (starts (s, "<mid-")) s= "<left-" * s (5, N(s));
  if (starts (s, "<right-")) s= "<left-" * s (7, N(s));
  if (starts (s, "<large-")) s= "<left-" * s (7, N(s));
  if (starts (s, "<left-")) {
    int pos= search_backwards ("-", N(s), s);
    if (pos > 6) ltype= s (6, pos);
  }
  if (starts (s, "<left-.")) {
    rew= "";
    return 0;
  }
  if (starts (s, "<left-|") || starts (s, "<left-interleave-")) {
    int nr= large_size (s);
    if (nr <= 0) {
      string r= large_type (s);
      r= r (5, N(r));
      if (N(r) > 1) r= "<" * r * ">";
      rew= r;
      return 0;
    }
    else {
      rew= "<" * large_type (s) * "-" * as_string (nr + 9) * ">";
      return 16;
    }
  }
  if (starts (s, "<left-") && ends (s, "-0>")) {
    rew= s;
    return 0;
  }
  if (starts (s, "<left-") && ends (s, "-1>")) {
    string r= s (6, N(s) - 3);
    if (N(r) > 1) r= "<" * r * ">";
    rew= r;
    return 7;
  }
  if (starts (s, "<left-") && ends (s, "-2>")) {
    string r= s (6, N(s) - 3);
    if (N(r) > 1) r= "<" * r * ">";
    rew= r;
    return 8;
  }
  if (starts (s, "<left-") && ends (s, "-3>")) {
    string r= s (6, N(s) - 3);
    if (N(r) > 1) r= "<" * r * ">";
    rew= r;
    return 9;
  }
  if (starts (s, "<left-") && ends (s, "-4>")) {
    string r= s (6, N(s) - 3);
    if (N(r) > 1) r= "<" * r * ">";
    rew= r;
    return 10;
  }
  if (starts (s, "<left-")) {
    int pos= search_backwards ("-", N(s), s);
    if (pos > 6) {
      string r= s (6, pos);
      int nr= as_int (s (pos+1, N(s)-1));
      if (r == "(" || r == ")" ||
          r == "[" || r == "]") {
        rew= "<left-" * r * "-" * as_string (nr + 5) * ">";
        return 17;
      }
      if (r == "{" || r == "}") {
        rew= "<left-" * r * "-" * as_string (nr + 2) * ">";
        return 17;
      }
      if (r == "lfloor" || r == "rfloor" ||
          r == "lceil" || r == "rceil") {
        rew= "<left-" * r * "-" * as_string (nr + 9) * ">";
        return 17;
      }
      if (r == "/" || r == "\\" ||
          r == "langle" || r == "rangle") {
        if (N(r) == 1) rew= r;
        else rew= "<" * r * ">";
        return 10;
      }
    }
  }
  if (starts (s, "<rubber-") && ends (s, ">")) {
    int pos= search_backwards ("-", N(s), s);
    if (pos > 8) {
      string r= s (8, pos);
      int nr= as_int (s (pos+1, N(s)-1));
      if (nr < 0) nr= 0;
      if (nr > 5) nr= 5;
      if (r == "hat") rew= "<#2C6>";
      else if (r == "tilde") rew= "<#2DC>";
      else if (r == "check") rew= "<#2C7>";
      else if (r == "bar") rew= "<#203E>";
      else if (r == "vect") rew= "<#20D7>";
      else if (r == "breve") rew= "<#2D8>";
      else if (r == "invbreve") rew= "<#311>";
      else if (r == "punderbrace") rew= "<#23DD>";
      else if (r == "punderbrace*") rew= "<#23DD>";
      else if (r == "underbrace") rew= "<#23DF>";
      else if (r == "underbrace*") rew= "<#23DF>";
      else if (r == "squnderbrace") rew= "<#23B5>";
      else if (r == "squnderbrace*") rew= "<#23B5>";
      else if (r == "poverbrace") rew= "<#23DC>";
      else if (r == "poverbrace*") rew= "<#23DC>";
      else if (r == "overbrace") rew= "<#23DE>";
      else if (r == "overbrace*") rew= "<#23DE>";
      else if (r == "sqoverbrace") rew= "<#23B4>";
      else if (r == "sqoverbrace*") rew= "<#23B4>";
      else {
        rew= s;
        return 0;
      }
      if (nr == 0) return 0;
      else return 10 + nr;
    }
  }
  rew= s;
  return 0;
}
 void PorterStemmer::step5() {
   if (k == k0) return; /* for Bug 1 */
   switch (b[k-1]) {
   case 'a':
     if (ends(_T("al"))) break;
     return;
   case 'c':
     if (ends(_T("ance"))) break;
     if (ends(_T("ence"))) break;
     return;
   case 'e':
     if (ends(_T("er"))) break; return;
   case 'i':
     if (ends(_T("ic"))) break; return;
   case 'l':
     if (ends(_T("able"))) break;
     if (ends(_T("ible"))) break; return;
   case 'n':
     if (ends(_T("ant"))) break;
     if (ends(_T("ement"))) break;
     if (ends(_T("ment"))) break;
     /* element etc. not stripped before the m */
     if (ends(_T("ent"))) break;
     return;
   case 'o':
     if (ends(_T("ion")) && j >= 0 && (b[j] == 's' || b[j] == 't')) break;
     /* j >= 0 fixes Bug 2 */
     if (ends(_T("ou"))) break;
     return;
     /* takes care of -ous */
   case 's':
     if (ends(_T("ism"))) break;
     return;
   case 't':
     if (ends(_T("ate"))) break;
     if (ends(_T("iti"))) break;
     return;
   case 'u':
     if (ends(_T("ous"))) break;
     return;
   case 'v':
     if (ends(_T("ive"))) break;
     return;
   case 'z':
     if (ends(_T("ize"))) break;
     return;
   default:
     return;
   }
   if (m() > 1)
     k = j;
 }
Exemple #16
0
static void step2() {

    switch (b[k - 1]) {

        case 'a':
            if (ends("\07" "ational")) {
                r("\03" "ate");
                break;
            }
            if (ends("\06" "tional")) {
                r("\04" "tion");
                break;
            }
            break;

        case 'c':
            if (ends("\04" "enci")) {
                r("\04" "ence");
                break;
            }
            if (ends("\04" "anci")) {
                r("\04" "ance");
                break;
            }
            break;

        case 'e':
            if (ends("\04" "izer")) {
                r("\03" "ize");
                break;
            }
            break;

        case 'l':
            if (ends("\03" "bli")) {
                r("\03" "ble");
                break;
            }

// DEPARTURE: To match the published algorithm, replace the above if clause with
//          if (ends("\04" "abli")) {
//              r("\04" "able");
//              break;
//           }

            if (ends("\04" "alli")) {
                r("\02" "al");
                break;
            }
            if (ends("\05" "entli")) {
                r("\03" "ent");
                break;
            }
            if (ends("\03" "eli")) {
                r("\01" "e");
                break;
            }
            if (ends("\05" "ousli")) {
                r("\03" "ous");
                break;
            }
            break;

        case 'o':
            if (ends("\07" "ization")) {
                r("\03" "ize");
                break;
            }
            if (ends("\05" "ation")) {
                r("\03" "ate");
                break;
            }
            if (ends("\04" "ator")) {
                r("\03" "ate");
                break;
            }
            break;

        case 's':
            if (ends("\05" "alism")) {
                r("\02" "al");
                break;
            }
            if (ends("\07" "iveness")) {
                r("\03" "ive");
                break;
            }
            if (ends("\07" "fulness")) {
                r("\03" "ful");
                break;
            }
            if (ends("\07" "ousness")) {
                r("\03" "ous");
                break;
            }
            break;

        case 't':
            if (ends("\05" "aliti")) {
                r("\02" "al");
                break;
            }
            if (ends("\05" "iviti")) {
                r("\03" "ive");
                break;
            }
            if (ends("\06" "biliti")) {
                r("\03" "ble");
                break;
            }
            break;

// DEPARTURE: To match the published algorithm, delete this next case statement

        case 'g':
            if (ends("\04" "logi")) {
               r("\03" "log");
               break;
            }

    }
}
void step1c() { if (ends("\01" "y") && vowelinstem()) b[k] = 'i'; }
IloModel ReadModel(IloEnv env, const char* filename,
                   IloConstraintArray& capacityCts,
                   IloConstraintArray& precedenceCts) {
  std::ifstream file(filename);
  if (!file){
    env.out() << "usage: sched_conflict <file> <failLimit>" << std::endl;
    throw FileError();
  }
  IloModel model(env);
  IloInt nbTasks, nbResources, i, j;
  file >> nbTasks;
  file >> nbResources;
  IloCumulFunctionExprArray resources(env, nbResources);
  IloIntArray capacities(env, nbResources);
  for (j=0; j<nbResources; j++) {
    IloInt c;
    file >> c;
    capacities[j] = c;
    resources[j] = IloCumulFunctionExpr(env);
  }
  IloIntervalVarArray tasks(env, nbTasks);
  char name[32];
  for (i=0; i<nbTasks; i++) {
    sprintf(name, "ACT%ld", i);
    tasks[i] = IloIntervalVar(env, name);
    ILOSETLOCATION(tasks[i]);
  }
  IloIntExprArray ends(env);
  for (i=0; i<nbTasks; i++) {
    IloIntervalVar task = tasks[i];
    IloInt d, smin, emax, nbSucc;
    file >> d >> smin >> emax;
    task.setSizeMin(d);
    task.setSizeMax(d);
    task.setStartMin(smin);
    task.setEndMax(emax);
    ends.add(IloEndOf(task));
    for (j = 0; j < nbResources; j++) {
      IloInt q;
      file >> q;
      if (q > 0) {
        resources[j] += IloPulse(task, q);
      }
    }
    file >> nbSucc;
    for (IloInt s=0; s<nbSucc; ++s) {
      IloInt succ;
      file >> succ;
      IloConstraint pct = IloEndBeforeStart(env, task, tasks[succ]);
      ILOADD(model, pct);
      precedenceCts.add(pct);
    }
  }
  for (j=0; j<nbResources; j++) {
    sprintf(name, "RES%ld", j);
    resources[j].setName(name);
    IloConstraint cct = (resources[j] <= capacities[j]);
    ILOADD(model, cct);
    capacityCts.add(cct);
  }
  model.add(IloMinimize(env, IloMax(ends)));
  return model;
}