सामान्य गणित फ़ंक्शन एक्स() लॉग() का उपयोग करते समय अतिप्रवाह को कैसे रोकें?

Question

सभी शीर्षक में हैं। दो फ़ंक्शन एक्सप() और लॉग() का उपयोग करते समय संभावित ओवरफ़्लो कैसे जांचें?

Answer 1

@TheOtherGuy के उत्तर का विस्तार करने के लिए, यदि ओवरफ़्लो होता है तो आप ऑपरेशन रद्द कर सकते हैं।

#include <stdio.h> 
#include <math.h> 
#include <errno.h> 

int main(void) 
{ 
    double param, result; 

    errno = 0; 
    param = 1e3; 
    result = exp (param); 
    if (errno == ERANGE) { 
     printf("exp(%f) overflows\n", param); 
     result = param; 
    } 
    printf ("The exponential value of %f is %f.\n", param, result); 
    return 0; 
} 

Answer 2

#include <errno.h> 

जब एक oferflow होता है, तो errnoERANGE को तैयार है।

अगली बार, मांगने से पहले अपना होमवर्क करना।

Googling: "C++ exp" पहले परिणाम के रूप में इस लौटे http://www.cplusplus.com/reference/cmath/exp/
पृष्ठ के बीच में, वहाँ आप के लिए क्या चाहिए, तो है।

Answer 3

पहले से ओवरफ्लो की जांच करने का सबसे अच्छा तरीका केस-दर-मामले आधार पर समझदारी से करना है।

लघुगणक और घातांक के अपने ज्ञान का उपयोग करके, आप INT_MAX की तरह गुणों का उपयोग करके संभावित अतिप्रवाह पहचान करने के लिए सक्षम होना चाहिए: इन C++ Limitations

की जांच मैं एक साथ एक मोटा नमूना C++ निष्पादन फेंक दिया, यह सोचते हैं आप पहले से पता है कि सीमित करता है आप प्रयास कर रहे हैं पीछा करना।

#include <iostream> 

// nTh root calculator 
bool is_exp_overflow(int input_val, int exponent) 
{ 
    my_max = pow(INT_MAX, (1/exponent); 
    if (input_val > my_max) 
    { 
     return true; 
    } 
    else 
     return false; 
} 

void runExp(int my_input, int my_exp) 
{ 
    // Do maths 
} 

int main() 
{ 
    int my_input = 0; 
    int my_exp = 0; 
    std::cout << "Enter test value\n"; 
    std::cin >> my_input; 
    std::cout << "Enter test exponent\n"; 
    std::cin >> my_exp; 
    bool exp_unsafe = 1; 
    exp_unsafe = is_exp_overflow(my_input, my_exp); 

    if (!exp_unsafe) 
     runExp(my_input, my_exp); 
    else 
     std::cout << "Code is unsafe\n"; 

    return 0; 
} 

आप त्रुटियों पोस्टमार्टम को पकड़ने के लिए देख रहे हैं, errno in range जांच करते हैं।

Answer 4

exp() से निपटने के लिए:

बस एक चर जो आप लॉग इन करने के आवंटित (FLT_MAX) के खिलाफ की तुलना करें। FLT_MAX सबसे बड़ी फ्लोट है। आप से पहले एक एक्स() की गणना कर सकते हैं। क्योंकि लॉग()एक्सप() के विपरीत है।

#include <iostream> 
#include <math.h> 
using namespace std; 

int main() 
{ 
    float a=1E+37f; // an example of maximum finite representable floating-point number. 
    //max value can change with platform so, 
    //either use definitions or use a function you wrote 
    // a= getMaxFloat(); or a=FLT_MAX 
    float b=log(a); // limit of float to give in exp(); 
    float c=3242325445.0f; // test variable 
    cout << "Hello world!" << endl; 
    if(c>b){cout<<"you should not take exp of "<<c<<endl;}else{cout<<"go on"<<endl;} 

    return 0; 
} 

लॉग() से निपटने के लिए:

1) आप एक्स बह निकला से पहले लॉग (एक्स) everflow नहीं कर सकते। (ऊपरी बाउंड के लिए)

2) फ्लोट/डबल (x) परिशुद्धता लॉग (x) के लिए नकारात्मक-अनंतता के अतिप्रवाह के लिए पर्याप्त नहीं है।

3) सुनिश्चित करें कि x शून्य से बड़ा है।

Answer 5

रोकें तुलना में बेहतर है, तो आप अपवाद पकड़ कर सकते हैं:

try { 
    z=exp(n); 
} catch (...) { 
    puts("Can't calcute exp..."); 
}