diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7ac68d4..f53c93b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -3,7 +3,7 @@ project(PRLearn C CXX)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
-find_package(Boost 1.54 REQUIRED COMPONENTS headers REQUIRED)
+find_package(Boost 1.54 REQUIRED)
 
 add_library(prlearn SHARED ${HEADER_FILES} MLearning.cpp SimpleMLearning.cpp RefinementTree.cpp structs.cpp)
 add_library(prlearnStatic STATIC ${HEADER_FILES} MLearning.cpp SimpleMLearning.cpp RefinementTree.cpp structs.cpp)
diff --git a/src/MLearning.cpp b/src/MLearning.cpp
index dae3256..2173dc7 100644
--- a/src/MLearning.cpp
+++ b/src/MLearning.cpp
@@ -1,24 +1,24 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   MLearning.cpp
  * Author: Peter G. Jensen
- * 
+ *
  * Created on July 25, 2017, 9:58 AM
  */
 
@@ -104,7 +104,8 @@ namespace prlearn {
     }
 
     void MLearning::addSample(size_t dimen, const double* f_var,
-            const double* t_var, size_t label,
+            const double* t_var, size_t*, size_t,
+            size_t label,
             size_t dest, double value, const std::vector<MLearning>& clouds,
             bool minimization, const double delta,
             const propts_t& options) {
@@ -225,7 +226,7 @@ namespace prlearn {
         }
     }
 
-    void MLearning::update(const std::vector<MLearning>&, bool) 
+    void MLearning::update(const std::vector<MLearning>&, bool)
     {
     }
 
@@ -254,10 +255,10 @@ namespace prlearn {
                     auto c = clouds[s._cloud]._nodes[s._nodes[i]]._q.avg();
                     fut = std::min(fut, c);
                     if (c == best)
-                        var = std::min(var, clouds[s._cloud]._nodes[s._nodes[i]]._q._variance);
+                        var = std::min(var, clouds[s._cloud]._nodes[s._nodes[i]]._q.variance());
                     else if ((c < best && minimize) || (c > best && !minimize)) {
                         best = c;
-                        var = clouds[s._cloud]._nodes[s._nodes[i]]._q._variance;
+                        var = clouds[s._cloud]._nodes[s._nodes[i]]._q.variance();
                     }
                 }
             }
