Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.aggregation;
 
 
 import java.util.List;
 
 import static com.facebook.presto.operator.aggregation.AggregationTestUtils.assertApproximateAggregation;
 import static com.facebook.presto.operator.aggregation.AggregationTestUtils.getFinalBlock;
 import static com.facebook.presto.spi.type.BigintType.BIGINT;
 import static com.facebook.presto.spi.type.DoubleType.DOUBLE;
 import static org.testng.Assert.assertTrue;
 
         extends AbstractTestAggregationFunction
 {
     private static final int WEIGHT = 10;
 
     protected abstract Type getType();
 
     // values may contain nulls
     protected abstract Double getExpectedValue(List<Numbervalues);
 
     @Override
     public double getConfidence()
     {
         return 0.5;
     }
 
     @Override
     protected boolean isApproximate()
     {
         return true;
     }
 
     @Override
     protected List<StringgetFunctionParameterTypes()
     {
         return ImmutableList.of(getType().getTypeSignature().toString());
     }
 
     @Override
     public Block[] getSequenceBlocks(int startint length)
     {
         BlockBuilder blockBuilder = getType().createBlockBuilder(new BlockBuilderStatus(), length);
         for (int i = starti < start + lengthi++) {
             if (getType().equals()) {
                 .writeLong(blockBuilder, (longi);
             }
             else {
                 .writeDouble(blockBuilder, (doublei);
             }
         }
         return new Block[] {blockBuilder.build()};
     }
 
     @Override
     public Double getExpectedValue(int startint length)
     {
         List<Numbervalues = new ArrayList<>();
         for (int i = 0; i < lengthi++) {
             if (getType().equals()) {
                 for (int j = 0; j < j++) {
                     values.add((longstart + i);
                 }
             }
             else {
                 for (int j = 0; j < j++) {
                     values.add((doublestart + i);
                 }
             }
         }
 
         return getExpectedValue(values);
     }
    @Override
    public Double getExpectedValueIncludingNulls(int startint lengthint lengthIncludingNulls)
    {
        List<Numbervalues = new ArrayList<>();
        for (int i = 0; i < lengthi++) {
            if (getType().equals()) {
                for (int j = 0; j < j++) {
                    values.add((longstart + i);
                }
            }
            else {
                for (int j = 0; j < j++) {
                    values.add((doublestart + i);
                }
            }
        }
        for (int i = lengthi < lengthIncludingNullsi++) {
            for (int j = 0; j < j++) {
                values.add(null);
            }
        }
        return getExpectedValue(values);
    }
    @Test
    public void testCorrectnessOnGaussianData()
            throws Exception
    {
        int originalDataSize = 10000;
        Random distribution = new Random(0);
        List<Numberlist = new ArrayList<>();
        for (int i = 0; i < originalDataSizei++) {
            list.add(distribution.nextGaussian() * 100);
        }
        testCorrectnessOfErrorFunction(list);
    }
    @Test
    public void testCorrectnessOnUniformData()
            throws Exception
    {
        int originalDataSize = 10000;
        Random distribution = new Random(0);
        List<Numberlist = new ArrayList<>();
        for (int i = 0; i < originalDataSizei++) {
            list.add(distribution.nextDouble() * 1000);
        }
        testCorrectnessOfErrorFunction(list);
    }
    private void testCorrectnessOfErrorFunction(List<NumberinputList)
            throws Exception
    {
        int inRange = 0;
        int numberOfRuns = 1000;
        double sampleRatio = 1 / (double;
        double actual = getExpectedValue(inputList);
        Random rand = new Random(1);
        for (int i = 0; i < numberOfRunsi++) {
            //Compute Sampled Value using sampledList (numberOfRuns times)
            ImmutableList.Builder<NumbersampledList = ImmutableList.builder();
            for (Number x : inputList) {
                if (rand.nextDouble() < sampleRatio) {
                    sampledList.add(x);
                }
            }
            ImmutableList<Numberlist = sampledList.build();
            BlockBuilder builder = getType().createBlockBuilder(new BlockBuilderStatus(), list.size());
            for (Number sample : list) {
                if (getType().equals()) {
                    .writeLong(buildersample.longValue());
                }
                else if (getType().equals()) {
                    .writeDouble(buildersample.doubleValue());
                }
                else {
                    throw new AssertionError("Can only handle longs and doubles");
                }
            }
            Page page = new Page(builder.build());
            page = OperatorAssertion.appendSampleWeight(ImmutableList.of(page), ).get(0);
            Accumulator accumulator = getFunction().bind(ImmutableList.of(0), Optional.empty(), Optional.of(page.getChannelCount() - 1), getConfidence()).createAccumulator();
            accumulator.addInput(page);
            Block result = getFinalBlock(accumulator);
            String approxValue = BlockAssertions.toValues(accumulator.getFinalType(), result).get(0).toString();
            double approx = Double.parseDouble(approxValue.split(" ")[0]);
            double error = Double.parseDouble(approxValue.split(" ")[2]);
            //Check if actual answer lies within [approxAnswer - error, approxAnswer + error]
            if (Math.abs(approx - actual) <= error) {
                inRange++;
            }
        }
        BinomialDistribution binomial = new BinomialDistribution(numberOfRunsgetConfidence());
        int lowerBound = binomial.inverseCumulativeProbability(0.01);
        int upperBound = binomial.inverseCumulativeProbability(0.99);
        assertTrue(lowerBound < inRange && inRange < upperBound, String.format("%d out of %d passed. Expected [%d, %d]"inRangenumberOfRunslowerBoundupperBound));
    }
    @Override
    protected void testAggregation(Object expectedValueBlock... block)
    {
        Page page = OperatorAssertion.appendSampleWeight(ImmutableList.of(new Page(block)), ).get(0);
        assertApproximateAggregation(getFunction(), page.getChannelCount() - 1, getConfidence(), (DoubleexpectedValuepage);
    }
New to GrepCode? Check out our FAQ X