স্কোয়ার রুট গণনা করার জন্য আনুমানিক প্রযুক্তি কী কী?

12

আমি একটি মাইক্রোকন্ট্রোলারের সাথে কাজ করায় আমার খুব সীমিত সংস্থান রয়েছে। এখানে কি টেলর-সিরিজ সম্প্রসারণ, সাধারণ সারণী, বা পুনরাবৃত্তির পদ্ধতি রয়েছে?

আমি গণিতের স্কয়ারটি () ব্যবহার না করেই কিছু করতে পছন্দ করব

http://www.cplusplus.com/reference/cmath/sqrt/

algorithms c numerical-algorithms

— tarabyte
সূত্র

5

এই লিঙ্কটি দেখুন: কোডেপ্রজেক্ট

— ম্যাট এল।

1

এটি আরও প্রোগ্রামিংয়ের প্রশ্ন ব্যতীত, কেন এটির উত্তর ম্যাট করবেন না?

— জোজেক

ভাসমান-পয়েন্ট বা স্থির-পয়েন্ট ইনপুট? ফিক্সড পয়েন্টের জন্য একটি পুনরাবৃত্তি পদ্ধতি পছন্দনীয় হতে পারে তবে আপনি যদি না চান তবে আমি এটি ব্যাখ্যা করার বিরক্ত করব না।

— অস্কার

@ অস্কার, আমি স্থির-পয়েন্ট পদ্ধতিটি শিখতে পছন্দ করব কারণ আমার ফার্মওয়্যারটিতে ভাসমান ব্যবহারের প্রয়োজন পড়ার দরকার নেই :)।

— তারাবিতে

13

যদি আপনি একটি সস্তা এবং নোংরা অপ্টিমাইজড পাওয়ার-সিরিজ সম্প্রসারণ (টেলর সিরিজের sqrt()সহগগুলি ধীরে ধীরে একত্রিত করতে চান) এবং অন্যান্য ট্রান্সেন্ডেন্টালের একগুচ্ছ চান, আমার অনেক আগে থেকেই কিছু কোড রয়েছে। আমি এই কোডটি বিক্রি করতাম, তবে প্রায় এক দশক ধরে কেউ আমাকে এর জন্য অর্থ প্রদান করেনি। সুতরাং আমার মনে হয় আমি এটি জনসাধারণের ব্যবহারের জন্য প্রকাশ করব। এই নির্দিষ্ট ফাইলটি এমন একটি অ্যাপ্লিকেশনের জন্য ছিল যেখানে প্রসেসরের ভাসমান পয়েন্ট ছিল (আইইইই -754 একক নির্ভুলতা) এবং তাদের একটি সি সংকলক এবং ডেভ সিস্টেম ছিল, কিন্তু তারা তা করেনিস্টাডলিবের (অথবা তারা লিঙ্ক করতে চাননি) যে মানক গণিতের কাজ করবে ma তাদের নিখুঁত নির্ভুলতার প্রয়োজন নেই, তবে তারা জিনিসগুলি দ্রুত হোক তা চেয়েছিল। আপনি পাওয়ার সিরিজের সহগগুলি কী কী তা দেখতে এবং নিজের কোডটি লিখতে খুব সহজেই ইঞ্জিনিয়ার কোডটি রিভার্স করতে পারেন। এই কোডটি আইইইই--75৪ ধরে এবং ম্যান্টিসা এবং ঘাতক হিসাবে বিটগুলি মুখোশযুক্ত।

দেখা যাচ্ছে যে এসই এর "কোড মার্কআপ" অ্যাঙ্গেল অক্ষরগুলির সাথে বন্ধুত্বপূর্ণ (আপনি জানেন ">" বা "<"), তাই আপনাকে সমস্ত কিছু দেখতে সম্ভবত "সম্পাদনা" চাপতে হবে।

//
//    FILE: __functions.h
//
//    fast and approximate transcendental functions
//
//    copyright (c) 2004  Robert Bristow-Johnson
//
//    rbj@audioimagination.com
//


#ifndef __FUNCTIONS_H
#define __FUNCTIONS_H

#define TINY 1.0e-8
#define HUGE 1.0e8

