Is it possible that the "m. file" code is converted from the double precision to the single precision??

I have "sqp.m" file which is attached here.

Is there anyway to convert this "m. file" from the double precision to the single precision??

(I found the below document and tried it, but it doesn't work.)

(https://kr.mathworks.com/help/fixedpoint/ref/converttosingle.html)

I wish that a result is "m.file" with 'single precision variables'

Thank you very much.

[John D'Errico]

Unless you are good enough to have written that code yourself, having sufficient knowledge and understanding to have written that code, then wanting to change it as you wish is just dangerous.

Yes, I know (from your previous questions) that you need code to run in a single precision environment. But this is just asking for trouble, strange failures, that you then won't understand.

[Changwoo Lee]

@John D'Errico Yes, there is a obvious minor data loss. However, my hardware only supports the single precision. There is no choice. Fortunately, the minor data loss is negligible for this case. Thank you.

[dpb]

So, what was the result of trying converttosingle?

Did it just fail to produce an output piece of code because was too complex for the function or did it produce SP code but that code didn't give expected results?

Briefly reading the description, sounds like it tries to ensure the numerics still work after converting double-->single; if it gives you an error about that sort of thing, as John implies above, "There be dragons!" in assuming that an algorithm implemented and successful in double precision will work in double precision just by reducing precision.

In particular, this being an optimization code, things like computing derivatives, particularly if it uses numerical methods instead of evaluating functional forms (the requirement for which would greatly reduce the field of possible applications of the routine to those for whom analytic expressions are available).

[Changwoo Lee]

@dpb Thank you for your reply. "converttosingle" was one of the trial methods.

As your comment, due to the complicated code, it seems that the "converttosingle" could not convert the code.

I used the code

-----

scfg = coder.config('single');

scfg.TestBenchName = 'sqp';

scfg.TestNumerics = true;

scfg.LogIOForComparisonPlotting = true;

convertToSingle -config scfg sqp

-----

Then, obtained the below results

----

===================================================

Design Name: sqp

Test Bench Name: sqp

===================================================

Input types not specified for design(s) 'sqp', inferring types by simulating the first test bench: 'sqp' in the base workspace.

Warning: The design 'sqp' has inputs but the

input types were inferred using test bench

'sqp'. Make sure the test bench 'sqp'

invokes the design.

============= Step1: Analyze Double-Precision Code ==============

Error

[dpb]

A geezer story on single vs double precision -- way back in the dark ages in the mid 70s I attended a conference of American Nuclear Society at which a MS candidate presented a point kernel model of neutron flux distribution in a power reactor to estimate flux at excore detector locations. It just so happened I was in the process of building a model for the same problem at the time so I requested and received a copy of his code for comparison/help in completing the work I was doing.

When I compiled and ran the code on the CDC Cyber76, I got results signficantly different from those he had produced and, unfortunately, on which his MS thesis conclusions were based(*). On exploration for the cause, it turned out he had relied on single precision and run his code on a 32-bit IBM mainframe. The CDC machines were 60-bit so single precision floating point on them was nearly as precise as double precision on the IBM.

The problem was that he accumulated summations from the the various nodes within the reactor at the external locations in a geometrical pattern (logically), but owing to the limited precision, many of the contributions to the total response from the inner assemblies were sufficiently small as to underflow the summation although the aggregation was sufficient overall to modify the response enough as to be in substantial error.

"There be dragons!" that you can't predict without extensive testing and quite likely major rewrites to solve. In the above case the solution could be obtained relatively easily without DP, but it was still much easier to just recompile, of course.

(*) Fortunately, his research thesis topic corporate sponsor and the university were flexible enough as to allow him to go ahead and receive his diploma and resubmit the work results and a revision/errata section to his thesis. It was a little dicey for a while for him, however...

[dpb]

I don't have the coder so can't test/experiment, but looks to me by the error messages it spit out like there are further input parameters to the conversion routine you could specify to let it know the data types of the input arguments and other refinements that could be tried before completely giving up on the conversion process.

Answer 1

[Jan]

This function has been developped an tested since 1995. You cannot be sure, if it works correctly with singles as inputs.

converttosingle is an interesting idea. Unfortunately you explain only, that "it doesn't work" without mentioning the details.

With using the debugger, you should be able to find all commands, which create double arrays or rely on the inputs to be doubles. Most of all these are a lot of eps(), ones() and zeros() calls. In addition I find eye() and inf. Some constants as 0, 1 and 2 are occuring also, but they might be used as integers, e.g. in indices.

I would not rely on an automatic conversion, because for such a complicated code this is too fragile.

[dpb]

Agreed wholeheartedly.

http://klaus-schittkowski.de/nlpqlp.htm has the original Fortran source code.

Many historic Fortran math libraries do have both single and double precision implementations so I searched for NLPQLP online. It seems not to have any SP implementations.

[Changwoo Lee]

I was wondering if there is a better way, but there doesn't seem to be an easy way...

Thank you very much.

Answer 2

[Andy Bartlett]

Hi,

The tools for converting double precision floating-point to single precision for MATLAB code and Simulink models work best at converting designs that (aside from numeric efficiency needs like data types) are close to ready for a "specific" embedded usage.

General purpose MATLAB code based on default doubles and designed to handle a very wide set of situations, such as your SQP function, is much less likely to convert well as compared to a design that has been narrowed down to a specific embedded real-time need.

Since the example you provided, sqp, is doing Quadratic Programming, my answer to your other question might be helpful. That answer refers to the Model Predictive Controller that I believe uses Quadratic Programming on the inside and supports single precision sim and code generation.

Andy