Mask matches in bit manipulation

Question

Here is a question related to bit manipulation(masks), I'm programming in Javascript. I want to do the following:

const entityMask1 = new MaskManager();
entityMask1.addElement(0);
entityMask1.addElement(1);
entityMask1.addElement(2);

let SOME_SYSTEM_MASK = 0;
SOME_SYSTEM_MASK |= (1 << 0); // -> 1
SOME_SYSTEM_MASK |= (1 << 1); // -> 3
SOME_SYSTEM_MASK |= (1 << 2); // -> 7
SOME_SYSTEM_MASK |= (1 << 3); // -> 15
SOME_SYSTEM_MASK |= (1 << 4); // -> 31

entityMask1.matcheAll(SOME_SYSTEM_MASK); // -> false
entityMask1.matchesOne(SOME_SYSTEM_MASK); // -> true
entityMask1.matchNoneOrMore(SOME_SYSTEM_MASK); // -> true
entityMask1.matchesNone(SOME_SYSTEM_MASK); // -> false

function MaskManager() {
    this.mask = 0;
}

MaskManager.prototype.addElement = function(element) {
    this.mask |= (1 << element);
}

MaskManager.prototype.delElement = function(element) {
    this.mask ^= (1 << element);
}

MaskManager.prototype.matchAll = function(targetMask) {
    return (this.mask === targetMask);
}

MaskManager.prototype.matchOne = function(targetMask) {
//    return ?;
}

MaskManager.prototype.matchNoneOrMore = function(targetMask) {
//    return ?;
}


MaskManager.prototype.matchNone = function(targetMask) {
//    return ?;
}

At where:

matchAll - mask has all elements.
matchOne - mask has at least one element.
matchNoneOrMore - mask has none or more elements.
matchNone - mask does not have these elements

PerduGames · Answer 1 · 2018-10-04T10:16:24.357

I believe you have succeeded, so far no test went wrong. I think it's right what I did, but I can be with the vision overshadowed for some case, I hope not:

  

const addElementInMask = (element, newElement) => (element |= (1 << newElement));

const maskEqualsTargetMask = (mask, targetMask) => mask === targetMask;

const maskContainsAllElements = (mask, targetMask) => targetMask === (mask & targetMask);

const maskContainsNoneElements = (mask, targetMask) => mask === (mask & ~targetMask);

const maskContainsOneOrMoreElements = (mask, targetMask) => targetMask === (mask | targetMask) && !maskContainsNoneElements(mask, targetMask);

const maskContainsNoneOrMoreElements = (mask, targetMask) => targetMask === true;

const matchResult = (matchName, expression) => console.log(matchName+': '+expression);

const element1 = 1;
const element2 = 2;
const element3 = 3;

let mask = 0;
mask = addElementInMask(mask, element1);
mask = addElementInMask(mask, element2);

let targetMask = 0;
targetMask = addElementInMask(targetMask, element1);
targetMask = addElementInMask(targetMask, element2);
targetMask = addElementInMask(targetMask, element3);

console.log('Expected: false, false, false, true, true');

matchResult('maskEqualsTargetMask', maskEqualsTargetMask(mask, targetMask));

matchResult('maskContainsAllElements', maskContainsAllElements(mask, targetMask));

matchResult('maskContainsNoneElements', maskContainsNoneElements(mask, targetMask));

matchResult('maskContainsOneOrMoreElements', maskContainsOneOrMoreElements(mask, targetMask));

matchResult('maskContainsNoneOrMoreElements', maskContainsNoneOrMoreElements(mask, targetMask));

`matchNoneOrMore` is **always** true so just return `true` or 1 — slebetman, Oct 04 '18 at 01:33
yes, it is really useless, just put it there because I asked about it XD — PerduGames, Oct 04 '18 at 10:15

score 0 · Answer 2 · answered Oct 04 '18 at 01:16

MaskManager.prototype.matchOne = function(targetMask) {
    return ((this.mask & targetMask) !== 0);
}

MaskManager.prototype.matchNone = function(targetMask) {
    return ((this.mask ^ targetMask) === 0);
}

MaskManager.prototype.matchNoneOrMore = function(targetMask) {
    return true;
}

Mask matches in bit manipulation

2 Answers2