BeMelaB

Arduino ile Bilimsel hesap makinesi programı.

π Sayısını Hesaplama Algoritmaları

Bailey-Borwein-Plouffe (BBP) formülü

Bailey-Borwein-Plouffe (BBP) formülü, önceki haneleri hesaplamadan pi’nin (veya herhangi bir tabanda diğer sayıların) n’inci onaltılık hanesini hesaplamak için kullanılan bir formüldür. Formül, Simon Plouffe tarafından 1995 yılında keşfedilmiş olup, Peter Borwein ve Simon Plouffe’nin daha önceki çalışmalarına dayanmaktadır ve ayrıca David Bailey, Peter Borwein ve Simon Plouffe tarafından bağımsız olarak bulunmuştur.

C, Octave, Basic dillerinde LambertW fonksiyonu

Lambert W fonksiyonu (aynı zamanda omega fonksiyonu olarak da bilinir), matematikte özellikle karmaşık analiz ve ilgili alanlarda kullanılan özel bir fonksiyondur. Fonksiyon, f(z) = z * e^z fonksiyonunun tersidir, yani w(z) fonksiyonu, w(z) * e^w(z) = z denklemini sağlayan fonksiyondur. W(z) olarak gösterilir.

Lambert W fonksiyonu, matematik, bilim ve mühendislik gibi çeşitli alanlarda kullanılır. Örneğin, x^a = b veya a^x = b gibi üstel denklemlerin çözümünde kullanılabilir. Ayrıca, istatistik mekaniği, termodinamik ve finansta da kullanılır.

Lambert W fonksiyonu, karmaşık değerli bir fonksiyondur ve sonsuz sayıda dalga sahiptir. Lambert W fonksiyonunun ana dalı, -1/e’den büyük veya eşit olan gerçek argümanlar için gerçek değerleri alır ve z > -1/e için tek bir değerli ters fonksiyona sahiptir. Diğer dallar karmaşık değerlidir ve ana dalın 2πi katları eklenerek elde edilir.

Lambert W fonksiyonu, MATLAB, Mathematica, Python ve R gibi birçok matematiksel yazılım paketinde ve programlama dilinde uygulanmıştır.

LambertW fonsiyonunun Amstrad CPC makinelerde de çalışabilecek BASiC dilinde yazılmış bir versiyonunu alta ki programda görebilirsiniz

10 INPUT X
20 W = X
30 WHILE ABS(W*EXP(W)-X)/X > 1E-8
40     W = W - (W*EXP(W)-X)/(EXP(W)*(W+1)-((W+2)*(W*EXP(W)-X))/((2*W+2)+W*EXP(W)))
50 WEND
60 PRINT W

Programı kendinizde şu linkte test edebilrisiniz https://benchmarko.github.io/CPCBasic/index.html

WolframAlpha da elde edilen sonuç ise

LambertW fonsiyonu aynı zamanda product log olarkata bilinir ve wolframalpha buadlandırmayı kullanıyor.

Sonuçları karşılaştıracak olursak BASİC ile yazılan program gayet iyi yakınsadıpını söyleyebiliriz

Programda şu değişiklikleri lgili satırda yaparsak

30 WHILE ABS(W*EXP(W)-X)/X > 1E-15

W(x)=1.04990889496404 noktadan sonra 14 basamak doğruğunda sonuç elde ederiz.

Dikkat edilmesi gereken husun x ler daima x>0 büyük olmalıdır. LambertW complex sayılar içinde tanımlı olsa da yazmış olduğumuz program sadece pozitif reel sayıların LambertW sunu hesaplayabilmektedir.

Örnek Porblem:

Şimdi W(ln(3)) programımıza hesaplatalım

Amstrad’da

ifadesini hesaplatalım

Görüldüğü üzere

W(log(3))=0.6018292835875305

x=1.82545502292483

Sonuçtan da anlaşılacağı gibi AMSTRAD CPC464 için yazılan LambertW Basic porgramı sıfırdan büyük pozitif reel sayılar gayet düzgün çalışıyor ve doğru sonuç veriyor.

Örnekteki problemi çözen tam programın listesini aşağıda veriyorum

