Package io.deephaven.chunk.util.hashing

Interface ChunkEquals

All Known Implementing Classes:
BooleanChunkEquals, ByteChunkEquals, CharChunkEquals, DoubleChunkEquals, FloatChunkEquals, IntChunkEquals, LongChunkEquals, ObjectChunkEquals, ObjectChunkIdentityEquals, ShortChunkEquals
public interface ChunkEquals

  • Method Details

    • equalReduce

      boolean equalReduce(Chunk<? extends Any> lhs, Chunk<? extends Any> rhs)
      Returns true iff the chunks have the same size() and each corresponding element of the chunk compares equal.
      Parameters:
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison

    • equal

      void equal(Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for the first (or only) pair of chunks, sets the corresponding destination entry to true if the values are equal, or false otherwise
      Parameters:
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • equalNext

      void equalNext(Chunk<? extends Any> chunk, WritableBooleanChunk destination)
      For each pair of indices i and i + 1 in chunk; write true to destination[i] if they are equal, otherwise write false.
      Parameters:
      chunk - the chunk to compare subsequent values in
      destination - the chunk to write equality values into, size is chunk.size() - 1

    • equalPermuted

      void equalPermuted(IntChunk<ChunkPositions> lhsPositions, IntChunk<ChunkPositions> rhsPositions, Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for the first (or only) pair of chunks, sets the corresponding destination entry to true if lhs[lhsPositions] == rhs[rhsPositions].
      Parameters:
      lhsPositions - the positions within left-hand side of the comparison
      rhsPositions - the positions within the right-hand side of the comparison
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • equalLhsPermuted

      void equalLhsPermuted(IntChunk<ChunkPositions> lhsPositions, Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for the first (or only) pair of chunks, sets the corresponding destination entry to true if lhs[lhsPositions] == rhs.
      Parameters:
      lhsPositions - the positions within left-hand side of the comparison
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • andEqual

      void andEqual(Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for subsequent pair of chunks, if the corresponding destination entry is false, do nothing. If true, then set to false if the corresponding values are not equal.
      Parameters:
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • andEqualNext

      void andEqualNext(Chunk<? extends Any> chunk, WritableBooleanChunk destination)
      For each pair of indices i and i + 1 in chunk; if destination[i] is false do nothing, otherwise write true to destination[i] if they are equal.
      Parameters:
      chunk - the chunk to compare subsequent values in
      destination - the chunk to write equality values into, size is chunk.size() - 1

    • andEqualPermuted

      void andEqualPermuted(IntChunk<ChunkPositions> lhsPositions, IntChunk<ChunkPositions> rhsPositions, Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      If destination[i] is false do nothing, otherwise, sets the corresponding destination entry to true if lhs[lhsPositions] == rhs[rhsPositions].
      Parameters:
      lhsPositions - the positions within left-hand side of the comparison
      rhsPositions - the positions within the right-hand side of the comparison
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • andEqualLhsPermuted

      void andEqualLhsPermuted(IntChunk<ChunkPositions> lhsPositions, Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      If destination[i] is false do nothing, otherwise, sets the corresponding destination entry to true if lhs[lhsPositions] == rhs.
      Parameters:
      lhsPositions - the positions within left-hand side of the comparison
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • notEqual

      void notEqual(Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for the first (or only) pair of chunks, sets the corresponding destination entry to true if the values are not equal, or false otherwise
      Parameters:
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • andNotEqual

      void andNotEqual(Chunk<? extends Any> lhs, Chunk<? extends Any> rhs, WritableBooleanChunk destination)
      Called for subsequent pair of chunks, if the corresponding destination entry is false, do nothing. If true, then set to false if the corresponding values are equal.
      Parameters:
      lhs - the left-hand side of the comparison
      rhs - the right-hand side of the comparison
      destination - the chunk to write equality values into

    • equalPairs

      void equalPairs(IntChunk<ChunkPositions> chunkPositionsToCheckForEquality, Chunk<? extends Any> valuesChunk, WritableBooleanChunk destinations)
      Compares valuesChunk[chunkPositionsToCheckForEquality[pp * 2]] and valuesChunk[chunkPositionsToCheckForEquality[pp * 2 + 1]] for each even/odd pair in chunkPositionsToCheckForEquality and writes the result to destinations.
      Parameters:
      chunkPositionsToCheckForEquality - the position pairs of interest
      valuesChunk - the chunk of values we are interested in
      destinations - the destination chunk to write equality values into

    • andEqualPairs

      void andEqualPairs(IntChunk<ChunkPositions> chunkPositionsToCheckForEquality, Chunk<? extends Any> valuesChunk, WritableBooleanChunk destinations)
      Compares valuesChunk[chunkPositionsToCheckForEquality[pp * 2]] and valuesChunk[chunkPositionsToCheckForEquality[pp * 2 + 1]] for each even/odd pair in chunkPositionsToCheckForEquality and writes the result to destinations.
      Parameters:
      chunkPositionsToCheckForEquality - the position pairs of interest
      valuesChunk - the chunk of values we are interested in
      destinations - the destination chunk to write equality values into

    • makeEqual

      static ChunkEquals makeEqual(ChunkType chunkType)