#define PI              (3.1415926535897932384626433832795028841972)        /* pi */
#define ONE_OVER_PI     (0.3183098861837906661338147750939)
#define TWOPI           (6.2831853071795864769252867665590057683943)        /* 2*pi */
#define ONE_OVER_TWOPI  (0.15915494309189535682609381638)
#define PI_2            (1.5707963267948966192313216916397514420986)        /* pi/2 */
#define TWO_OVER_PI     (0.636619772367581332267629550188)
#define LN2             (0.6931471805599453094172321214581765680755)        /* ln(2) */
#define ONE_OVER_LN2    (1.44269504088896333066907387547)
#define LN10            (2.3025850929940456840179914546843642076011)        /* ln(10) */
#define ONE_OVER_LN10   (0.43429448190325177635683940025)
#define ROOT2           (1.4142135623730950488016887242096980785697)        /* sqrt(2) */
#define ONE_OVER_ROOT2  (0.707106781186547438494264988549)

#define DB_LOG2_ENERGY          (3.01029995663981154631945610163)           /* dB = DB_LOG2_ENERGY*__log2(energy) */
#define DB_LOG2_AMPL            (6.02059991327962309263891220326)           /* dB = DB_LOG2_AMPL*__log2(amplitude) */
#define ONE_OVER_DB_LOG2_AMPL   (0.16609640474436811218256075335)           /* amplitude = __exp2(ONE_OVER_DB_LOG2_AMPL*dB) */

#define LONG_OFFSET     4096L
#define FLOAT_OFFSET    4096.0



float   __sqrt(float x);

float   __log2(float x);
float   __exp2(float x);

float   __log(float x);
float   __exp(float x);

float   __pow(float x, float y);

float   __sin_pi(float x);
float   __cos_pi(float x);

float   __sin(float x);
float   __cos(float x);
float   __tan(float x);

float   __atan(float x);
float   __asin(float x);
float   __acos(float x);

float   __arg(float Imag, float Real);

float   __poly(float *a, int order, float x);
float   __map(float *f, float scaler, float x);
float   __discreteMap(float *f, float scaler, float x);

unsigned long __random();

#endif




//
//    FILE: __functions.c
//
//    fast and approximate transcendental functions
//
//    copyright (c) 2004  Robert Bristow-Johnson
//
//    rbj@audioimagination.com
//

#define STD_MATH_LIB 0

#include "__functions.h"

#if STD_MATH_LIB
#include "math.h"   // angle brackets don't work with SE markup
#endif




float   __sqrt(register float x)
    {
#if STD_MATH_LIB
    return (float) sqrt((double)x);
#else
    if (x > 5.877471754e-39)
        {
        register float accumulator, xPower;
        register long intPart;
        register union {float f; long i;} xBits;

        xBits.f = x;

        intPart = ((xBits.i)>>23);                  /* get biased exponent */
        intPart -= 127;                             /* unbias it */

        x = (float)(xBits.i & 0x007FFFFF);          /* mask off exponent leaving 0x800000*(mantissa - 1) */
        x *= 1.192092895507812e-07;                 /* divide by 0x800000 */

        accumulator =  1.0 + 0.49959804148061*x;
        xPower = x*x;
        accumulator += -0.12047308243453*xPower;
        xPower *= x;
        accumulator += 0.04585425015501*xPower;
        xPower *= x;
        accumulator += -0.01076564682800*xPower;

        if (intPart & 0x00000001)
            {
            accumulator *= ROOT2;                   /* an odd input exponent means an extra sqrt(2) in the output */
            }

        xBits.i = intPart >> 1;                     /* divide exponent by 2, lose LSB */
        xBits.i += 127;                             /* rebias exponent */
        xBits.i <<= 23;                             /* move biased exponent into exponent bits */

        return accumulator * xBits.f;
        }
     else
        {
        return 0.0;
        }
#endif
    }




