使用 Python 中 C DLL 中的函数时出现奇怪的情况

Question

I'm having a strange issue where I'm using DLL functions that return more or less the same float value (ie their residual is less than 1e-08), but I'm somehow seeing different behavior.

Here is the general way I'm writing the function prototypes in Python; this should be enough information to give you an idea of how I'm doing this part.

class OWTP:

    def __init__(self):
        self._lib = CDLL("../Include/OWTP.dll")
        protoTwoParams = CFUNCTYPE(c_double, c_double, c_double)
        ptApi = (1, "P"), (1, "T")

        #properties as functions of pressure and temperature
        self.v_PT = protoTwoParams(("v_P_T", self._lib), ptApi)
        self.u_PT = protoTwoParams(("u_P_T", self._lib), ptApi)
        self.s_PT = protoTwoParams(("s_P_T", self._lib), ptApi)
        self.h_PT = protoTwoParams(("h_P_T", self._lib), ptApi)
        self.cp_PT = protoTwoParams(("cp_P_T", self._lib), ptApi)
        self.cv_PT = protoTwoParams(("cv_P_T", self._lib), ptApi)
        #much more past this point, but it's generally more of the same

Next, I'm writing a couple of classes that are intended to basically do a bunch of calculations and hold a bunch of property data.

Root class

class ThermoProperties(ABC):

    def __init__(self):
        self._P = float('nan')
        self._T = float('nan')
        self._h = float('nan')
        self._s = float('nan')
        self._u = float('nan')
        self._v = float('nan')
        self._cp = float('nan')
        self._cv = float('nan')

Concrete class

class OrdinaryWaterThermoProperties(ThermoProperties):

    _owtp = OWTP()

    def __init__(self):
        super(ThermoProperties, self).__init__()
        self._x = float('nan')

And now for the function in question that's on OrdinaryWaterThermoProperties

def Set_Tx(self, T, x):
    P = self._owtp.PSat_T(T)
    self._P = P
    self._T = T
    self._v = self._owtp.v_Tx(T,x)
    self._u = self._owtp.u_Tx(T,x)
    self._s = self._owtp.s_Tx(T,x)
    self._h = self._owtp.h_Tx(T,x)
    self._x = x

    #at this point, linearly interpolate between the cps
    #and cvs @ 0 and 1 vapor quality

    if (x <= 1e-08):
        cpLow = self._owtp.cp_Ps(P, self._s)
        cvLow = self._owtp.cv_Ps(P, self._s)
    else:
        s = self._owtp.s_Tx(T,0)
        cpLow = self._owtp.cp_Ps(P, s)
        cvLow = self._owtp.cv_Ps(P, s)

    if (1.0 - x <= 1e-08):
        cpHigh = self._owtp.cp_Ps(P, self._s)
        cvHigh = self._owtp.cv_Ps(P, self._s)
    else:
        s = self._owtp.s_Tx(T,1)
        cpHigh = self._owtp.cp_Ps(P, s)
        cvHigh = self._owtp.cv_Ps(P, s)

    self._cp = cpLow + x * (cpHigh - cpLow)
    self._cv = cvLow + x * (cvHigh - cvLow)

The issue is that the last 2 lines evaluate to some ridiculous number. At first, I obviously thought that this was just an issue with the library that I wrote, but as I tried more things, I'm not so sure about that now.

This line self._s = self._owtp.s_Tx(T,x) stores a nearly identical value (ie residual less than 1e-08) if I replace it with this self._s = self._owtp.s_Px(P,x) , but once I do the replacement, those last 2 lines evaluate to the reference values I have.

Is there something I've done wrong or is there something that Python does to which I'm not aware?

I just want to know why exactly this is happening.

Please let me know if more info is needed.

Edit:

Using these commands:

from properties import *
p = OrdinaryWaterThermoProperties()
p.Set_Tx(507.008845,1)

#a function that does the same thing as p.Set_Tx(), but uses a different input.
p.Set_Px(3.000021637933144,1)

I generated these outputs:

After using p.Set_Tx(507.008845,1) :

cpLow = 4.713721716228506
cvLow = 3.1991548400342227
cpHigh = -892771.9785675189
cvHigh = -892771.9785675189
self._s = 6.185784988287523
self._cp = -892771.9785675189
self._cv = -892771.9785675189
P = 3.000021637933144
T = 507.008845

After using p.Set_Px(3.000021637933144,1) :

cpLow = 4.713721716228509
cvLow = 3.1991548400342205
cpHigh = 3.612225802173107
cvHigh = 2.328260186952078
self._s = 6.185784988287527
self._cp = 3.612225802173107
self._cv = 2.328260186952078
P = 3.000021637933144
T = 507.0088450000006

Note, that p.Set_Px(3.000021637933144,1) produces the desired outputs of self._cp and self._cv .

Answer 1

After further investigation, it seems that there was a very small floating point error band (less than 1e-10) where self._s was effectively infeasible in the C DLL.