@eagleoutice/flowr 2.4.6 → 2.4.7

package/README.md

@@ -24,7 +24,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.6, R v4.5.0 (r-shell engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -33,7 +33,7 @@ It offers a wide variety of features, for example:
     
     
     ```text
-    Query: linter (3 ms)
+    Query: linter (2 ms)
        ╰ **Deprecated Functions** (deprecated-functions):
            ╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **File Path Validity** (file-path-validity):
@@ -45,18 +45,18 @@ It offers a wide variety of features, for example:
        ╰ **Absolute Paths** (absolute-file-paths):
            ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
-           ╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":1,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Unused Definitions** (unused-definitions):
            ╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Naming Convention** (naming-convention):
            ╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Dataframe Access Validation** (dataframe-access-validation):
-           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":1}</code>
        ╰ **Dead Code** (dead-code):
            ╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Useless Loops** (useless-loop):
-           ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":1}</code>
-    All queries together required ≈3 ms (1ms accuracy, total 9 ms)
+           ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>
+    All queries together required ≈2 ms (1ms accuracy, total 8 ms)
     ```
     
     
@@ -92,7 +92,7 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":2,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Unused Definitions** (unused-definitions):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Naming Convention** (naming-convention):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Dataframe Access Validation** (dataframe-access-validation):\
@@ -101,11 +101,11 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":1,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Useless Loops** (useless-loop):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>\
-    _All queries together required ≈14 ms (1ms accuracy, total 209 ms)_
+    _All queries together required ≈13 ms (1ms accuracy, total 210 ms)_
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _209.4 ms_ (including parsing and normalization and the query) within the generation environment.	
+    The analysis required _210.1 ms_ (including parsing and normalization and the query) within the generation environment.	
     
     In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
     Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -184,7 +184,7 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalConsidered": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           },
           "naming-convention": {
@@ -228,7 +228,7 @@ It offers a wide variety of features, for example:
         }
       },
       ".meta": {
-        "timing": 14
+        "timing": 13
       }
     }
     ```
@@ -295,7 +295,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.6, R v4.5.0 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -378,7 +378,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.6, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -679,7 +679,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _14.5 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _14.2 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/abstract-interpretation/data-frame/dataframe-domain.d.ts

@@ -0,0 +1,40 @@
+import type { AbstractDomain } from '../domains/abstract-domain';
+import { PosIntervalDomain } from '../domains/positive-interval-domain';
+import { ProductDomain } from '../domains/product-domain';
+import { SetBoundedSetDomain } from '../domains/set-bounded-set-domain';
+import { StateAbstractDomain } from '../domains/state-abstract-domain';
+/** The type of the abstract product representing the shape of data frames */
+export type AbstractDataFrameShape = {
+    colnames: SetBoundedSetDomain<string>;
+    cols: PosIntervalDomain;
+    rows: PosIntervalDomain;
+};
+/** The type of abstract values of a sub abstract domain (shape property) of the data frame shape product */
+type DataFrameShapeProperty<Property extends keyof AbstractDataFrameShape> = AbstractDataFrameShape[Property] extends AbstractDomain<unknown, unknown, unknown, unknown, infer Lift> ? Lift : never;
+/**
+ * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
+ */
+export declare class DataFrameDomain extends ProductDomain<AbstractDataFrameShape> {
+    constructor(value: AbstractDataFrameShape, maxColNames?: number);
+    create(value: AbstractDataFrameShape, maxColNames?: number): DataFrameDomain;
+    /**
+     * The current abstract value of the column names domain.
+     */
+    get colnames(): DataFrameShapeProperty<'colnames'>;
+    /**
+     * The current abstract value of the column count domain.
+     */
+    get cols(): DataFrameShapeProperty<'cols'>;
+    /**
+     * The current abstract value of the row count domain.
+     */
+    get rows(): DataFrameShapeProperty<'rows'>;
+    static bottom(maxColNames?: number): DataFrameDomain;
+    static top(maxColNames?: number): DataFrameDomain;
+}
+/**
+ * The data frame state abstract domain as state abstract domain mapping AST node IDs to inferred abstract data frame shapes.
+ */
+export declare class DateFrameStateDomain extends StateAbstractDomain<DataFrameDomain> {
+}
+export {};

package/abstract-interpretation/data-frame/dataframe-domain.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFrameStateDomain = exports.DataFrameDomain = void 0;
+const positive_interval_domain_1 = require("../domains/positive-interval-domain");
+const product_domain_1 = require("../domains/product-domain");
+const set_bounded_set_domain_1 = require("../domains/set-bounded-set-domain");
+const state_abstract_domain_1 = require("../domains/state-abstract-domain");
+/**
+ * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
+ */
+class DataFrameDomain extends product_domain_1.ProductDomain {
+    constructor(value, maxColNames) {
+        super({
+            colnames: new set_bounded_set_domain_1.SetBoundedSetDomain(value.colnames.value, maxColNames),
+            cols: new positive_interval_domain_1.PosIntervalDomain(value.cols.value),
+            rows: new positive_interval_domain_1.PosIntervalDomain(value.rows.value)
+        });
+    }
+    create(value, maxColNames) {
+        return new DataFrameDomain(value, maxColNames);
+    }
+    /**
+     * The current abstract value of the column names domain.
+     */
+    get colnames() {
+        return this.value.colnames.value;
+    }
+    /**
+     * The current abstract value of the column count domain.
+     */
+    get cols() {
+        return this.value.cols.value;
+    }
+    /**
+     * The current abstract value of the row count domain.
+     */
+    get rows() {
+        return this.value.rows.value;
+    }
+    static bottom(maxColNames) {
+        return new DataFrameDomain({
+            colnames: set_bounded_set_domain_1.SetBoundedSetDomain.bottom(maxColNames),
+            cols: positive_interval_domain_1.PosIntervalDomain.bottom(),
+            rows: positive_interval_domain_1.PosIntervalDomain.bottom()
+        });
+    }
+    static top(maxColNames) {
+        return new DataFrameDomain({
+            colnames: set_bounded_set_domain_1.SetBoundedSetDomain.top(maxColNames),
+            cols: positive_interval_domain_1.PosIntervalDomain.top(),
+            rows: positive_interval_domain_1.PosIntervalDomain.top()
+        });
+    }
+}
+exports.DataFrameDomain = DataFrameDomain;
+/**
+ * The data frame state abstract domain as state abstract domain mapping AST node IDs to inferred abstract data frame shapes.
+ */
+class DateFrameStateDomain extends state_abstract_domain_1.StateAbstractDomain {
+}
+exports.DateFrameStateDomain = DateFrameStateDomain;
+//# sourceMappingURL=dataframe-domain.js.map

package/abstract-interpretation/data-frame/domain.js

@@ -105,7 +105,7 @@ function subtractColNames(set1, set2) {
  * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
  */
 function wideningColNames(set1, set2) {
-    return leqColNames(set1, set2) ? set2 : exports.ColNamesTop;
+    return leqColNames(set2, set1) ? set1 : exports.ColNamesTop;
 }
 /** Checks whether an abstract value of the column names domain satisfies a column name */
 function satisfiesColsNames(set, value) {

package/abstract-interpretation/domains/abstract-domain.d.ts

@@ -0,0 +1,56 @@
+import type { Bottom, Lattice, Top } from './lattice';
+/**
+ * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
+ */
+export declare const DEFAULT_INFERENCE_LIMIT = 50;
+/**
+ * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
+ * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (may exclude `Top` and `Bot`)
+ * @template Top      - Type of the Top element of the abstract domain representing all possible elements (defaults to {@link Top})
+ * @template Bot      - Type of the Bottom element of the abstract domain representing no possible elements (defaults to {@link Bottom})
+ * @template Lift     - Type of the abstract elements of the abstract domain (defaults to `Abstract` or `Top` or `Bot`)
+ */
+export interface AbstractDomain<Concrete, Abstract, Top = typeof Top, Bot = typeof Bottom, Lift extends Abstract | Top | Bot = Abstract | Top | Bot> extends Lattice<Abstract, Top, Bot, Lift> {
+    /**
+     * Widens the current abstract value with another abstract value as a sound over-approximation of the join (least upper bound) for fixpoint iteration acceleration.
+     */
+    widen(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    /**
+     * Narrows the current abstract value with another abstract value as a sound over-approximation of the meet (greatest lower bound) to refine the value after widening.
+     */
+    narrow(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    /**
+     * Maps the current abstract value into a set of possible concrete values as concretization function of the abstract domain.
+     * The result should be `Top` if the number of concrete values would reach the `limit` or the resulting set would have infinite many elements.
+     */
+    concretize(limit?: number): ReadonlySet<Concrete> | typeof Top;
+    /**
+     * Maps a set of possible concrete values into an abstract value as abstraction function of the abstract domain (should additionally be provided as static function).
+     */
+    abstract(concrete: ReadonlySet<Concrete> | typeof Top): AbstractDomain<Concrete, Abstract, Top, Bot>;
+}
+/**
+ * The type of the concrete domain of an abstract domain.
+ * @template Domain - The abstract domain to get the concrete domain type for
+ */
+export type ConcreteDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+/**
+ * The type of the Top element (greatest element) of an abstract domain.
+ * @template Domain - The abstract domain to get the Top element type for
+ */
+export type AbstractDomainTop<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, infer Top, unknown> ? Top : never;
+/**
+ * The type of the Bottom element (least element) of an abstract domain.
+ * @template Domain - The abstract domain to get the Bottom element type for
+ */
+export type AbstractDomainBottom<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, unknown, infer Bot> ? Bot : never;
+/**
+ * The type of the abstract values of an abstract domain (including the Top and Bottom element).
+ * @template Domain - The abstract domain to get the abstract value type for
+ */
+export type AbstractDomainValue<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, infer Value, infer Top, infer Bot> ? Value | Top | Bot : never;
+/**
+ * Converts an element of an abstract domain into a string.
+ */
+export declare function domainElementToString(value: AbstractDomain<unknown, unknown, unknown, unknown> | unknown): string;

package/abstract-interpretation/domains/abstract-domain.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INFERENCE_LIMIT = void 0;
+exports.domainElementToString = domainElementToString;
+/**
+ * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
+ */
+exports.DEFAULT_INFERENCE_LIMIT = 50;
+/**
+ * Converts an element of an abstract domain into a string.
+ */
+function domainElementToString(value) {
+    if (typeof value === 'object' && value !== null && value.toString !== Object.prototype.toString) {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return value.toString();
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=abstract-domain.js.map

package/abstract-interpretation/domains/bounded-set-domain.d.ts

@@ -0,0 +1,43 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of the actual values of the bounded set domain as set */
+export type BoundedSetValue<T> = ReadonlySet<T>;
+/** The type of the Top element of the bounded set domain as {@link Top} symbol */
+export type BoundedSetTop = typeof Top;
+/** The type of the Bottom element of the bounded set domain as empty set */
+export type BoundedSetBottom = ReadonlySet<never>;
+/** The type of the abstract values of the bounded set domain that are Top, Bottom, or actual values */
+export type BoundedSetLift<T> = BoundedSetValue<T> | BoundedSetTop | BoundedSetBottom;
+/**
+ * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
+ * The Bottom element is defined as the empty set and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the values in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class BoundedSetDomain<T, Value extends BoundedSetLift<T> = BoundedSetLift<T>> implements AbstractDomain<T, BoundedSetValue<T>, BoundedSetTop, BoundedSetBottom, Value> {
+    private readonly limit;
+    private _value;
+    constructor(value: Value, limit?: number);
+    get value(): Value;
+    static top<T>(limit?: number): BoundedSetDomain<T, BoundedSetTop>;
+    static bottom<T>(limit?: number): BoundedSetDomain<T, BoundedSetBottom>;
+    static abstract<T>(concrete: ReadonlySet<T> | typeof Top, limit?: number): BoundedSetDomain<T>;
+    top(): BoundedSetDomain<T, BoundedSetTop>;
+    bottom(): BoundedSetDomain<T, BoundedSetBottom>;
+    equals(other: BoundedSetDomain<T>): boolean;
+    leq(other: BoundedSetDomain<T>): boolean;
+    join(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
+    meet(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    widen(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    narrow(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    concretize(limit?: number): ReadonlySet<T> | typeof Top;
+    abstract(concrete: ReadonlySet<T> | typeof Top): BoundedSetDomain<T>;
+    toString(): string;
+    isTop(): this is BoundedSetDomain<T, BoundedSetTop>;
+    isBottom(): this is BoundedSetDomain<T, BoundedSetBottom>;
+    isValue(): this is BoundedSetDomain<T, BoundedSetValue<T>>;
+}

package/abstract-interpretation/domains/bounded-set-domain.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedSetDomain = void 0;
+const set_1 = require("../../util/collections/set");
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
+ * The Bottom element is defined as the empty set and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the values in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class BoundedSetDomain {
+    limit;
+    _value;
+    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (value !== lattice_1.Top) {
+            this._value = (value.size > limit ? lattice_1.Top : new Set(value));
+        }
+        else {
+            this._value = value;
+        }
+        this.limit = limit;
+    }
+    get value() {
+        return this._value;
+    }
+    static top(limit) {
+        return new BoundedSetDomain(lattice_1.Top, limit);
+    }
+    static bottom(limit) {
+        return new BoundedSetDomain(new Set(), limit);
+    }
+    static abstract(concrete, limit) {
+        return new BoundedSetDomain(concrete, limit);
+    }
+    top() {
+        return BoundedSetDomain.top(this.limit);
+    }
+    bottom() {
+        return BoundedSetDomain.bottom(this.limit);
+    }
+    equals(other) {
+        return this.value === other.value || (this.isValue() && other.isValue() && (0, set_1.setEquals)(this.value, other.value));
+    }
+    leq(other) {
+        return other.value === lattice_1.Top || (this.isValue() && this.value.isSubsetOf(other.value));
+    }
+    join(...values) {
+        const result = new BoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Top || other.value === lattice_1.Top) {
+                result._value = lattice_1.Top;
+            }
+            else {
+                const join = result.value.union(other.value);
+                result._value = join.size > this.limit ? lattice_1.Top : join;
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new BoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Top) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Top) {
+                result._value = result.value;
+            }
+            else {
+                result._value = result.value.intersection(other.value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other) {
+        if (this.value === lattice_1.Top) {
+            return this.top();
+        }
+        else if (other.value === lattice_1.Top) {
+            return new BoundedSetDomain(this.value, this.limit);
+        }
+        else {
+            return new BoundedSetDomain(this.value.difference(other.value), this.limit);
+        }
+    }
+    widen(other) {
+        return other.leq(this) ? new BoundedSetDomain(this.value, this.limit) : this.top();
+    }
+    narrow(other) {
+        return this.isTop() ? other : this;
+    }
+    concretize(limit = this.limit) {
+        return this.value === lattice_1.Top || this.value.size > limit ? lattice_1.Top : this.value;
+    }
+    abstract(concrete) {
+        return BoundedSetDomain.abstract(concrete, this.limit);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            return '⊤';
+        }
+        const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        return `{${string}}`;
+    }
+    isTop() {
+        return this.value === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value !== lattice_1.Top && this.value.size === 0;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top;
+    }
+}
+exports.BoundedSetDomain = BoundedSetDomain;
+//# sourceMappingURL=bounded-set-domain.js.map

package/abstract-interpretation/domains/interval-domain.d.ts

@@ -0,0 +1,61 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the actual values of the interval domain as tuple of the lower and upper bound */
+export type IntervalValue = readonly [number, number];
+/** The type of the Top element of the interval domain as interval [-∞, +∞] from -∞ to +∞ */
+export type IntervalTop = readonly [typeof Infinity, typeof Infinity];
+/** The type of the Bottom element of the interval domain as {@link Bottom} symbol */
+export type IntervalBottom = typeof Bottom;
+/** The type of the abstract values of the interval domain that are Top, Bottom, or actual values */
+export type IntervalLift = IntervalValue | IntervalTop | IntervalBottom;
+/**
+ * The interval abstract domain as intervals with possibly infinite bounds representing possible numeric values.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [-∞, +∞].
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> implements AbstractDomain<number, IntervalValue, IntervalTop, IntervalBottom, Value> {
+    private _value;
+    constructor(value: Value);
+    get value(): Value;
+    static top(): IntervalDomain<IntervalTop>;
+    static bottom(): IntervalDomain<IntervalBottom>;
+    static abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
+    top(): IntervalDomain<IntervalTop>;
+    bottom(): IntervalDomain<IntervalBottom>;
+    equals(other: IntervalDomain): boolean;
+    leq(other: IntervalDomain): boolean;
+    join(...values: IntervalDomain[]): IntervalDomain;
+    meet(...values: IntervalDomain[]): IntervalDomain;
+    widen(other: IntervalDomain): IntervalDomain;
+    narrow(other: IntervalDomain): IntervalDomain;
+    concretize(limit?: number): ReadonlySet<number> | typeof Top;
+    abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
+    /**
+     * Adds another abstract value to the current abstract value by adding the two lower and upper bounds, respectively.
+     */
+    add(other: IntervalDomain): IntervalDomain;
+    /**
+     * Subtracts another abstract value from the current abstract value by subtracting the two lower and upper bounds from each other, respectively.
+     */
+    subtract(other: IntervalDomain): IntervalDomain;
+    /**
+     * Creates the minimum between the current abstract value and another abstract value by creating the minimum of the two lower and upper bounds, respectively.
+     */
+    min(other: IntervalDomain): IntervalDomain;
+    /**
+     * Creates the maximum between the current abstract value and another abstract value by creating the maximum of the two lower and upper bounds, respectively.
+     */
+    max(other: IntervalDomain): IntervalDomain;
+    /**
+     * Extends the lower bound of the current abstract value down to -∞.
+     */
+    extendDown(): IntervalDomain;
+    /**
+     * Extends the upper bound of the current abstract value up to +∞.
+     */
+    extendUp(): IntervalDomain;
+    toString(): string;
+    isTop(): this is IntervalDomain<IntervalTop>;
+    isBottom(): this is IntervalDomain<IntervalBottom>;
+    isValue(): this is IntervalDomain<IntervalValue>;
+}