float   __log2(register float x)
    {
#if STD_MATH_LIB
    return (float) (ONE_OVER_LN2*log((double)x));
#else
    if (x > 5.877471754e-39)
        {
        register float accumulator, xPower;
        register long intPart;

        register union {float f; long i;} xBits;

        xBits.f = x;

        intPart = ((xBits.i)>>23);                  /* get biased exponent */
        intPart -= 127;                             /* unbias it */

        x = (float)(xBits.i & 0x007FFFFF);          /* mask off exponent leaving 0x800000*(mantissa - 1) */
        x *= 1.192092895507812e-07;                 /* divide by 0x800000 */

        accumulator = 1.44254494359510*x;
        xPower = x*x;
        accumulator += -0.71814525675041*xPower;
        xPower *= x;
        accumulator += 0.45754919692582*xPower;
        xPower *= x;
        accumulator += -0.27790534462866*xPower;
        xPower *= x;
        accumulator += 0.12179791068782*xPower;
        xPower *= x;
        accumulator += -0.02584144982967*xPower;

        return accumulator + (float)intPart;
        }
     else
        {
        return -HUGE;
        }
#endif
    }


float   __exp2(register float x)
    {
#if STD_MATH_LIB
    return (float) exp(LN2*(double)x);
#else
    if (x >= -127.0)
        {
        register float accumulator, xPower;
        register union {float f; long i;} xBits;

        xBits.i = (long)(x + FLOAT_OFFSET) - LONG_OFFSET;       /* integer part */
        x -= (float)(xBits.i);                                  /* fractional part */

        accumulator = 1.0 + 0.69303212081966*x;
        xPower = x*x;
        accumulator += 0.24137976293709*xPower;
        xPower *= x;
        accumulator += 0.05203236900844*xPower;
        xPower *= x;
        accumulator += 0.01355574723481*xPower;

        xBits.i += 127;                                         /* bias integer part */
        xBits.i <<= 23;                                         /* move biased int part into exponent bits */

        return accumulator * xBits.f;
        }
     else
        {
        return 0.0;
        }
#endif
    }


float   __log(register float x)
    {
#if STD_MATH_LIB
    return (float) log((double)x);
#else
    return LN2*__log2(x);
#endif
    }

float   __exp(register float x)
    {
#if STD_MATH_LIB
    return (float) exp((double)x);
#else
    return __exp2(ONE_OVER_LN2*x);
#endif
    }

float   __pow(float x, float y)
    {
#if STD_MATH_LIB
    return (float) pow((double)x, (double)y);
#else
    return __exp2(y*__log2(x));
#endif
    }




float   __sin_pi(register float x)
    {
#if STD_MATH_LIB
    return (float) sin(PI*(double)x);
#else
    register float accumulator, xPower, xSquared;

    register long evenIntPart = ((long)(0.5*x + 1024.5) - 1024)<<1;
    x -= (float)evenIntPart;

    xSquared = x*x;
    accumulator = 3.14159265358979*x;
    xPower = xSquared*x;
    accumulator += -5.16731953364340*xPower;
    xPower *= xSquared;
    accumulator += 2.54620566822659*xPower;
    xPower *= xSquared;
    accumulator += -0.586027023087261*xPower;
    xPower *= xSquared;
    accumulator += 0.06554823491427*xPower;

    return accumulator;
#endif
    }


float   __cos_pi(register float x)
    {
#if STD_MATH_LIB
    return (float) cos(PI*(double)x);
#else
    register float accumulator, xPower, xSquared;

    register long evenIntPart = ((long)(0.5*x + 1024.5) - 1024)<<1;
    x -= (float)evenIntPart;

    xSquared = x*x;
    accumulator = 1.57079632679490*x;                       /* series for sin(PI/2*x) */
    xPower = xSquared*x;
    accumulator += -0.64596406188166*xPower;
    xPower *= xSquared;
    accumulator += 0.07969158490912*xPower;
    xPower *= xSquared;
    accumulator += -0.00467687997706*xPower;
    xPower *= xSquared;
    accumulator += 0.00015303015470*xPower;

    return 1.0 - 2.0*accumulator*accumulator;               /* cos(w) = 1 - 2*(sin(w/2))^2 */
#endif
    }


float   __sin(register float x)
    {
#if STD_MATH_LIB
    return (float) sin((double)x);
#else
    x *= ONE_OVER_PI;
    return __sin_pi(x);
#endif
    }

float   __cos(register float x)
    {
#if STD_MATH_LIB
    return (float) cos((double)x);
#else
    x *= ONE_OVER_PI;
    return __cos_pi(x);
#endif
    }

