ultra-mega-enumerator/dist/objects/ImmutableCombination.js

Ultra Mega Enumerator is a lightweight library designed to enumerate various combinatorial objects.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImmutableCombination = void 0;
const _1 = require(".");
/**
 * The {@code ImmutableCombination} class represents a combination of elements that cannot
 * be modified after creation. It encapsulates an instance of the {@code Combination} class,
 * providing an immutable interface for handling set operations relevant to combinatorial
 * structures in various contexts, including music theory.
 */
class ImmutableCombination {
    constructor(combination) {
        this.combination = combination;
    }
    static fromCombination(c) {
        return new ImmutableCombination(c);
    }
    static fromBinarySequence(seq) {
        return new ImmutableCombination(_1.Combination.fromBooleanArray(seq));
    }
    static createWithSize(n) {
        return new ImmutableCombination(new _1.Combination(n));
    }
    static createWithSizeAndSet(n, set) {
        return new ImmutableCombination(_1.Combination.createWithSizeAndSet(n, set));
    }
    getN() {
        return this.combination.size();
    }
    getK() {
        return this.combination.cardinality();
    }
    combinationString() {
        return this.combination.combinationString();
    }
    /*
    public calcSpan(): number {
        return this.combination.calcSpan();
    }
    */
    getIntervalVector() {
        return this.combination.getIntervalVector();
    }
    rotate(t) {
        return new ImmutableCombination(this.combination.rotate(t));
    }
    intersect(c) {
        return new ImmutableCombination(this.combination.intersect(c.combination));
    }
    minus(c) {
        return new ImmutableCombination(this.combination.minus(c.combination));
    }
    static merge(a, b) {
        return new ImmutableCombination(_1.Combination.merge(a.combination, b.combination));
    }
    mergeWith(c) {
        return new ImmutableCombination(this.combination.mergeWith(c.combination));
    }
    symmetricDifference(y) {
        return new ImmutableCombination(this.combination.symmetricDifference(y.combination));
    }
    /*
    public getComposition(): Composition {
        return this.combination.getComposition();
    }
    */
    get(bitIndex) {
        return this.combination.get(bitIndex);
    }
    isEmpty() {
        return this.combination.isEmpty();
    }
    toString() {
        return this.combination.toString();
    }
    asSequence() {
        return this.combination.asSequence();
    }
    equals(obj) {
        if (!(obj instanceof ImmutableCombination))
            return false;
        return this.combination.equals(obj.combination);
    }
}
exports.ImmutableCombination = ImmutableCombination;
//# sourceMappingURL=ImmutableCombination.js.map