package com.google.common.primitives;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Converter;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.RandomAccess;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.Nullable;

@GwtCompatible(emulated=true)
public final class Floats
{
  public static final int BYTES = 4;
  
  public static List<Float> asList(float... paramVarArgs)
  {
    if (paramVarArgs.length == 0) {
      return Collections.emptyList();
    }
    return new a(paramVarArgs);
  }
  
  private static int c(float[] paramArrayOfFloat, float paramFloat, int paramInt1, int paramInt2)
  {
    while (paramInt1 < paramInt2)
    {
      if (paramArrayOfFloat[paramInt1] == paramFloat) {
        return paramInt1;
      }
      paramInt1 += 1;
    }
    return -1;
  }
  
  public static int compare(float paramFloat1, float paramFloat2)
  {
    return Float.compare(paramFloat1, paramFloat2);
  }
  
  public static float[] concat(float[]... paramVarArgs)
  {
    int k = paramVarArgs.length;
    int i = 0;
    int j = 0;
    while (i < k)
    {
      j += paramVarArgs[i].length;
      i += 1;
    }
    float[] arrayOfFloat1 = new float[j];
    k = paramVarArgs.length;
    j = 0;
    i = 0;
    while (i < k)
    {
      float[] arrayOfFloat2 = paramVarArgs[i];
      System.arraycopy(arrayOfFloat2, 0, arrayOfFloat1, j, arrayOfFloat2.length);
      j += arrayOfFloat2.length;
      i += 1;
    }
    return arrayOfFloat1;
  }
  
  public static boolean contains(float[] paramArrayOfFloat, float paramFloat)
  {
    boolean bool2 = false;
    int j = paramArrayOfFloat.length;
    int i = 0;
    for (;;)
    {
      boolean bool1 = bool2;
      if (i < j)
      {
        if (paramArrayOfFloat[i] == paramFloat) {
          bool1 = true;
        }
      }
      else {
        return bool1;
      }
      i += 1;
    }
  }
  
  private static int d(float[] paramArrayOfFloat, float paramFloat, int paramInt1, int paramInt2)
  {
    paramInt2 -= 1;
    while (paramInt2 >= paramInt1)
    {
      if (paramArrayOfFloat[paramInt2] == paramFloat) {
        return paramInt2;
      }
      paramInt2 -= 1;
    }
    return -1;
  }
  
