C内核流量计算方法优化，前端文件名称读取优化

native/components/kernels.c

@@ -346,27 +346,79 @@ static double pipe_friction_derivative(double re,double rr,double rough,double *
     double db=8.37293695*b*(1-b)/(re-89.96829989);
     *df=dl*(1-b)+b*dt+db*(turb-lam);return lam+b*(turb-lam);
 }
+static double pipe_checked_solution(double re,double f,double K,double rr,double rough,
+                                    double flow_per_re,NativePipeSolve *status) {
+    double target=sqrt(K/f),change=fabs(target-re);
+    /* Separate the absolute and relative tests so a large flow scale cannot
+       make both sides overflow and accidentally satisfy the stopping test. */
+    if(!isfinite(target) || !isfinite(target*flow_per_re) ||
+       !(change<=re*1e-10 || change*flow_per_re<=1e-13))return NAN;
+    double value=target*target*pipe_friction_prepared(target,rr,rough);
+    status->relative_residual=fabs(value/K-1);
+    if(isfinite(value) && status->relative_residual<=1e-9) {
+        status->converged=1;return target;
+    }
+    return NAN;
+}
 double native_pipe_resistance(double K,double rr,double flow_per_re,NativePipeSolve *status) {
     NativePipeSolve local={0,0,0,INFINITY};if(!status)status=&local;
     *status=local;
     if(!(K>=0 && rr>=0 && flow_per_re>0) || !isfinite(K) || !isfinite(rr) || !isfinite(flow_per_re))return NAN;
-    if(K/64<=89.96829989){status->converged=1;status->relative_residual=0;return K/64;}
-    double rough=pipe_rough_limit(rr),lo=0,hi=fmax(sqrt(K/.02),1),df;
-    for(int i=0;i<128 && hi*hi*pipe_friction_prepared(hi,rr,rough)<K;i++)hi*=2;
-    if(!isfinite(hi))return NAN;
-    double re=fmin(sqrt(K/.02),hi);
-    for(int i=0;i<80;i++) {
-        status->iterations=i+1;
-        double f=pipe_friction_derivative(re,rr,rough,&df),F=re*re*f-K;
-        double target=sqrt(K/f);
-        if(fabs(target-re)*flow_per_re<=fmax(1e-13,re*flow_per_re*1e-10)) {
-            /* Check the returned point, not just the change of successive guesses. */
-            status->relative_residual=fabs(target*target*pipe_friction_prepared(target,rr,rough)/K-1);
-            if(isfinite(target) && status->relative_residual<=1e-9){status->converged=1;return target;}
+    if(K==0){status->converged=1;status->relative_residual=0;return 0;}
+    if(K/64<=89.96829989) {
+        double re=K/64;
+        status->relative_residual=fabs(64*re/K-1);
+        if(re>0 && isfinite(re*flow_per_re) && status->relative_residual<=1e-9) {
+            status->converged=1;return re;
         }
+        return NAN;
+    }
+    double rough=pipe_rough_limit(rr),lo=0,hi=fmax(sqrt(K/.02),1),df;
+    if(!isfinite(rough) || !isfinite(hi))return NAN;
+    int bracketed=0;
+    for(int i=0;i<128;i++) {
+        double value=hi*hi*pipe_friction_prepared(hi,rr,rough);
+        if(!isfinite(value))return NAN;
+        if(value>=K){bracketed=1;break;}
+        lo=hi;hi*=2;
+        if(!isfinite(hi))return NAN;
+    }
+    /* F(0)=-K; each positive lower endpoint was checked while expanding.
+       Never start iteration with an unchecked or non-finite upper residual. */
+    if(!bracketed)return NAN;
+    double re=fmax(lo,fmin(sqrt(K/.02),hi)),previous_residual=INFINITY;
+    int previous_newton=0;
+    for(int i=0;i<128;i++) {
+        status->iterations=i+1;
+        double f=pipe_friction_derivative(re,rr,rough,&df),value=re*re*f,F=value-K;
+        if(!(f>0) || !isfinite(f) || !isfinite(value))return NAN;
+        status->relative_residual=fabs(value/K-1);
+        double target=pipe_checked_solution(re,f,K,rr,rough,flow_per_re,status);
+        if(status->converged)return target;
         if(F>0)hi=re;else lo=re;
-        double next=re-F/(2*re*f+re*re*df);
-        if(!isfinite(next) || next<=lo || next>=hi){next=.5*(lo+hi);status->bisections++;}
+        double slope=2*re*f+re*re*df;
+        double next=slope>0 && isfinite(slope) ? re-F/slope : NAN;
+        /* An in-bracket Newton step is useful only if it reduces |F|.
+           After a step that fails to halve it, bisect the retained bracket;
+           successive Newton steps therefore cannot stagnate near an endpoint. */
+        int bisect=(previous_newton && fabs(F)>.5*previous_residual) ||
+                   !(slope>0) || !isfinite(slope) || !isfinite(next) || next<=lo || next>=hi;
+        if(bisect) {
+            next=lo+.5*(hi-lo);status->bisections++;
+            if(next<=lo || next>=hi) {
+                /* Adjacent floating-point endpoints: inspect both actual
+                   candidates, then fail if neither meets the original tests. */
+                double endpoints[]={lo,hi};
+                for(int j=0;j<2;j++) {
+                    double endpoint=endpoints[j];
+                    target=pipe_checked_solution(endpoint,pipe_friction_prepared(endpoint,rr,rough),
+                                                 K,rr,rough,flow_per_re,status);
+                    if(status->converged)return target;
+                }
+                return NAN;
+            }
+        }
+        previous_newton=!bisect;previous_residual=fabs(F);
         re=next;
     }
     return NAN;