001 /**
002 * Copyright (C) 2007-2008, Jens Lehmann
003 *
004 * This file is part of DL-Learner.
005 *
006 * DL-Learner is free software; you can redistribute it and/or modify
007 * it under the terms of the GNU General Public License as published by
008 * the Free Software Foundation; either version 3 of the License, or
009 * (at your option) any later version.
010 *
011 * DL-Learner is distributed in the hope that it will be useful,
012 * but WITHOUT ANY WARRANTY; without even the implied warranty of
013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
014 * GNU General Public License for more details.
015 *
016 * You should have received a copy of the GNU General Public License
017 * along with this program. If not, see <http://www.gnu.org/licenses/>.
018 *
019 */
020
021 package org.dllearner.core.configurators;
022
023 import java.util.Set;
024 import org.dllearner.algorithms.refinement2.ROLComponent2;
025 import org.dllearner.core.ComponentManager;
026 import org.dllearner.core.LearningProblem;
027 import org.dllearner.core.LearningProblemUnsupportedException;
028 import org.dllearner.core.ReasonerComponent;
029
030 /**
031 * automatically generated, do not edit manually.
032 * run org.dllearner.scripts.ConfigJavaGenerator to update
033 **/
034 public class ROLComponent2Configurator implements Configurator {
035
036 private boolean reinitNecessary = false;
037 @SuppressWarnings("unused")
038
039 private ROLComponent2 rOLComponent2;
040
041 /**
042 * @param rOLComponent2 see ROLComponent2
043 **/
044 public ROLComponent2Configurator(ROLComponent2 rOLComponent2){
045 this.rOLComponent2 = rOLComponent2;
046 }
047
048 /**
049 * @param reasoningService see reasoningService
050 * @param learningProblem see learningProblem
051 * @throws LearningProblemUnsupportedException see
052 * @return ROLComponent2
053 **/
054 public static ROLComponent2 getROLComponent2(LearningProblem learningProblem, ReasonerComponent reasoningService) throws LearningProblemUnsupportedException{
055 ROLComponent2 component = ComponentManager.getInstance().learningAlgorithm(ROLComponent2.class, learningProblem, reasoningService);
056 return component;
057 }
058
059 /**
060 * writeSearchTree specifies whether to write a search tree.
061 * mandatory: false| reinit necessary: true
062 * default value: false
063 * @return boolean
064 **/
065 public boolean getWriteSearchTree() {
066 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "writeSearchTree") ;
067 }
068 /**
069 * searchTreeFile file to use for the search tree.
070 * mandatory: false| reinit necessary: true
071 * default value: log/searchTree.txt
072 * @return String
073 **/
074 public String getSearchTreeFile() {
075 return (String) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "searchTreeFile") ;
076 }
077 /**
078 * replaceSearchTree specifies whether to replace the search tree in the log file after each run or append the new search tree.
079 * mandatory: false| reinit necessary: true
080 * default value: false
081 * @return boolean
082 **/
083 public boolean getReplaceSearchTree() {
084 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "replaceSearchTree") ;
085 }
086 /**
087 * heuristic specifiy the heuristic to use.
088 * mandatory: false| reinit necessary: true
089 * default value: lexicographic
090 * @return String
091 **/
092 public String getHeuristic() {
093 return (String) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "heuristic") ;
094 }
095 /**
096 * applyAllFilter usage of equivalence ALL R.C AND ALL R.D = ALL R.(C AND D).
097 * mandatory: false| reinit necessary: true
098 * default value: true
099 * @return boolean
100 **/
101 public boolean getApplyAllFilter() {
102 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "applyAllFilter") ;
103 }
104 /**
105 * applyExistsFilter usage of equivalence EXISTS R.C OR EXISTS R.D = EXISTS R.(C OR D).
106 * mandatory: false| reinit necessary: true
107 * default value: true
108 * @return boolean
109 **/
110 public boolean getApplyExistsFilter() {
111 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "applyExistsFilter") ;
112 }
113 /**
114 * useTooWeakList try to filter out too weak concepts without sending them to the reasoner.
115 * mandatory: false| reinit necessary: true
116 * default value: true
117 * @return boolean
118 **/
119 public boolean getUseTooWeakList() {
120 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useTooWeakList") ;
121 }
122 /**
123 * useOverlyGeneralList try to find overly general concept without sending them to the reasoner.
124 * mandatory: false| reinit necessary: true
125 * default value: true
126 * @return boolean
127 **/
128 public boolean getUseOverlyGeneralList() {
129 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useOverlyGeneralList") ;
130 }
131 /**
132 * useShortConceptConstruction shorten concept to see whether they already exist.
133 * mandatory: false| reinit necessary: true
134 * default value: true
135 * @return boolean
136 **/
137 public boolean getUseShortConceptConstruction() {
138 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useShortConceptConstruction") ;
139 }
140 /**
141 * horizontalExpansionFactor horizontal expansion factor (see publication for description).
142 * mandatory: false| reinit necessary: true
143 * default value: 0.6
144 * @return double
145 **/
146 public double getHorizontalExpansionFactor() {
147 return (Double) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "horizontalExpansionFactor") ;
148 }
149 /**
150 * improveSubsumptionHierarchy simplify subsumption hierarchy to reduce search space (see publication for description).
151 * mandatory: false| reinit necessary: true
152 * default value: true
153 * @return boolean
154 **/
155 public boolean getImproveSubsumptionHierarchy() {
156 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "improveSubsumptionHierarchy") ;
157 }
158 /**
159 * allowedConcepts concepts the algorithm is allowed to use.
160 * mandatory: false| reinit necessary: true
161 * default value: null
162 * @return Set(String)
163 **/
164 @SuppressWarnings("unchecked")
165 public Set<String> getAllowedConcepts() {
166 return (Set<String>) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "allowedConcepts") ;
167 }
168 /**
169 * ignoredConcepts concepts the algorithm must ignore.
170 * mandatory: false| reinit necessary: true
171 * default value: null
172 * @return Set(String)
173 **/
174 @SuppressWarnings("unchecked")
175 public Set<String> getIgnoredConcepts() {
176 return (Set<String>) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "ignoredConcepts") ;
177 }
178 /**
179 * allowedRoles roles the algorithm is allowed to use.
180 * mandatory: false| reinit necessary: true
181 * default value: null
182 * @return Set(String)
183 **/
184 @SuppressWarnings("unchecked")
185 public Set<String> getAllowedRoles() {
186 return (Set<String>) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "allowedRoles") ;
187 }
188 /**
189 * ignoredRoles roles the algorithm must ignore.
190 * mandatory: false| reinit necessary: true
191 * default value: null
192 * @return Set(String)
193 **/
194 @SuppressWarnings("unchecked")
195 public Set<String> getIgnoredRoles() {
196 return (Set<String>) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "ignoredRoles") ;
197 }
198 /**
199 * useAllConstructor specifies whether the universal concept constructor is used in the learning algorithm.
200 * mandatory: false| reinit necessary: true
201 * default value: true
202 * @return boolean
203 **/
204 public boolean getUseAllConstructor() {
205 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useAllConstructor") ;
206 }
207 /**
208 * useExistsConstructor specifies whether the existential concept constructor is used in the learning algorithm.
209 * mandatory: false| reinit necessary: true
210 * default value: true
211 * @return boolean
212 **/
213 public boolean getUseExistsConstructor() {
214 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useExistsConstructor") ;
215 }
216 /**
217 * useHasValueConstructor specifies whether the hasValue constructor is used in the learning algorithm.
218 * mandatory: false| reinit necessary: true
219 * default value: false
220 * @return boolean
221 **/
222 public boolean getUseHasValueConstructor() {
223 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useHasValueConstructor") ;
224 }
225 /**
226 * valueFrequencyThreshold specifies how often an object must occur as value in order to be considered for hasValue restrictions.
227 * mandatory: false| reinit necessary: true
228 * default value: 3
229 * @return int
230 **/
231 public int getValueFrequencyThreshold() {
232 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "valueFrequencyThreshold") ;
233 }
234 /**
235 * useCardinalityRestrictions specifies whether CardinalityRestrictions is used in the learning algorithm.
236 * mandatory: false| reinit necessary: true
237 * default value: true
238 * @return boolean
239 **/
240 public boolean getUseCardinalityRestrictions() {
241 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useCardinalityRestrictions") ;
242 }
243 /**
244 * cardinalityLimit Gives the maximum number used in cardinality restrictions..
245 * mandatory: false| reinit necessary: true
246 * default value: 5
247 * @return int
248 **/
249 public int getCardinalityLimit() {
250 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "cardinalityLimit") ;
251 }
252 /**
253 * useNegation specifies whether negation is used in the learning algorothm.
254 * mandatory: false| reinit necessary: true
255 * default value: true
256 * @return boolean
257 **/
258 public boolean getUseNegation() {
259 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useNegation") ;
260 }
261 /**
262 * useBooleanDatatypes specifies whether boolean datatypes are used in the learning algorothm.
263 * mandatory: false| reinit necessary: true
264 * default value: true
265 * @return boolean
266 **/
267 public boolean getUseBooleanDatatypes() {
268 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useBooleanDatatypes") ;
269 }
270 /**
271 * useDoubleDatatypes specifies whether boolean datatypes are used in the learning algorothm.
272 * mandatory: false| reinit necessary: true
273 * default value: true
274 * @return boolean
275 **/
276 public boolean getUseDoubleDatatypes() {
277 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "useDoubleDatatypes") ;
278 }
279 /**
280 * maxExecutionTimeInSeconds algorithm will stop after specified seconds.
281 * mandatory: false| reinit necessary: true
282 * default value: 0
283 * @return int
284 **/
285 public int getMaxExecutionTimeInSeconds() {
286 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "maxExecutionTimeInSeconds") ;
287 }
288 /**
289 * minExecutionTimeInSeconds algorithm will run at least specified seconds.
290 * mandatory: false| reinit necessary: true
291 * default value: 0
292 * @return int
293 **/
294 public int getMinExecutionTimeInSeconds() {
295 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "minExecutionTimeInSeconds") ;
296 }
297 /**
298 * guaranteeXgoodDescriptions algorithm will run until X good (100%) concept descritpions are found.
299 * mandatory: false| reinit necessary: true
300 * default value: 1
301 * @return int
302 **/
303 public int getGuaranteeXgoodDescriptions() {
304 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "guaranteeXgoodDescriptions") ;
305 }
306 /**
307 * maxClassDescriptionTests The maximum number of candidate hypothesis the algorithm is allowed to test (0 = no limit). The algorithm will stop afterwards. (The real number of tests can be slightly higher, because this criterion usually won't be checked after each single test.).
308 * mandatory: false| reinit necessary: true
309 * default value: 0
310 * @return int
311 **/
312 public int getMaxClassDescriptionTests() {
313 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "maxClassDescriptionTests") ;
314 }
315 /**
316 * logLevel determines the logLevel for this component, can be {TRACE, DEBUG, INFO}.
317 * mandatory: false| reinit necessary: true
318 * default value: DEBUG
319 * @return String
320 **/
321 public String getLogLevel() {
322 return (String) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "logLevel") ;
323 }
324 /**
325 * usePropernessChecks specifies whether to check for equivalence (i.e. discard equivalent refinements).
326 * mandatory: false| reinit necessary: true
327 * default value: false
328 * @return boolean
329 **/
330 public boolean getUsePropernessChecks() {
331 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "usePropernessChecks") ;
332 }
333 /**
334 * maxPosOnlyExpansion specifies how often a node in the search tree of a posonly learning problem needs to be expanded before it is considered as solution candidate.
335 * mandatory: false| reinit necessary: true
336 * default value: 4
337 * @return int
338 **/
339 public int getMaxPosOnlyExpansion() {
340 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "maxPosOnlyExpansion") ;
341 }
342 /**
343 * noisePercentage the (approximated) percentage of noise within the examples.
344 * mandatory: false| reinit necessary: true
345 * default value: 0.0
346 * @return double
347 **/
348 public double getNoisePercentage() {
349 return (Double) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "noisePercentage") ;
350 }
351 /**
352 * terminateOnNoiseReached specifies whether to terminate when noise criterion is met.
353 * mandatory: false| reinit necessary: true
354 * default value: true
355 * @return boolean
356 **/
357 public boolean getTerminateOnNoiseReached() {
358 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "terminateOnNoiseReached") ;
359 }
360 /**
361 * startClass the named class which should be used to start the algorithm (GUI: needs a widget for selecting a class).
362 * mandatory: false| reinit necessary: true
363 * default value: null
364 * @return String
365 **/
366 public String getStartClass() {
367 return (String) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "startClass") ;
368 }
369 /**
370 * forceRefinementLengthIncrease specifies whether nodes should be expanded until only longer refinements are reached.
371 * mandatory: false| reinit necessary: true
372 * default value: null
373 * @return boolean
374 **/
375 public boolean getForceRefinementLengthIncrease() {
376 return (Boolean) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "forceRefinementLengthIncrease") ;
377 }
378 /**
379 * negativeWeight Used to penalise errors on negative examples different from those of positive examples (lower = less importance for negatives)..
380 * mandatory: false| reinit necessary: true
381 * default value: 1.0
382 * @return double
383 **/
384 public double getNegativeWeight() {
385 return (Double) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "negativeWeight") ;
386 }
387 /**
388 * startNodeBonus You can use this to give a heuristic bonus on the start node (= initially broader exploration of search space)..
389 * mandatory: false| reinit necessary: true
390 * default value: 0.0
391 * @return double
392 **/
393 public double getStartNodeBonus() {
394 return (Double) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "startNodeBonus") ;
395 }
396 /**
397 * negationPenalty Penalty on negations (TODO: better explanation)..
398 * mandatory: false| reinit necessary: true
399 * default value: 0
400 * @return int
401 **/
402 public int getNegationPenalty() {
403 return (Integer) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "negationPenalty") ;
404 }
405 /**
406 * expansionPenaltyFactor describes the reduction in heuristic score one is willing to accept for reducing the length of the concept by one.
407 * mandatory: false| reinit necessary: true
408 * default value: 0.02
409 * @return double
410 **/
411 public double getExpansionPenaltyFactor() {
412 return (Double) ComponentManager.getInstance().getConfigOptionValue(rOLComponent2, "expansionPenaltyFactor") ;
413 }
414
415 /**
416 * @param writeSearchTree specifies whether to write a search tree.
417 * mandatory: false| reinit necessary: true
418 * default value: false
419 **/
420 public void setWriteSearchTree(boolean writeSearchTree) {
421 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "writeSearchTree", writeSearchTree);
422 reinitNecessary = true;
423 }
424 /**
425 * @param searchTreeFile file to use for the search tree.
426 * mandatory: false| reinit necessary: true
427 * default value: log/searchTree.txt
428 **/
429 public void setSearchTreeFile(String searchTreeFile) {
430 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "searchTreeFile", searchTreeFile);
431 reinitNecessary = true;
432 }
433 /**
434 * @param replaceSearchTree specifies whether to replace the search tree in the log file after each run or append the new search tree.
435 * mandatory: false| reinit necessary: true
436 * default value: false
437 **/
438 public void setReplaceSearchTree(boolean replaceSearchTree) {
439 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "replaceSearchTree", replaceSearchTree);
440 reinitNecessary = true;
441 }
442 /**
443 * @param heuristic specifiy the heuristic to use.
444 * mandatory: false| reinit necessary: true
445 * default value: lexicographic
446 **/
447 public void setHeuristic(String heuristic) {
448 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "heuristic", heuristic);
449 reinitNecessary = true;
450 }
451 /**
452 * @param applyAllFilter usage of equivalence ALL R.C AND ALL R.D = ALL R.(C AND D).
453 * mandatory: false| reinit necessary: true
454 * default value: true
455 **/
456 public void setApplyAllFilter(boolean applyAllFilter) {
457 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "applyAllFilter", applyAllFilter);
458 reinitNecessary = true;
459 }
460 /**
461 * @param applyExistsFilter usage of equivalence EXISTS R.C OR EXISTS R.D = EXISTS R.(C OR D).
462 * mandatory: false| reinit necessary: true
463 * default value: true
464 **/
465 public void setApplyExistsFilter(boolean applyExistsFilter) {
466 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "applyExistsFilter", applyExistsFilter);
467 reinitNecessary = true;
468 }
469 /**
470 * @param useTooWeakList try to filter out too weak concepts without sending them to the reasoner.
471 * mandatory: false| reinit necessary: true
472 * default value: true
473 **/
474 public void setUseTooWeakList(boolean useTooWeakList) {
475 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useTooWeakList", useTooWeakList);
476 reinitNecessary = true;
477 }
478 /**
479 * @param useOverlyGeneralList try to find overly general concept without sending them to the reasoner.
480 * mandatory: false| reinit necessary: true
481 * default value: true
482 **/
483 public void setUseOverlyGeneralList(boolean useOverlyGeneralList) {
484 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useOverlyGeneralList", useOverlyGeneralList);
485 reinitNecessary = true;
486 }
487 /**
488 * @param useShortConceptConstruction shorten concept to see whether they already exist.
489 * mandatory: false| reinit necessary: true
490 * default value: true
491 **/
492 public void setUseShortConceptConstruction(boolean useShortConceptConstruction) {
493 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useShortConceptConstruction", useShortConceptConstruction);
494 reinitNecessary = true;
495 }
496 /**
497 * @param horizontalExpansionFactor horizontal expansion factor (see publication for description).
498 * mandatory: false| reinit necessary: true
499 * default value: 0.6
500 **/
501 public void setHorizontalExpansionFactor(double horizontalExpansionFactor) {
502 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "horizontalExpansionFactor", horizontalExpansionFactor);
503 reinitNecessary = true;
504 }
505 /**
506 * @param improveSubsumptionHierarchy simplify subsumption hierarchy to reduce search space (see publication for description).
507 * mandatory: false| reinit necessary: true
508 * default value: true
509 **/
510 public void setImproveSubsumptionHierarchy(boolean improveSubsumptionHierarchy) {
511 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "improveSubsumptionHierarchy", improveSubsumptionHierarchy);
512 reinitNecessary = true;
513 }
514 /**
515 * @param allowedConcepts concepts the algorithm is allowed to use.
516 * mandatory: false| reinit necessary: true
517 * default value: null
518 **/
519 public void setAllowedConcepts(Set<String> allowedConcepts) {
520 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "allowedConcepts", allowedConcepts);
521 reinitNecessary = true;
522 }
523 /**
524 * @param ignoredConcepts concepts the algorithm must ignore.
525 * mandatory: false| reinit necessary: true
526 * default value: null
527 **/
528 public void setIgnoredConcepts(Set<String> ignoredConcepts) {
529 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "ignoredConcepts", ignoredConcepts);
530 reinitNecessary = true;
531 }
532 /**
533 * @param allowedRoles roles the algorithm is allowed to use.
534 * mandatory: false| reinit necessary: true
535 * default value: null
536 **/
537 public void setAllowedRoles(Set<String> allowedRoles) {
538 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "allowedRoles", allowedRoles);
539 reinitNecessary = true;
540 }
541 /**
542 * @param ignoredRoles roles the algorithm must ignore.
543 * mandatory: false| reinit necessary: true
544 * default value: null
545 **/
546 public void setIgnoredRoles(Set<String> ignoredRoles) {
547 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "ignoredRoles", ignoredRoles);
548 reinitNecessary = true;
549 }
550 /**
551 * @param useAllConstructor specifies whether the universal concept constructor is used in the learning algorithm.
552 * mandatory: false| reinit necessary: true
553 * default value: true
554 **/
555 public void setUseAllConstructor(boolean useAllConstructor) {
556 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useAllConstructor", useAllConstructor);
557 reinitNecessary = true;
558 }
559 /**
560 * @param useExistsConstructor specifies whether the existential concept constructor is used in the learning algorithm.
561 * mandatory: false| reinit necessary: true
562 * default value: true
563 **/
564 public void setUseExistsConstructor(boolean useExistsConstructor) {
565 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useExistsConstructor", useExistsConstructor);
566 reinitNecessary = true;
567 }
568 /**
569 * @param useHasValueConstructor specifies whether the hasValue constructor is used in the learning algorithm.
570 * mandatory: false| reinit necessary: true
571 * default value: false
572 **/
573 public void setUseHasValueConstructor(boolean useHasValueConstructor) {
574 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useHasValueConstructor", useHasValueConstructor);
575 reinitNecessary = true;
576 }
577 /**
578 * @param valueFrequencyThreshold specifies how often an object must occur as value in order to be considered for hasValue restrictions.
579 * mandatory: false| reinit necessary: true
580 * default value: 3
581 **/
582 public void setValueFrequencyThreshold(int valueFrequencyThreshold) {
583 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "valueFrequencyThreshold", valueFrequencyThreshold);
584 reinitNecessary = true;
585 }
586 /**
587 * @param useCardinalityRestrictions specifies whether CardinalityRestrictions is used in the learning algorithm.
588 * mandatory: false| reinit necessary: true
589 * default value: true
590 **/
591 public void setUseCardinalityRestrictions(boolean useCardinalityRestrictions) {
592 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useCardinalityRestrictions", useCardinalityRestrictions);
593 reinitNecessary = true;
594 }
595 /**
596 * @param cardinalityLimit Gives the maximum number used in cardinality restrictions..
597 * mandatory: false| reinit necessary: true
598 * default value: 5
599 **/
600 public void setCardinalityLimit(int cardinalityLimit) {
601 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "cardinalityLimit", cardinalityLimit);
602 reinitNecessary = true;
603 }
604 /**
605 * @param useNegation specifies whether negation is used in the learning algorothm.
606 * mandatory: false| reinit necessary: true
607 * default value: true
608 **/
609 public void setUseNegation(boolean useNegation) {
610 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useNegation", useNegation);
611 reinitNecessary = true;
612 }
613 /**
614 * @param useBooleanDatatypes specifies whether boolean datatypes are used in the learning algorothm.
615 * mandatory: false| reinit necessary: true
616 * default value: true
617 **/
618 public void setUseBooleanDatatypes(boolean useBooleanDatatypes) {
619 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useBooleanDatatypes", useBooleanDatatypes);
620 reinitNecessary = true;
621 }
622 /**
623 * @param useDoubleDatatypes specifies whether boolean datatypes are used in the learning algorothm.
624 * mandatory: false| reinit necessary: true
625 * default value: true
626 **/
627 public void setUseDoubleDatatypes(boolean useDoubleDatatypes) {
628 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "useDoubleDatatypes", useDoubleDatatypes);
629 reinitNecessary = true;
630 }
631 /**
632 * @param maxExecutionTimeInSeconds algorithm will stop after specified seconds.
633 * mandatory: false| reinit necessary: true
634 * default value: 0
635 **/
636 public void setMaxExecutionTimeInSeconds(int maxExecutionTimeInSeconds) {
637 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "maxExecutionTimeInSeconds", maxExecutionTimeInSeconds);
638 reinitNecessary = true;
639 }
640 /**
641 * @param minExecutionTimeInSeconds algorithm will run at least specified seconds.
642 * mandatory: false| reinit necessary: true
643 * default value: 0
644 **/
645 public void setMinExecutionTimeInSeconds(int minExecutionTimeInSeconds) {
646 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "minExecutionTimeInSeconds", minExecutionTimeInSeconds);
647 reinitNecessary = true;
648 }
649 /**
650 * @param guaranteeXgoodDescriptions algorithm will run until X good (100%) concept descritpions are found.
651 * mandatory: false| reinit necessary: true
652 * default value: 1
653 **/
654 public void setGuaranteeXgoodDescriptions(int guaranteeXgoodDescriptions) {
655 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "guaranteeXgoodDescriptions", guaranteeXgoodDescriptions);
656 reinitNecessary = true;
657 }
658 /**
659 * @param maxClassDescriptionTests The maximum number of candidate hypothesis the algorithm is allowed to test (0 = no limit). The algorithm will stop afterwards. (The real number of tests can be slightly higher, because this criterion usually won't be checked after each single test.).
660 * mandatory: false| reinit necessary: true
661 * default value: 0
662 **/
663 public void setMaxClassDescriptionTests(int maxClassDescriptionTests) {
664 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "maxClassDescriptionTests", maxClassDescriptionTests);
665 reinitNecessary = true;
666 }
667 /**
668 * @param logLevel determines the logLevel for this component, can be {TRACE, DEBUG, INFO}.
669 * mandatory: false| reinit necessary: true
670 * default value: DEBUG
671 **/
672 public void setLogLevel(String logLevel) {
673 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "logLevel", logLevel);
674 reinitNecessary = true;
675 }
676 /**
677 * @param usePropernessChecks specifies whether to check for equivalence (i.e. discard equivalent refinements).
678 * mandatory: false| reinit necessary: true
679 * default value: false
680 **/
681 public void setUsePropernessChecks(boolean usePropernessChecks) {
682 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "usePropernessChecks", usePropernessChecks);
683 reinitNecessary = true;
684 }
685 /**
686 * @param maxPosOnlyExpansion specifies how often a node in the search tree of a posonly learning problem needs to be expanded before it is considered as solution candidate.
687 * mandatory: false| reinit necessary: true
688 * default value: 4
689 **/
690 public void setMaxPosOnlyExpansion(int maxPosOnlyExpansion) {
691 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "maxPosOnlyExpansion", maxPosOnlyExpansion);
692 reinitNecessary = true;
693 }
694 /**
695 * @param noisePercentage the (approximated) percentage of noise within the examples.
696 * mandatory: false| reinit necessary: true
697 * default value: 0.0
698 **/
699 public void setNoisePercentage(double noisePercentage) {
700 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "noisePercentage", noisePercentage);
701 reinitNecessary = true;
702 }
703 /**
704 * @param terminateOnNoiseReached specifies whether to terminate when noise criterion is met.
705 * mandatory: false| reinit necessary: true
706 * default value: true
707 **/
708 public void setTerminateOnNoiseReached(boolean terminateOnNoiseReached) {
709 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "terminateOnNoiseReached", terminateOnNoiseReached);
710 reinitNecessary = true;
711 }
712 /**
713 * @param startClass the named class which should be used to start the algorithm (GUI: needs a widget for selecting a class).
714 * mandatory: false| reinit necessary: true
715 * default value: null
716 **/
717 public void setStartClass(String startClass) {
718 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "startClass", startClass);
719 reinitNecessary = true;
720 }
721 /**
722 * @param forceRefinementLengthIncrease specifies whether nodes should be expanded until only longer refinements are reached.
723 * mandatory: false| reinit necessary: true
724 * default value: null
725 **/
726 public void setForceRefinementLengthIncrease(boolean forceRefinementLengthIncrease) {
727 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "forceRefinementLengthIncrease", forceRefinementLengthIncrease);
728 reinitNecessary = true;
729 }
730 /**
731 * @param negativeWeight Used to penalise errors on negative examples different from those of positive examples (lower = less importance for negatives)..
732 * mandatory: false| reinit necessary: true
733 * default value: 1.0
734 **/
735 public void setNegativeWeight(double negativeWeight) {
736 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "negativeWeight", negativeWeight);
737 reinitNecessary = true;
738 }
739 /**
740 * @param startNodeBonus You can use this to give a heuristic bonus on the start node (= initially broader exploration of search space)..
741 * mandatory: false| reinit necessary: true
742 * default value: 0.0
743 **/
744 public void setStartNodeBonus(double startNodeBonus) {
745 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "startNodeBonus", startNodeBonus);
746 reinitNecessary = true;
747 }
748 /**
749 * @param negationPenalty Penalty on negations (TODO: better explanation)..
750 * mandatory: false| reinit necessary: true
751 * default value: 0
752 **/
753 public void setNegationPenalty(int negationPenalty) {
754 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "negationPenalty", negationPenalty);
755 reinitNecessary = true;
756 }
757 /**
758 * @param expansionPenaltyFactor describes the reduction in heuristic score one is willing to accept for reducing the length of the concept by one.
759 * mandatory: false| reinit necessary: true
760 * default value: 0.02
761 **/
762 public void setExpansionPenaltyFactor(double expansionPenaltyFactor) {
763 ComponentManager.getInstance().applyConfigEntry(rOLComponent2, "expansionPenaltyFactor", expansionPenaltyFactor);
764 reinitNecessary = true;
765 }
766
767 /**
768 * true, if this component needs reinitializsation.
769 * @return boolean
770 **/
771 public boolean isReinitNecessary(){
772 return reinitNecessary;
773 }
774
775
776 }