WEiTI M3 - 2007

wrzuce wam moj program z opornikami
warunki mi wszystkie dzialaja tylko funkcji nie mam.

/* Autor: Michal Dziedzicki
   Program sluzy do wyznaczania oporu zastepczego dla podanego schematu
   Program odrzuca niepoprawne dane wejsciowe takie jak: liczby ujemne, litery, znaki
   Program pomija przy wczytywaniu zbedne znaki ktore moga byc przypadkowo wpisane (np. "56h" jest odczytywane jako "56",
   "123.124.321" jest wczytywane jako "123.124")
*/

//Wczytanie potrzebnych bibliotek:
#include <stdio.h>
#include <stdlib.h>
#include <float.h>

// Zainicjowanie funkcji "main"
int main(void)

{
// Zadeklarowanie zmiennych:
  float r1,r2,r3,r4,r5,r6,R1,RR;
  char syf;
 
// Wypisanie schemtu dla ktorego ma byc wyznaczony opor zastepczy: 
      printf("Program wyznacza opor zastepczy dla podanego schematu: \n");
      printf(" \n");
      printf("          +------r4------+\n");
      printf("          |              |\n");
      printf("       ---+--r1--r2--r3--+---r5--r6---\n");
      printf(" \n");

// Prosba o wprowadzenie pierwszej danej:     
printf("Wprowadz wartosc pierwszego oporu: ");
         

// Przeprowadzenie walidacji danych wejsciowych: 
          while (scanf("%f", &r1) == 0 || r1<0 || r1>=FLT_MAX )
          {
// Sprawdzenie czy zmienna miesci sie w zakresie "float"
          if (r1>=FLT_MAX)
                   {
                          printf("\rLiczba jest spoza zakresu! ");
                   r1=0;
                   }
// Sprawdzenie czy zmienna jest ujemna                   
          else
          if (r1<0)
             {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r1=0;
             }
// Sprawdzenie czy zmienna jest liczba
                   else
                       if (scanf("%f", &r1) == 0)
                        {
                        scanf("%*s");
                        printf("\rNalezy wprowadzic liczbe!!! ");
                        r1=0;

                        }
             }
// Pominiecie wszystkich zbednych znakow             
          do
              {
                   syf = getchar();
              }
                    while (syf!= '\n');
                   
                   
// Dla kolejnych pieciu danych kod programu wyglada analogicznie         
printf("Wprowadz wartosc drugiego oporu: ");


          while (scanf("%f", &r2) == 0 || r2<0 || r2>=FLT_MAX )
          {
          if (r2>=FLT_MAX)
                   {
                          printf("\rLiczba jest spoza zakresu! ");
                   r2=0;
                   }
         
          else
          if (r2<0)
             {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r2=0;
             }
             
                   else
                       if (scanf("%f", &r2) == 0)
                       {
                       scanf("%*s");
                       printf("\rNalezy wprowadzic liczbe!!! ");
                       r2=0;

                       }
             }
          do
             {
                   syf = getchar();
             }
                    while (syf!= '\n');
                   
         
printf("Wprowadz wartosc trzeciego oporu: ");


          while (scanf("%f", &r3) == 0 || r3<0 || r3>=FLT_MAX )
          {
          if (r3>=FLT_MAX)
                   {
                          printf("\rLiczba jest spoza zakresu! ");
                   r3=0;
                   }
          else
          if (r3<0)
             {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r3=0;
                                     }
                   else
                   if (scanf("%f", &r3) == 0)
                   {
                   scanf("%*s");
                   printf("\rNalezy wprowadzic liczbe!!! ");
                   r3=0;

                   }
              }
          do
          {
                   syf = getchar();
          }
                    while (syf!= '\n');
         
         
printf("Wprowadz wartosc czwartego oporu: ");


            while (scanf("%f", &r4) == 0 || r4<0 || r4>=FLT_MAX )
            {
            if (r4>=FLT_MAX)
                   {
                            printf("\rLiczba jest spoza zakresu! ");
                   r4=0;
                   }
                   else
                   if (r4<0)
            {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r4=0;
                                     }
                   else
                   if (scanf("%f", &r4) == 0)
                   {
                   scanf("%*s");
                   printf("\rNalezy wprowadzic liczbe!!! ");
                   r4=0;

                   }
             }
          do
          {
                   syf = getchar();
          }
                    while (syf!= '\n');       
                   
                   
printf("Wprowadz wartosc piatego oporu: ");


            while (scanf("%f", &r5) == 0 || r5<0 || r5>=FLT_MAX )
            {
            if (r5>=FLT_MAX)
                   {
                            printf("\rLiczba jest spoza zakresu! ");
                   r5=0;
                   }
                   else
                   if (r5<0)
            {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r5=0;
            }
                   else
                   if (scanf("%f", &r5) == 0)
                   {
                    scanf("%*s");
                    printf("\rNalezy wprowadzic liczbe!!! ");
                    r5=0;
                   }
            }
          do
          {
                   syf = getchar();
                    }
                    while (syf!= '\n');       
                   
                   
printf("Wprowadz wartosc szostego oporu: ");


            while (scanf("%f", &r6) == 0 || r6<0 || r6>=FLT_MAX )
            {
            if (r6>=FLT_MAX)
                   {
                            printf("\rLiczba jest spoza zakresu! ");
                   r6=0;
                   }
                   else
                   if (r6<0)
            {

                   printf("Wartosc oporu musi byc dodatnia!!! Wprowadz jeszcze raz! ");
                   r6=0;
                                     }
                   else
                   if (scanf("%f", &r6) == 0)
                   {
                   scanf("%*s");
                   printf("\rNalezy wprowadzic liczbe!!! ");
                   r6=0;
                   }
             }
          do
          {
                   syf = getchar();
                    }
                    while (syf!= '\n');
                   
// Unikniecie dzielenia przez "0"         
      if (r1+r2+r4+r3==0)
         
      R1=0;
// Wyznaczenie wartosci oporu zastepczego         
      else
          R1=((r1+r2+r3)*r4)/(r1+r2+r3+r4);
         
          RR=R1+r5+r6;
// Wypisanie wyniku
          printf("\n");
          printf("Opor zastepczy wynosi: %f \n", RR);
          printf("\n");
// Wykluczenie mozliwosci wylaczenia sie programu przed odczytaniem wyniku         
          system("PAUSE");
          return(0);
}
// KONIEC

