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 Doubles
{
  public static final int BYTES = 8;
  @GwtIncompatible("regular expressions")
  static final Pattern a;
  
  static
  {
    String str1 = String.valueOf("(?:\\d++(?:\\.\\d*+)?|\\.\\d++)").concat("(?:[eE][+-]?\\d++)?[fFdD]?");
    String str2 = String.valueOf(String.valueOf("(?:\\p{XDigit}++(?:\\.\\p{XDigit}*+)?|\\.\\p{XDigit}++)"));
    str2 = str2.length() + 25 + "0[xX]" + str2 + "[pP][+-]?\\d++[fFdD]?";
    str1 = String.valueOf(String.valueOf(str1));
    str2 = String.valueOf(String.valueOf(str2));
    a = Pattern.compile(str1.length() + 23 + str2.length() + "[+-]?(?:NaN|Infinity|" + str1 + "|" + str2 + ")");
  }
  
  public static List<Double> asList(double... paramVarArgs)
  {
    if (paramVarArgs.length == 0) {
      return Collections.emptyList();
    }
    return new a(paramVarArgs);
  }
  
  private static int c(double[] paramArrayOfDouble, double paramDouble, int paramInt1, int paramInt2)
  {
    while (paramInt1 < paramInt2)
    {
      if (paramArrayOfDouble[paramInt1] == paramDouble) {
        return paramInt1;
      }
      paramInt1 += 1;
    }
    return -1;
  }
  
  public static int compare(double paramDouble1, double paramDouble2)
  {
    return Double.compare(paramDouble1, paramDouble2);
  }
  
  public static double[] concat(double[]... paramVarArgs)
  {
    int k = paramVarArgs.length;
    int i = 0;
    int j = 0;
    while (i < k)
    {
      j += paramVarArgs[i].length;
      i += 1;
    }
    double[] arrayOfDouble1 = new double[j];
    k = paramVarArgs.length;
    j = 0;
    i = 0;
    while (i < k)
    {
      double[] arrayOfDouble2 = paramVarArgs[i];
      System.arraycopy(arrayOfDouble2, 0, arrayOfDouble1, j, arrayOfDouble2.length);
      j += arrayOfDouble2.length;
      i += 1;
    }
    return arrayOfDouble1;
  }
  
  public static boolean contains(double[] paramArrayOfDouble, double paramDouble)
  {
    boolean bool2 = false;
    int j = paramArrayOfDouble.length;
    int i = 0;
    for (;;)
    {
      boolean bool1 = bool2;
      if (i < j)
      {
        if (paramArrayOfDouble[i] == paramDouble) {
          bool1 = true;
        }
      }
      else {
        return bool1;
      }
      i += 1;
    }
  }
  
  private static int d(double[] paramArrayOfDouble, double paramDouble, int paramInt1, int paramInt2)
  {
    paramInt2 -= 1;
    while (paramInt2 >= paramInt1)
    {
      if (paramArrayOfDouble[paramInt2] == paramDouble) {
        return paramInt2;
      }
      paramInt2 -= 1;
    }
    return -1;
  }
  
  public static double[] ensureCapacity(double[] paramArrayOfDouble, 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) });
      double[] arrayOfDouble = paramArrayOfDouble;
      if (paramArrayOfDouble.length < paramInt1)
      {
        paramInt1 += paramInt2;
        arrayOfDouble = new double[paramInt1];
        System.arraycopy(paramArrayOfDouble, 0, arrayOfDouble, 0, Math.min(paramArrayOfDouble.length, paramInt1));
      }
      return arrayOfDouble;
      bool = false;
      break;
    }
  }
  
  public static int hashCode(double paramDouble)
  {
    return Double.valueOf(paramDouble).hashCode();
  }
  
  public static int indexOf(double[] paramArrayOfDouble, double paramDouble)
  {
    return c(paramArrayOfDouble, paramDouble, 0, paramArrayOfDouble.length);
  }
  
  public static int indexOf(double[] paramArrayOfDouble1, double[] paramArrayOfDouble2)
  {
    Preconditions.checkNotNull(paramArrayOfDouble1, "array");
    Preconditions.checkNotNull(paramArrayOfDouble2, "target");
    if (paramArrayOfDouble2.length == 0) {
      return 0;
    }
    int i = 0;
    while (i < paramArrayOfDouble1.length - paramArrayOfDouble2.length + 1)
    {
      int j = 0;
      while (j < paramArrayOfDouble2.length)
      {
        if (paramArrayOfDouble1[(i + j)] != paramArrayOfDouble2[j]) {
          break label63;
        }
        j += 1;
      }
      return i;
      label63:
      i += 1;
    }
    return -1;
  }
  
  public static boolean isFinite(double paramDouble)
  {
    int j = 1;
    int i;
    if (Double.NEGATIVE_INFINITY < paramDouble)
    {
      i = 1;
      if (paramDouble >= Double.POSITIVE_INFINITY) {
        break label29;
      }
    }
    for (;;)
    {
      return j & i;
      i = 0;
      break;
      label29:
      j = 0;
    }
  }
  
  public static String join(String paramString, double... 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(double[] paramArrayOfDouble, double paramDouble)
  {
    return d(paramArrayOfDouble, paramDouble, 0, paramArrayOfDouble.length);
  }
  
  public static Comparator<double[]> lexicographicalComparator()
  {
    return c.a;
  }
  
  public static double max(double... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    double d;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      d = paramVarArgs[0];
      while (i < paramVarArgs.length)
      {
        d = Math.max(d, paramVarArgs[i]);
        i += 1;
      }
    }
    return d;
  }
  
  public static double min(double... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    double d;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      d = paramVarArgs[0];
      while (i < paramVarArgs.length)
      {
        d = Math.min(d, paramVarArgs[i]);
        i += 1;
      }
    }
    return d;
  }
  
  @Beta
  public static Converter<String, Double> stringConverter()
  {
    return b.a;
  }
  
  public static double[] toArray(Collection<? extends Number> paramCollection)
  {
    int i = 0;
    if ((paramCollection instanceof a))
    {
      paramCollection = (a)paramCollection;
      i = paramCollection.size();
      arrayOfDouble = new double[i];
      System.arraycopy(paramCollection.a, paramCollection.b, arrayOfDouble, 0, i);
      return arrayOfDouble;
    }
    paramCollection = paramCollection.toArray();
    int j = paramCollection.length;
    double[] arrayOfDouble = new double[j];
    while (i < j)
    {
      arrayOfDouble[i] = ((Number)Preconditions.checkNotNull(paramCollection[i])).doubleValue();
      i += 1;
    }
    return arrayOfDouble;
  }
  
  @Nullable
  @Beta
  @GwtIncompatible("regular expressions")
  public static Double tryParse(String paramString)
  {
    if (a.matcher(paramString).matches()) {
      try
      {
        double d = Double.parseDouble(paramString);
        return Double.valueOf(d);
      }
      catch (NumberFormatException paramString) {}
    }
    return null;
  }
  
  @GwtCompatible
  static final class a
    extends AbstractList<Double>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final double[] a;
    final int b;
    final int c;
    
    a(double[] paramArrayOfDouble)
    {
      this(paramArrayOfDouble, 0, paramArrayOfDouble.length);
    }
    
    private a(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
    {
      this.a = paramArrayOfDouble;
      this.b = paramInt1;
      this.c = paramInt2;
    }
    
    public final boolean contains(Object paramObject)
    {
      return ((paramObject instanceof Double)) && (Doubles.a(this.a, ((Double)paramObject).doubleValue(), 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 + Doubles.hashCode(this.a[i]);
        i += 1;
      }
      return j;
    }
    
    public final int indexOf(Object paramObject)
    {
      if ((paramObject instanceof Double))
      {
        int i = Doubles.a(this.a, ((Double)paramObject).doubleValue(), 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 Double))
      {
        int i = Doubles.b(this.a, ((Double)paramObject).doubleValue(), 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<Double> 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, Double>
    implements Serializable
  {
    static final b a = new b();
    private static final long serialVersionUID = 1L;
    
    private Object readResolve()
    {
      return a;
    }
    
    public final String toString()
    {
      return "Doubles.stringConverter()";
    }
  }
  
  static enum c
    implements Comparator<double[]>
  {
    private c() {}
  }
}


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