Class Mappings

    • Constructor Detail

      • Mappings

        private Mappings()
    • Method Detail

      • create

        public static Mapping create​(MappingType mappingType,
                                     int sourceCount,
                                     int targetCount)
        Creates a mapping with required properties.
      • createIdentity

        public static Mappings.IdentityMapping createIdentity​(int fieldCount)
        Creates the identity mapping.

        For example, createIdentity(2) returns the mapping {0:0, 1:1, 2:2}.

        Parameters:
        fieldCount - Number of sources/targets
        Returns:
        Identity mapping
      • invert

        public static Mapping invert​(Mapping mapping)
        Converts a mapping to its inverse.
      • divide

        public static Mapping divide​(Mapping mapping1,
                                     Mapping mapping2)
        Divides one mapping by another.

        divide(A, B) returns a mapping C such that B . C (the mapping B followed by the mapping C) is equivalent to A.

        Parameters:
        mapping1 - First mapping
        mapping2 - Second mapping
        Returns:
        Mapping mapping3 such that mapping1 = mapping2 . mapping3
      • multiply

        public static Mapping multiply​(Mapping mapping1,
                                       Mapping mapping2)
        Multiplies one mapping by another.

        divide(A, B) returns a mapping C such that B . C (the mapping B followed by the mapping C) is equivalent to A.

        Parameters:
        mapping1 - First mapping
        mapping2 - Second mapping
        Returns:
        Mapping mapping3 such that mapping1 = mapping2 . mapping3
      • apply

        public static java.util.BitSet apply​(Mapping mapping,
                                             java.util.BitSet bitSet)
        Applies a mapping to a BitSet.

        If the mapping does not affect the bit set, returns the original. Never changes the original.

        Parameters:
        mapping - Mapping
        bitSet - Bit set
        Returns:
        Bit set with mapping applied
      • apply

        public static ImmutableBitSet apply​(Mapping mapping,
                                            ImmutableBitSet bitSet)
        Applies a mapping to an ImmutableBitSet.

        If the mapping does not affect the bit set, returns the original. Never changes the original.

        Parameters:
        mapping - Mapping
        bitSet - Bit set
        Returns:
        Bit set with mapping applied
      • apply2

        public static com.google.common.collect.ImmutableList<ImmutableBitSet> apply2​(Mapping mapping,
                                                                                      java.lang.Iterable<ImmutableBitSet> bitSets)
        Applies a mapping to a collection of ImmutableBitSets.
        Parameters:
        mapping - Mapping
        bitSets - Collection of bit sets
        Returns:
        Sorted bit sets with mapping applied
      • apply

        public static <T> java.util.List<T> apply​(Mapping mapping,
                                                  java.util.List<T> list)
        Applies a mapping to a list.
        Type Parameters:
        T - Element type
        Parameters:
        mapping - Mapping
        list - List
        Returns:
        List with elements permuted according to mapping
      • apply2

        public static java.util.List<java.lang.Integer> apply2​(Mapping mapping,
                                                               java.util.List<java.lang.Integer> list)
      • apply3

        public static <T> java.util.List<T> apply3​(Mapping mapping,
                                                   java.util.List<T> list)
        Creates a view of a list, permuting according to a mapping.
        Type Parameters:
        T - Element type
        Parameters:
        mapping - Mapping
        list - List
        Returns:
        Permuted view of list
      • permute

        public static <T> java.util.List<T> permute​(java.util.List<T> list,
                                                    Mappings.TargetMapping mapping)
        Creates a view of a list, permuting according to a target mapping.
        Type Parameters:
        T - Element type
        Parameters:
        mapping - Mapping
        list - List
        Returns:
        Permuted view of list
      • asList

        public static java.util.List<java.lang.Integer> asList​(Mappings.TargetMapping mapping)
        Returns a mapping as a list such that list.get(source) is mapping.getTarget(source) and list.size() is mapping.getSourceCount().

        Converse of target(List, int)

      • target

        public static Mappings.TargetMapping target​(java.util.function.IntFunction<java.lang.Integer> function,
                                                    int sourceCount,
                                                    int targetCount)
      • target

        public static Mapping target​(java.lang.Iterable<IntPair> pairs,
                                     int sourceCount,
                                     int targetCount)
      • source

        public static Mapping source​(java.util.List<java.lang.Integer> targets,
                                     int targetCount)
      • target

        public static Mapping target​(java.util.List<java.lang.Integer> sources,
                                     int sourceCount)
      • bijection

        public static Mapping bijection​(java.util.List<java.lang.Integer> targets)
        Creates a bijection.

        Throws if sources and targets are not one to one.

      • bijection

        public static Mapping bijection​(java.util.Map<java.lang.Integer,​java.lang.Integer> targets)
        Creates a bijection.

        Throws if sources and targets are not one to one.

      • isIdentity

        public static boolean isIdentity​(Mappings.TargetMapping mapping)
        Returns whether a mapping is the identity.
      • keepsOrdering

        public static boolean keepsOrdering​(Mappings.TargetMapping mapping)
        Returns whether a mapping keeps order.

        For example, {0:0, 1:1} and {0:1, 1:1} keeps order, and {0:1, 1:0} breaks the initial order.

      • createShiftMapping

        public static Mappings.TargetMapping createShiftMapping​(int sourceCount,
                                                                int... ints)
        Creates a mapping that consists of a set of contiguous ranges.

        For example,

        createShiftMapping(60,
             100, 0, 3,
             200, 50, 5);
         

        creates

        Example mapping
        SourceTarget
        0100
        1101
        2102
        3-1
        ...-1
        50200
        51201
        52202
        53203
        54204
        55-1
        ...-1
        59-1
        Parameters:
        sourceCount - Maximum value of source
        ints - Collection of ranges, each (target, source, count)
        Returns:
        Mapping that maps from source ranges to target ranges
      • offsetSource

        public static Mappings.TargetMapping offsetSource​(Mappings.TargetMapping mapping,
                                                          int offset)
        Returns a mapping that shifts a given mapping's source by a given offset, incrementing the number of sources by the minimum possible.
        Parameters:
        mapping - Input mapping
        offset - Offset to be applied to each source
        Returns:
        Shifted mapping
      • offsetSource

        public static Mappings.TargetMapping offsetSource​(Mappings.TargetMapping mapping,
                                                          int offset,
                                                          int sourceCount)
        Returns a mapping that shifts a given mapping's source by a given offset.

        For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3) returns a mapping with sourceCount=5, targetCount=8, and (source, target) entries {[3: 5], [4: 7]}.

        Parameters:
        mapping - Input mapping
        offset - Offset to be applied to each source
        sourceCount - New source count; must be at least mapping's source count plus offset
        Returns:
        Shifted mapping
      • offsetTarget

        public static Mappings.TargetMapping offsetTarget​(Mappings.TargetMapping mapping,
                                                          int offset)
        Returns a mapping that shifts a given mapping's target by a given offset, incrementing the number of targets by the minimum possible.
        Parameters:
        mapping - Input mapping
        offset - Offset to be applied to each target
        Returns:
        Shifted mapping
      • offsetTarget

        public static Mappings.TargetMapping offsetTarget​(Mappings.TargetMapping mapping,
                                                          int offset,
                                                          int targetCount)
        Returns a mapping that shifts a given mapping's target by a given offset.

        For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetTarget(mapping, 3) returns a mapping with sourceCount=2, targetCount=11, and (source, target) entries {[0: 8], [1: 10]}.

        Parameters:
        mapping - Input mapping
        offset - Offset to be applied to each target
        targetCount - New target count; must be at least mapping's target count plus offset
        Returns:
        Shifted mapping
      • offset

        public static Mappings.TargetMapping offset​(Mappings.TargetMapping mapping,
                                                    int offset,
                                                    int sourceCount)
        Returns a mapping that shifts a given mapping's source and target by a given offset.

        For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3) returns a mapping with sourceCount=5, targetCount=8, and (source, target) entries {[3: 8], [4: 10]}.

        Parameters:
        mapping - Input mapping
        offset - Offset to be applied to each source
        sourceCount - New source count; must be at least mapping's source count plus offset
        Returns:
        Shifted mapping
      • isIdentity

        public static boolean isIdentity​(java.util.List<java.lang.Integer> list,
                                         int count)
        Returns whether a list of integers is the identity mapping [0, ..., n - 1].
      • invert

        public static java.lang.Iterable<IntPair> invert​(java.lang.Iterable<IntPair> pairs)
        Inverts an Iterable over IntPairs.
      • invert

        public static java.util.Iterator<IntPair> invert​(java.util.Iterator<IntPair> pairs)
        Inverts an Iterator over IntPairs.
      • apply

        public static int apply​(Mappings.TargetMapping mapping,
                                int i)
        Applies a mapping to an optional integer, returning an optional result.