albo drugi wariant tego niedkoskonałego jesczze programu...ale z Waszą pomocą kto wie
#include<stdio.h>
#include<stdlib.h>

#define R 1



main()
{
      int i, k;
        double N, N1, x, y;
        float s;
        float PI;
        printf("Jest to program liczacy liczbe PI metoda Monte-Carlo\n");
        printf("Podaj N - liczbe punktow w kwadracie(najlepiej powyżej 10tys)\n");
        scanf("%d", &N);
               
          for(i=1; i<10; i++)
        {     
       
       
               for(k=1; k<N; k++)
           {
               N1=0;
                   if(sqrt((double)x*x+y*y)<R) N1++; 
              x = ((double) rand()/(float)(RAND_MAX+1.0));
              y =((double) rand()/(float)(RAND_MAX+1.0));
                       
               } 
               printf("N1=%d\n", N1);
       
        s=N1/N;
        PI=4*s;
        printf("Liczba PI w %d losowaniu wynosi PI=%.7f\n", i, PI);
        }
        system("PAUSE");
      return 0;
}

http://pl.wikipedia.org/wiki/Metoda_eliminacji_Gaussa - proszę

I jeszcze taki mały request: jeżeli ktoś ma już gotową dokumentację nie mógłby się nią podzielić? Potrzebuję mieć coś na wzór, bo mam średnie pojęcie o tym, jak to ma wyglądać.

ile stron zajmuje Wasza dokumentacja?

Tutaj są przykładowe wzory specyfikacji <ze strony Podgórskiego, a chyba bardziej Arabasa, tylko link jest u Podgórskiego i co dziwne DZIAŁA!!!!!!>


http://elektron.elka.pw.edu.pl/~jarabas … pecfun.pdf

http://elektron.elka.pw.edu.pl/~jarabas … ectech.pdf

Moj zajebisty projekt(wlasnie skonczylem pisac...) - jak sie komus przyda o tej porze to prosze bardzo ;-)

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

