Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

Pre-allocate logical array with unassigned elements (not true or false)

I'm looking for the most efficient method of pre-allocating a logical array in MATLAB without specifying true or false at the time of pre-allocation.

When pre-allocating e.g. a ×ばつ5 numeric array I can use nan(1,5). To my mind, this is better than using zeros(1,5), since I can easily tell which slots have been filled with data versus those that are yet to be filled. If using the zeros() solution it's hard to know whether any 0s are intentional 0s or just unfilled slots in the array.

I'm aware that I can pre-alloate a logical array using true(1,5) or false(1,5). The problem with these is similar to the use of zeros() in the numeric example; there's no way of knowing whether a slot is filled or not.

I know that one solution to this problem is to treat the array as numeric and pre-allocate using nan(1,5), and only converting to a logical array later when all the slots are filled. But this strikes me as inefficient.

Is there some smart way to pre-allocate a logical array in MATLAB and remain agnostic as to the actual content of that array until it is ready to be filled?

Answer*

The short answer is no, the point of a logical array is that each element takes a single byte, and the implementation is only capable of storing only two states (true=1 or false=0). You might assume that logicals only need a single bit, but in fact [they need 8 bits (a byte)](https://uk.mathworks.com/matlabcentral/answers/22439-logical-array-memory-allocation) to avoid compromising on performance.

If memory is a concern, you could use a `single` array instead of a `double` array, moving from 64-bit to 32-bit numbers and still capable of storing `NaN`. Then you can cast to `logical` whenever required (assuming you have no NaNs by that point, otherwise it will error).

If it was really important to track whether a value was ever assigned whilst also reducing memory, you could have a 2nd logical array which you update at the same time as the first, and stores simply whether a value was ever assigned. Then this can be used as a check on whether you have any default values left after assignments. Now we've dropped from 32-bit singles to two 8-bit logicals, which is worse than one logical but still twice as efficient than using floating point numbers for the sake of the NaN. Obviously assignment operations now take twice as long as using a single logical array, I don't know how they compare to float assignments.

Going off-piste, you could make your own class to do this assignment-tracking for you, and display the logical array as if it was capable of storing NaNs. This isn't really recommended but I've written the below code to complete the thought experiment.
**Note** you originally ask for "the most efficient method", in terms of execution time this is definitely not going to be as efficient than the native implementation of logical arrays.

```
classdef nanBool
 properties
 assigned % Tracks whether element of "value" was ever assigned
 value % Tracks boolean array
 end
 methods 
 function obj = nanBool(varargin)
 % Constructor: initialise main and tracking arrays to false
 % handles same inputs as using "false()" normally
 obj.value = false(varargin{:});
 obj.assigned = false(size(obj.value)); 
 end
 function b = subsref(obj,S)
 % Override the indexing operator so that indexing works like it
 % would for a logical array unless accessing object properties
 if strcmp(S.type,'.')
 b = obj.(S.subs);
 else
 b = builtin('subsref',obj.value,S); 
 end
 end
 function obj = subsasgn(obj,S,B)
 % Override the assignement operator so that the value array is
 % updated when normal array indexing is used. In sync, update
 % the assigned state for the corresponding elements
 obj.value = builtin('subsasgn',obj.value,S,B);
 obj.assigned = builtin('subsasgn',obj.assigned,S,true(size(B)));
 end 
 function disp(obj)
 % Override the disp function so printing to the command window
 % renders NaN for elements which haven't been assigned
 a = double(obj.value);
 a(~obj.assigned) = NaN;
 disp(a);
 end
 end 
end
```

Test cases:

```
>> a = nanBool(3,1)

a = 
 NaN
 NaN
 NaN

>> a(2) = true

a = 
 NaN
 1
 NaN

>> a(3) = false

a = 
 NaN
 1
 0

>> a(:) = true

a = 
 1
 1
 1

>> whos a
 Name Size Bytes Class Attributes

 a 1x1 6 nanBool 

>> b = false(3,1); whos b
 Name Size Bytes Class Attributes

 b 3x1 3 logical 
```

Note the `whos` test shows this custom class has the same memory footprint as two logical arrays the same size. It also shows that the size is reported incorrectly, indicating we'd also have to override the `size` function in our custom class, I'm sure there are lots of other similar edge cases you'd want to handle.

you could check whether there's any "logical NaNs" (unassigned values) with something like this, or add a function which does this to the class:

```
fullyAssigned = all(a.assigned);
```

In 21b and newer you can do some more controlled indexing overrides for custom classes instead of `subsref` and `subsasgn`, but I can't test this:

https://uk.mathworks.com/help/matlab/customize-object-indexing.html

Draft saved

Draft discarded

Edit Summary*

Cancel

1

Good, answer Wolfie! But indeed, this is an overkill. If OP has memory issues between single and logical, then they better not accidentally open a tab in chrome because their computer will explode.

Ander Biguri
– Ander Biguri

2022年07月21日 15:27:20 +00:00
Commented Jul 21, 2022 at 15:27
1

@AnderBiguri lol indeed, I saw a challenge and thought I might as well post the results, but I would not use my own class here

Wolfie
– Wolfie

2022年07月21日 15:29:28 +00:00
Commented Jul 21, 2022 at 15:29

Add a comment |

How to Edit

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

How to Format

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

How to Tag

A tag is a keyword or label that categorizes your question with other, similar questions. Choose one or more (up to 5) tags that will help answerers to find and interpret your question.

complete the sentence: my question is about...
use tags that describe things or concepts that are essential, not incidental to your question
favor using existing popular tags
read the descriptions that appear below the tag

If your question is primarily about a topic for which you can't find a tag:

combine multiple words into single-words with hyphens (e.g. python-3.x), up to a maximum of 35 characters
creating new tags is a privilege; if you can't yet create a tag you need, then post this question without it, then ask the community to create it for you

popular tags »

lang-matlab

CollectivesTM on Stack Overflow

Pre-allocate logical array with unassigned elements (not true or false)

Answer*