/**
 * Copyright © 2014  Mattias Andrée (maandree@member.fsf.org)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package algorithms.bits;


/**
 * Operations on individual bits
 */
public class Bits
{
£<function ones-table
  {
      if [ $1 = 0 ]; then
          echo -n "${2}, "
      else
	  level=$(( $1 - 1 ))
          ones-table $level $(( $2 + 0 ))
          ones-table $level $(( $2 + 1 ))
          ones-table $level $(( $2 + 1 ))
          ones-table $level $(( $2 + 2 ))
      fi
£>}

    /**
     * Lookup table for the number of set bits in a byte
     */
    private static byte[] ONES_TABLE_256 = { £(ones-table 4 0) };
    /* ONES_TABLE_256[0] = 0;
     * for (int i = 0; i < 256; i++)
     *     ONES_TABLE_256[i] = (i & 1) + ONES_TABLE_256[i / 2];
     */


£<function parity-table
  {
      if [ $1 = 0 ]; then
          echo -n "${2}, "
      else
	  level=$(( $1 - 1 ))
          parity-table $level $(( $2 ^ 0 ))
          parity-table $level $(( $2 ^ 1 ))
          parity-table $level $(( $2 ^ 1 ))
          parity-table $level $(( $2 ^ 0 ))
      fi
£>}

    /**
     * Lookup table for the parity of the bits in a byte
     */
    private static byte[] PARITY_TABLE_256 = { £(parity-table 4 0) };


£<function reverse-table
  {
      if [ $1 = 0 ]; then
	  if (( $2 < 128 )); then
              echo -n "${2}, "
	  else
              echo -n "$(( $2 - 256 )), "
	  fi
      else
	  level=$(( $1 - 1 ))
	  reverse-table $level $(( $2 + 0 * 4 ** (4 - $1) ))
	  reverse-table $level $(( $2 + 2 * 4 ** (4 - $1) ))
	  reverse-table $level $(( $2 + 1 * 4 ** (4 - $1) ))
	  reverse-table $level $(( $2 + 3 * 4 ** (4 - $1) ))
      fi
£>}

    /**
     * Lookup table for the revered bit order in a byte
     */
    private static byte[] REVERSE_TABLE_256 = { £(reverse-table 4 0) };
    
    
    /**
     * Compute the parity of all bits in an integer, 64-bit multiply–modulus version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static int parity_64bit(byte value)
    {
	return (int)(((value * 0x0101010101010101L) & 0x8040201008040201L) % 0x1FF) & 1;
    }
    
    /**
     * Reverse the order of all bits in an integer, 64-bit instructions version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static byte reverse_64bit(byte value)
    {
	return (byte)(((value * 0x0202020202L) & 0x010884422010L) % 1023);
    }
    
    /**
     * Reverse the order of all bits in an integer, division-free 64-bit instructions version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static byte reverse_64bit_noMod(byte value)
    {
	return (byte)(((value * 0x80200802L) & 0x0884422110L) * 0x0101010101L >> 32);
    }
    
    /**
     * Reverse the order of all bits in an integer, 32-bit instructions version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static byte reverse_32bit(byte value)
    {
	return (byte)(((value * 0x0802 & 0x22110) | (value * 0x8020 & 0x88440)) * 0x10101 >> 16);
    }
    
£<for T_S in char_2 byte_1 short_2 int_4 long_8; do
  T=${T_S%_*}
£>S=${T_S#*_}
    /**
     * Sets or clears individual bits in an integer
     * 
     * @param   value  The value to modify
     * @param   mask   Mask of bits to modify
     * @param   flag   1 if the bit should be set, 0 if the bit should be clears
     * @return         The value with the bits modified
     */
    public static £{T} set_clear(£{T} value, £{T} mask, £{T} flag)
    {
	return (£{T})(value ^ ((-flag ^ value) & mask));
    }
    
    /**
     * Sets or clears individual bits in an integer, superscalar version
     * 
     * @param   value  The value to modify
     * @param   mask   Mask of bits to modify
     * @param   flag   1 if the bit should be set, 0 if the bit should be clears
     * @return         The value with the bits modified
     */
    public static £{T} set_clear_superscalar(£{T} value, £{T} mask, £{T} flag)
    {
	return (£{T})((value & ~mask) | (-flag & mask));
    }
    
    /**
     * Merge bits from two values
     * 
     * @param   zero  Integer whose bits should be kept where the mask has zeroes
     * @param   one   Integer whose bits should be kept where the mask has onces
     * @param   mask  The merge mask
     * @return        {@code (zero & ~mask) | (one & mask)}
     */
    public static £{T} merge(£{T} zero, £{T} one, £{T} mask)
    {
	return (£{T})(zero ^ ((£{T})(zero ^ one) & mask));
    }
    
    /**
     * Clears the least significant bit set
     * 
     * @param   value  The integer
     * @return         The value with its least significant set bit cleared
     */
    public static £{T} clearLeastSignificant(£{T} value)
    {
	return (£{T})(value & (value - 1));
    }
    