10 'INPUT X
20 x=LOG(3)
30 W=0
40 WHILE ABS(W*EXP(W)-X)/X>1E-15
50 W=W-(W*EXP(W)-X)/(EXP(W)*(W+1)-(W+2)*(W*EXP(W)-X)/(2*W+2+W*EXP(W)))
60 WEND
70 PRINT "W(x)="W
80 x=LOG(3)/W
90 PRINT
100 PRINT "x=log(3)/W(log(3))=";x
110 PRINT
120 PRINT "x^x=";x^x

Programı linkini https://benchmarko.github.io/CPCBasic/index.html online olan Amstrad simülatöründe deneyebilirsiniz

Bir sonraki macerada görüşmek üzere

Amstrad CPC bilgisayarı 2^128 hesaplıyor

ChatGPT ye Arduino için yazdırdığım programı Amstrad Basic diline chatGPT ye çevrttim ancak bir hata yaptı onuda düzelttim satır 160 INT eklnmesi gerekiyordu. Ayıca sonucu daha düzgün görmek için satır 240-270 ekledim. Alta programı görebilrsiniz

10 MODE 2:CLS
20 REM Define the number of digits required to store the result
30 DIM result(40)
40 FOR i=1 TO 40
50 result(i)=0
60 NEXT i
70 REM Set the first digit to 1
80 result(1)=1
90 REM Calculate 2^128 iteratively
100 FOR i=1 TO 128
110 carry=0
120 REM Multiply each digit of the result by 2 and add the carry from the previous digit
130 FOR j=1 TO 40
140 product=2*result(j)+carry
150 result(j)=product MOD 10
160 carry=INT(product/10)
170 NEXT j
180 NEXT i
190 REM Print the result
200 PRINT "2^128 = ";
210 FOR i=40 TO 1 STEP -1
220 PRINT result(i);
230 NEXT i
240 FOR i=40 TO 1 STEP -1
250 res$=res$+MID$(STR$(result(i)),2)
260 NEXT i
270 PRINT res$

Sonucuda Amtrad mükemmel şekilde hesapladı.

Arduino ile 2^128 hesaplayan yazılımı ChatGPT ile beraber yazdık

// Define the number of digits required to store the result
#define NUM_DIGITS 40