#define PLIK	"wynik.txt"	// nazwa pliku z wynikami
#define KULA	1
#define WALEC	2
#define DOKL	10000	// dokladnosc losowania liczby zmiennoprzecinkowej
#define MINITER	1000	// minimalna liczba iteracji
#define MAXITER	30000	// max liczba iteracji

/* Punkt(x,y,z) w przestrzeni */
typedef struct{
	float x, y, z;
}punkt; 
/******************************************************************************/

/*	
	Oblicza wymiary prostopadloscianu opisanego na podanej bryle 
	bryla - 		rodzaj bryly(KULA lub WALEC)
	dla kuli r - 	promien
	dla walca r - 	promien, h - wysokosc
*/
punkt wym_ppscian(char bryla, float r, float h)
{
	punkt p;
	
	if(bryla == KULA)
	{	
		p.x = p.y = p.z = 2*r;
		return p;	
	}
	else
	{
		p.x = p.y = 2*r;
		p.z = h;
		return p;
	}
}
/******************************************************************************/

/*	
	Sprawdza czy punkt nalezy do bryly(kuli lub walca)
	Zwraca 1, gdy nalezy
	Zwraca 0, gdy nie nalezy
	bryla - 		rodzaj bryly(KULA lub WALEC)
	dla kuli r - 	promien
	dla walca r - 	promien, h - wysokosc
	p - 			punkt
*/
int sprawdz_punkt(char bryla, float r, float h, punkt p)
{
	float l;	// kwadrat odleglosci od srodka kuli(kola)
	
	if(bryla == KULA)
	{
		l = (p.x-r)*(p.x-r) + (p.y-r)*(p.y-r) + (p.z-r)*(p.z-r);
	}	
	else
	{
		// wspolrzedna p.z zawsze nalezy do walca - sprawdzamy tylko
		// podstawe
		l = (p.x-r)*(p.x-r) + (p.y-r)*(p.y-r);
	}
	if(l <= (r*r))
			return 1;
	return 0;
}
/******************************************************************************/

/*
	Losuje liczbe zmiennoprzecinkowa <0-zakres>
	zakres	-		zakres losowania
*/
float frand(float zakres)
{
	int d, rd;		// czesc calkowita, wylosowana cz. calk.     
	float f, rf;	// czesc ulamkowa, wylosowana cz. ul.
	
	d = (int)zakres;
	f = zakres - d;
	
	// zeby losowac tez wartosci dla zakresu = liczba calkowita
	if(f == 0) 
	{
		d <= -1 ? d = 0 : d --;
		f = 1.0;
	}
	
	// losujemy czesc calkowita
	rd = rand()%(d+1);
	
	// losujemy czesc ulamkowa
	while((rf = rand()%(DOKL+1) / (float)DOKL)> f) {}
	
	return (rf+rd);
}
/******************************************************************************/


/*
	Losuje wspolrzedne punktu zawartego w prostopadloscianie
	ppscian	-		prostopadloscian
*/
punkt losuj_punkt(punkt ppscian)
{
	punkt p;
	p.x = frand(ppscian.x);
	p.y = frand(ppscian.y);
	p.z = frand(ppscian.z);
	
	return p;	
}
/******************************************************************************/

/*
	Wczytuje zmienna typu float wieksza od zera. Zawiera obsluge bledow.
	Zwraca wczytana liczbe.
*/
float wczytaj_float()
{
	float f;
	int flaga = 1; // warunek wyjscia z petli = 0
	
	while(flaga)
	{
		// jesli uzytkownik wpisal litere(-y) lub liczbe <=0
		if(!scanf("%f", &f) || (f <= 0))
		{
			printf("Mozesz podac TYLKO LICZBE wieksza od zera z zakresu float: ");
			fflush(stdin); 
		}
		else
			flaga = 0; // wszystko OK - wychodzimy z petli
	}
	
	return f;
}
/******************************************************************************/