@@ -274,8 +275,8 @@ namespace prlearn {
                     auto v = s._variance[d];
                     v.first.avg() += best;
                     v.second.avg() += best;
-                    v.first._variance = std::max(v.first._variance, var);
-                    v.second._variance = std::max(v.second._variance, var);
+                    v.first.set_variance(std::max(v.first.variance(), var));
+                    v.second.set_variance(std::max(v.second.variance(), var));
                     tmpq[d].first.addPoints(v.first.cnt(), v.first.avg());
                     tmpq[d].second.addPoints(v.second.cnt(), v.second.avg());
                     mean.addPoints(v.first.cnt(), v.first.avg());
@@ -287,8 +288,8 @@ namespace prlearn {
                     auto v = s._old[d];
                     v.first.avg() += best;
                     v.second.avg() += best;
-                    v.first._variance = std::max(v.first._variance, var);
-                    v.second._variance = std::max(v.second._variance, var);
+                    v.first.set_variance(std::max(v.first.variance(), var));
+                    v.second.set_variance(std::max(v.second.variance(), var));
                     old_mean.addPoints(v.first.cnt(), v.first.avg());
                     old_mean.addPoints(v.second.cnt(), v.second.avg());
                     old_var.push_back(v.first);
@@ -304,7 +305,7 @@ namespace prlearn {
         for (auto& s : sample_qvar) {
             {
                 const auto dif = std::abs(s.avg() - mean._avg);
-                const auto std = std::sqrt(s._variance);
+                const auto std = std::sqrt(s.variance());
                 auto var = (std::pow(dif + std, 2.0) + std::pow(dif - std, 2.0)) / 2.0;
                 svar.addPoints(s.cnt(), var);
             }
@@ -316,7 +317,7 @@ namespace prlearn {
             }
             {
                 const auto dif = std::abs(s.avg() - dmin);
-                const auto std = std::sqrt(s._variance);
+                const auto std = std::sqrt(s.variance());
                 auto var = (std::pow(dif + std, 2.0) + std::pow(dif - std, 2.0)) / 2.0;
                 vars[id].addPoints(s.cnt(), var);
             }
@@ -327,18 +328,20 @@ namespace prlearn {
 
         for (auto& s : old_var) {
             const auto dif = std::abs(s.avg() - old_mean._avg);
-            const auto std = std::sqrt(s._variance);
+            const auto std = std::sqrt(s.variance());
             auto var = (std::pow(dif + std, 2.0) + std::pow(dif - std, 2.0)) / 2.0;
             ovar.addPoints(s.cnt(), var);
         }
 
         for (size_t i = 0; i < dimen; ++i) {
-            tmpq[i].first._variance = vars[i]._avg;
-            tmpq[i].second._variance = vars[i + dimen]._avg;
+            tmpq[i].first.set_variance(vars[i]._avg);
+            tmpq[i].second.set_variance(vars[i + dimen]._avg);
         }
 
-        qvar_t nq(mean._avg, mean._cnt / (dimen * 2), svar._avg);
-        qvar_t oq(old_mean._avg, old_mean._cnt / (dimen * 2), ovar._avg);
+        qvar_t nq(mean._avg, mean._cnt / (dimen * 2), 0);
+        nq.set_variance(svar._avg);
+        qvar_t oq(old_mean._avg, old_mean._cnt / (dimen * 2), 0);
+        oq.set_variance(ovar._avg);
         return std::make_pair(nq, oq);
     }
 
diff --git a/src/MLearning.h b/src/MLearning.h
index 6c41223..86e0cbd 100644
--- a/src/MLearning.h
+++ b/src/MLearning.h
@@ -1,22 +1,22 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-/* 
+/*
  * File:   MLearning.h
  * Author: Peter G. Jensen
  *
@@ -32,7 +32,7 @@
 #include <map>
 #include <limits>
 
-namespace prlearn { 
+namespace prlearn {
 
     class MLearning {
     public:
@@ -45,6 +45,7 @@ namespace prlearn {
 
         void addSample(size_t dimen, // dimensions
                 const double* f_var, const double* t_var, // doubles
+                size_t* next_labels, size_t n_labels, // actions in dest, ignored in m learning
                 size_t label, // edge chosen, edge taken
                 size_t dest, double value, // cost
                 const std::vector<MLearning>& clouds, // other points
diff --git a/src/QLearning.h b/src/QLearning.h
index 3617c2f..7d6e718 100644
--- a/src/QLearning.h
+++ b/src/QLearning.h
@@ -1,21 +1,21 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   QLearning.h
  * Author: Peter G. Jensen
  *
@@ -46,6 +46,7 @@ namespace prlearn {
 
         void addSample(size_t dimen, // dimensions
                 const double* f_val, const double* t_val, // source, destination-states
+                size_t* next_labels, size_t n_labels,
                 size_t label, // action chosen,
                 size_t dest, double value, // destination, cost
                 const std::vector<QLearning>& clouds, // other points
@@ -67,6 +68,7 @@ namespace prlearn {
     template<typename Regressor>
     void QLearning<Regressor>::addSample(size_t dimen, // dimensions
             const double* f_var, const double* t_var, // doubles
+            size_t* next_labels, size_t n_labels,     // possible actions
             size_t label, size_t dest, double value, // cost
             const std::vector<QLearning<Regressor>>&clouds, // other points
             bool minimization, const double delta, const propts_t& options) {
@@ -74,7 +76,7 @@ namespace prlearn {
         auto toDone = 0.0;
 
         if (dest != 0 && options._discount != 0)
-            toDone = clouds[dest]._regressor.getBestQ(t_var, minimization); // 0 is a special sink-node.
+            toDone = clouds[dest]._regressor.getBestQ(t_var, minimization, next_labels, n_labels); // 0 is a special sink-node.
         auto nval = value;
         // if future is not a weird number, then add it (discounted)
         if (!std::isinf(toDone) && !std::isnan(toDone)) {
diff --git a/src/RefinementTree.cpp b/src/RefinementTree.cpp
index 158b9ab..0c8c26a 100644
--- a/src/RefinementTree.cpp
+++ b/src/RefinementTree.cpp
@@ -1,24 +1,24 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   RefinementTree.cpp
  * Author: Peter G. Jensen
- * 
+ *
  * Created on July 18, 2017, 5:09 PM
  */
 
@@ -67,23 +67,41 @@ namespace prlearn {
         auto res = std::lower_bound(std::begin(_mapping), std::end(_mapping), lf);
         if (res == std::end(_mapping) || res->_label != label)
             return qvar_t(std::numeric_limits<double>::quiet_NaN(), 0, 0);
-        assert(dimen == _dimen);
         auto n = _nodes[res->_nid].get_leaf(point, res->_nid, _nodes);
         auto& node = _nodes[n];
-        return qvar_t(node._predictor._q.avg(), node._predictor._cnt, node._predictor._q._variance);
+        return qvar_t(node._predictor._q.avg(), node._predictor._cnt, node._predictor._q.squared());
     }
 
-    double RefinementTree::getBestQ(const double* point, bool minimization) const {
+    double RefinementTree::getBestQ(const double* point, bool minimization, size_t* next_labels, size_t n_labels) const {
         auto val = std::numeric_limits<double>::infinity();
         if (!minimization)
             val = -val;
-        for (const el_t& el : _mapping) {
-            auto node = _nodes[el._nid].get_leaf(point, el._nid, _nodes);
-            auto v = _nodes[node]._predictor._q.avg();
-            if (!std::isinf(v) && !std::isnan(v))
-                val = minimization ?
-                    std::min(v, val) :
-                std::max(v, val);
+        if(next_labels == nullptr)
+        {
+            for (const el_t& el : _mapping) {
+                auto node = _nodes[el._nid].get_leaf(point, el._nid, _nodes);
+                auto v = _nodes[node]._predictor._q.avg();
+                if (!std::isinf(v) && !std::isnan(v))
+                    val = minimization ?
+                        std::min(v, val) :
+                    std::max(v, val);
+            }
+        }
+        else {
+            for(size_t i = 0; i < n_labels; ++i)
+            {
+                size_t j = 0;
+                for(;j < _mapping.size() && _mapping[j]._label < next_labels[i]; ++j) {};
+                if(j >= _mapping.size()) continue;
+                if(_mapping[j]._label != next_labels[i]) continue;
+                const auto& res = _mapping[j];
+                auto node = _nodes[res._nid].get_leaf(point, res._nid, _nodes);
+                auto v = _nodes[node]._predictor._q.avg();
+                if (!std::isinf(v) && !std::isnan(v))
+                    val = minimization ?
+                        std::min(v, val) :
+                    std::max(v, val);
+            }
         }
         return val;
     }
@@ -162,7 +180,7 @@ namespace prlearn {
                 _predictor._data[i]._hmid += point[i];
             }
 
-            // update the split-filters 
+            // update the split-filters
             _predictor._data[i]._splitfilter.add(_predictor._data[i]._lowq,
                     _predictor._data[i]._highq,
                     delta * options._indefference,
@@ -213,12 +231,12 @@ namespace prlearn {
                 if (nodes[slow]._predictor._q.cnt() == 0) {
                     nodes[slow]._predictor._q.cnt() = 1;
                     nodes[slow]._predictor._q.avg() = oq.avg();
-                    nodes[slow]._predictor._q._variance = 0;
+                    nodes[slow]._predictor._q.squared() = std::pow(oq.avg(), 2.0);
                 }
                 if (nodes[shigh]._predictor._q.cnt() == 0) {
                     nodes[shigh]._predictor._q.cnt() = 1;
                     nodes[shigh]._predictor._q.avg() = oq.avg();
-                    nodes[shigh]._predictor._q._variance = 0;
+                    nodes[shigh]._predictor._q.squared() = std::pow(oq.avg(), 2.0);
                 }
             }
             nodes[shigh]._predictor._cnt = nodes[shigh]._predictor._q.cnt();
diff --git a/src/RefinementTree.h b/src/RefinementTree.h
index eb3794b..45924f4 100644
--- a/src/RefinementTree.h
+++ b/src/RefinementTree.h
@@ -1,22 +1,22 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-/* 
+/*
  * File:   RefinementTree.h
  * Author: Peter G. Jensen
  *
@@ -48,7 +48,7 @@ namespace prlearn {
 
         void print(std::ostream& s, size_t tabs, std::map<size_t, size_t>& edge_map) const;
 
-        double getBestQ(const double* val, bool minimization) const;
+        double getBestQ(const double* val, bool minimization, size_t* next_labels = nullptr, size_t n_labels = 0) const;
 
     protected:
 
@@ -78,7 +78,7 @@ namespace prlearn {
         };
 
         struct node_t {
-            // we could do these two values as a single pointer 
+            // we could do these two values as a single pointer
             // which dynamically allocates enough space for both split and pred_t
             // including space for the run-time sized arrays.
             // however, this is at current time of writing a premature optimization.
diff --git a/src/SimpleMLearning.cpp b/src/SimpleMLearning.cpp
index 472d799..65b1da9 100644
--- a/src/SimpleMLearning.cpp
+++ b/src/SimpleMLearning.cpp
@@ -1,22 +1,22 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-/* 
+/*
  * File:   SimpleMLearning.cpp
  * Author: Peter G. Jensen
  *
@@ -30,7 +30,7 @@ namespace prlearn {
     SimpleMLearning::~SimpleMLearning() {
     }
 
-    void SimpleMLearning::addSample(size_t, const double*, const double*, size_t label, size_t dest, double value, const std::vector<SimpleMLearning>& clouds, bool minimization, const double, const propts_t& options) {
+    void SimpleMLearning::addSample(size_t, const double*, const double*, size_t*, size_t, size_t label, size_t dest, double value, const std::vector<SimpleMLearning>& clouds, bool minimization, const double, const propts_t& options) {
         node_t act;
         act._label = label;
         auto lb = std::lower_bound(std::begin(_nodes), std::end(_nodes), act);
@@ -63,7 +63,7 @@ namespace prlearn {
         for (size_t i = 0; i < tabs; ++i) s << "\t";
         s << "{\"id\":" << (this - other.data()) << ",";
         bool first = true;
-        
+
         for (auto& el : _nodes) {
             if (!first) s << ",";
             first = false;
@@ -110,14 +110,14 @@ namespace prlearn {
             for(auto& s : n._succssors)
             {
                 const auto dif = std::abs(s._cost.avg() - nq._avg);
-                const auto std = std::sqrt(s._cost._variance);
+                const auto std = std::sqrt(s._cost.variance());
                 auto var = (std::pow(dif + std, 2.0) + std::pow(dif - std, 2.0)) / 2.0;
                 nv.addPoints(s._cost.cnt(), var);
             }
             n._q = qvar_t(nq._avg, nq._cnt, nv._avg);
             if ((minimization && n._q.avg() <= rq.avg()) ||
                     (!minimization && n._q.avg() >= rq.avg())) {
-                if(n._q.avg() != rq.avg() || n._q._variance < rq._variance || n._q.cnt() > rq.cnt())
+                if(n._q.avg() != rq.avg() || n._q.variance() < rq.variance() || n._q.cnt() > rq.cnt())
                     rq = n._q;
             }
         }
diff --git a/src/SimpleMLearning.h b/src/SimpleMLearning.h
index e2f9776..cb820a9 100644
--- a/src/SimpleMLearning.h
+++ b/src/SimpleMLearning.h
@@ -1,22 +1,22 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-/* 
+/*
  * File:   SimpleMLearning.h
  * Author: Peter G. Jensen
  *
@@ -46,6 +46,7 @@ namespace prlearn {
 
         void addSample(size_t dimen, // dimensions
                 const double*, const double*, // doubles
+                size_t* next_labels, size_t n_labels, // ignored by m-learning
                 size_t label,
                 size_t dest, double value, // cost
                 const std::vector<SimpleMLearning>& clouds, // other points
diff --git a/src/SimpleRegressor.h b/src/SimpleRegressor.h
index bb79bd3..25f2154 100644
--- a/src/SimpleRegressor.h
+++ b/src/SimpleRegressor.h
@@ -1,21 +1,21 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   SimpleRegressor.h
  * Author: Peter G. Jensen
  *
@@ -47,20 +47,29 @@ namespace prlearn {
             auto res = std::lower_bound(std::begin(_labels), std::end(_labels), lf);
 
             if (res != std::end(_labels) && res->_label == label)
-                return qvar_t{res->_value.avg(), (double)res->_cnt, res->_value._variance};
+                return qvar_t{res->_value.avg(), (double)res->_cnt, res->_value.squared()};
             else
                 return qvar_t{std::numeric_limits<double>::quiet_NaN(), 0, 0};
         }
 
-        double getBestQ(const double*, bool minimization) const {
+        double getBestQ(const double*, bool minimization, size_t* next_labels = nullptr, size_t n_labels = 0) const {
             double res = std::numeric_limits<double>::infinity();
             if (!minimization)
                 res = -res;
+            size_t j = 0;
             for (auto& e : _labels)
+            {
+                if(next_labels != nullptr)
+                {
+                    for(;j < n_labels && next_labels[j] < e._label; ++j) {}
+                    if(j >= n_labels) return res;
+                    if(next_labels[j] != e._label) continue;
+                }
                 if (!std::isinf(e._value.avg()) && !std::isnan(e._value.avg()))
                     res = minimization ?
                         std::min(res, e._value.avg()) :
                     std::max(res, e._value.avg());
+            }
             return res;
         }
 
diff --git a/src/structs.cpp b/src/structs.cpp
index b4c3692..dc1d056 100644
--- a/src/structs.cpp
+++ b/src/structs.cpp
@@ -1,21 +1,21 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   structs.cpp
  * Author: Peter G. Jensen
  *
@@ -44,7 +44,7 @@ namespace prlearn {
     void qvar_t::print(std::ostream& stream) const {
         stream << "[";
         stream << (*(avg_t*)this);
-        stream << ", " << _variance << "]";
+        stream << ", " << variance() << "]";
     }
 
     std::ostream& operator<<(std::ostream& o, const qvar_t& v) {
@@ -59,29 +59,15 @@ namespace prlearn {
             return a;
         qvar_t res = a;
         res.addPoints(b._cnt, b._avg);
-        const auto adif = std::abs(res._avg - a._avg);
-        const auto bdif = std::abs(res._avg - b._avg);
-        const auto astd = std::sqrt(a._variance);
-        const auto bstd = std::sqrt(b._variance);
-        auto ca = std::pow(adif + astd, 2.0) + std::pow(adif - astd, 2.0);
-        auto cb = std::pow(bdif + bstd, 2.0) + std::pow(bdif - bstd, 2.0);
-        avg_t tmp;
-        tmp.addPoints(a._cnt, ca / 2.0);
-        tmp.addPoints(b._cnt, cb / 2.0);
-        res._variance = tmp._avg;
+        res._sq = (a._sq * (a._cnt / res._cnt)) + (b._sq * (b._cnt / res._cnt));
         return res;
     }
 
     qvar_t& qvar_t::operator+=(double d) {
         assert(!std::isinf(d));
         avg_t::operator+=(d);
-        auto nvar = std::pow(d - _avg, 2.0);
-        assert(!std::isinf(nvar));
-        if (_cnt == 1) _variance = nvar;
-        else {
-            nvar -= _variance;
-            _variance += nvar / _cnt;
-        }
+        auto diff = std::pow(d, 2.0) - _sq;
+        _sq += diff / _cnt;
         return *this;
     }
 
@@ -89,18 +75,9 @@ namespace prlearn {
         assert(weight >= 0);
         assert(_cnt >= 0);
         if (weight == 0) return;
-        auto oa = _avg;
         avg_t::addPoints(weight, d);
-        auto nvar = std::abs((d - oa)*(d - _avg));
-        assert(!std::isinf(nvar));
-        if (_cnt == weight) _variance = nvar;
-        else {
-            nvar -= _variance;
-            _variance += (nvar * weight) / _cnt;
-        }
-        assert(_variance >= 0);
-        assert(!std::isnan(_variance));
-        assert(!std::isinf(_variance));
+        auto diff = std::pow(d, 2.0) - _sq;
+        _sq += diff * (weight / _cnt);
     }
 
     double triangular_cdf(double mid, double width, double point) {
@@ -117,10 +94,10 @@ namespace prlearn {
         constexpr double minvar = 0.0001;
         if (std::min(a.cnt(), b.cnt()) <= 1)
             return;
-        if (a._variance == b._variance && a.avg() == b.avg())
+        if (a.variance() == b.variance() && a.avg() == b.avg())
             return;
-        auto vara = std::max(minvar, a._variance);
-        auto varb = std::max(minvar, b._variance);
+        auto vara = std::max(minvar, a.variance());
+        auto varb = std::max(minvar, b.variance());
 
         double tval = std::abs(a.avg() - b.avg()) / std::sqrt(((vara * a.cnt()) + (varb * b.cnt())) / (a.cnt() * b.cnt()));
 
diff --git a/src/structs.h b/src/structs.h
index 6ca44fa..fbbfe5f 100644
--- a/src/structs.h
+++ b/src/structs.h
@@ -1,21 +1,21 @@
 /*
  * Copyright Peter G. Jensen
- *  
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* 
+/*
  * File:   structs.h
  * Author: Peter G. Jensen
  *
@@ -33,6 +33,8 @@
 #include <cassert>
 #include <vector>
 #include <ostream>
+#include <iostream>
+
 namespace prlearn {
 
     struct avg_t {
@@ -54,7 +56,7 @@ namespace prlearn {
             } else {
                 _cnt += weight;
                 double diff = d - _avg;
-                _avg += ((diff * weight) / (double) _cnt); // add only "share" of difference
+                _avg += diff * (weight / _cnt); // add only "share" of difference
             }
             assert(!std::isnan(_avg));
         }
@@ -96,15 +98,14 @@ namespace prlearn {
 
         qvar_t() = default;
 
-        qvar_t(double d, double w, double v) {
+        qvar_t(double d, double w, double squared) {
             _avg = d;
             _cnt = w;
-            _variance = v;
+            _sq = squared;
         };
         // this is a dirty hijack!
         qvar_t& operator+=(double d);
         void addPoints(double weight, double d);
-        double _variance = 0;
 
         auto& avg() {
             return _avg;
@@ -127,6 +128,27 @@ namespace prlearn {
         }
         void print(std::ostream& stream) const;
         static qvar_t approximate(const qvar_t& a, const qvar_t& b);
+        double variance() const {
+            auto pow = std::pow(_avg, 2.0);
+            if(pow >= _sq)
+                return 0;
+            return _sq - pow;
+        }
+
+        void set_variance(double var) {
+            _sq = std::pow(_avg, 2.0) + var;
+        }
+
+       double& squared() {
+            return _sq;
+       }
+
+        const double& squared() const {
+            return _sq;
+        }
+
+    private:
+        double _sq = 0;
     };
 
     struct splitfilter_t {