float   __tan(register float x)
    {
#if STD_MATH_LIB
    return (float) tan((double)x);
#else
    x *= ONE_OVER_PI;
    return __sin_pi(x)/__cos_pi(x);
#endif
    }




float   __atan(register float x)
    {
#if STD_MATH_LIB
    return (float) atan((double)x);
#else
    register float accumulator, xPower, xSquared, offset;

    offset = 0.0;

    if (x < -1.0)
        {
        offset = -PI_2;
        x = -1.0/x;
        }
     else if (x > 1.0)
        {
        offset = PI_2;
        x = -1.0/x;
        }
    xSquared = x*x;
    accumulator = 1.0;
    xPower = xSquared;
    accumulator += 0.33288950512027*xPower;
    xPower *= xSquared;
    accumulator += -0.08467922817644*xPower;
    xPower *= xSquared;
    accumulator += 0.03252232640125*xPower;
    xPower *= xSquared;
    accumulator += -0.00749305860992*xPower;

    return offset + x/accumulator;
#endif
    }


float   __asin(register float x)
    {
#if STD_MATH_LIB
    return (float) asin((double)x);
#else
    return __atan(x/__sqrt(1.0 - x*x));
#endif
    }

float   __acos(register float x)
    {
#if STD_MATH_LIB
    return (float) acos((double)x);
#else
    return __atan(__sqrt(1.0 - x*x)/x);
#endif
    }


float   __arg(float Imag, float Real)
    {
#if STD_MATH_LIB
    return (float) atan2((double)Imag, (double)Real);
#else
    register float accumulator, xPower, xSquared, offset, x;

    if (Imag > 0.0)
        {
        if (Imag <= -Real)
            {
            offset = PI;
            x = Imag/Real;
            }
         else if (Imag > Real)
            {
            offset = PI_2;
            x = -Real/Imag;
            }
         else
            {
            offset = 0.0;
            x = Imag/Real;
            }
        }
     else
        {
        if (Imag >= Real)
            {
            offset = -PI;
            x = Imag/Real;
            }
         else if (Imag < -Real)
            {
            offset = -PI_2;
            x = -Real/Imag;
            }
         else
            {
            offset = 0.0;
            x = Imag/Real;
            }
        }

    xSquared = x*x;
    accumulator = 1.0;
    xPower = xSquared;
    accumulator += 0.33288950512027*xPower;
    xPower *= xSquared;
    accumulator += -0.08467922817644*xPower;
    xPower *= xSquared;
    accumulator += 0.03252232640125*xPower;
    xPower *= xSquared;
    accumulator += -0.00749305860992*xPower;

    return offset + x/accumulator;
#endif
    }




float   __poly(float *a, int order, float x)
    {
    register float accumulator = 0.0, xPower;
    register int n;

    accumulator = a[0];
    xPower = x;
    for (n=1; n<=order; n++)
        {
        accumulator += a[n]*xPower;
        xPower *= x;
        }

    return accumulator;
    }


float   __map(float *f, float scaler, float x)
    {
    register long i;

    x *= scaler;

    i = (long)(x + FLOAT_OFFSET) - LONG_OFFSET;         /* round down without floor() */

    return f[i] + (f[i+1] - f[i])*(x - (float)i);       /* linear interpolate between points */
    }


float   __discreteMap(float *f, float scaler, float x)
    {
    register long i;

    x *= scaler;

    i = (long)(x + (FLOAT_OFFSET+0.5)) - LONG_OFFSET;   /* round to nearest */

    return f[i];
    }


unsigned long __random()
    {
    static unsigned long seed0 = 0x5B7A2775, seed1 = 0x80C7169F;

    seed0 += seed1;
    seed1 += seed0;

    return seed1;
    }

— রবার্ট ব্রিস্টো-জনসন
সূত্র

এই কোড মার্কআপটি এসই এর সাথে কীভাবে কাজ করে তা কি কেউ জানেন? আপনি যদি "সম্পাদনা" টিপুন তবে আপনি যে কোডটি চেয়েছিলেন তা দেখতে পাচ্ছেন, তবে আমরা এখানে যা দেখি তাতে কোডের অনেকগুলি লাইন বাদ যায় এবং কেবল ফাইলের শেষে থাকে না। আমি মার্কআপ রেফারেন্সটি ব্যবহার করছি যা আমাদের এসই মার্কআপ সহায়তা দ্বারা পরিচালিত হয়েছে । যদি কেউ এটি বের করতে পারে তবে দয়া করে উত্তরটি সম্পাদনা করুন এবং আপনি কী করেছেন তা আমাদের জানান।