/*
	Wczytuje zmienna typu int >= MINITER. Zawiera obsluge bledow.
	Zwraca wczytana liczbe.
*/
int wczytaj_int()
{
	int d;
	int flaga = 1; // warunek wyjscia z petli = 0
	
	while(flaga)
	{
		// jesli uzytkownik wpisal litere(-y) lub liczbe <=0
		if(!scanf("%d", &d) || (d < MINITER) || (d > MAXITER))
		{
			printf("Mozesz podac TYLKO LICZBE calkowita (%d-%d> ", MINITER, MAXITER);
			fflush(stdin); 
		}
		else
			flaga = 0; // wszystko OK - wychodzimy z petli
	}
	
	return d;
}
/******************************************************************************/







int main(int argc, char *argv[])
{
	FILE *f;			// plik w ktorym bedziemy zapisywac wyniki
	punkt ppscian;		// wymiary prostopadloscianu
	float r = 0;		// promien kuli lub walca
	float h;			// wysokosc walca
	char bryla = 0;		// rodzaj bryly
	int iter = 0;		// liczba interakcji 
	int traf = 0;		// liczba trafionych punktow
	int i;			
	
	srand(time(0));		// inicjacja generatora licz pseduolosowych
	
	printf("Witaj w programie Monte Carlo!!!\n");
	printf("Wybierz bryle, ktorej objetosc chcesz obliczyc:\n");
	printf("[K]ula\n[W]alec\n");
	while(!bryla)
	{
		printf("Wpisz K dla kuli lub W dla walca: ");
		
		// jesli trafi sie jakis dziwny blad
		if(!scanf("%c", &bryla))
		{
			printf("\nNieznany blad wejscia.\n");
			return -1;	
		}
		// czyscimy bufor klawiatury zeby nie czytac dalszych znakow w linii
		fflush(stdin);
		switch(bryla)
		{
			case 'K':		// wielkosc litery bez znaczenia
			case 'k':
				bryla = KULA;
			break;
			
			case 'W':
			case 'w':
				bryla = WALEC;
			break;
			
			default:
				bryla = 0;		// bo wtedy !bryla = TRUE => petla sie kreci dalej
		}
	}
	
	if(bryla == KULA)
	{
		printf("OK - program obliczy objetosc kuli.\nPodaj promien kuli: ");
		r = wczytaj_float(); // wczytujemy promien
	}
	else	// czyli walec
	{
		printf("OK - program obliczy objetosc walca.\nPodaj promien podstawy: ");
		r = wczytaj_float(); // wczytujemy promien podstawy
		
		printf("Podaj wysokosc: ");
		h = wczytaj_float(); // ... i wysokosc
	}
	
	// wczytujemy liczbe iteracji
	printf("Podaj liczbe punktow do losowania(%d-%d>: ", MINITER, MAXITER);
	iter = wczytaj_int();
	
	// opisujemy prostopadloscian na bryle
	ppscian = wym_ppscian(bryla, r, h);
	
	// otwieramy plik
	if((f = fopen(PLIK, "w")) == NULL)
	{
		printf("BLAD!!! Nie mozna utworzyc pliku %s\n", PLIK);
		return -1;
	}
	
	// losujemy i sprawdzamy czy kolejne iter punktow zawiera sie w bryle
	for(i = 0; i < iter; i ++)
	{
		if(sprawdz_punkt(bryla, r, h, losuj_punkt(ppscian)))
			traf ++;
		// zapisujemy wyniki co 100
		if((i % 100 == 0) && i)
			fprintf(f, "%d %d\n", i, traf);
		
	}
	
	// zamykamy plik
	fclose(f);
	
	// wyprowadzenie wyniku na ekran
	if(bryla == KULA)
		printf("\nObjetosc kuli wynosi: %g\n", (float)traf/iter*ppscian.x*ppscian.y*ppscian.z);
	else if(bryla == WALEC)
		printf("\nObjetosc walca wynosi: %g\n", (float)traf/iter*ppscian.x*ppscian.y*ppscian.z);
	
    return 0;
}

Gdyby się komuś przydało:
http://elka.mine.nu/attach/download.php?fid=219 wygrzebany na elka.mine.nu przykładowy projekt, za który autor dostał max u niewińskiego. Co ważniejsze - jest tam również dokumentacja!

Do korzystania zapewne potrzebne jest konto na elka.mine.nu, ale zakładam że wszyscy mają - przecież bez tego się nie da zaliczyć pomów :>