diff --git a/rxjava-contrib/rxjava-math/build.gradle b/rxjava-contrib/rxjava-math/build.gradle
new file mode 100644
index 0000000000..cbc8cca804
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/build.gradle
@@ -0,0 +1,31 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    testCompile project(":rxjava-core").sourceSets.test.output 
+    provided 'junit:junit-dep:4.10'
+    provided 'org.mockito:mockito-core:1.8.5'
+}
+
+javadoc {
+    options {
+        doclet = "org.benjchristensen.doclet.DocletExclude"
+        docletpath = [rootProject.file('./gradle/doclet-exclude.jar')]
+        stylesheetFile = rootProject.file('./gradle/javadocStyleSheet.css')
+        windowTitle = "RxJava Javadoc ${project.version}"
+    }
+    options.addStringOption('top').value = '<h2 class="title" style="padding-top:40px">RxJava</h2>'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-math'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
new file mode 100644
index 0000000000..25d6bc7376
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
@@ -0,0 +1,348 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+/**
+ * A few operators for implementing the averaging operation.
+ * 
+ * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average%28v=vs.103%29.aspx">MSDN: Observable.Average</a>
+ */
+public final class OperationAverage {
+    private static final class Tuple2<T> {
+        private final T current;
+        private final Integer count;
+
+        private Tuple2(T v1, Integer v2) {
+            current = v1;
+            count = v2;
+        }
+    }
+
+    public static Observable<Integer> average(Observable<Integer> source) {
+        return source.reduce(new Tuple2<Integer>(0, 0), new Func2<Tuple2<Integer>, Integer, Tuple2<Integer>>() {
+            @Override
+            public Tuple2<Integer> call(Tuple2<Integer> accu, Integer next) {
+                return new Tuple2<Integer>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Integer>, Integer>() {
+            @Override
+            public Integer call(Tuple2<Integer> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Long> averageLongs(Observable<Long> source) {
+        return source.reduce(new Tuple2<Long>(0L, 0), new Func2<Tuple2<Long>, Long, Tuple2<Long>>() {
+            @Override
+            public Tuple2<Long> call(Tuple2<Long> accu, Long next) {
+                return new Tuple2<Long>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Long>, Long>() {
+            @Override
+            public Long call(Tuple2<Long> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Float> averageFloats(Observable<Float> source) {
+        return source.reduce(new Tuple2<Float>(0.0f, 0), new Func2<Tuple2<Float>, Float, Tuple2<Float>>() {
+            @Override
+            public Tuple2<Float> call(Tuple2<Float> accu, Float next) {
+                return new Tuple2<Float>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Float>, Float>() {
+            @Override
+            public Float call(Tuple2<Float> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Double> averageDoubles(Observable<Double> source) {
+        return source.reduce(new Tuple2<Double>(0.0d, 0), new Func2<Tuple2<Double>, Double, Tuple2<Double>>() {
+            @Override
+            public Tuple2<Double> call(Tuple2<Double> accu, Double next) {
+                return new Tuple2<Double>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Double>, Double>() {
+            @Override
+            public Double call(Tuple2<Double> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    /**
+     * Compute the average by extracting integer values from the source via an
+     * extractor function.
+     * 
+     * @param <T>
+     *            the source value type
+     */
+    public static final class AverageIntegerExtractor<T> implements OnSubscribeFunc<Integer> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Integer> valueExtractor;
+
+        public AverageIntegerExtractor(Observable<? extends T> source, Func1<? super T, Integer> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Integer> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Integer> observer;
+            int sum;
+            int count;
+
+            public AverageObserver(Observer<? super Integer> observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+
+        }
+    }
+
+    /**
+     * Compute the average by extracting long values from the source via an
+     * extractor function.
+     * 
+     * @param <T>
+     *            the source value type
+     */
+    public static final class AverageLongExtractor<T> implements OnSubscribeFunc<Long> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Long> valueExtractor;
+
+        public AverageLongExtractor(Observable<? extends T> source, Func1<? super T, Long> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Long> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Long> observer;
+            long sum;
+            int count;
+
+            public AverageObserver(Observer<? super Long> observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+
+        }
+    }
+
+    /**
+     * Compute the average by extracting float values from the source via an
+     * extractor function.
+     * 
+     * @param <T>
+     *            the source value type
+     */
+    public static final class AverageFloatExtractor<T> implements OnSubscribeFunc<Float> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Float> valueExtractor;
+
+        public AverageFloatExtractor(Observable<? extends T> source, Func1<? super T, Float> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Float> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Float> observer;
+            float sum;
+            int count;
+
+            public AverageObserver(Observer<? super Float> observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+
+        }
+    }
+
+    /**
+     * Compute the average by extracting double values from the source via an
+     * extractor function.
+     * 
+     * @param <T>
+     *            the source value type
+     */
+    public static final class AverageDoubleExtractor<T> implements OnSubscribeFunc<Double> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Double> valueExtractor;
+
+        public AverageDoubleExtractor(Observable<? extends T> source, Func1<? super T, Double> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Double> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Double> observer;
+            double sum;
+            int count;
+
+            public AverageObserver(Observer<? super Double> observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
new file mode 100644
index 0000000000..cfa92d4fce
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
@@ -0,0 +1,147 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import rx.Observable;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+/**
+ * Returns the minimum element in an observable sequence.
+ */
+public class OperationMinMax {
+
+    public static <T extends Comparable<? super T>> Observable<T> min(
+            Observable<T> source) {
+        return minMax(source, -1L);
+    }
+
+    public static <T> Observable<T> min(Observable<T> source,
+            final Comparator<? super T> comparator) {
+        return minMax(source, comparator, -1L);
+    }
+
+    public static <T, R extends Comparable<? super R>> Observable<List<T>> minBy(
+            Observable<T> source, final Func1<T, R> selector) {
+        return minMaxBy(source, selector, -1L);
+    }
+
+    public static <T, R> Observable<List<T>> minBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator) {
+        return minMaxBy(source, selector, comparator, -1L);
+    }
+
+    public static <T extends Comparable<? super T>> Observable<T> max(
+            Observable<T> source) {
+        return minMax(source, 1L);
+    }
+
+    public static <T> Observable<T> max(Observable<T> source,
+            final Comparator<? super T> comparator) {
+        return minMax(source, comparator, 1L);
+    }
+
+    public static <T, R extends Comparable<? super R>> Observable<List<T>> maxBy(
+            Observable<T> source, final Func1<T, R> selector) {
+        return minMaxBy(source, selector, 1L);
+    }
+
+    public static <T, R> Observable<List<T>> maxBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator) {
+        return minMaxBy(source, selector, comparator, 1L);
+    }
+
+    private static <T extends Comparable<? super T>> Observable<T> minMax(
+            Observable<T> source, final long flag) {
+        return source.reduce(new Func2<T, T, T>() {
+            @Override
+            public T call(T acc, T value) {
+                if (flag * acc.compareTo(value) > 0) {
+                    return acc;
+                }
+                return value;
+            }
+        });
+    }
+
+    private static <T> Observable<T> minMax(Observable<T> source,
+            final Comparator<? super T> comparator, final long flag) {
+        return source.reduce(new Func2<T, T, T>() {
+            @Override
+            public T call(T acc, T value) {
+                if (flag * comparator.compare(acc, value) > 0) {
+                    return acc;
+                }
+                return value;
+            }
+        });
+    }
+
+    private static <T, R extends Comparable<? super R>> Observable<List<T>> minMaxBy(
+            Observable<T> source, final Func1<T, R> selector, final long flag) {
+        return source.reduce(new ArrayList<T>(),
+                new Func2<List<T>, T, List<T>>() {
+
+                    @Override
+                    public List<T> call(List<T> acc, T value) {
+                        if (acc.isEmpty()) {
+                            acc.add(value);
+                        } else {
+                            int compareResult = selector.call(acc.get(0))
+                                    .compareTo(selector.call(value));
+                            if (compareResult == 0) {
+                                acc.add(value);
+                            } else if (flag * compareResult < 0) {
+                                acc.clear();
+                                acc.add(value);
+                            }
+                        }
+                        return acc;
+                    }
+                });
+    }
+
+    private static <T, R> Observable<List<T>> minMaxBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator,
+            final long flag) {
+        return source.reduce(new ArrayList<T>(),
+                new Func2<List<T>, T, List<T>>() {
+
+                    @Override
+                    public List<T> call(List<T> acc, T value) {
+                        if (acc.isEmpty()) {
+                            acc.add(value);
+                        } else {
+                            int compareResult = comparator.compare(
+                                    selector.call(acc.get(0)),
+                                    selector.call(value));
+                            if (compareResult == 0) {
+                                acc.add(value);
+                            } else if (flag * compareResult < 0) {
+                                acc.clear();
+                                acc.add(value);
+                            }
+                        }
+                        return acc;
+                    }
+                });
+    }
+
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
new file mode 100644
index 0000000000..3d519e4220
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import rx.Observable;
+import rx.functions.Func2;
+
+/**
+ * A few operators for implementing the sum operation.
+ * 
+ * @see <a
+ *      href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum%28v=vs.103%29.aspx">MSDN:
+ *      Observable.Sum</a>
+ */
+public final class OperationSum {
+
+    public static Observable<Integer> sumIntegers(Observable<Integer> source) {
+        return source.reduce(0, ACCUM_INT);
+    }
+
+    public static Observable<Long> sumLongs(Observable<Long> source) {
+        return source.reduce(0l, ACCUM_LONG);
+    }
+
+    public static Observable<Float> sumFloats(Observable<Float> source) {
+        return source.reduce(0.0f, ACCUM_FLOAT);
+    }
+
+    public static Observable<Double> sumDoubles(Observable<Double> source) {
+        return source.reduce(0.0d, ACCUM_DOUBLE);
+    }
+
+    public static Observable<Integer> sumAtLeastOneIntegers(Observable<Integer> source) {
+        return source.reduce(ACCUM_INT);
+    }
+
+    public static Observable<Long> sumAtLeastOneLongs(Observable<Long> source) {
+        return source.reduce(ACCUM_LONG);
+    }
+
+    public static Observable<Float> sumAtLeastOneFloats(Observable<Float> source) {
+        return source.reduce(ACCUM_FLOAT);
+    }
+
+    public static Observable<Double> sumAtLeastOneDoubles(Observable<Double> source) {
+        return source.reduce(ACCUM_DOUBLE);
+    }
+
+    private static final Func2<Integer, Integer, Integer> ACCUM_INT = new Func2<Integer, Integer, Integer>() {
+        @Override
+        public Integer call(Integer accu, Integer next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Long, Long, Long> ACCUM_LONG = new Func2<Long, Long, Long>() {
+        @Override
+        public Long call(Long accu, Long next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Float, Float, Float> ACCUM_FLOAT = new Func2<Float, Float, Float>() {
+        @Override
+        public Float call(Float accu, Float next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Double, Double, Double> ACCUM_DOUBLE = new Func2<Double, Double, Double>() {
+        @Override
+        public Double call(Double accu, Double next) {
+            return accu + next;
+        }
+    };
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
new file mode 100644
index 0000000000..2614983bf8
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
@@ -0,0 +1,378 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.observables;
+
+import java.util.Comparator;
+
+import rx.Observable;
+import rx.functions.Func1;
+import rx.math.operators.OperationAverage;
+import rx.math.operators.OperationMinMax;
+import rx.math.operators.OperationSum;
+
+public class MathObservable<T> {
+
+    private final Observable<T> o;
+
+    private MathObservable(Observable<T> o) {
+        this.o = o;
+    }
+
+    public static <T> MathObservable<T> from(Observable<T> o) {
+        return new MathObservable<T>(o);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Doubles emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits a single item: the average of all the Doubles emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Double> averageDouble(Observable<Double> source) {
+        return OperationAverage.averageDoubles(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Floats emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits a single item: the average of all the Floats emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Float> averageFloat(Observable<Float> source) {
+        return OperationAverage.averageFloats(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Integers emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits a single item: the average of all the Integers emitted by the source
+     *         Observable
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Integer> averageInteger(Observable<Integer> source) {
+        return OperationAverage.average(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Longs emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits a single item: the average of all the Longs emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Long> averageLong(Observable<Long> source) {
+        return OperationAverage.averageLongs(source);
+    }
+
+    /**
+     * Returns an Observable that emits the single item emitted by the source Observable with the maximum
+     * numeric value. If there is more than one item with the same maximum value, it emits the last-emitted of
+     * these.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
+     * 
+     * @param source
+     *            an Observable to scan for the maximum emitted item
+     * @return an Observable that emits this maximum item
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
+     */
+    public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
+        return OperationMinMax.max(source);
+    }
+
+    /**
+     * Returns an Observable that emits the single numerically minimum item emitted by the source Observable.
+     * If there is more than one such item, it returns the last-emitted one.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
+     * 
+     * @param source
+     *            an Observable to determine the minimum item of
+     * @return an Observable that emits the minimum item emitted by the source Observable
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
+     */
+    public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
+        return OperationMinMax.min(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            the source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Doubles emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Double> sumDouble(Observable<Double> source) {
+        return OperationSum.sumDoubles(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Floats emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            the source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Floats emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Float> sumFloat(Observable<Float> source) {
+        return OperationSum.sumFloats(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Integers emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Integers emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Integer> sumInteger(Observable<Integer> source) {
+        return OperationSum.sumIntegers(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Longs emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Longs emitted by the
+     *         source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Long> sumLong(Observable<Long> source) {
+        return OperationSum.sumLongs(source);
+    }
+
+    /**
+     * Returns an Observable that transforms items emitted by the source Observable into Doubles by using a
+     * function you provide and then emits the Double average of the complete sequence of transformed values.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to transform an item emitted by the source Observable into a Double
+     * @return an Observable that emits a single item: the Double average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Doubles by the specified function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageDoubleExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that transforms items emitted by the source Observable into Floats by using a
+     * function you provide and then emits the Float average of the complete sequence of transformed values.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to transform an item emitted by the source Observable into a Float
+     * @return an Observable that emits a single item: the Float average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Floats by the specified function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageFloatExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that transforms items emitted by the source Observable into Integers by using a
+     * function you provide and then emits the Integer average of the complete sequence of transformed values.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to transform an item emitted by the source Observable into an Integer
+     * @return an Observable that emits a single item: the Integer average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Integers by the specified function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageIntegerExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that transforms items emitted by the source Observable into Longs by using a
+     * function you provide and then emits the Long average of the complete sequence of transformed values.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to transform an item emitted by the source Observable into a Long
+     * @return an Observable that emits a single item: the Long average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Longs by the specified function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageLongExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that emits the maximum item emitted by the source Observable, according to the
+     * specified comparator. If there is more than one item with the same maximum value, it emits the
+     * last-emitted of these.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
+     * 
+     * @param comparator
+     *            the comparer used to compare items
+     * @return an Observable that emits the maximum item emitted by the source Observable, according to the
+     *         specified comparator
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
+     */
+    public final Observable<T> max(Comparator<? super T> comparator) {
+        return OperationMinMax.max(o, comparator);
+    }
+
+    /**
+     * Returns an Observable that emits the minimum item emitted by the source Observable, according to a
+     * specified comparator. If there is more than one such item, it returns the last-emitted one.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
+     * 
+     * @param comparator
+     *            the comparer used to compare elements
+     * @return an Observable that emits the minimum item emitted by the source Observable according to the
+     *         specified comparator
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-min">RxJava Wiki: min()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
+     */
+    public final Observable<T> min(Comparator<? super T> comparator) {
+        return OperationMinMax.min(o, comparator);
+    }
+
+    /**
+     * Returns an Observable that extracts a Double from each of the items emitted by the source Observable via
+     * a function you specify, and then emits the sum of these Doubles.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to extract a Double from each item emitted by the source Observable
+     * @return an Observable that emits the Double sum of the Double values corresponding to the items emitted
+     *         by the source Observable as transformed by the provided function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
+        return OperationSum.sumAtLeastOneDoubles(o.map(valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that extracts a Float from each of the items emitted by the source Observable via
+     * a function you specify, and then emits the sum of these Floats.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to extract a Float from each item emitted by the source Observable
+     * @return an Observable that emits the Float sum of the Float values corresponding to the items emitted by
+     *         the source Observable as transformed by the provided function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
+        return OperationSum.sumAtLeastOneFloats(o.map(valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that extracts an Integer from each of the items emitted by the source Observable
+     * via a function you specify, and then emits the sum of these Integers.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to extract an Integer from each item emitted by the source Observable
+     * @return an Observable that emits the Integer sum of the Integer values corresponding to the items emitted
+     *         by the source Observable as transformed by the provided function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
+        return OperationSum.sumAtLeastOneIntegers(o.map(valueExtractor));
+    }
+
+    /**
+     * Returns an Observable that extracts a Long from each of the items emitted by the source Observable via a
+     * function you specify, and then emits the sum of these Longs.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @param valueExtractor
+     *            the function to extract a Long from each item emitted by the source Observable
+     * @return an Observable that emits the Long sum of the Long values corresponding to the items emitted by
+     *         the source Observable as transformed by the provided function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
+        return OperationSum.sumAtLeastOneLongs(o.map(valueExtractor));
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
new file mode 100644
index 0000000000..a77868dc7a
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
@@ -0,0 +1,342 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationAverage.*;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+import rx.observables.MathObservable;
+
+public class OperationAverageTest {
+
+    @SuppressWarnings("unchecked")
+    Observer<Integer> w = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Long> wl = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Float> wf = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Double> wd = mock(Observer.class);
+
+    @Test
+    public void testAverageOfAFewInts() throws Throwable {
+        Observable<Integer> src = Observable.from(1, 2, 3, 4, 6);
+        average(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(3);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverage() throws Throwable {
+        Observable<Integer> src = Observable.empty();
+        average(src).subscribe(w);
+
+        verify(w, never()).onNext(anyInt());
+        verify(w, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(w, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewLongs() throws Throwable {
+        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 6L);
+        averageLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(3L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageLongs() throws Throwable {
+        Observable<Long> src = Observable.empty();
+        averageLongs(src).subscribe(wl);
+
+        verify(wl, never()).onNext(anyLong());
+        verify(wl, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wl, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewFloats() throws Throwable {
+        Observable<Float> src = Observable.from(1.0f, 2.0f);
+        averageFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(1.5f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageFloats() throws Throwable {
+        Observable<Float> src = Observable.empty();
+        averageFloats(src).subscribe(wf);
+
+        verify(wf, never()).onNext(anyFloat());
+        verify(wf, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wf, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewDoubles() throws Throwable {
+        Observable<Double> src = Observable.from(1.0d, 2.0d);
+        averageDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(1.5d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageDoubles() throws Throwable {
+        Observable<Double> src = Observable.empty();
+        averageDoubles(src).subscribe(wd);
+
+        verify(wd, never()).onNext(anyDouble());
+        verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wd, never()).onCompleted();
+    }
+
+    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+
+    <N extends Number> void testValue(Observer<Object> o, N value) {
+        verify(o, times(1)).onNext(value);
+        verify(o, times(1)).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testIntegerAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2);
+    }
+
+    @Test
+    public void testLongAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2L);
+    }
+
+    @Test
+    public void testFloatAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2.5f);
+    }
+
+    @Test
+    public void testDoubleAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2.5d);
+    }
+
+    @Test
+    public void testIntegerAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testLongAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testFloatAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testDoubleAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testIntegerAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testLongAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testFloatAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testDoubleAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+    
+    static class CustomException extends RuntimeException {
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
new file mode 100644
index 0000000000..63eee7b28f
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
@@ -0,0 +1,354 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationMinMax.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+
+public class OperationMinMaxTest {
+    @Test
+    public void testMin() {
+        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4));
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(1);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinWithEmpty() {
+        Observable<Integer> observable = min(Observable.<Integer> empty());
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinWithComparator() {
+        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(4);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinWithComparatorAndEmpty() {
+        Observable<Integer> observable = min(Observable.<Integer> empty(),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinBy() {
+        Observable<List<String>> observable = minBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithEmpty() {
+        Observable<List<String>> observable = minBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithComparator() {
+        Observable<List<String>> observable = minBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithComparatorAndEmpty() {
+        Observable<List<String>> observable = minBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMax() {
+        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4));
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(4);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxWithEmpty() {
+        Observable<Integer> observable = max(Observable.<Integer> empty());
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxWithComparator() {
+        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(1);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxWithComparatorAndEmpty() {
+        Observable<Integer> observable = max(Observable.<Integer> empty(),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxBy() {
+        Observable<List<String>> observable = maxBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithEmpty() {
+        Observable<List<String>> observable = maxBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithComparator() {
+        Observable<List<String>> observable = maxBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithComparatorAndEmpty() {
+        Observable<List<String>> observable = maxBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
new file mode 100644
index 0000000000..43e2805d43
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
@@ -0,0 +1,346 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationSum.*;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+import rx.observables.MathObservable;
+
+public class OperationSumTest {
+
+    @SuppressWarnings("unchecked")
+    Observer<Integer> w = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Long> wl = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Float> wf = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Double> wd = mock(Observer.class);
+
+    @Test
+    public void testSumOfAFewInts() throws Throwable {
+        Observable<Integer> src = Observable.from(1, 2, 3, 4, 5);
+        sumIntegers(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(15);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySum() throws Throwable {
+        Observable<Integer> src = Observable.empty();
+        sumIntegers(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(0);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewLongs() throws Throwable {
+        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 5L);
+        sumLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(15L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumLongs() throws Throwable {
+        Observable<Long> src = Observable.empty();
+        sumLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(0L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewFloats() throws Throwable {
+        Observable<Float> src = Observable.from(1.0f);
+        sumFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(1.0f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumFloats() throws Throwable {
+        Observable<Float> src = Observable.empty();
+        sumFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(0.0f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewDoubles() throws Throwable {
+        Observable<Double> src = Observable.from(0.0d, 1.0d, 0.5d);
+        sumDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(1.5d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumDoubles() throws Throwable {
+        Observable<Double> src = Observable.empty();
+        sumDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(0.0d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+
+    <N extends Number> void testValue(Observer<Object> o, N value) {
+        verify(o, times(1)).onNext(value);
+        verify(o, times(1)).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testIntegerSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10);
+    }
+
+    @Test
+    public void testLongSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10L);
+    }
+
+    @Test
+    public void testFloatSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10f);
+    }
+
+    @Test
+    public void testDoubleSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10d);
+    }
+
+    @Test
+    public void testIntegerSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testLongSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testFloatSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testDoubleSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testIntegerSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testLongSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testFloatSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testDoubleSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    static class CustomException extends RuntimeException {
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c244fb5001..92ae1c7c40 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -441,6 +441,7 @@ public final static Observable<Integer> average(Observable<Integer> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Double> averageDouble(Observable<Double> source) {
         return OperationAverage.averageDoubles(source);
@@ -457,6 +458,7 @@ public final static Observable<Double> averageDouble(Observable<Double> source)
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Float> averageFloat(Observable<Float> source) {
         return OperationAverage.averageFloats(source);
@@ -475,6 +477,7 @@ public final static Observable<Float> averageFloat(Observable<Float> source) {
      *             if the source Observable emits no items
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Integer> averageInteger(Observable<Integer> source) {
         return OperationAverage.average(source);
@@ -491,6 +494,7 @@ public final static Observable<Integer> averageInteger(Observable<Integer> sourc
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Long> averageLong(Observable<Long> source) {
         return OperationAverage.averageLongs(source);
@@ -1595,6 +1599,7 @@ public final static <T> Observable<T> just(T value, Scheduler scheduler) {
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
         return OperationMinMax.max(source);
@@ -2309,6 +2314,7 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @throws IllegalArgumentException
      *             if the source is empty
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
         return OperationMinMax.min(source);
@@ -2485,7 +2491,7 @@ public final Boolean call(T first, T second) {
     public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
         return OperationSequenceEqual.sequenceEqual(first, second, equality);
     }
-
+    
     /**
      * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
      * <p>
@@ -2497,6 +2503,7 @@ public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Double> sumDouble(Observable<Double> source) {
         return OperationSum.sumDoubles(source);
@@ -2513,6 +2520,7 @@ public final static Observable<Double> sumDouble(Observable<Double> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Float> sumFloat(Observable<Float> source) {
         return OperationSum.sumFloats(source);
@@ -2529,6 +2537,7 @@ public final static Observable<Float> sumFloat(Observable<Float> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Integer> sumInteger(Observable<Integer> source) {
         return OperationSum.sumIntegers(source);
@@ -2545,6 +2554,7 @@ public final static Observable<Integer> sumInteger(Observable<Integer> source) {
      *         source Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Long> sumLong(Observable<Long> source) {
         return OperationSum.sumLongs(source);
@@ -3413,6 +3423,7 @@ public final Observable<T> asObservable() {
      *         emitted by the source Observable when transformed into Doubles by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
         return create(new OperationAverage.AverageDoubleExtractor<T>(this, valueExtractor));
@@ -3430,6 +3441,7 @@ public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtr
      *         emitted by the source Observable when transformed into Floats by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
         return create(new OperationAverage.AverageFloatExtractor<T>(this, valueExtractor));
@@ -3447,6 +3459,7 @@ public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtract
      *         emitted by the source Observable when transformed into Integers by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
         return create(new OperationAverage.AverageIntegerExtractor<T>(this, valueExtractor));
@@ -3464,6 +3477,7 @@ public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueE
      *         emitted by the source Observable when transformed into Longs by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
         return create(new OperationAverage.AverageLongExtractor<T>(this, valueExtractor));
@@ -4843,6 +4857,7 @@ public final Observable<Notification<T>> materialize() {
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<T> max(Comparator<? super T> comparator) {
         return OperationMinMax.max(this, comparator);
@@ -5011,6 +5026,7 @@ public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends It
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-min">RxJava Wiki: min()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<T> min(Comparator<? super T> comparator) {
         return OperationMinMax.min(this, comparator);
@@ -7053,6 +7069,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      *         by the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
         return OperationSum.sumAtLeastOneDoubles(map(valueExtractor));
@@ -7070,6 +7087,7 @@ public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtracto
      *         the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
         return OperationSum.sumAtLeastOneFloats(map(valueExtractor));
@@ -7087,6 +7105,7 @@ public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor)
      *         by the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
         return OperationSum.sumAtLeastOneIntegers(map(valueExtractor));
@@ -7104,6 +7123,7 @@ public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtra
      *         the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
         return OperationSum.sumAtLeastOneLongs(map(valueExtractor));
diff --git a/settings.gradle b/settings.gradle
index 5be4134cef..5a9e3e8cb0 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,6 +9,7 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
+'rxjava-contrib:rxjava-math', \
 'rxjava-contrib:rxjava-debug', \
 'rxjava-contrib:rxjava-async-util', \
 'rxjava-contrib:rxjava-computation-expressions'