— রবার্ট ব্রিস্টো-জনসন 20

আমি কী জানি না এটি @ রোয়াই।

— রবার্ট ব্রিস্টো-জনসন

পেস্টবিন.

— com

সুতরাং @ রোয়াই, আমার সাথে ঠিক আছে যে এই কোডটি সেই পেস্টবিনের জায়গায় পোস্ট করা হয়েছে। আপনি যদি চান, আপনি এই কোডটি পোস্ট করতে পারেন যা বাইনারি দশমিক পরীক্ষায় এবং দশমিক পাঠ্যকে বাইনারি রূপান্তর করে । এটি একই এমবেডড প্রকল্পে ব্যবহৃত হয়েছিল যেখানে আমরা stdlibএটিতে চাইনি ।

— রবার্ট ব্রিস্টো-জনসন

7

যদি আপনি এটি না দেখে থাকেন তবে "ভূমিকম্পের স্কোয়ার রুট" কেবল মজাদার। আপনাকে প্রথমে খুব ভাল প্রাক্কলন দিতে কিছু বিট-লেভেল ম্যাজিক ব্যবহার করে এবং এরপরে পুনরায় সংশোধন করতে নিউটনের প্রায় দুটি গোলের ব্যবহার করা হয়েছে। আপনি সীমিত সংস্থান নিয়ে কাজ করলে এটি আপনাকে সহায়তা করতে পারে।

https://en.wikipedia.org/wiki/Fast_inverse_square_root

http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/

— অ্যাডাম স্মিথ
সূত্র

6

আপনি নিউটনের পদ্ধতি ব্যবহার করে বর্গমূলের ফাংশনটিও আনুমানিক করতে পারেন । নিউটনের পদ্ধতিটি যেখানে কোনও ফাংশনের শিকড় থাকে সেখানে অনুমানের একটি উপায়। এটি একটি পুনরাবৃত্তি পদ্ধতি যেখানে পূর্ববর্তী পুনরাবৃত্তির ফলাফল পরবর্তী পুনরাবৃত্তিতে অভিব্যক্ত হওয়া অবধি ব্যবহার করা হয়। প্রাথমিক অনুমান দেওয়া ফাংশন এর মূলটি অনুমান করার জন্য নিউটনের পদ্ধতির সমীকরণটি সংজ্ঞায়িত করা হয়েছে: $f(x)$ $x_0$

