Examples with Type com.sri.ai.expresso.api.Type used on opensource projects

Example 36 with Type

use of com.sri.ai.expresso.api.Type in project aic-expresso by aic-sri-international.

the class DefaultRegistry method makeNewContextWithAddedType.

@Override
public DefaultRegistry makeNewContextWithAddedType(Type type) {
    DefaultRegistry result = clone();
    String name = type.getName();
    Expression typeExpression = parse(name);
    LinkedHashMap<Expression, Type> additionalTypeMap = map(typeExpression, type);
    result.fromTypeExpressionToType = new StackedHashMap<>(additionalTypeMap, fromTypeExpressionToType);
    return result;
}

Example 37 with Type

use of com.sri.ai.expresso.api.Type in project aic-expresso by aic-sri-international.

the class TrueContext method getType.

@Override
public Type getType(String name) {
    Expression typeExpression = parse(name);
    Type result = getTypeFromTypeExpression(typeExpression);
    return result;
}

Example 38 with Type

use of com.sri.ai.expresso.api.Type in project aic-expresso by aic-sri-international.

the class AbstractTheoryTestingSupport method extendWithTestingInformation.

@Override
public Context extendWithTestingInformation(Context context) {
    // we only need to provide the variables types, and not the known constant types, because the latter will be extracted from the already registered types.
    Map<String, String> mapFromSymbolNamesToTypeNames = new LinkedHashMap<String, String>();
    for (Map.Entry<String, Type> symbolAndType : getVariableNamesAndTypesForTesting().entrySet()) {
        mapFromSymbolNamesToTypeNames.put(symbolAndType.getKey(), symbolAndType.getValue().toString());
    }
    for (Map.Entry<String, Type> symbolAndType : getExtendedVariableNamesAndTypesForTesting().entrySet()) {
        mapFromSymbolNamesToTypeNames.put(symbolAndType.getKey(), symbolAndType.getValue().toString());
    }
    Context result = (Context) GrinderUtil.extendRegistryWith(mapFromSymbolNamesToTypeNames, getTypesForTesting(), context);
    return result;
}

Example 39 with Type

use of com.sri.ai.expresso.api.Type in project aic-expresso by aic-sri-international.

the class AbstractTheoryTestingSupport method getTypesForTesting.

@Override
public Collection<Type> getTypesForTesting() {
    if (cachedTypesForTesting == null) {
        Set<Type> topTypesForTesting = new LinkedHashSet<>(getVariableNamesAndTypesForTesting().values());
        topTypesForTesting.addAll(getTheory().getNativeTypes());
        // Ensure we include embedded types (e.g. in a function or tuple type) as well
        Set<Type> embeddedTypes = new LinkedHashSet<>();
        for (Type topType : topTypesForTesting) {
            embeddedTypes.addAll(topType.getEmbeddedTypes());
        }
        topTypesForTesting.addAll(embeddedTypes);
        cachedTypesForTesting = Collections.unmodifiableCollection(topTypesForTesting);
    }
    return cachedTypesForTesting;
}

Example 40 with Type

use of com.sri.ai.expresso.api.Type in project aic-expresso by aic-sri-international.

the class AssignmentsSamplingIterator method getTypeToSampleFrom.

public static Type getTypeToSampleFrom(Expression variable, Expression condition, Context context) {
    Type result = GrinderUtil.getTypeOfExpression(variable, context);
    if (result instanceof FunctionType) {
        FunctionType functionType = (FunctionType) result;
        result = new LazySampledFunctionType(functionType.getCodomain(), functionType.getArgumentTypes().toArray(new Type[functionType.getArity()]));
    } else {
        if (condition.equals(false)) {
            result = null;
        } else if (condition.equals(true)) {
        // we leave as is.
        } else if (result instanceof RealExpressoType || result instanceof RealInterval) {
            LinearRealArithmeticTheory theory = new LinearRealArithmeticTheory(true, true);
            SingleVariableLinearRealArithmeticConstraint constraint = (SingleVariableLinearRealArithmeticConstraint) theory.makeSingleVariableConstraint(variable, context);
            constraint = (SingleVariableLinearRealArithmeticConstraint) constraint.conjoin(condition, context);
            IntervalWithMeasureEquivalentToSingleVariableLinearRealArithmeticConstraintStepSolver solver = new IntervalWithMeasureEquivalentToSingleVariableLinearRealArithmeticConstraintStepSolver(constraint);
            Expression realInterval = solver.solve(context);
            if (Sets.isEmptySet(realInterval)) {
                // used to indicate an empty set.
                result = null;
            } else if (ExtensionalSets.isExtensionalSet(realInterval) && ExtensionalSets.isSingleton(realInterval)) {
                String singletonValue = realInterval.get(0).toString();
                result = new RealInterval("[" + singletonValue + ";" + singletonValue + "]");
            } else {
                result = new RealInterval(realInterval.toString());
            }
        } else if (result instanceof IntegerExpressoType || result instanceof IntegerInterval) {
            DifferenceArithmeticTheory theory = new DifferenceArithmeticTheory(true, true);
            SingleVariableDifferenceArithmeticConstraint constraint = (SingleVariableDifferenceArithmeticConstraint) theory.makeSingleVariableConstraint(variable, context);
            constraint = (SingleVariableDifferenceArithmeticConstraint) constraint.conjoin(condition, context);
            ValuesOfSingleVariableDifferenceArithmeticConstraintStepSolver solver = new ValuesOfSingleVariableDifferenceArithmeticConstraintStepSolver(constraint);
            // NOTE: the exceptions set returned here is implicit in the condition so no need to use it here.
            RangeAndExceptionsSet rangeAndExceptionsSet = (RangeAndExceptionsSet) solver.solve(context);
            if (rangeAndExceptionsSet.isEmpty()) {
                // used to indicate an empty set.
                result = null;
            } else if (rangeAndExceptionsSet.isSingleton()) {
                result = new IntegerInterval(rangeAndExceptionsSet.getSingleValue().intValueExact(), rangeAndExceptionsSet.getSingleValue().intValueExact());
            } else {
                result = new IntegerInterval(rangeAndExceptionsSet.getStrictLowerBound().intValueExact() + 1, rangeAndExceptionsSet.getNonStrictUpperBound().intValueExact());
            }
        }
    }
    if (result != null && !result.isSampleUniquelyNamedConstantSupported()) {
        throw new IllegalArgumentException("Unable to sample " + variable + " from " + result);
    }
    return result;
}