Arduinodagi sinuslarni (va kosinalarni) hisoblash uchun turli usullar (va eng tezkor)

I am using an Arduino Uno board to compute the angles of my system (robotic arm). The angles are actually 10 bit values (0 to 1023) from the ADC, using the full range of the ADC. I am only going to be operating in the 1st quadrant (0 to 90 deg), where both sines and cosines are positive, so there is no problem with negative numbers. My doubts can be expressed in 3 questions:

  1. What are the different ways to compute these trigonometric functions on Arduino?

  2. What is the fastest way to do the same?

  3. There are the sin() and cos() functions in the Arduino IDE, but how does the Arduino actually calculate them (as in do they use look-up tables, or approximations etc.)? They seem like an obvious solution, but I would like to know their actual implementation before I try them out.

PS: I am open to both standard coding on the Arduino IDE and assembly coding, as well as any other options not mentioned. Also I have no problems with errors and approximations, which are inevitable for a digital system; however if possible it would be good to mention the extent of possible errors

8
Men sizning darajangizda ishlashni xohlayotganingizni taxmin qilaman. Burchak uchun tamsayılar yoki kasr sonlarini kiritishni xohlaysizmi?
qo'shib qo'ydi muallif Yoni Baciu, manba
Taxminan qiymatlar bilan yaxshi bo'larmidingiz?
qo'shib qo'ydi muallif Yoni Baciu, manba
Sizning aniqlik talabingizni aniqlay olasizmi? Cos (p/2x) ≈ 1-x2 yaqinligi 5,6e-2 maksimal xatoga ega. Va (1-x2) (1-0.224x2), u 3 marta ko'paytiriladi, 9.20e-4da yaxshi bo'ladi.
qo'shib qo'ydi muallif Sprogz, manba
Faqatgina 90 (to'liq) daraja uchun 90 kirishli qo'ng'iroq jadvali eng tezkor va eng samarali bo'ladi. Darhaqiqat, to'liq 360 daraja uchun siz 90 kirishli qo'ng'iroq jadvalidan foydalanishingiz mumkin. Faqat 90-179 raqamini orqaga qarab o'qing va 180-269 raqamiga o'tkazing. Ikkalasini ham 270-359 gacha bajaring.
qo'shib qo'ydi muallif Majenko, manba
@EdgarBonet kech javob uchun uzr so'raymiz. Hozirgi vaqtda aniqlangan aniqlik aniqligi yo'q. Men hozir faqat barcha mumkin bo'lgan variantlarni bilmoqchiman
qo'shib qo'ydi muallif Ken Arnold, manba
Darajalar ha. Men kodni yozishni osonlashtiraman deb o'ylayman va agar biz tamsayılardan foydalansak sinovdan o'tamiz, shuning uchun men bu bilan boraman. O'zgarishlar haqida aniqroq ma'lumot beraman
qo'shib qo'ydi muallif Ken Arnold, manba
Ha, aslida, lekin turli usullarning xatolarini bilmoqchiman. Bu aniq mahsulot emas, balki yonimdagi loyihadir. Matematik funktsiyani amalga oshiradigan deyarli har qanday (agar mavjud bo'lmasa) raqamli tizim uchun aslida yaqinlashuvlar muqarrar
qo'shib qo'ydi muallif Ken Arnold, manba

8 javoblar

Ikkala asosiy usul matematik hisoblash (polinomlar bilan) va qidirish jadvallari.

Arduino matematika kutubxonasi (libm, avr-libcning bir qismi) avvaldan foydalanadi. U AVR uchun 100% montaj tili bilan yozilganligi uchun optimallashtirilgan va shuning uchun u nima qilayotganiga amal qilish deyarli imkonsizdir (nol izohlar ham bor). Shuni ishonch bilan aytish mumkinki, bu bizning eng yuqori darajaga ko'tarilgan eng yaxshi optimallashtirilgan sof-floatlarni ishlab chiqarish miyalari bo'ladi.

Biroq kalit float mavjud. Arduino-da suzuvchi nuqta bilan bog'liq har qanday narsa sof son bilan taqqoslaganda og'ir vazn toifasi bo'ladi va faqat 0 dan 90 darajagacha bo'lgan sonli raqamlarni talab qilganingiz sababli, oddiy qidirish jadvali eng oddiy va eng samarali uslubdir.

91 qiymatdan iborat jadval sizga 0 dan 90 gacha har bir narsani beradi. Biroq, agar siz 0.0 va 1.0 oralig'idagi suzuvchi nuqta qiymatlari jadvalini o'zgartirsangiz, siz hali ham floats bilan ishlashning samarasizligi bor (bu kodni sinash uchun sin deb samarasiz deb berilgan), shuning uchun sobit nuqta qiymati buning o'rniga ancha samarali bo'ladi.

Qiymat 1000 ga ko'paytirilganda oddiy bo'lishi mumkin, shuning uchun siz 0.0 va 1.0 oralig'idagi 0 va 1000 oralig'ida (masalan, sin (30) 0.5 o'rniga 0,5 deb saqlanadi). Masalan, qiymatlarni (masalan, har bir qiymat (bit) 1.0/65536dan 1.0ni tashkil etadigan Q16 qiymati sifatida saqlash kerak). Ushbu Q16 qiymatlari (va tegishli Q15, Q1.15 va hokazo) ishlash uchun yanada samaraliroq bo'ladi, chunki sizning kompyuterlaringiz bilan ishlashdan nafratlanadigan o'ndan ortiq vakolat o'rniga ishlashni yaxshi ko'radigan kuchlarga egasiz.

Shuni unutmangki sin() funktsiyasi radyanlarni kutadi, shuning uchun siz avval kodlashingiz mumkin bo'lgan radionlar qiymatiga aylantirmoqchi bo'lsangiz, sin() to'g'ridan-to'g'ri tamsayı daraja qiymati bilan ishlaydigan qidiruv jadvaliga nisbatan ancha samarasiz.

Ikkala senariyning kombinatsiyasi ham mumkin. Lineer enterpolasyon ikkita tamsayı o'rtasida suzuvchi nuqta burchagi yaqinlashishini ta'minlaydi. Qidiruv jadvalidagi ikkita nuqta orasidagi masofani qanday qilib ishlayotganingiz va ikki qiymatdan kelib chiqadigan masofaga asoslangan vaznli o'rtacha yaratish kabi oddiy. Misol uchun, agar siz 23,6 darajaga kelsangiz, siz (sintable [23] * (1-0.6)) + (sintable [24] * 0.6)) ni olishingiz mumkin. Asosan, sinus to'lqinlar to'g'ri chiziqlar bilan bir-biriga qo'shilgan alohida nuqtalar qatoriga aylanadi. Siz tezkorlik uchun savdo qilasiz.

8
qo'shib qo'ydi
Kutubxonadan tezroq bo'lgan sin/cos uchun Teylor polinomidan foydalangan holda kutubxonani yozdim. Ko'rib turganimizdek, ikkala tomon uchun ham kirish nuqtasi sifatida radionlarni ishlatmoqdaman.
qo'shib qo'ydi muallif tuskiomi, manba

Bu erda yaxshi javoblar mavjud, ammo men hali aytib o'tilmagan usulni qo'shishni istadim, bu ichki tizimlarda trigonometrik funksiyani hisoblash uchun juda mos keladi va CORDIC usuli Wiki bu yerda Bu faqat siljishlar va qo'shimchalar va kichik ko'rinish jadvalidan foydalangan holda, bu funksiyalarni hisoblashi mumkin.

Aslida, C-da xam misol. Cordic-dan foydalanib, C-kutubxonalaridagi atan2() funktsiyasini amalga oshiradi (ya'ni ikki burilish nuqtasi berilgan burchakni toping.) Bu suzuvchi nuqta foydalanadi, lekin sobit-nuqta arifmetik bilan ishlatish uchun moslash mumkin.

/*
 * Simple example of using the CORDIC algorithm.
 */

#include 
#include 

#define CORDIC_TABLE_SIZE  16

double cordic_table[CORDIC_TABLE_SIZE];

void init_table(void);
double angle(double I, double Q);

/*
 * Given a sine and cosine component of an
 * angle, compute the angle using the CORIDC
 * algoritm.
 */
double angle(double I, double Q)
{
    int L;
    double K = 1;
    double angle_acc = 0;
    double tmp_I;

    if (I < 0) {
        /* rotate by an initial +/- 90 degrees */
        tmp_I = I;
        if (Q > 0.0) {
            I = Q;           /* subtract 90 degrees */
            Q = -tmp_I;
            angle_acc = -90;
        } else {
            I = -Q;          /* add 90 degrees */
            Q = tmp_I;
            angle_acc = 90;
        }
    } else {
        angle_acc = 0;
    }

    /* rotate using "1 + jK" factors */
    for (L = 0, K = 1; L <= CORDIC_TABLE_SIZE; L++) {
        tmp_I = I;
        if (Q >= 0.0) {
            /* angle is positive: do negative roation */
            I += Q * K;
            Q -= tmp_I * K;
            angle_acc -= cordic_table[L];
        } else {
            /* angle is negative: do positive rotation */
            I -= Q * K;
            Q += tmp_I * K;
            angle_acc += cordic_table[L];
        }
        K /= 2.0;
    }
    return -angle_acc;
}

void init_table(void)
{
    int i;
    double K = 1;

    for (i = 0; i < CORDIC_TABLE_SIZE; i++) {
        cordic_table[i] = 180 * atan(K)/M_PI;
        K /= 2.0;
    }
}
int main(int argc, char **argv)
{
    double I, Q, A, Ar, R, Ac;

    init_table();

    printf("# Angle,    CORDIC Angle,  Error\n");
    for (A = 0; A < 90.0; A += 0.5) {

        Ar = A * M_PI/180; /* convert to radians for C's sin & cos fn's */

        R = 5; //Arbitrary radius

        I = R * cos(Ar);
        Q = R * sin(Ar);

        Ac = angle(I, Q);
        printf("%9f, %9f,   %12.4e\n", A, Ac, Ac-A);
    }
    return 0;
}

Lekin birinchi Arduino tabiiy vazifalarini sinab ko'ring - ular baribir tezda bo'lishi mumkin.

5
qo'shib qo'ydi
O'tmishda, xuddi shunday yondashuvni men stm8 da olganman. sin (x), sin (x/2) dan sin (x +/- x/2) ni sin (x), (2x) dan sin (x) va cos (x) , Cos (x) va cos (x/2) -> iteratsiya orqali maqsadingizga yaqinlasha olasiz. Men 45 daraja (0,707) bilan boshladim va maqsadga chiqdim. standart RAR sin() funktsiyasidan ancha sekinroq.
qo'shib qo'ydi muallif dannyf, manba

Men sintaksis va kosinalarni hisoblash bilan bir oz o'ynardim Arduino qattiq nuqta polinomli yaqinlashuvlar yordamida. Mana mening O'rtacha ijro etuvchi vaqtni va eng yomon vaziyatni o'lchashni taqqoslash avr-libc dan standart cos() va sin()

function    max error   cycles   time
-----------------------------------------
cos_fix()   9.53e-5     108.25    6.77 µs
sin_fix()   9.53e-5     110.25    6.89 µs
cos()       2.98e-8     1720.8   107.5 µs
sin()       2.98e-8     1725.1   107.8 µs

It's based on a 6th degree polynomial computed with only 4 multiplications. The multiplications themselves are done in assembly, as I found that gcc implemented them inefficiently. The angles are expressed as uint16_t in units of 1/65536 of a revolution, which makes the arithmetic of angles naturally work modulo one revolution.

Agar bu sizning hisob raqamingizga mos kelishi mumkin deb hisoblasangiz, bu erda kod: Ruxsat etilgan nuqta trigonometri . Kechirasiz, men hali bu sahifani frantsuz tilida tarjima qilmadim, lekin siz Tenglama va kodni tushunish mumkin (o'zgarmaydigan ismlar, izohlar ...) ingliz tilida.


Edit: Since the server seems to have vanished, here is some info on the approximations I found.

Ikki tomonlama sobit nuqtada, kvadrant birliklarida burchak yozishni istadim (Yoki o'z navbatida, o'z navbatida). Va men ham bir xil foydalanishni xohladim polinom, chunki ular o'zboshimchalik bilan hisoblash uchun yanada samarali hisoblanadi polinomlar. Boshqacha aytganda, men bunday polinom P() ni istadim

x ∈ [0,1] uchun cos (p/2 x) ≈ P (x 2

I also required the approximation to be exact at both ends of the interval, to ensure that cos(0) = 1 and cos(π/2) = 0. These constraints led to the form

P (u) = (1 - u) (1 + uQ (u))

Q() - bu o'zboshimchalik bilan polinomdir.

Undan keyin men eng yaxshi qarorni daraja vazifasi sifatida qidirdim Q() topildi va shunday qildi:

        Q(u)             │ degree of P(x²) │ max error
─────────────────────────┼─────────────────┼──────────
          0              │         2       │  5.60e-2
       −0.224            │         4       │  9.20e-4
−0.2335216 + 0.0190963 u │         6       │  9.20e-6

Yuqoridagi echimlar orasida tanlov tez/aniqlik bilan savdo-sotiqdir. Ushbu uchinchi yechim 16-bit bilan erishishdan ko'ra ko'proq aniqlik beradi va Bu 16-bit dasturni tanlaganim.

5
qo'shib qo'ydi
@TLW: javobni qo'shdi.
qo'shib qo'ydi muallif Sprogz, manba
@TLW: (1-x²) (1 + xQQ (x2)) shaklida cheklangan ba'zi "chiroyli" xususiyatlarga (masalan, cos (0) = 1) ega bo'lishni talab qildim, bu yerda Q (u) ixtiyoriy polinom (bu sahifada tushuntirilgan). Men birinchi darajali Q (faqat 2 koeffitsent) qabul qildim, taxminiy koeffitsiyentlarni moslashtirib topdik, keyin sinov va xato orqali optimallashtirishni qo'l bilan sozladim.
qo'shib qo'ydi muallif Sprogz, manba
Bu ajoyib, @Edgar.
qo'shib qo'ydi muallif SDsolar, manba
Polinomni topish uchun nima qildingiz?
qo'shib qo'ydi muallif ThomasX, manba
@EdgarBonet - qiziqarli. Ushbu sahifada keshlangan ishlarga qaramasdan, men uchun yuk emas. Ushbu javob uchun ishlatiladigan polinomni ilova qila olasizmi?
qo'shib qo'ydi muallif ThomasX, manba

Qidiruv jadvallari sini topishning eng tezkor usulidir. Agar siz sobit nuqtadagi raqamlar bilan hisoblashingiz qulay bo'lsa (ikkilik nuqta bit-0 o'ngidan boshqa joyga ega bo'lgan sonlar), sizning sininalar bilan keyingi hisoblashlar ham tezroq bo'ladi. Keyinchalik bu jadval RAM bo'shlig'ini saqlash uchun Flashdagi so'zlarning stoli bo'lishi mumkin. O'zingizning matematikada katta qidiruv natijalari uchun uzunlikni ishlatishingiz mumkinligiga e'tibor bering.

2
qo'shib qo'ydi

Muayyan burchakdagi sin() va cos() ni aniqlash uchun chiziqli yaqinlashuvdan foydalanadigan bir necha funktsiyalarni yaratishingiz mumkin.

Men shunga o'xshash narsalarni o'ylayman:

Har bir kishi uchun gunoh() va cos() ning grafik ko'rinishini 3 qismga sindirdim va ushbu bo'limning chiziqli yondashuvini qildim.

Sizning funktsiyangiz avval farishtaning oralig'i 0 dan 90 gacha bo'lganligini tekshiradi So'ngra u tegishli bo'lgan 3 ta bo'limni aniqlash uchun ifelse iborasini ishlatadi va keyin to'g'ri keladigan lineer hisoblashni amalga oshiradi (ya'ni output = mX + c ),

2
qo'shib qo'ydi
Majburiy emas. Buning natijasi 0-1100 dan 0-1 o'rtasida o'zgargan bo'lishi mumkin. Shunday qilib, suzuvchi nuqta emas, butun sonlar bilan ishlaysiz. Eslatma: 100 tasodifiy edi. Chiqarishni 0-128 yoki 0-512 yoki 0-1000 yoki 0-1024 oralig'ida o'lchamasligingiz uchun hech qanday sabab yo'q. 2-sonli turkumdan foydalanib, natijani pastga siljitish uchun faqat o'ng tomonga o'tishni amalga oshirishingiz kerak.
qo'shib qo'ydi muallif Yoni Baciu, manba
Juda aqlli, @sa_leinad. Upvote. Transistorlar bilan ishlashda bu ishni eslayman.
qo'shib qo'ydi muallif SDsolar, manba
Bu suzuvchi nuqta ko'paytirishni talab qilmaydi?
qo'shib qo'ydi muallif Ken Arnold, manba

Cos() va sin() ga yaqinlashib qolgan boshqa odamlarni qidirdim va men bu javobni qabul qildim:

Dtb ning oldindan hisoblash tilidan foydalangan holda "Tez sin/Cos" ga javob "

Asosan u matematika kutubxonasidagi math.sin() funktsiyasi qiymatlar jadvalini ishlatishdan ko'ra tezroq ekanligini anglatardi. Lekin men aytadigan narsadan, bu kompyuterda hisoblangan.

Arduino, sin() va cos() ni hisoblashi mumkin bo'lgan matematika kutubxonasiga ega.

2
qo'shib qo'ydi
Kompyuterlarda ularni tezda bajaradigan FPUlar mavjud. Arduino yo'q, va bu sekinlashtiradi.
qo'shib qo'ydi muallif Majenko, manba
Javob qatori chegara tekshiruvi kabi narsalarni bajaradigan C# uchun ham javob.
qo'shib qo'ydi muallif Longdaysjourneyintocode, manba

generally, look-up table > approximation -> calculation. ram > flash. integer > fixed point > floating point. pre-calclation > real time calculation. mirroring (sine to cosine or cosine to sine) vs. actual calculation/look-up....

each has its pluses and minuses.

you can make all sorts of combinations to see which works best for your application.

edit: I did a quick checking. using 8-bit integer output, calculating 1024 sin values with look-up table takes 0.6ms, and 133ms with floaters, or 200x slower.

1
qo'shib qo'ydi

Menda OPga simillar qo'yilgan edi. Funktsiyani dastlabki quadrantini 0x8000 dan 0xffffgacha bo'lgan 16 bit tamsayı belgisi sifatida hisoblash uchun LUT jadvali yaratmoqchi edim. Va men buni qiziqarli va foyda uchun yozdim. Eslatma: Agar "if" so'zlari ishlatilsa, u yanada samarali ishlaydi. Bundan tashqari, bu juda aniq emas, lekin sintezatorda sinus to'lqin uchun etarli bo'ladi

void sin_lut_ctor(){

//Make a Look Up Table for 511 terms of the sine function.
//Plugin in some polynomials to do some magic
//and you get an aproximation for sines up to π/2.
//

//All sines yonder π/2 can be derived with math

const uint16_t uLut_d = 0x0200; //maximum LUT depth for π/2 terms. 
uint16_t uLut_0[uLut_d];        //The LUT itself.
//Put the 2 above before your void setup() as global variables.
//This coefficients will only work for uLut_d = 511.

uint16_t arna_poly_0 = 0x000a;//11
uint16_t arna_poly_1 = 0x0001;//1
uint16_t arna_poly_2 = 0x0007;//7
uint16_t arna_poly_3 = 0x0001;//1   Precalculated Polynomials
uint16_t arna_poly_4 = 0x0001;//1   
uint16_t arna_poly_5 = 0x0007;//7
uint16_t arna_poly_6 = 0x0002;//2
uint16_t arna_poly_7 = 0x0001;//1

uint16_t Imm_UI_0 = 0x0001;             // Itterator
uint16_t Imm_UI_1 = 0x007c;             // An incrementor that decreases in time

uint16_t Imm_UI_2 = 0x0000;             // 
uint16_t Imm_UI_3 = 0x0000;             //             
uint16_t Imm_UI_4 = 0x0000;              //
uint16_t Imm_UI_5 = 0x0000;              //
uint16_t Imm_UI_6 = 0x0000;             // Temporary variables
uint16_t Imm_UI_7 = 0x0000;              //
uint16_t Imm_UI_8 = 0x0000;              //
uint16_t Imm_UI_9 = 0x0000;              //
uint16_t Imm_UI_A = 0x0000;
uint16_t Imm_UI_B = 0x0000;

uint16_t Imm_UI_A = uLut_d - 0x0001;    // 510

uLut_0[0x0000] = 0x8000;        //Assume that the middle point is 32768 (0x8000 hex)
while (Imm_UI_0 < Imm_UI_A) //Construct a quarter of the sine table
  {
Imm_UI_2++;                                   //Increase temporary variable by 1

Imm_UI_B = Imm_UI_2/arna_coeff_0;           //Divide it with the first coefficient (note: integer division)
Imm_UI_3 += Imm_UI_B;                         //Increase the next temporary value if the first one has increased up to the 1st coefficient
Imm_UI_1 -= Imm_UI_B;                         //Decrease the incrementor if this is the case
Imm_UI_2 *= 0x001 - Imm_UI_B;                 //Set the first temporary variable back to 0

Imm_UI_B = Imm_UI_3/arna_poly_1;           //Do the same thing as before with the next set of temporary variables
Imm_UI_4 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_3 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_4/arna_poly_2;           //And again... and again... you get the idea.
Imm_UI_5 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_4 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_5/arna_poly_3;
Imm_UI_6 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_5 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_6/arna_poly_4;
Imm_UI_7 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_6 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_7/arna_poly_5;
Imm_UI_8 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_7 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_8/arna_poly_6;
Imm_UI_9 += Imm_UI_B;
Imm_UI_1 -= Imm_UI_B;
Imm_UI_8 *= 0x0001 - Imm_UI_B;

Imm_UI_B = Imm_UI_9/arna_poly_7          //the last set won't need to increment a next variable so skip the step where you would increase it.
Imm_UI_1 -= Imm_UI_B;
Imm_UI_9 *= 1 - Imm_UI_B;

uLut_0[Imm_UI_0] = (uLut_0[Imm_UI_0 - 0x0001] + Imm_UI_1); //Set the current value as the previous one increased by our incrementor
Imm_UI_0++;              //Increase the itterator
  }   
  uLut_0[Imm_UI_A] = 0xffff; //Lastly, set the last value to 0xffff

  //And there you have it. A sine table with only one if statement (a while loop)
}

Endi qiymatlarni qaytarish uchun bu funktsiyadan foydalaning. 0x0000 dan 0x0800 gacha bo'lgan qiymatni qabul qiladi va LUT

uint16_t lu_sin(uint16_t lu_val0)
{
  //Get a value from 0x0000 to 0x0800. Return an appropriate sin(value)
  Imm_UI_0 = lu_val0/0x0200; //determine quadrant
  Imm_UI_1 = lu_val0%0x0200; //Get which value
  if (Imm_UI_0 == 0x0000)
  {
    return uLut_0[Imm_UI_1];
  }
  if (Imm_UI_0 == 0x0001)
  {
    return uLut_0[0x01ff - Imm_UI_1];
  }
  if (Imm_UI_0 == 0x0002)
  {
    return 0xffff - uLut_0[Imm_UI_1];
  }
  if (Imm_UI_0 == 0x0003)
  {
    return 0xffff - uLut_0[0x01ff - Imm_UI_1];
  }
}// I'm using if statements here but similarly to the above code block, 
 //you can do without. just with integer divisions and modulos

Esingizda bo'lsin, bu vazifa uchun eng samarali yondashuv emas, men faqatgina Teylor seriyasini tegishli diapazonda natijalarni berishga qanday erishish mumkinligini tushunolmadim.

1
qo'shib qo'ydi
Sizning kodingiz tuzilmaydi: Imm_UI_A ikki marta e'lon qilinadi, ; va ba'zi bir o'zgaruvchan deklaratsiyalar yo'q va uLut_0 global bo'lishi kerak. Kerakli tuzatishlar bilan lu_sin() tez (27 dan 42 gacha CPU tsikli), lekin juda noto'g'ri (maksimal xato ≈ 5.04e-2). Men "Arnadiya polinomlari" ning nuqtasini ololmayman: bu juda og'ir hisoblangan bo'lsa-da, natija deyarli kvadratik yaqinlik kabi deyarli yomon. Bu usulda katta xotira ham bor. Kompyuteringizda jadvalni hisoblash va kodni PROGMEM qatori sifatida qo'yish yaxshiroq bo'lar edi.
qo'shib qo'ydi muallif Sprogz, manba
Matematiklar
Matematiklar
633 ishtirokchilar

Kanalga obuna buling @Matematikak Masala va misollar yechimlari uchun guruh Guruhda faqat matematikaga oid ma'lumot bo'lishi shart.

MATEMATIKA GRANT
MATEMATIKA GRANT
356 ishtirokchilar

Guruh muallifi : @Yusupov_Ahadjon Guruh rasmiy kanali @dtm_axborotnoma Kimda chiqmagan misoli bo'lsa guruhga jo'natishi mumkin! Guruh qoidalari Chat Reklama Soʻkingan Futbol Sticker Xamma bir birini xurmat qilsin