#Reuben Grinberg
#reuben dot grinberg at aya dot yale dot e d u
class Array
    def  jj() return "[#{self.join(",")}]"; end

    def replaceWith(a, b)
        Array.new(self).replaceWith!(a,b)
    end

    def replaceWith!(a, b)
#        map! { |obj| obj == a ? b : obj }

        each_with_index { |obj, i| self[i] = b if obj == a }
        self
    end

    def copy() return Array.new(self);  end

    def slidingPairs(&block)
        self[0,length-1].zip(cdr).map(&block)
    end

    def transpose!() return replace(transpose); end

    def diff!(other) return replace(diff(other)) end

    def diff(other)
        zip(other).map{|x,y| (x-y) }
    end

    def diffabs(other)
        zip(other).map{|x,y| (x-y).abs }
    end

    def sum(&block)
        map(&block).inject { |sum, obj| sum+obj }
    end

    def product(&block)
        map(&block).inject {|prod,obj| prod*obj }
    end

    def mean(&block)
        sum(&block)/length.to_f
    end

    def to_hash
        inject({}) {|h, k| h[k[0]] = k[1]; h }
    end

    def mean_stdev
        m = mean
        return [m, Math.sqrt(mean { |v| (v - m) ** 2 } )]
    end

    def stdev() return mean_stdev[1]; end

    # the whole list except the first element
    def cdr() return self[1...length]; end

    def set(inds, value)
        inds.each{ |i| self[i] = value }
        self
    end

    def matchingIndices(b)
        indices.select { |i| self[i] == b[i] }
    end

    def location
        # return a Vector object of me and don't copy me but use a reference.
        Vector.elements(self, false)
    end

    def mode() return mode_count[0]; end

    def mode_count
        h = inject(Hash.new(0)) { |hash, v| hash[v]+=1; hash }
        mx = h.values.max
        [h.invert[mx], mx]
    end

    def count(v) return grep(v).length; end

    #same as flatten except it doesn't work recursively - just flattens once
    def flatten_once
        inject([]) { |vals, a| Array === a ? vals += a : vals << a }
    end

    def indices
        (0...length).to_a
    end

    def flatten_once!
        replace(flatten_once)
    end

    # removes runs of the same element
    def squeeze
        inject([]) { |arr, v| arr << v if v!=arr.last || arr.empty?; arr }
    end

    def bag_by
        bags = Hash.new {|h,k| h[k] = [] }
        each { |v| bags[yield(v)] << v }
        bags
    end

    def uniform
        uniq.length == 1
    end

    def recursiveGet
        return map { |e| e.respond_to?(:recursiveGet) ? e.recursiveGet() : e }.flatten
    end
end