JeffGrigg

NumericStreamFactory

Sep 9th, 2018
499
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5 4.68 KB | None | 0 0
  1. import java.math.BigInteger;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. import java.util.NoSuchElementException;
  6. import java.util.function.Supplier;
  7. import java.util.function.UnaryOperator;
  8. import java.util.stream.Stream;
  9.  
  10. abstract public class NumericStreamFactory {
  11.  
  12.     private NumericStreamFactory() {
  13.         throw new IllegalStateException("Not expecting to create instances of this class");
  14.     }
  15.  
  16.     public static Stream<Long> getFibonacciStreamOfLongValues() {
  17.  
  18.         return Stream.generate(new Supplier<Long>() {
  19.  
  20.             private int _elementNumber = 0;
  21.             private long _priorValueOne = 0;
  22.             private long _priorValueTwo = 0;
  23.             private boolean _exceedsLongValue = false;
  24.  
  25.             @Override
  26.             public Long get() {
  27.                 ++_elementNumber;
  28.  
  29.                 final long nextValue = _priorValueOne + ((_priorValueTwo == 0) ? 1 : _priorValueTwo);
  30.                 _priorValueOne = _priorValueTwo;
  31.                 _priorValueTwo = nextValue;
  32.  
  33.                 if (nextValue < 0 || _exceedsLongValue) {
  34.                     _exceedsLongValue = true;
  35.                     throw new NoSuchElementException("Fibonacci element number " + _elementNumber + " exceeds the maximum value that can be held in a Java 'long' type.");
  36.                 }
  37.  
  38.                 return nextValue;
  39.             }
  40.         });
  41.     }
  42.  
  43.     public static Stream<BigInteger> getFibonacciStreamOfBigIntegerValues() {
  44.  
  45.         return Stream.generate(new Supplier<BigInteger>() {
  46.  
  47.             private BigInteger _priorValueOne = null;
  48.             private BigInteger _priorValueTwo = BigInteger.ZERO;
  49.  
  50.             @Override
  51.             public BigInteger get() {
  52.  
  53.                 final BigInteger nextValue;
  54.                 if (_priorValueOne == null) {
  55.                     nextValue = BigInteger.ONE;
  56.                 } else {
  57.                     nextValue = _priorValueOne.add(_priorValueTwo);
  58.                 }
  59.  
  60.                 _priorValueOne = _priorValueTwo;
  61.                 _priorValueTwo = nextValue;
  62.  
  63.                 return nextValue;
  64.             }
  65.         });
  66.     }
  67.  
  68.     public static Stream<Integer> getPrimeStream() {
  69.         return Stream.generate(new Supplier<Integer>() {
  70.             private int _lastPrime = 2 - 1;  // = one before the first known prime number
  71.             private List<Integer> _primeNumbers = new ArrayList<>();
  72.             @Override
  73.             public Integer get() {
  74.                 int candidatePrime = _lastPrime + 1;
  75.                 boolean tryAnotherNumber = true;
  76.                 while (tryAnotherNumber) {
  77.                     tryAnotherNumber = false;
  78.                     for (final Integer factor : _primeNumbers) {
  79.                         if (candidatePrime % factor == 0) {
  80.                             ++candidatePrime;
  81.                             tryAnotherNumber = true;
  82.                             break;
  83.                         }
  84.                     }
  85.                 }
  86.                 _primeNumbers.add(candidatePrime);
  87.                 _lastPrime = candidatePrime;
  88.                 return candidatePrime;
  89.             }
  90.         });
  91.     }
  92.  
  93.     public static Stream<Long> getCombinedStreamOfLongValues() {
  94.  
  95.         return Stream.generate(new Supplier<Long>() {
  96.  
  97.             private boolean nextIsPrime = false;
  98.             final Iterator<Long> fibonacciStreamIterator = getFibonacciStreamOfLongValues().iterator();
  99.             final Iterator<Integer> primeStreamIterator = getPrimeStream().iterator();
  100.  
  101.             @Override
  102.             public Long get() {
  103.                 if (nextIsPrime) {
  104.                     nextIsPrime = false;
  105.                     return (long) primeStreamIterator.next();
  106.                 } else {
  107.                     nextIsPrime = true;
  108.                     return fibonacciStreamIterator.next();
  109.                 }
  110.             }
  111.         });
  112.     }
  113.  
  114.     public static Stream<BigInteger> getCombinedStreamOfBigIntegerValues() {
  115.  
  116.         return Stream.generate(new Supplier<BigInteger>() {
  117.  
  118.             private boolean nextIsPrime = false;
  119.             final Iterator<BigInteger> fibonacciStreamIterator = getFibonacciStreamOfBigIntegerValues().iterator();
  120.             final Iterator<Integer> primeStreamIterator = getPrimeStream().iterator();
  121.  
  122.             @Override
  123.             public BigInteger get() {
  124.                 if (nextIsPrime) {
  125.                     nextIsPrime = false;
  126.                     return new BigInteger(String.valueOf(primeStreamIterator.next()));
  127.                 } else {
  128.                     nextIsPrime = true;
  129.                     return fibonacciStreamIterator.next();
  130.                 }
  131.             }
  132.         });
  133.     }
  134.  
  135. }
Add Comment
Please, Sign In to add comment