feat: optimize evaluator control flow and data handling for scalars

Nelson-numerical-software · Nelson-numerical-software · commit 2d4ad3e645c5 · 2026-03-03T21:29:09.000+01:00
diff --git a/modules/interpreter/src/cpp/EvaluatorControlFlow.cpp b/modules/interpreter/src/cpp/EvaluatorControlFlow.cpp
@@ -161,22 +161,32 @@ Evaluator::ifStatement(AbstractSyntaxTreePtr t)
             }
         }
     }
+
+    // Early return if condition is true - avoids checking elseOrElseIf unnecessarily
+    if (conditionedStatement(t)) {
+        return;
+    }
+
     AbstractSyntaxTreePtr elseOrElseIf = t->right;
-    if (!conditionedStatement(t)) {
-        if (elseOrElseIf != nullptr && elseOrElseIf->opNum == OP_ELSEIFBLOCK) {
-            AbstractSyntaxTreePtr s = elseOrElseIf->down;
-            while (s != nullptr) {
-                if (conditionedStatement(s)) {
-                    return;
-                }
-                s = s->right;
+    if (elseOrElseIf == nullptr) {
+        return;
+    }
+
+    if (elseOrElseIf->opNum == OP_ELSEIFBLOCK) {
+        AbstractSyntaxTreePtr s = elseOrElseIf->down;
+        while (s != nullptr) {
+            if (conditionedStatement(s)) {
+                return;
             }
-            elseOrElseIf = elseOrElseIf->right;
+            s = s->right;
         }
-        if (elseOrElseIf != nullptr) {
-            block(elseOrElseIf);
+        elseOrElseIf = elseOrElseIf->right;
+        if (elseOrElseIf == nullptr) {
+            return;
         }
     }
+
+    block(elseOrElseIf);
 }
 //=============================================================================
 //!
diff --git a/modules/interpreter/src/cpp/EvaluatorDebug.cpp b/modules/interpreter/src/cpp/EvaluatorDebug.cpp
@@ -253,13 +253,16 @@ Evaluator::stepBreakpointExists(const Breakpoint& bp)
 bool
 Evaluator::onBreakpoint(AbstractSyntaxTreePtr t)
 {
+    if (breakpoints.empty() && !bpActive) {
+        return false;
+    }
     std::string currentFunctionName = context->getCurrentScope()->getName();
     // Fast path: if we are in step-next mode and the line changed, break immediately
     if (bpActive && stepMode && stepBreakpoint.has_value() && stepBreakpoint->stepNext) {
         const Breakpoint& sb = *stepBreakpoint;
-        std::wstring sbFile = sb.filename;
+        const std::wstring& sbFile = sb.filename;
         if (!sbFile.empty() && filenamesMatch(sbFile, context->getCurrentScope()->getFilename())) {
-            std::string currentFunction = context->getCurrentScope()->getName();
+            const std::string& currentFunction = context->getCurrentScope()->getName();
             // For step-over: ONLY break in the same function (no depth check to avoid confusion)
             bool inSameFunction = !sb.functionName.empty() && sb.functionName == currentFunction;
             bool shouldBreak = sb.stepInto || inSameFunction;
diff --git a/modules/interpreter/src/cpp/MacroFunctionDef.cpp b/modules/interpreter/src/cpp/MacroFunctionDef.cpp
@@ -169,7 +169,12 @@ MacroFunctionDef::evaluateMFunction(Evaluator* eval, const ArrayOfVector& inputs
 
     uint64 tic = 0;
     try {
-        insertLocalFunctions(context);
+        // Only insert local functions on first entry (they don't change during recursion).
+        if (recursionDepth == 1) {
+            insertLocalFunctions(context);
+        } else if (this->nextFunction != nullptr || this->prevFunction != nullptr) {
+            insertLocalFunctions(context);
+        }
         setInputArgumentNames(context, inputs);
         bindInputs(context, inputs);
         context->getCurrentScope()->setNargOut(nargout);
@@ -202,12 +207,15 @@ MacroFunctionDef::evaluateMFunction(Evaluator* eval, const ArrayOfVector& inputs
 
         outputs = prepareOutputs(context, nargout);
 
-        onCleanup(eval);
-
+        if (!cleanupTasks.empty()) {
+            onCleanup(eval);
+        }
         context->popScope();
         eval->callstack.popDebug();
     } catch (const Exception&) {
-        onCleanup(eval);
+        if (!cleanupTasks.empty()) {
+            onCleanup(eval);
+        }
         if (recursionDepth == 1 && tic != 0) {
             internalProfileFunction stack
                 = computeProfileStack(eval, getCompleteName(), this->getFilename(), false);
@@ -283,12 +291,26 @@ MacroFunctionDef::evaluateMScript(Evaluator* eval, const ArrayOfVector& inputs,
 ArrayOfVector
 MacroFunctionDef::evaluateFunction(Evaluator* eval, const ArrayOfVector& inputs, int nargout)
 {
-    lock();
-    updateCode();
-    if (isScript) {
-        return evaluateMScript(eval, inputs, nargout);
+    // Skip lock/updateCode on recursive calls � code cannot change mid-recursion.
+    static thread_local int evaluateFunctionDepth = 0;
+    if (evaluateFunctionDepth == 0) {
+        lock();
+        updateCode();
+    }
+    ++evaluateFunctionDepth;
+    ArrayOfVector result;
+    try {
+        if (isScript) {
+            result = evaluateMScript(eval, inputs, nargout);
+        } else {
+            result = evaluateMFunction(eval, inputs, nargout);
+        }
+    } catch (...) {
+        --evaluateFunctionDepth;
+        throw;
     }
-    return evaluateMFunction(eval, inputs, nargout);
+    --evaluateFunctionDepth;
+    return result;
 }
 //=============================================================================
 std::string
diff --git a/modules/types/src/cpp/ArrayOf.cpp b/modules/types/src/cpp/ArrayOf.cpp
@@ -470,6 +470,11 @@ ArrayOf::ArrayOf(
     dp = new Data(type, dims, data, sparse, fnames);
 }
 //=============================================================================
+ArrayOf::ArrayOf(NelsonType type, const Dimensions& dims, const void* scalarData, size_t dataSize)
+{
+    dp = new Data(type, dims, scalarData, dataSize);
+}
+//=============================================================================
 ArrayOf::ArrayOf(NelsonType type) { dp = new Data(type, Dimensions(0, 0), nullptr); }
 //=============================================================================
 /**
diff --git a/modules/types/src/cpp/ArrayOf_Constructors.cpp b/modules/types/src/cpp/ArrayOf_Constructors.cpp
@@ -115,7 +115,7 @@ ArrayOf
 ArrayOf::emptyCell(const Dimensions& dim)
 {
     if (dim.getElementCount() == 0) {
-        return ArrayOf(NLS_CELL_ARRAY, dim, nullptr, false);
+        return ArrayOf(NLS_CELL_ARRAY, dim, (void*)nullptr, false);
     }
     Error(_W("Invalid dimensions."));
     return {};
@@ -125,7 +125,7 @@ ArrayOf
 ArrayOf::emptyConstructor(const Dimensions& dim, bool bIsSparse)
 {
     if (dim.getElementCount() == 0) {
-        return ArrayOf(NLS_DOUBLE, dim, nullptr, bIsSparse);
+        return ArrayOf(NLS_DOUBLE, dim, (void*)nullptr, bIsSparse);
     }
     Error(_W("Invalid dimensions."));
 
@@ -137,7 +137,7 @@ ArrayOf::emptyConstructor(indexType m, indexType n, bool bIsSparse)
 {
     if (((m == 0) && (n == 0)) || ((m == 0) && (n != 0)) || ((m != 0) && (n == 0))) {
         Dimensions dim(m, n);
-        return ArrayOf(NLS_DOUBLE, dim, nullptr, bIsSparse);
+        return ArrayOf(NLS_DOUBLE, dim, (void*)nullptr, bIsSparse);
     }
     Error(_W("Invalid dimensions."));
 
diff --git a/modules/types/src/cpp/ArrayOf_DoubleType.cpp b/modules/types/src/cpp/ArrayOf_DoubleType.cpp
@@ -52,9 +52,7 @@ ArrayOf::isNdArrayDoubleType(bool realOnly) const
 ArrayOf
 ArrayOf::doubleConstructor(double aval)
 {
-    double* data = static_cast<double*>(allocateArrayOf(NLS_DOUBLE, 1, stringVector(), false));
-    *data = aval;
-    return ArrayOf(NLS_DOUBLE, Dimensions(1, 1), data);
+    return ArrayOf(NLS_DOUBLE, Dimensions(1, 1), static_cast<const void*>(&aval), sizeof(double));
 }
 //=============================================================================
 ArrayOf
@@ -94,10 +92,8 @@ ArrayOf::doubleMatrix2dConstructor(indexType m, indexType n)
 ArrayOf
 ArrayOf::dcomplexConstructor(double aval, double bval)
 {
-    double* data = static_cast<double*>(allocateArrayOf(NLS_DCOMPLEX, 1, stringVector(), false));
-    data[0] = aval;
-    data[1] = bval;
-    return ArrayOf(NLS_DCOMPLEX, Dimensions(1, 1), data);
+    double data[2] = { aval, bval };
+    return ArrayOf(NLS_DCOMPLEX, Dimensions(1, 1), static_cast<const void*>(data), sizeof(data));
 }
 //=============================================================================
 std::vector<double>
diff --git a/modules/types/src/cpp/ArrayOf_HandleType.cpp b/modules/types/src/cpp/ArrayOf_HandleType.cpp
@@ -28,21 +28,16 @@ ArrayOf::isHandle() const
 ArrayOf
 ArrayOf::handleConstructor(nelson_handle hl)
 {
-    nelson_handle* ptrObject = static_cast<nelson_handle*>(
-        ArrayOf::allocateArrayOf(NLS_HANDLE, 1, stringVector(), false));
     Dimensions dims(1, 1);
-    ptrObject[0] = hl;
-    return ArrayOf(NLS_HANDLE, dims, (void*)ptrObject);
+    return ArrayOf(NLS_HANDLE, dims, static_cast<const void*>(&hl), sizeof(nelson_handle));
 }
 //=============================================================================
 ArrayOf
 ArrayOf::handleConstructor(HandleGenericObject* ptr)
 {
-    nelson_handle* ptrObject = static_cast<nelson_handle*>(
-        ArrayOf::allocateArrayOf(NLS_HANDLE, 1, stringVector(), false));
     Dimensions dims(1, 1);
-    ptrObject[0] = HandleManager::getInstance()->addHandle(ptr);
-    return ArrayOf(NLS_HANDLE, dims, (void*)ptrObject);
+    nelson_handle hl = HandleManager::getInstance()->addHandle(ptr);
+    return ArrayOf(NLS_HANDLE, dims, static_cast<const void*>(&hl), sizeof(nelson_handle));
 }
 //=============================================================================
 HandleGenericObject*
diff --git a/modules/types/src/cpp/ArrayOf_IntegersType.cpp b/modules/types/src/cpp/ArrayOf_IntegersType.cpp
@@ -24,9 +24,7 @@ scalarConstructor(NelsonType type, T value)
 {
     Dimensions dim;
     dim.makeScalar();
-    T* data = static_cast<T*>(ArrayOf::allocateArrayOf(type, 1, stringVector(), false));
-    *data = value;
-    return ArrayOf(type, dim, data);
+    return ArrayOf(type, dim, static_cast<const void*>(&value), sizeof(T));
 }
 //=============================================================================
 template <typename T>
@@ -329,19 +327,19 @@ ArrayOf::integerRangeConstructor(indexType minval, indexType stepsize, indexType
     if (stepsize == 0) {
         Cdim[0] = 1;
         Cdim[1] = 0;
-        return ArrayOf(classC, Cdim, nullptr, false);
+        return ArrayOf(classC, Cdim, (void*)nullptr, false);
     }
     if (minval < maxval) {
         if (stepsize < 0) {
             Cdim[0] = 1;
             Cdim[1] = 0;
-            return ArrayOf(classC, Cdim, nullptr, false);
+            return ArrayOf(classC, Cdim, (void*)nullptr, false);
         }
     }
     if (minval > maxval) {
         Cdim[0] = 0;
         Cdim[1] = 1;
-        return ArrayOf(classC, Cdim, nullptr, false);
+        return ArrayOf(classC, Cdim, (void*)nullptr, false);
     }
     auto dn = static_cast<double>((((maxval - minval) / stepsize) + 1));
 #ifdef NLS_INDEX_TYPE_64
diff --git a/modules/types/src/cpp/ArrayOf_LogicalType.cpp b/modules/types/src/cpp/ArrayOf_LogicalType.cpp
@@ -38,9 +38,8 @@ ArrayOf::logicalConstructor(bool aval)
 {
     Dimensions dim;
     dim.makeScalar();
-    logical* data = static_cast<logical*>(allocateArrayOf(NLS_LOGICAL, 1, stringVector(), false));
-    *data = static_cast<logical>(aval);
-    return ArrayOf(NLS_LOGICAL, dim, data);
+    logical val = static_cast<logical>(aval);
+    return ArrayOf(NLS_LOGICAL, dim, static_cast<const void*>(&val), sizeof(logical));
 }
 //=============================================================================
 logical
diff --git a/modules/types/src/cpp/ArrayOf_MissingType.cpp b/modules/types/src/cpp/ArrayOf_MissingType.cpp
@@ -37,10 +37,8 @@ ArrayOf::missingScalarConstructor()
 {
     Dimensions dim;
     dim.makeScalar();
-    double* data
-        = static_cast<double*>(allocateArrayOf(NLS_MISSING_ARRAY, 1, stringVector(), false));
-    *data = std::nan("");
-    return ArrayOf(NLS_MISSING_ARRAY, dim, data);
+    double val = std::nan("");
+    return ArrayOf(NLS_MISSING_ARRAY, dim, static_cast<const void*>(&val), sizeof(double));
 }
 //=============================================================================
 } // namespace Nelson
diff --git a/modules/types/src/cpp/ArrayOf_SingleType.cpp b/modules/types/src/cpp/ArrayOf_SingleType.cpp
@@ -60,9 +60,7 @@ ArrayOf::singleConstructor(float aval)
 {
     Dimensions dim;
     dim.makeScalar();
-    float* data = static_cast<float*>(allocateArrayOf(NLS_SINGLE, 1, stringVector(), false));
-    *data = aval;
-    return ArrayOf(NLS_SINGLE, dim, data);
+    return ArrayOf(NLS_SINGLE, dim, static_cast<const void*>(&aval), sizeof(float));
 }
 //=============================================================================
 ArrayOf
@@ -106,10 +104,8 @@ ArrayOf::complexConstructor(float aval, float bval)
 {
     Dimensions dim;
     dim.makeScalar();
-    float* data = static_cast<float*>(allocateArrayOf(NLS_SCOMPLEX, 1, stringVector(), false));
-    data[0] = aval;
-    data[1] = bval;
-    return ArrayOf(NLS_SCOMPLEX, dim, data);
+    float data[2] = { aval, bval };
+    return ArrayOf(NLS_SCOMPLEX, dim, static_cast<const void*>(data), sizeof(data));
 }
 //=============================================================================
 single
diff --git a/modules/types/src/cpp/Data.cpp b/modules/types/src/cpp/Data.cpp
@@ -10,19 +10,33 @@
 //=============================================================================
 #include <utility>
 #include <atomic>
+#include <cstring>
 //=============================================================================
 #include "Data.hpp"
 #include "SparseDynamicFunctions.hpp"
 //=============================================================================
 namespace Nelson {
 //=============================================================================
 Data::Data(NelsonType aClass, const Dimensions& dims, void* s, bool sparseflag, stringVector fields)
-    : cp(s), owners(1), dimensions(dims), fieldNames(std::move(fields)), dataClass(aClass)
+    : cp(s)
+    , owners(1)
+    , dimensions(dims)
+    , fieldNames(std::move(fields))
+    , dataClass(aClass)
+    , isInline(false)
 {
     sparse = sparseflag;
     refreshDimensionCache();
 }
 //=============================================================================
+Data::Data(NelsonType aClass, const Dimensions& dims, const void* scalarData, size_t dataSize)
+    : owners(1), dimensions(dims), dataClass(aClass), sparse(false), isInline(true)
+{
+    std::memcpy(inlineBuffer, scalarData, dataSize);
+    cp = inlineBuffer;
+    refreshDimensionCache();
+}
+//=============================================================================
 Data::~Data() { freeDataBlock(); }
 //=============================================================================
 Data*
@@ -39,6 +53,7 @@ Data::putData(
     if ((owners.load() <= 1)) {
         freeDataBlock();
         cp = s;
+        isInline = false;
         dataClass = aClass;
         dimensions = dims;
         fieldNames = fields;
@@ -133,6 +148,11 @@ Data::numberOfOwners() const
 void
 Data::freeDataBlock()
 {
+    if (isInline) {
+        cp = nullptr;
+        isInline = false;
+        return;
+    }
     if (cp) {
         switch (dataClass) {
         case NLS_MISSING_ARRAY: {
diff --git a/modules/types/src/cpp/FindCommonType.cpp b/modules/types/src/cpp/FindCommonType.cpp
diff --git a/modules/types/src/include/ArrayOf.hpp b/modules/types/src/include/ArrayOf.hpp
diff --git a/modules/types/src/include/Data.hpp b/modules/types/src/include/Data.hpp

Original file line number	Diff line number	Diff line change
`@@ -161,22 +161,32 @@ Evaluator::ifStatement(AbstractSyntaxTreePtr t)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`}`
	`164`	`+`
	`165`	`+ // Early return if condition is true - avoids checking elseOrElseIf unnecessarily`
	`166`	`+ if (conditionedStatement(t)) {`
	`167`	`+ return;`
	`168`	`+ }`
	`169`	`+`
`164`	`170`	`AbstractSyntaxTreePtr elseOrElseIf = t->right;`
`165`		`- if (!conditionedStatement(t)) {`
`166`		`- if (elseOrElseIf != nullptr && elseOrElseIf->opNum == OP_ELSEIFBLOCK) {`
`167`		`- AbstractSyntaxTreePtr s = elseOrElseIf->down;`
`168`		`- while (s != nullptr) {`
`169`		`- if (conditionedStatement(s)) {`
`170`		`- return;`
`171`		`- }`
`172`		`- s = s->right;`
	`171`	`+ if (elseOrElseIf == nullptr) {`
	`172`	`+ return;`
	`173`	`+ }`
	`174`	`+`
	`175`	`+ if (elseOrElseIf->opNum == OP_ELSEIFBLOCK) {`
	`176`	`+ AbstractSyntaxTreePtr s = elseOrElseIf->down;`
	`177`	`+ while (s != nullptr) {`
	`178`	`+ if (conditionedStatement(s)) {`
	`179`	`+ return;`
`173`	`180`	`}`
`174`		`- elseOrElseIf = elseOrElseIf->right;`
	`181`	`+ s = s->right;`
`175`	`182`	`}`
`176`		`- if (elseOrElseIf != nullptr) {`
`177`		`- block(elseOrElseIf);`
	`183`	`+ elseOrElseIf = elseOrElseIf->right;`
	`184`	`+ if (elseOrElseIf == nullptr) {`
	`185`	`+ return;`
`178`	`186`	`}`
`179`	`187`	`}`
	`188`	`+`
	`189`	`+ block(elseOrElseIf);`
`180`	`190`	`}`
`181`	`191`	`//=============================================================================`
`182`	`192`	`//!`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ ArrayOf`
`115`	`115`	`ArrayOf::emptyCell(const Dimensions& dim)`
`116`	`116`	`{`
`117`	`117`	`if (dim.getElementCount() == 0) {`
`118`		`- return ArrayOf(NLS_CELL_ARRAY, dim, nullptr, false);`
	`118`	`+ return ArrayOf(NLS_CELL_ARRAY, dim, (void*)nullptr, false);`
`119`	`119`	`}`
`120`	`120`	`Error(_W("Invalid dimensions."));`
`121`	`121`	`return {};`
`@@ -125,7 +125,7 @@ ArrayOf`
`125`	`125`	`ArrayOf::emptyConstructor(const Dimensions& dim, bool bIsSparse)`
`126`	`126`	`{`
`127`	`127`	`if (dim.getElementCount() == 0) {`
`128`		`- return ArrayOf(NLS_DOUBLE, dim, nullptr, bIsSparse);`
	`128`	`+ return ArrayOf(NLS_DOUBLE, dim, (void*)nullptr, bIsSparse);`
`129`	`129`	`}`
`130`	`130`	`Error(_W("Invalid dimensions."));`
`131`	`131`
`@@ -137,7 +137,7 @@ ArrayOf::emptyConstructor(indexType m, indexType n, bool bIsSparse)`
`137`	`137`	`{`
`138`	`138`	`if (((m == 0) && (n == 0)) \|\| ((m == 0) && (n != 0)) \|\| ((m != 0) && (n == 0))) {`
`139`	`139`	`Dimensions dim(m, n);`
`140`		`- return ArrayOf(NLS_DOUBLE, dim, nullptr, bIsSparse);`
	`140`	`+ return ArrayOf(NLS_DOUBLE, dim, (void*)nullptr, bIsSparse);`
`141`	`141`	`}`
`142`	`142`	`Error(_W("Invalid dimensions."));`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -52,9 +52,7 @@ ArrayOf::isNdArrayDoubleType(bool realOnly) const`
`52`	`52`	`ArrayOf`
`53`	`53`	`ArrayOf::doubleConstructor(double aval)`
`54`	`54`	`{`
`55`		`- double* data = static_cast<double*>(allocateArrayOf(NLS_DOUBLE, 1, stringVector(), false));`
`56`		`- *data = aval;`
`57`		`- return ArrayOf(NLS_DOUBLE, Dimensions(1, 1), data);`
	`55`	`+ return ArrayOf(NLS_DOUBLE, Dimensions(1, 1), static_cast<const void*>(&aval), sizeof(double));`
`58`	`56`	`}`
`59`	`57`	`//=============================================================================`
`60`	`58`	`ArrayOf`
`@@ -94,10 +92,8 @@ ArrayOf::doubleMatrix2dConstructor(indexType m, indexType n)`
`94`	`92`	`ArrayOf`
`95`	`93`	`ArrayOf::dcomplexConstructor(double aval, double bval)`
`96`	`94`	`{`
`97`		`- double* data = static_cast<double*>(allocateArrayOf(NLS_DCOMPLEX, 1, stringVector(), false));`
`98`		`- data[0] = aval;`
`99`		`- data[1] = bval;`
`100`		`- return ArrayOf(NLS_DCOMPLEX, Dimensions(1, 1), data);`
	`95`	`+ double data[2] = { aval, bval };`
	`96`	`+ return ArrayOf(NLS_DCOMPLEX, Dimensions(1, 1), static_cast<const void*>(data), sizeof(data));`
`101`	`97`	`}`
`102`	`98`	`//=============================================================================`
`103`	`99`	`std::vector<double>`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,7 @@ scalarConstructor(NelsonType type, T value)`
`24`	`24`	`{`
`25`	`25`	`Dimensions dim;`
`26`	`26`	`dim.makeScalar();`
`27`		`- T* data = static_cast<T*>(ArrayOf::allocateArrayOf(type, 1, stringVector(), false));`
`28`		`- *data = value;`
`29`		`- return ArrayOf(type, dim, data);`
	`27`	`+ return ArrayOf(type, dim, static_cast<const void*>(&value), sizeof(T));`
`30`	`28`	`}`
`31`	`29`	`//=============================================================================`
`32`	`30`	`template <typename T>`
`@@ -329,19 +327,19 @@ ArrayOf::integerRangeConstructor(indexType minval, indexType stepsize, indexType`
`329`	`327`	`if (stepsize == 0) {`
`330`	`328`	`Cdim[0] = 1;`
`331`	`329`	`Cdim[1] = 0;`
`332`		`- return ArrayOf(classC, Cdim, nullptr, false);`
	`330`	`+ return ArrayOf(classC, Cdim, (void*)nullptr, false);`
`333`	`331`	`}`
`334`	`332`	`if (minval < maxval) {`
`335`	`333`	`if (stepsize < 0) {`
`336`	`334`	`Cdim[0] = 1;`
`337`	`335`	`Cdim[1] = 0;`
`338`		`- return ArrayOf(classC, Cdim, nullptr, false);`
	`336`	`+ return ArrayOf(classC, Cdim, (void*)nullptr, false);`
`339`	`337`	`}`
`340`	`338`	`}`
`341`	`339`	`if (minval > maxval) {`
`342`	`340`	`Cdim[0] = 0;`
`343`	`341`	`Cdim[1] = 1;`
`344`		`- return ArrayOf(classC, Cdim, nullptr, false);`
	`342`	`+ return ArrayOf(classC, Cdim, (void*)nullptr, false);`
`345`	`343`	`}`
`346`	`344`	`auto dn = static_cast<double>((((maxval - minval) / stepsize) + 1));`
`347`	`345`	`#ifdef NLS_INDEX_TYPE_64`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,8 @@ ArrayOf::logicalConstructor(bool aval)`
`38`	`38`	`{`
`39`	`39`	`Dimensions dim;`
`40`	`40`	`dim.makeScalar();`
`41`		`- logical* data = static_cast<logical*>(allocateArrayOf(NLS_LOGICAL, 1, stringVector(), false));`
`42`		`- *data = static_cast<logical>(aval);`
`43`		`- return ArrayOf(NLS_LOGICAL, dim, data);`
	`41`	`+ logical val = static_cast<logical>(aval);`
	`42`	`+ return ArrayOf(NLS_LOGICAL, dim, static_cast<const void*>(&val), sizeof(logical));`
`44`	`43`	`}`
`45`	`44`	`//=============================================================================`
`46`	`45`	`logical`
Original file line number	Diff line number	Diff line change
`@@ -37,10 +37,8 @@ ArrayOf::missingScalarConstructor()`
`37`	`37`	`{`
`38`	`38`	`Dimensions dim;`
`39`	`39`	`dim.makeScalar();`
`40`		`- double* data`
`41`		`- = static_cast<double*>(allocateArrayOf(NLS_MISSING_ARRAY, 1, stringVector(), false));`
`42`		`- *data = std::nan("");`
`43`		`- return ArrayOf(NLS_MISSING_ARRAY, dim, data);`
	`40`	`+ double val = std::nan("");`
	`41`	`+ return ArrayOf(NLS_MISSING_ARRAY, dim, static_cast<const void*>(&val), sizeof(double));`
`44`	`42`	`}`
`45`	`43`	`//=============================================================================`
`46`	`44`	`} // namespace Nelson`