    /**
     * Calculate the number of set bits in an integer, naïve version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static £{T} ones_naïve(£{T} value)
    {
	£{T} count = 0;
	for (; value != 0; value >>>= 1)
	    count += (£{T})(value & 1);
	return count;
    }
    
    /**
     * Calculate the number of set bits in an integer, Wegner's version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static £{T} ones_wegner(£{T} value)
    {
	£{T} count = 0;
	for (; value != 0; count++)
	    value &= value - 1; /* clear the least significant bit set */
	return count;
    }
    
    /**
     * Calculate the number of set bits in an integer, partial lookup table version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static byte ones_table(£{T} value)
    {
£>function _ { echo "ONES_TABLE_256[(int)((value >> $1) & 255)]" ; }
        return (byte)((byte)(£(_ 0) + £(_ 8)) + (byte)(£(_ 16) + £(_ 24)));
	/* In C you can split the value by getting the address of the value and cast the pointer to char* */
    }
    
    /**
     * Calculate the number of set bits in an integer, 64-bits instructions version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static long ones_64bits(£{T} value)
    {
	long v = value, rc;
£>(( $S > 1 )) &&
	if ((v & (1L << 14L) - 1L) == v)
	{
	    rc = (v * 0x200040008001L & 0x111111111111111L) % 0xF;
	}
£>if (( $S >= 2 )); then
	else
£>(( $S > 3 )) &&
	    if ((v & (1L << 24L) - 1L) == v)
	{
	    rc = ((v & 0xFFF) * 0x1001001001001L & 0x84210842108421L) % 0x1F;
	    rc += (((v & 0XFFF000) >> 12) * 0x1001001001001L & 0x84210842108421L) % 0x1F;
	}
£>if (( $S > 3 )); then
	else
£>(( $S > 4 )) &&
	    if ((v & (1L << 32L) - 1L) == v)
	{
	    rc = ((v & 0xFFF) * 0x1001001001001L & 0x84210842108421L) % 0x1F;
	    rc += (((v & 0xFFF000) >> 12) * 0x1001001001001L & 0x84210842108421L) % 0x1F;
	    rc += ((v >> 24) * 0x1001001001001L & 0x84210842108421L) % 0x1F;
	}
£>if (( $S > 4 )); then
	else
	{
	    rc = ones_64bits(v & (1L << 32L) - 1L);
	    rc += ones_64bits(v >>> 32);
	}
£>fi;fi;fi
	return rc;
    }
    
    /**
     * Calculate the number of set bits in an integer, naïve parallel version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static £{T} ones_parallel(£{T} value)
    {
	£{T} rc = value;
	rc = (£{T})(((rc >>  1) & (£{T})0xAAAAAAAAAAAAAAAAL) + (rc & (£{T})0xAAAAAAAAAAAAAAAAL));
	rc = (£{T})(((rc >>  2) & (£{T})0xCCCCCCCCCCCCCCCCL) + (rc & (£{T})0xCCCCCCCCCCCCCCCCL));
	rc = (£{T})(((rc >>  4) & (£{T})0xF0F0F0F0F0F0F0F0L) + (rc & (£{T})0xF0F0F0F0F0F0F0F0L));
£>(( $S > 1 )) &&
	rc = (£{T})(((rc >>  8) & (£{T})0xFF00FF00FF00FF00L) + (rc & (£{T})0xFF00FF00FF00FF00L));
£>(( $S > 2 )) &&
	rc = (£{T})(((rc >> 16) & (£{T})0xFFFF0000FFFF0000L) + (rc & (£{T})0xFFFF0000FFFF0000L));
£>(( $S > 4 )) &&
	rc = (£{T})(((rc >> 32) & (£{T})0xFFFFFFFF00000000L) + (rc & (£{T})0xFFFFFFFF00000000L));
	return rc;
    }
    
    /**
     * Calculate the number of set bits in an integer, optimised parallel version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static £{T} ones_optimised_parallel(£{T} value)
    {
	£{T} rc = (£{T})(value - ((value >> 1) & (£{T})0x5555555555555555L));
	rc = (£{T})(((rc >>  2) & (£{T})0x3333333333333333L) + (rc & (£{T})0x3333333333333333L));
	rc = (£{T})(((rc >>  4) + rc) & (£{T})0x0F0F0F0F0F0F0F0FL);
£>(( $S > 1 )) &&
	rc = (£{T})(((rc >>  8) + rc) & (£{T})0x00FF00FF00FF00FFL);
£>(( $S > 2 )) &&
	rc = (£{T})(((rc >> 16) + rc) & (£{T})0x0000FFFF0000FFFFL);
£>(( $S > 4 )) &&
	rc = (£{T})(((rc >> 32) + rc) & (£{T})0x00000000FFFFFFFFL);
	return rc;
    }
    
    /**
     * Calculate the number of set bits in an integer, parallel–64bits-like hybrid version, probably the best version
     * 
     * @param   value  The integer
     * @return         The number of set bits
     */
    public static £{T} ones_hybrid(£{T} value)
    {
£>L1="($T)$(bc <<< "(256^$S - 1) / 3")L"
£>L2="($T)$(bc <<< "(256^$S - 1) / 15 * 3")L"
£>L3="($T)$(bc <<< "(256^$S - 1) / 255 * 15")L"
£>L4="($T)$(bc <<< "(256^$S - 1) / 255")L"

	value -= (value >> 1) & £{L1};
	value = (£{T})((value & £{L2}) + ((value >> 2) & £{L2}));
	value = (£{T})((value + (value >> 4)) & £{L3});
	value = (£{T})((value * £{L4}) >> ((£{S} - 1) * 8));
	return value; /* Only applicable upto 128 bits */
    }
    
    /**
     * Compute the parity of all bits in an integer, naïve version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static £{T} parity_naïve(£{T} value)
    {
	£{T} rc = 0;
	while (value != 0)
	{
	    rc ^= 1;
	    value &= value - 1;
	}
	return rc;
    }
    
    /**
     * Compute the parity of all bits in an integer, parallel version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static £{T} parity_parallel(£{T} value)
    {
£>(( $S > 4 )) &&
	value ^= value >> 32;
£>(( $S > 2 )) &&
	value ^= value >> 16;
£>(( $S > 1 )) &&
	value ^= value >> 8;
	value ^= value >> 4;
	value ^= value >> 3;
	value ^= value >> 2;
	value ^= value >> 1;
	return (£{T})(value & 1);
    }
    
    /**
     * Compute the parity of all bits in an integer, partial lookup table version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static byte parity_table(£{T} value)
    {
£>(( $S > 4 )) &&
	value ^= value >> 32;
£>(( $S > 2 )) &&
	value ^= value >> 16;
£>(( $S > 1 )) &&
	value ^= value >> 8;
	return PARITY_TABLE_256[(int)value];
    }
    
    /**
     * Compute the parity of all bits in an integer, optimised parallel version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static int parity_optimised_parallel(£{T} value)
    {
£>(( $S > 4 )) &&
	value ^= value >> 32;
£>(( $S > 2 )) &&
	value ^= value >> 16;
£>(( $S > 1 )) &&
	value ^= value >> 8;
	value ^= value >> 4;
	return (0x6996 >> (value & 15)) & 1;
    }
    
    /**
     * Compute the parity of all bits in an integer, multiplication version
     * 
     * @param   value  The integer
     * @return         The parity
     */
    public static £{T} parity_multiplication(£{T} value)
    {
	value ^= value >> 1;
	value ^= value >> 2;
	value = (£{T})((value & (£{T})0x1111111111111111L) * (£{T})0x1111111111111111L);
	return (£{T})((value >> (£{S} - 4)) & 1);
    }
    
    /**
     * Reverse the order of all bits in an integer, naïve version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static £{T} reverse_naïve(£{T} value)
    {
	int s = £{S} * 8 - 1;
	£{T} rc = value;
	for (value >>>= 1; value != 0; value >>>= 1)
	{
	    rc <<= 1;
	    rc |= value & 1;
	    s--;
	}
	return (£{T})(rc << s);
    }
    
    /**
     * Reverse the order of all bits in an integer, parallel version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static £{T} reverse_parallel(£{T} value)
    {
	value = (£{T})(((value & (£{T})0x5555555555555555L) <<  1) | ((value >>  1) & (£{T})0x5555555555555555L));
	value = (£{T})(((value & (£{T})0x3333333333333333L) <<  2) | ((value >>  2) & (£{T})0x3333333333333333L));
	value = (£{T})(((value & (£{T})0x0F0F0F0F0F0F0F0FL) <<  4) | ((value >>  4) & (£{T})0x0F0F0F0F0F0F0F0FL));
£>(( $S > 1 )) &&
	value = (£{T})(((value & (£{T})0x00FF00FF00FF00FFL) <<  8) | ((value >>  8) & (£{T})0x00FF00FF00FF00FFL));
£>(( $S > 2 )) &&
	value = (£{T})(((value & (£{T})0x0000FFFF0000FFFFL) << 16) | ((value >> 16) & (£{T})0x0000FFFF0000FFFFL));
£>(( $S > 4 )) &&
	value = (£{T})(((value & (£{T})0x00000000FFFFFFFFL) << 32) | ((value >> 32) & (£{T})0x00000000FFFFFFFFL));
	return value;
    }
    
    /**
     * Reverse the order of all bits in an integer, partial lookup table version
     * 
     * @param   value  The integer
     * @return         The integer reversed
     */
    public static £{T} reverse_table(£{T} value)
    {
£>function _ { echo "(${T})(REVERSE_TABLE_256[(int)((value >> $1) & 255)] << $2)" ; }
	£{T} rc = 0;
£>for s in `seq 0 8 $(( $S - 8 ))`; do
	rc |= £(_ $s "($S - 8 - $s)");
£>done
	return rc;
    }
£>done
}