void setup() {
  Serial.begin(9600);
  
  // Define the array to store the result
  int result[NUM_DIGITS] = {0};

  // Set the first digit to 1
  result[0] = 1;

  // Calculate 2^128 iteratively
  for (int i = 0; i < 128; i++) {
    int carry = 0;

    // Multiply each digit of the result by 2 and add the carry from the previous digit
    for (int j = 0; j = 0; i--) {
    Serial.print(result[i]);
  }
}

void loop() {
  // Nothing to do here
}

Wowki

https://wokwi.com/projects/361996755593355265

ChatGPT ile olan diyaloğumuz altaki resimde görülüyor

Arduino ile 100! hesaplayan kodu chatGPT ye yazdırdım

BU chatGPT ye aklıma gelen işkence vari arduino kodları yazdırmak bir takıntı haline geldi bazen uğraştırıyor bazen ne dediğini anlamıyor bazen sabrımı taşırıyor. Daha önceleri de yaptığım denemelerde epey hatalı kodlar üretiyordu. ChatGPT ye olabildiğince net talimatla rvermek gerekiyor ve doğru sonuç verme olasılığı artmış olur.

Bugün tekrar Arduino için 100! (faktoryel) kodunu yazmasın istedim.

Chat kutusuna “write a code for arduino calculating 100! without using bigINT library”

ve chatGPT’ nin yazdığı kod;

void setup() {
  Serial.begin(9600);   // Start serial communication
}

void loop() {
  int result[200];   // Array to store the digits of the factorial
  int n = 100;   // Calculate the factorial of 100
  int length = 1;   // Current length of the factorial

  // Initialize the array with 1 digit
  result[0] = 1;

  // Multiply the factorial by each number from 2 to n
  for (int i = 2; i <= n; i++) {
    int carry = 0;   // Carry from the previous multiplication

    // Multiply each digit of the factorial by i and add the carry
    for (int j = 0; j = 0; i--) {
    Serial.print(result[i]);
  }
  Serial.println();

  while(1);   // Stop the program
}

Bu programı wowki de, siz de bu altaki linkte deneybilirsiniz

https://wokwi.com/projects/361886801962539009

Ben çalıştırdım ve sonuç

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Sonucu Full Precision Calculator ‘ da teyyit ettim sonuç mükemmel.

chatGPT gitgide kendini geliştiriyor. Daha zorlu kodlara geçme zamanı geldi. Yeni denemelere devam edeceğim takipte kalın.

ChaGPT Arduino’ da uzun bölme yapan program yazdı

void setup() {
   Serial.begin(9600);
}

void loop() {
   long dividend = 12345;
   long divisor = 123456;
   int decimal_places = 1000;
   
   char result[decimal_places+2]; // +2 for decimal point and null terminator
   memset(result, 0, sizeof(result)); // initialize result to all zeroes
   
   // Handle negative values
   bool negative = false;
   if ((dividend  0) || (dividend > 0 && divisor < 0)) {
     negative = true;
   }
   dividend = abs(dividend);
   divisor = abs(divisor);
   
   // Calculate integer part of quotient
   long quotient = dividend / divisor;
   ltoa(quotient, result, 10);
   
   // Add decimal point
   strcat(result, ".");
   
   // Calculate decimal part of quotient
   long remainder = dividend % divisor;
   for (int i = 0; i < decimal_places; i++) {
     remainder *= 10;
     quotient = remainder / divisor;
     remainder = remainder % divisor;
     result[i+2] = quotient + '0';
   }
   
   // Print result
   if (negative) {
     Serial.print("-");
   }
   Serial.println(result);
   
   while (1) {} // stop program from continuing indefinitely
}

ChaGPT kullanarak arduino ya program yazdırdım

ChatGPT ilk aktif olduğunda üye olup kullanmışlığım vardı. sadece iki sorudan oluşan bir muhabbet. Biri Aşkın tanımı nedir diğeri de Steve Jobs’ un Biyografisi hakkındaydı. Daha sonraları sistemin yoğunluğundan dolayı giriş yapamadım ve çok fazla deneme fırsatım olmadı hatta neler yapılabileceği konusunda da çok fikrim yoktu. Yine dedim bir zamanlar çok fonksiyonel olmayan yapay zeka ile Chat yazılımlarına benziyordur diye çok üstüne düşmedim. Son bir kaç haftadır youtube de sıkça videolar görmeye başladım. Merakımı tekrar celbetti. Hadi ChapGPT Arduino için bana bir yazılım yazmasını istedim . Blog da daha önce Amstrad bilgisayar için BASIC’ te yazılan bir programı ChatGPT’ nin Arduino için yazmasını istedim.

Çok büyük sayılar çarpımını yapabilecek bir Arduino programını yazması için chat kutusuna yazmaya başladım.

bemelab

C programı ile Sonsuz Bölme

Bu program ile 2 sayının bölümünü virgülden sonra istediğiniz kadar hesaplatabilirsiniz. Aşağıdaki programı devC++ ile çalıştırabilirsiniz. Program virgülden sonra 1000 basamak hesaplamaktadır, istediğiniz taktirde programdan yapacağınız değişiklikle basamak sayısını arttırabilirsiniz.

#include 

int main(){
	int bnn,bln,sayac=0;
	printf("-HESAP MAKINESI-\n");
	printf("Bolunen Giriniz: ");
	scanf("%d",&bnn);
	printf("Bolen Giriniz: ");
	scanf("%d",&bln);
		
	float temp;
	printf("\n %d.",bnn/bln);
	bnn=bnn%bln;
	while(sayacbln){
			
			printf("%d",bnn/bln);
			bnn=bnn%bln;
			//printf(" -%d- ",bnn);
		}
		else{
			bnn*=10;
			if(bnn<bln){
				if(bnn%bln!=0){
					printf("0");
				}
			}
			//printf(" +%d+ ",bnn);
			if(bnn%bln==0 && !(bnn/bln!=0)){
				printf("0");
			}
		}
	}
}

Buradaki bağlantıdan Full Precision Calculator’a erişebilirsiniz https://www.mathsisfun.com/calculator-precision.html.

Full Precision Calculator ile 1000 basamak hesaplatılmıştır. C programı ile karşılaştırmayı yapabilirsiniz.