hi

Here's the code which does the job. 

hello dimkir,

thank you so much for your huge effort.
I appreciate it a lot and I feel really great!

Nevertheless I still feel we are wasting a lot of space here.

Because when you have boolean array
true - false - true
it's like bits:
101
which would be 5.

So my thinking was converting it to a int or long and save it.

Because I have so many of those boolean-arrays, I'd like to store them in one file.

Thanks again!

Greetings, Chrisir    

Because when you have boolean array
true - false - true
it's like bits:
101
which would be 5.

I wish that'd be true but... AFAIK, the boolean primitive uses a whole byte to store true or false.
So, 7 bits go to waste for each boolean anyways.  :P

It can be worth to look at Java's BitSet class...

@Chrisir,

Very true. The concept of "waste" is very relative, particularly today.

I started programming in the 80s, with computers having 16 KB of memory and 1 MHz CPUs, so I can understand the conservative mindset (but I try to shake it off...).

interesting discussion, thanks to you all.

It is true that space isn't so important anymore.

Another issue I have is that I'd like to store all the byte-arrays (probably one million+X) in one file.
As a String I would use one line per byte-array and then append the next line.
How can this be done with a byte-array?

Because I have so many of those boolean-arrays, I'd like to store them in one file.

Thanks again!

Greetings, Chrisir    

i'm a 'bit' late to this, ... here's my version that encodes boolean to bits.
i think it does quite the same as java's bitset.

 public void setup() {
   
    BitBool bitbool;
    
    // generate some data, and save it
    bitbool = new BitBool(19); // needs 3 byte of memory.
    bitbool.set( 0, true);
    bitbool.set( 1, false);
    bitbool.set( 2, true);
    bitbool.set( 3, false);
    bitbool.set( 7, true);
    bitbool.set(18, true);
    bitbool.save("bitbool.dat");

    
    // load data from file
    bitbool = new BitBool("bitbool.dat");
    for(int i = 0; i < bitbool.length; i++){
      System.out.println("["+i+"] "+bitbool.get(i));
    }
    
       
    exit();
  }

 
 
 
  public class BitBool{
    
    public final byte[] bool;
    public final int length;
    
    
    // init with given size, and all "false"
    public BitBool(int length){
      this.length = length;
      bool = new byte[(length+7)>>3];
    }
    
    // init from given array
    public BitBool(boolean[] src){
      length = src.length;
      bool = new byte[(length+7)>>3];
      
      for(int i = 0; i < length; i++){
        bool[i>>3] |= (src[i]?1:0) << (i&7);
      }
    }
    
    // init from given file
    public BitBool(String filename){
      bool = loadBytes(filename);
      length = bool.length*8; 
      // TODO: maybe the exact length should be saved in the first 4 bytes of 
      // the file. Or, mark the end (=length+1) with 1.
    }
    
    
    
    // set boolean
    public void set(int i, boolean IO){
      int arr = i>>3;
      int bit = i&7;
      bool[arr] &= ~(1<<bit);         // clear old bit
      bool[arr] |= (IO?1:0) << bit;   // set new bit
    }
    
    // get boolean
    public boolean get(int i){
      int arr = i>>3;
      int bit = i&7;
      return ((bool[arr]>>bit)&1)==1;
    }
    
    
    
    // save bytes
    public void save(String filename){
      
      // version 1: 
//      try {
//        saveBytes(new FileOutputStream(new File(filename)), bool);
//      } catch (FileNotFoundException e) {
//        e.printStackTrace();
//      }
      
      // version 2: had an error when trying to overwrite an 
      //            existing file (processing 1.5.1)
       saveBytes(filename, bool);
      
      // version 3: saves a view byte more actually
      // saveStrings(filename, new String[]{ new String(bool) } );
    }
  }

... about the discussion in general.

e.g. one wants to save a huge number of bit-mask (stencil buffers from frames) or whatever, i think it makes total sense to represent booleans as bits. first it saves HD-space, and second it reduced the time for reading/writing the files. And also a lot more of such masks can be kept in memory, which reduced reading/writing again.

Thank you so much Thomas, great!

But here I am still with one array per file, right?   

How would it look like when it was all arrays in one file?

Greetings, Chrisir    

If you want to save space on hard-disk, there's an undocumented processing feature:

I didn't know this

Thanks a lot

Can anybody answer how I can store multiple byte-arrays in one file?

I think even Thomas' solution does only one array per file, right?

Greetings, Chrisir

@Chrisir, 

i too would go for one array per file.

but you can also use the class from yesterday, and initialize it with the correct size (number of all boolean of all arrays) and insert the values then at the right position.

anyway, if its really just about saving/loading a bunch of boolean arrays, then the following does the job.


... as you can see, most of the code is just copied from the BitBool class

  public void setup() {
    
    // some test-arrays, that we want to save
    boolean[] b1 = {true, true, false, false};
    boolean[] b2 = {true};
    boolean[] b3 = {false, true, false, true, false, true};

    
    
    // save: boolean -> bit -> file
    saveBooleanAsBit("data/tmp.dat", b1, b2, b3);
    
    
    
    // load: file -> bit -> boolean
    boolean[] bool = loadBitAsBoolean("data/tmp.dat");
    
    
    
    // check if everything is right
    for(int i = 0; i < bool.length; i++){
      System.out.println(bool[i]);
    }
    
    
    exit();
  }
  
  
  
  

  public boolean[] loadBitAsBoolean(String filename){
    // load bytes
    byte[] bytebool = loadBytes(filename);
    // get number of boolean values (TODO: byteorder)
    int num_bool = bytebool[0]<<24 | bytebool[1]<<16 | bytebool[2]<<8 | bytebool[3];
    // alloc arrays
    boolean[] bool = new boolean[num_bool];
    // bit -> boolean
    for(int i = 0; i < num_bool; i++){
      bool[i] = ((bytebool[4 + (i>>3)]>>(i&7))&1)==1;
    }
    return bool;
  }
  
  
  
  
  
  public void saveBooleanAsBit(String filename, boolean[] ... bool){
    
    // get number of all boolean
    int num_bool = 0;
    for(int i = 0; i < bool.length; i++){
      num_bool += bool[i].length;
    }

    // alloc buffer
    byte[] bytebool = new byte[4 + ((num_bool+7)>>3)];

    // save number of boolean in first 4 bytes (TODO: byteorder)
    bytebool[0] = (byte) ((num_bool>>24)&0xFF);
    bytebool[1] = (byte) ((num_bool>>16)&0xFF);
    bytebool[2] = (byte) ((num_bool>> 8)&0xFF);
    bytebool[3] = (byte) ((num_bool    )&0xFF);
    
    // boolean -> bit
    int idx = 0;
    for(int i = 0; i < bool.length; i++){
      boolean[] bool_i = bool[i];
      for(int j = 0; j < bool_i.length; j++){
        bytebool[4+(idx>>3)] |= (bool_i[j]?1:0)<<(idx&7);
        idx++;
      }
    }
    
    
    
    // save 
    // version 1:
//    try {
//      saveBytes(new FileOutputStream(new File(filename)), bytebool);
//    } catch (FileNotFoundException e) {
//      e.printStackTrace();
//    }
    
    // version 2: // had an error when trying to overwrite a file
    saveBytes(filename, bytebool); 
    
    // version 3: seems to 
//    saveStrings(filename, new String[]{new String(bool)});
  }
  

I thought the the opening and closing of files would take way too much time if I had one file per array? I stay with java mode thanks! Greetings, Chrisir

If you just read files, then opening/closing them wont' take too much time.

ok, thanks a lot, I will try....  

Greetings, Chrisir