{এক্স}_{1} = {এক্স}_{0} - \frac{চ ({এক্স}_{0})}{চ^{'} ({এক্স}_{0})}

$x_1 = x_0 - \frac{f(x_0)}{f'(x_0)}$

হ'ল মূলটি কোথায় রয়েছে তার প্রথম অনুমান। উত্তরটি পরিবর্তন না হওয়া পর্যন্ত আমরা সমীকরণটি পুনর্ব্যবহার করছি এবং পূর্ববর্তী পুনরাবৃত্তির ফলাফলগুলি ব্যবহার করি। সাধারণভাবে, পুনরাবৃত্তিতে মূলটির অনুমান নির্ধারণের জন্য পুনরাবৃত্তিরঅনুমানের ভিত্তিতেসংজ্ঞা দেওয়া হয়েছে: $x_1$ $(n+1)$ $n$

{এক্স}_{এন + + 1} = {এক্স}_{এন} - \frac{চ ({এক্স}_{এন})}{চ^{'} ({এক্স}_{এন})}

$x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}$

নিউটনের পদ্ধতি ব্যবহার করার জন্য বর্গমূল জন্য আনুমানিক যাও, অনুমান করা যে আমরা একটি নম্বর দেওয়া হয় । যেমন, গণনা করতে আমাদের গুণতে হবে $a$ এর মতো, আমরা এরকম একটি উত্তর খুঁজতে চাই যে $\sqrt{a}$ । উভয় পক্ষের বর্গাকার, এবং চলন্তসমীকরণ উৎপাদনের অন্য পারে। যেমন, এই সমীকরণ উত্তর $x = \sqrt{a}$ $a$ $x^2 - a = 0$ এবং এইভাবেফাংশনেরমূল। যেমন,সমীকরণ হোক যা আমরা এর মূলটি খুঁজতে চাই। নিউটনের পদ্ধতিতে এটিকে প্রতিস্থাপন করে,, এবং তাই: $\sqrt{a}$ $f(x) = x^2 - a$ $f'(x) = 2x$

{এক্স}_{এন + + 1} = {এক্স}_{এন} - \frac{{এক্স}_{এন}^{2} - একটি}{2 {এক্স}_{এন}}

$x_{n+1} = x_n - \frac{x_{n}^2 - a}{2x_{n}}$

{এক্স}_{এন + + 1} = \frac{1}{2} ({এক্স}_{এন} + + \frac{একটি}{{এক্স}_{এন}})

$x_{n+1} = \frac{1}{2}\left(x_n + \frac{a}{x_n}\right)$

সুতরাং, এর বর্গমূলকে গণনা করতে, আমাদের রূপান্তর না হওয়া পর্যন্ত আমাদের কেবল নিউটনের পদ্ধতিটি গণনা করা দরকার। যাইহোক, @ রবার্টব্রিস্টো-জনসন দ্বারা উল্লিখিত হিসাবে, বিভাগ একটি অত্যন্ত ব্যয়বহুল অপারেশন - বিশেষত সীমিত সংস্থানযুক্ত মাইক্রোকন্ট্রোলার / ডিএসপিদের জন্য s তদতিরিক্ত, এমন একটি ঘটনাও হতে পারে যেখানে অনুমান 0 হতে পারে, যা বিভাজন অপারেশনের কারণে 0 টি ত্রুটি দ্বারা বিভাজন হতে পারে। যেমনটি, আমরা যা করতে পারি তা হ'ল নিউটনের পদ্ধতিটি ব্যবহার করুন এবং পরিবর্তে পারস্পরিক কার্যকারিতার জন্য সমাধান করুন, অর্থাত $a$ । এটি যে কোনও বিভাগকে এড়িয়ে চলে, যেমন আমরা পরে দেখব। উভয় পক্ষের স্কোয়ারিং, এবং চলন্ত $\frac{1}{x} = \sqrt{a}$ বাম দিকে ওভার এইভাবে দেয় $\sqrt{a}$ । সুতরাং, এর সমাধান হবে $\frac{1}{x^2} - a = 0$ । দ্বারা গুন দ্বারা, আমরা আমাদের অভিপ্রেত ফলাফলের পেতে হবে। আবার, নিউটনের পদ্ধতিটি ব্যবহার করে, আমাদের এইভাবে: $\frac{1}{\sqrt{a}}$ $a$

{এক্স}_{এন + + 1} = {এক্স}_{এন} - \frac{চ ({এক্স}_{এন})}{চ^{'} ({এক্স}_{এন})}

$x_{n+1} = x_{n} - \frac{f(x_n)}{f'(x_n)}$

{এক্স}_{এন + + 1} = {এক্স}_{এন} - \frac{\frac{1}{({এক্স}_{এন})^{2}} - একটি}{\frac{- 2}{({এক্স}_{এন})^{3}}}

$x_{n+1} = x_{n} - \frac{\frac{1}{(x_n)^2} - a}{\frac{-2}{(x_n)^3}}$

{এক্স}_{এন + + 1} = \frac{1}{2} (3 {এক্স}_{এন} - ({এক্স}_{এন})^{3} একটি)

$x_{n+1} = \frac{1}{2}\left(3x_n - (x_n)^3a\right)$

তবে, একটি সতর্কতা রয়েছে যা উপরের সমীকরণটি দেখার সময় আমাদের বিবেচনা করা উচিত। বর্গাকার মূলের জন্য, সমাধানটি ইতিবাচক হওয়া উচিত এবং তাই পুনরাবৃত্তির (এবং ফলাফল) ইতিবাচক হওয়ার জন্য, নিম্নলিখিত শর্তটি অবশ্যই সন্তুষ্ট থাকতে হবে:

3 {এক্স}_{এন} - ({এক্স}_{এন})^{3} একটি > 0

$3x_n - (x_n)^3a > 0$

3 {এক্স}_{এন} > ({এক্স}_{এন})^{3} একটি

$3x_n > (x_n)^3a$

({এক্স}_{এন})^{2} একটি < 3

$(x_n)^2a < 3$

অতএব:

({এক্স}_{0})^{2} একটি < 3

$(x_0)^2a < 3$

$x_0$ $x_0$ $x_0$ $10^{-6}$

আপনার ট্যাগটি যেমন একটি অ্যালগরিদমের সন্ধান করছে C, আসুন খুব দ্রুত একটি লিখুন:

#include <stdio.h> // For printf
#include <math.h> // For fabs
void main() 
{
   float a = 5.0; // Number we want to take the square root of
   float x = 1.0; // Initial guess
   float xprev; // Root for previous iteration
   int count; // Counter for iterations

   // Find a better initial guess
   // Half at each step until condition is satisfied
   while (x*x*a >= 3.0)
       x *= 0.5;

   printf("Initial guess: %f\n", x);

   count = 1; 
   do { 
       xprev = x; // Save for previous iteration
       printf("Iteration #%d: %f\n", count++, x);                   
       x = 0.5*(3*xprev - (xprev*xprev*xprev)*a); // Find square root of the reciprocal
   } while (fabs(x - xprev) > 1e-6); 

   x *= a; // Actual answer - Multiply by a
   printf("Square root is: %f\n", x);
   printf("Done!");
}

এটি নিউটনের পদ্ধতির একটি সুন্দর বুনিয়াদী বাস্তবায়ন। দ্রষ্টব্য যে আমরা প্রাথমিক অনুমানটি অর্ধেক কমাতে চলেছি যতক্ষণ না আমরা আগে শর্তটি পূর্বে কথা বলি না। আমি 5 এর বর্গমূলও অনুসন্ধান করার চেষ্টা করছি আমরা জানি যে এটি প্রায় 2.236 বা এর সমান। উপরের কোড ব্যবহার করে নিম্নলিখিত আউটপুট দেয়:

Initial guess: 0.500000
Iteration #1: 0.500000
Iteration #2: 0.437500
Iteration #3: 0.446899
Iteration #4: 0.447213
Square root is: 2.236068
Done!

$a$

Initial guess: 0.015625
Iteration #1: 0.015625
Iteration #2: 0.004601
Iteration #3: 0.006420
Iteration #4: 0.008323
Iteration #5: 0.009638
Iteration #6: 0.010036
Iteration #7: 0.010062
Square root is: 99.378067
Done!

যেমন আপনি দেখতে পাচ্ছেন, কেবলমাত্র আলাদা জিনিসটি বর্গমূলকে গণনা করার জন্য কতগুলি পুনরাবৃত্তির প্রয়োজন। আপনি যে পরিমাণ গণনা করতে চান তার সংখ্যা যত বেশি হবে, তত বেশি পুনরাবৃত্তি লাগবে।

আমি জানি যে এই পদ্ধতিটি ইতিমধ্যে একটি পূর্ববর্তী পোস্টে পরামর্শ দেওয়া হয়েছিল, তবে আমি অনুভব করেছি যে আমি পদ্ধতিটি বের করার পাশাপাশি কিছু কোড সরবরাহ করব!

— rayryeng
সূত্র

2

f (x) = \frac{1}{\sqrt{x}}

$f(x)=\frac{1}{\sqrt{x}}$

x

$x$

\sqrt{x}

$\sqrt{x}$

3

এটি কেবলমাত্র, ডিএসপি এবং কিছু অন্যান্য চিপস কোডিংয়ের জন্য, বিভাগটি বিশেষত ব্যয়বহুল, যখন এই চিপগুলি সংখ্যাটি তত দ্রুত গতিতে পারে, তারা সংখ্যাটি সরিয়ে নিতে পারে।

— রবার্ট ব্রিস্টো-জনসন

1

@ রবার্টব্রিস্টো-জনসন - এবং আরও একটি দুর্দান্ত পয়েন্ট। আমার মনে আছে আমি যখন মটোরোলা with৮১১ এর সাথে কাজ করেছি যে গুণটি কয়েক চক্র নিয়েছিল এবং বিভাগ কয়েকশো লেগেছিল। সুন্দর ছিল না।

— রাইরিং

3

আহ, ভাল ওল '68HC11। 6809 (দ্রুত গুনের মতো) থেকে কিছু স্টাফ ছিল তবে আরও একটি মাইক্রোকন্ট্রোলার।

— রবার্ট ব্রিস্টো-জনসন

1

@ রবার্টব্রিস্টো-জনসন - হ্যাঁ স্যার 68HC11 :)। আমি এটি একটি বায়োমেডিকাল সিগন্যাল জেনারেশন সিস্টেম তৈরি করতে ব্যবহার করেছি যা চিকিত্সা সরঞ্জামগুলি ক্রমাঙ্কন করতে এবং মেডিকেল শিক্ষার্থীদের প্রশিক্ষণের জন্য কৃত্রিম হার্ট সংকেত তৈরি করেছিল। অনেক দিন হয়েছে, তবে খুব প্রিয় স্মৃতি!

— রাইরিং

6

$\sqrt{x}$

হ্যাঁ, একটি পাওয়ার সিরিজ দ্রুত এবং দক্ষতার সাথে বর্গমূলের ফাংশনটি আনুমানিকভাবে তৈরি করতে পারে এবং কেবলমাত্র একটি সীমিত ডোমেনের উপরে। বৃহত্তর ডোমেন, ত্রুটি পর্যাপ্ত পরিমাণে কম রাখতে আপনার পাওয়ার সিরিজে আরও শর্তাদি দরকার।

$1 \le x \le 2$

\begin{aligned} \sqrt{এক্স} & \approx 1 + + {একটি}_{1} (এক্স - 1) + + {একটি}_{2} (এক্স - 1)^{2} + + {একটি}_{3} (এক্স - 1)^{3} + + {একটি}_{4} (এক্স - 1)^{4} \\ = 1 + + (এক্স - 1) ({একটি}_{1} + + (এক্স - 1) ({একটি}_{2} + + (এক্স - 1) ({একটি}_{3} + + (এক্স - 1) {একটি}_{4}))) \end{aligned}

$\begin{align} \sqrt{x} \ &\approx \ 1 + a_1 (x-1) + a_2 (x-1)^2 + a_3 (x-1)^3 + a_4 (x-1)^4 \\ \\ & = 1 + (x-1)\bigg( a_1 + (x-1)\Big( a_2 + (x-1)\big( a_3 + (x-1)a_4 \big) \Big) \bigg) \\ \end{align}$

কোথায়

$a_1$

$a_2$

$a_3$

$a_4$

$x=1$ $x=2$

$2n$ $n$ $\sqrt{2}$

যদি এটি ভাসমান বিন্দু হয়, তবে আপনাকে অন্য উত্তরে আমার সি কোডের মতো বেদী এবং ম্যান্টিসা আলাদা করতে হবে।

— রবার্ট ব্রিস্টো-জনসন
সূত্র

4

আসলে এটি নিউটন পদ্ধতিটি ব্যবহার করে একটি চতুর্ভুজ সমীকরণ সমাধান করে করা হয়:

http://en.wikipedia.org/wiki/Methods_of_computing_square_roots

একের বেশি সংখ্যার জন্য আপনি নিম্নলিখিত টেলর সম্প্রসারণটি ব্যবহার করতে পারেন:

http://planetmath.org/taylorexpansionofsqrt1x

— Royi
সূত্র

3

$a>b$

\sqrt{{একটি}^{2} + + খ^{2}} \approx 0.96 একটি + + 0.4 খ ।

$\sqrt{a^2+b^2}\approx 0.96a+0.4 b.$

4% নির্ভুলতার মধ্যে, যদি আমি ভাল মনে করি। এটি ইঞ্জিনিয়াররা লোগারিদমিক রুলার এবং ক্যালকুলেটরগুলির আগে ব্যবহার করতেন। আমি এটি নোটস এবং ফর্মুলি ডি লিংগার, ডি লাহারেপে , 1923 সালে শিখেছি

— লরেন্ট ডুভাল
সূত্র