Merge pull request #117 from mpsonntag/fixAxis

Quick fix Dimension axis, ticksAt, positionAt error

LGTM

Author: gicmo

+nix/RangeDimension.m

@@ -23,7 +23,7 @@
                 index = index - 1;
             end
             func_name = strcat(obj.alias, '::tick_at');
-            tickAt = nix_mx(func_name, obj.nix_handle, uint64(index));
+            tickAt = nix_mx(func_name, obj.nix_handle, index);
         end
 
         function indexOf = index_of(obj, position)
@@ -40,7 +40,7 @@
             end
 
             func_name = strcat(obj.alias, '::axis');
-            axis = nix_mx(func_name, obj.nix_handle, uint64(count), uint64(startIndex));
+            axis = nix_mx(func_name, obj.nix_handle, count, startIndex);
         end
 
     end

+nix/SampledDimension.m

@@ -28,7 +28,7 @@
                 index = index - 1;
             end
             func_name = strcat(obj.alias, '::position_at');
-            posAt = nix_mx(func_name, obj.nix_handle, uint64(index));
+            posAt = nix_mx(func_name, obj.nix_handle, index);
         end
 
         function axis = axis(obj, count, startIndex)
@@ -39,8 +39,7 @@
                 startIndex = startIndex - 1;
             end
             func_name = strcat(obj.alias, '::axis');
-            axis = nix_mx(func_name, obj.nix_handle, uint64(count), uint64(startIndex));
+            axis = nix_mx(func_name, obj.nix_handle, count, startIndex);
         end
     end
 end
-   

nix_mx.cc

@@ -322,20 +322,20 @@ void mexFunction(int            nlhs,
             .reg("set_samplingInterval", SETTER(double, nix::SampledDimension, samplingInterval))
             .reg("set_offset", SETTER(double, nix::SampledDimension, offset))
             .reg("set_none_offset", SETTER(const boost::none_t, nix::SampledDimension, offset))
-            .reg("index_of", &nix::SampledDimension::indexOf)
-            .reg("position_at", &nix::SampledDimension::positionAt)
-            .reg("axis", &nix::SampledDimension::axis);
-        
+            .reg("index_of", &nix::SampledDimension::indexOf);
+        methods->add("SampledDimension::position_at", nixdimensions::sampled_position_at);
+        methods->add("SampledDimension::axis", nixdimensions::sampled_axis);
+
         classdef<nix::RangeDimension>("RangeDimension", methods)
             .desc(&nixdimensions::describe)
             .reg("set_label", SETTER(const std::string&, nix::RangeDimension, label))
             .reg("set_none_label", SETTER(const boost::none_t, nix::RangeDimension, label))
             .reg("set_unit", SETTER(const std::string&, nix::RangeDimension, unit))
             .reg("set_none_unit", SETTER(const boost::none_t, nix::RangeDimension, unit))
             .reg("set_ticks", SETTER(const std::vector<double>&, nix::RangeDimension, ticks))
-            .reg("index_of", &nix::RangeDimension::indexOf)
-            .reg("tick_at", &nix::RangeDimension::tickAt)
-            .reg("axis", &nix::RangeDimension::axis);
+            .reg("index_of", &nix::RangeDimension::indexOf);
+        methods->add("RangeDimension::tick_at", nixdimensions::range_tick_at);
+        methods->add("RangeDimension::axis", nixdimensions::range_axis);
 
         mexAtExit(on_exit);
     });

src/nixdimensions.cc

@@ -40,4 +40,46 @@ namespace nixdimensions {
 
         return sb.array();
     }
+
+    void sampled_position_at(const extractor &input, infusor &output) {
+        nix::SampledDimension dim = input.entity<nix::SampledDimension>(1);
+        const size_t index = static_cast<size_t>(input.num<double>(2));
+
+        double pos = dim.positionAt(index);
+        output.set(0, pos);
+    }
+
+    void sampled_axis(const extractor &input, infusor &output) {
+        nix::SampledDimension dim = input.entity<nix::SampledDimension>(1);
+        const size_t count = static_cast<size_t>(input.num<double>(2));
+        const size_t startIndex = static_cast<size_t>(input.num<double>(3));
+
+        std::vector<double> a = dim.axis(count, startIndex);
+        mxArray *axis = mxCreateDoubleMatrix(1, a.size(), mxREAL);
+        std::copy(a.begin(), a.end(), mxGetPr(axis));
+
+        output.set(0, axis);
+    }
+
+    void range_tick_at(const extractor &input, infusor &output) {
+        nix::RangeDimension dim = input.entity<nix::RangeDimension>(1);
+        const size_t index = static_cast<size_t>(input.num<double>(2));
+
+        double tick = dim.tickAt(index);
+        output.set(0, tick);
+    }
+
+    void range_axis(const extractor &input, infusor &output) {
+        nix::RangeDimension dim = input.entity<nix::RangeDimension>(1);
+        const size_t count = static_cast<size_t>(input.num<double>(2));
+        const size_t startIndex = static_cast<size_t>(input.num<double>(3));
+
+        std::vector<double> a = dim.axis(count, startIndex);
+        mxArray *axis = mxCreateDoubleMatrix(1, a.size(), mxREAL);
+        std::copy(a.begin(), a.end(), mxGetPr(axis));
+
+        output.set(0, axis);
+    }
+
 } // namespace nixdimensions
+

src/nixdimensions.h

@@ -11,6 +11,14 @@ namespace nixdimensions {
 
     mxArray *describe(const nix::RangeDimension &dim);
 
-} // namespace nixtag
+    void sampled_position_at(const extractor &input, infusor &output);
 
-#endif
+    void sampled_axis(const extractor &input, infusor &output);
+
+    void range_tick_at(const extractor &input, infusor &output);
+
+    void range_axis(const extractor &input, infusor &output);
+
+} // namespace nixdimensions
+
+#endif