Rozwiązywanie układów równań liniowych Metodą Gaussa

Program rozwiązywania układu równań liniowych metodą Gaussa z częściowym wyborem elementu głównego: czytanie danych macierzowych z pliku.

Obrót wektora wokół zadanej osi

Program umożliwia obrót wektora wokół osi układu współrzędnych.

Długość ortodromy, czyli odległość dwóch punktów na sferze

Program oblicza najkrótszą odległość kątową dwóch dowolnych punktów sfery niebieskiej.

Pole figury metodą Mote Carlo

Programy wyznaczają metodą Monte-Carlo pola wybranej figury:

Operacje na macierzach

Operacje na macierzach zapisanych w pliku:

Wzory rekurencyjne na sumę szeregu

Wzory rekurencyjne:

Czytanie przykładowych znaków z pliku

#include <stdio.h>

int main(void)
{
    int w=1;
    char buff[200];
    FILE *f;

    f=fopen("kaczka3.zzz", "r");
    if(f==NULL)
    {
	puts("Nie ma dancyh");
	return 1;
    }

    while(w<=30)
    {
	fgets(buff,195,f);
	if (w==7) printf("%c", buff[23]);
	if (w==11) printf("%c", buff[21]);
	if (w==16) printf("%c", buff[2]);
	if (w==21) printf("%c", buff[24]);
	if (w==26) printf("%c", buff[20]);
	if (w==29) printf("%cn", buff[5]);
	w++;
    }

    fclose(f);
    return 0;
}

Intel GMA500 (Poulsbo) - EMGD drivers w Ubuntu 11.04

Długo męczyłem się z moją GMA500, która jest wbudowana w lapka. Koszmarnie długo... nie dało się w przystępny sposób ustawić grafiki i otrzymać poprawnej wydajności, ale znalazłem wreszcie radę:

sudo add-apt-repository ppa:gma500/emgd
sudo apt-get update
sudo apt-get install xorg-emgd emgd-dkms emgd-xorg-conf
sudo emgd-xorg-conf

Reboocik i  cieszysz się 1366x736 ; )

 

edit 19 września 2012: https://wiki.ubuntu.com/HardwareSupportComponentsVideoCardsPoulsbo

Dodawanie kątów i normalizacja do

Program przyjmuje wartości kątów w tradycyjnym astronomicznym formacie. Konwertuje wartości na radiany, dodaje, normalizuje przedział <-pi, pi> i wyświetla wynik znów w tradycyjnym formacie.

Funkcja printf zaokrągla wynik dlatego konieczny był warunek sprawdzania i dodawania w wyniku do sekund łuku 59.999999 (sześć miejsc po przecinku, bo tyle jest domyślnie wyświetlane) , aby uniknąć wyświetlania 60". Program na zamiennych podwójnej precyzji, więc inne zaokrąglenia wynikające z obliczeń nie są rażące.

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

int main(void)
{
    double rad, sek1, sek2, stopnie, minuty, sekundy;
    double st1, st2, m1=60, m2;
    char z1, z2;

    while (m1 >= 60 || m2 >= 60 || sek1 >= 60 || sek2 >= 60 || (z1 != '+' && z1 != '-') ||
                                                                 (z2 != '+' && z2 != '-'))
    {
       printf("nWprowadź wartości kątów ZE ZNAKIEM oddzielone spacjami i naciśnij enter: n");
       printf("nPierwszy kąt: ");
       scanf(" %c %lf %lf %lf", &z1, &st1, &m1, &sek1);
       printf("Drugi kąt:    ");
       scanf(" %c %lf %lf %lf", &z2, &st2, &m2, &sek2);
    }

    if (z1 == '-')
    {
       st1=st1*(-1);
       m1=m1*(-1);
       sek1=sek1*(-1);
    }
    if (z2 == '-')
    {
       st2=st2*(-1);
       m2=m2*(-1);
       sek2=sek2*(-1);
    }

    rad = (( st1  +  (m1 / 60.0) + (sek1 / 3600.0)  +  st2 + (m2 / 60.0) + (sek2 / 3600.0) )
                                                                               * M_PI / 180);
    while (rad > M_PI) rad -= 2*M_PI;
    while (rad <= -M_PI) rad += 2*M_PI;

    stopnie = (rad * 180.0 / M_PI);

    if (stopnie < 0)
    {
        minuty = ( stopnie - ceil(stopnie) ) * 60;
        sekundy = ( minuty - ceil(minuty) ) * 60;
        if (sekundy <= -59.999999)
        {
            minuty--;
            sekundy+=59.9999999;
        }
        if (minuty < -59)
        {
            stopnie--;
            minuty+=60;
        }
        minuty=minuty*(-1);
        sekundy=sekundy*(-1);
        printf(" = %.0lf260 %.0lf' %lf"nn",  ceil(stopnie), floor(minuty), sekundy);
    }
    else
    {
        minuty = ( stopnie - floor(stopnie) ) * 60;
        sekundy = ( minuty - floor(minuty) ) * 60;
        if (sekundy >= 59.999999)
        {
            minuty++;
            sekundy-=59.9999999;
        }
        if (minuty > 59)
        {
            stopnie++;
            minuty-=60;
        }
        printf("= %.0lf260 %2.0lf' %lf"nn", floor(stopnie), floor(minuty), sekundy);
    }
    return 0;
}

Deterministyczny test pierwszości (liczby nieparzyste)

Program sprawdza podzielność danej liczby przez liczby nieparzyste z zakresu: od 3 do pierwiastka z danej liczby.

#include<stdio.h>
#include<math.h>
int main(void)
{
  unsigned long long int x, z, i=3, y=0;
  while(1)
  {
     printf("nnWprowadz liczbę: ");
     scanf(" %lld", &x);

     if (x == 0)
     {
         printf("nDziękujemy za użycie programu!n");
	     break;
     }
     if (x == 1)
     {
         printf("1 nie jest liczbą pierwszą ani złożoną.");
         continue;
     }
     if (x == 2)
     {
         printf("2 jest liczbą pierwszą.");
         continue;
     }
     if (x%2 == 0)
     {
         printf("Liczba %lld jest parzysta.", x);
         continue;
     }
     z = sqrt(x);
     for (i=3; i<=z; i+=2)
     {
         if (x%i == 0)
         {
         y = i;
         break;
         }
     }
     if (y != 0) printf("Liczba %lld nie jest pierwsza, ponieważ dzili się przez %lld.", x, y);
     else printf("Podana liczba jest liczbą pierwszą.");
     y = 0;
  }
  return 0;
}