  public static float[] ensureCapacity(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    if (paramInt1 >= 0)
    {
      bool = true;
      Preconditions.checkArgument(bool, "Invalid minLength: %s", new Object[] { Integer.valueOf(paramInt1) });
      if (paramInt2 < 0) {
        break label86;
      }
    }
    label86:
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Invalid padding: %s", new Object[] { Integer.valueOf(paramInt2) });
      float[] arrayOfFloat = paramArrayOfFloat;
      if (paramArrayOfFloat.length < paramInt1)
      {
        paramInt1 += paramInt2;
        arrayOfFloat = new float[paramInt1];
        System.arraycopy(paramArrayOfFloat, 0, arrayOfFloat, 0, Math.min(paramArrayOfFloat.length, paramInt1));
      }
      return arrayOfFloat;
      bool = false;
      break;
    }
  }
  
  public static int hashCode(float paramFloat)
  {
    return Float.valueOf(paramFloat).hashCode();
  }
  
  public static int indexOf(float[] paramArrayOfFloat, float paramFloat)
  {
    return c(paramArrayOfFloat, paramFloat, 0, paramArrayOfFloat.length);
  }
  
  public static int indexOf(float[] paramArrayOfFloat1, float[] paramArrayOfFloat2)
  {
    Preconditions.checkNotNull(paramArrayOfFloat1, "array");
    Preconditions.checkNotNull(paramArrayOfFloat2, "target");
    if (paramArrayOfFloat2.length == 0) {
      return 0;
    }
    int i = 0;
    while (i < paramArrayOfFloat1.length - paramArrayOfFloat2.length + 1)
    {
      int j = 0;
      while (j < paramArrayOfFloat2.length)
      {
        if (paramArrayOfFloat1[(i + j)] != paramArrayOfFloat2[j]) {
          break label63;
        }
        j += 1;
      }
      return i;
      label63:
      i += 1;
    }
    return -1;
  }
  
  public static boolean isFinite(float paramFloat)
  {
    int j = 1;
    int i;
    if (Float.NEGATIVE_INFINITY < paramFloat)
    {
      i = 1;
      if (paramFloat >= Float.POSITIVE_INFINITY) {
        break label27;
      }
    }
    for (;;)
    {
      return j & i;
      i = 0;
      break;
      label27:
      j = 0;
    }
  }
  
  public static String join(String paramString, float... paramVarArgs)
  {
    Preconditions.checkNotNull(paramString);
    if (paramVarArgs.length == 0) {
      return "";
    }
    StringBuilder localStringBuilder = new StringBuilder(paramVarArgs.length * 12);
    localStringBuilder.append(paramVarArgs[0]);
    int i = 1;
    while (i < paramVarArgs.length)
    {
      localStringBuilder.append(paramString).append(paramVarArgs[i]);
      i += 1;
    }
    return localStringBuilder.toString();
  }
  
  public static int lastIndexOf(float[] paramArrayOfFloat, float paramFloat)
  {
    return d(paramArrayOfFloat, paramFloat, 0, paramArrayOfFloat.length);
  }
  
  public static Comparator<float[]> lexicographicalComparator()
  {
    return c.a;
  }
  
  public static float max(float... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    float f;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      f = paramVarArgs[0];
      while (i < paramVarArgs.length)
      {
        f = Math.max(f, paramVarArgs[i]);
        i += 1;
      }
    }
    return f;
  }
  
  public static float min(float... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    float f;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      f = paramVarArgs[0];
      while (i < paramVarArgs.length)
      {
        f = Math.min(f, paramVarArgs[i]);
        i += 1;
      }
    }
    return f;
  }
  
  @Beta
  public static Converter<String, Float> stringConverter()
  {
    return b.a;
  }
  
  public static float[] toArray(Collection<? extends Number> paramCollection)
  {
    int i = 0;
    if ((paramCollection instanceof a))
    {
      paramCollection = (a)paramCollection;
      i = paramCollection.size();
      arrayOfFloat = new float[i];
      System.arraycopy(paramCollection.a, paramCollection.b, arrayOfFloat, 0, i);
      return arrayOfFloat;
    }
    paramCollection = paramCollection.toArray();
    int j = paramCollection.length;
    float[] arrayOfFloat = new float[j];
    while (i < j)
    {
      arrayOfFloat[i] = ((Number)Preconditions.checkNotNull(paramCollection[i])).floatValue();
      i += 1;
    }
    return arrayOfFloat;
  }
  
  @Nullable
  @Beta
  @GwtIncompatible("regular expressions")
  public static Float tryParse(String paramString)
  {
    if (Doubles.a.matcher(paramString).matches()) {
      try
      {
        float f = Float.parseFloat(paramString);
        return Float.valueOf(f);
      }
      catch (NumberFormatException paramString) {}
    }
    return null;
  }
  
  @GwtCompatible
  static final class a
    extends AbstractList<Float>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final float[] a;
    final int b;
    final int c;
    
    a(float[] paramArrayOfFloat)
    {
      this(paramArrayOfFloat, 0, paramArrayOfFloat.length);
    }
    
    private a(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
    {
      this.a = paramArrayOfFloat;
      this.b = paramInt1;
      this.c = paramInt2;
    }
    
    public final boolean contains(Object paramObject)
    {
      return ((paramObject instanceof Float)) && (Floats.a(this.a, ((Float)paramObject).floatValue(), this.b, this.c) != -1);
    }
    
    public final boolean equals(Object paramObject)
    {
      if (paramObject == this) {}
      for (;;)
      {
        return true;
        if (!(paramObject instanceof a)) {
          break;
        }
        paramObject = (a)paramObject;
        int j = size();
        if (((a)paramObject).size() != j) {
          return false;
        }
        int i = 0;
        while (i < j)
        {
          if (this.a[(this.b + i)] != paramObject.a[(paramObject.b + i)]) {
            return false;
          }
          i += 1;
        }
      }
      return super.equals(paramObject);
    }
    
    public final int hashCode()
    {
      int j = 1;
      int i = this.b;
      while (i < this.c)
      {
        j = j * 31 + Floats.hashCode(this.a[i]);
        i += 1;
      }
      return j;
    }
    
    public final int indexOf(Object paramObject)
    {
      if ((paramObject instanceof Float))
      {
        int i = Floats.a(this.a, ((Float)paramObject).floatValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final int lastIndexOf(Object paramObject)
    {
      if ((paramObject instanceof Float))
      {
        int i = Floats.b(this.a, ((Float)paramObject).floatValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final int size()
    {
      return this.c - this.b;
    }
    
    public final List<Float> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      if (paramInt1 == paramInt2) {
        return Collections.emptyList();
      }
      return new a(this.a, this.b + paramInt1, this.b + paramInt2);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder(size() * 12);
      localStringBuilder.append('[').append(this.a[this.b]);
      int i = this.b + 1;
      while (i < this.c)
      {
        localStringBuilder.append(", ").append(this.a[i]);
        i += 1;
      }
      return ']';
    }
  }
  
  static final class b
    extends Converter<String, Float>
    implements Serializable
  {
    static final b a = new b();
    private static final long serialVersionUID = 1L;
    
    private Object readResolve()
    {
      return a;
    }
    
    public final String toString()
    {
      return "Floats.stringConverter()";
    }
  }
  
  static enum c
    implements Comparator<float[]>
  {
    private c() {}
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/primitives/Floats.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */