[java] Binomium van Newton

[battler]

Ik zit even vast met mijn code. Al enige malen ben ik aan de haal geweest om deze formule te veranderen in een werkende java applet. De vorige applicatie werkte, maar de docent wou het graag in meerder methodes zien.

Nu ben ik er volgens mij bijna met mijn code:

code:

public class app
{
    //fields
    private static int a = 4;
    private static int b = 6;
    private static int n = 5;
    private static int k = 3;
    private static int ab;
    //constructor
    
    //methode
    public static void main(String[] args) 
    {
    System.out.println("a = " +a);
    System.out.println("b = " +b);
    System.out.println("k = " +k);
    System.out.println("macht" +macht(a,k));
    System.out.println("faculteit n =  " +faculteit(n));
    System.out.println("faculteit k = " +faculteit(k));
    System.out.println("binomiaal =  " +binomiaal(faculteit(n)));
    System.out.println("binomium =  " +newton(binomiaal(faculteit(n)),macht(a,k)));
    System.out.println("test = " +ab);
    }
    
    public static double macht(int a, int k)
    {
    double macht = Math.pow(a, k)* Math.pow(b,n-k);
    return macht;
    }
    
    public static double faculteit(int n)
    {
    int waarde = 1;
    for (int start = 1;start <= n;start++)
        {
        waarde = waarde * start;
        }
    int faculteit = waarde;
    return faculteit;
    }
    
    public static double binomiaal(double faculteit)
                           {
    double fack = faculteit(n - k) * faculteit(k);
    double binomiaal = faculteit(n)/fack;
    return binomiaal;
    }
    
    
    public static double newton (double binomiaal, double macht)
    
    {
        double newton = binomiaal(faculteit(n))* macht(a,k);
    return newton;
    }


    }
}

De code geeft nu als laatste terug een waarde Newton.
Nu is hij bij elke voorgaande formule ervan uitgegaan dat K == 3.
Nu moet hij eigenlijk alle formules afgaan met k == 1,
daarbij een waarde newton terug geven.
Vervolgens overnieuw beginnen met k == 2, en de nieuwe waarde van newton
optellen bij de vorige. Dit moet hij net zolang doen totdat k == n.
//ik hoop dat het een beetje begrijpelijk is.

Nu zal er vast ergens een for loop moeten komen, maar hoe pas ik die toe
op alle methodes?

[NMe]

Gewoon een loopje maken waarin je de method newton zo vaak aanroept als je hem nodig hebt, lijkt me?

[Soultaker]

Je code is nogal een zootje; waarschijnlijk ben je pas begonnen met leren programmeren. Dat geeft niet echt, maar ik zou je aanraden om je code in het begin zo simpel mogelijk te houden; complexere code schrijven komt vanzelf als je de basis beter onder de knie hebt.

Dat betekent in de eerste plaats al die globale variabelen afschaffen. Waarom krijg een functie als macht a als argument mee en b niet? Door alle argumenten van een functie expliciet mee te geven, wordt het veel eenvoudiger die afzonderlijk te bekijken.

Verder heb je gelijk dat je er bijna bent, maar je code verdient geen schoonheidsprijs. Waarom retourneren functies als faculteit en binomiaal doubles, terwijl faculteiten en binomiaalcoëfficienten altijd integers zijn?

[battler]

@ -NMe- Klinkt ook niet meer dan logish, ik was er al de hele dag mee bezig dus misschien een beetje te veel van het goede. Ik ga hem zo proberen in orde te maken. In ieder geval bedank.
@Soultake Het klopt dat ik pas begin met programmeren. Ik heb echt 0,0 ervaring ermee. Ik zou graag het een stukje langzamer aan doen, helaas zijn dit de school opdrachten dus aan de complexiteit van de programma's kan ik niets doen. Behalve dan zo snel mogelijk de materie me eigen zien te maken.

Over het expliciet meegeven van argumenten bij een methode (ik hoop dat ik je goed begrijp).
Ik kan A en K meegeven, omdat die ten alle tijden zo worden aangeroepen. Maar bij B gebeurd dat niet.
Volgens mij heeft dit te maken met overloading, dat wanneer ik 3 variabelen verwacht dat ik er ook daadwerkelijk 3 moet geven. Zou jij kunnen aangeven hoe je dit zou oplossen? Want op dit moment zou hij moeten werken, maar doordat de code (er voor mij) zo complex is het erg vermoeiend om het te lezen.

code:

public class app
{
    //fields
    private static int a = 4;
    private static int b = 6;
    private static double n = 5;
    //  private static double k = 3;
    private static int ab;
    private static double newton =40;
    //constructor
    
    //methode
    public static void main(String[] args) 
    {
 
    System.out.println("a = " +a);
    System.out.println("b = " +b);
    System.out.println("k = " +k);
    System.out.println("macht" +macht(a,k));
    System.out.println("faculteit n =  " +faculteit(n));
    System.out.println("faculteit k = " +faculteit(k));
    System.out.println("binomiaal =  " +binomiaal(faculteit(n),k));
    //System.out.println("binomium =  " +newton(binomiaal(faculteit(n)),macht(a,k)));
    System.out.println("newton = " +newton);

    }
    
    public static double macht(int a, double k)
    {
    double macht = Math.pow(a, k)* Math.pow(b,n-k);
    return macht;
    }
    
    public static double faculteit(double n)
    {
    int waarde = 1;
    for (int start = 1;start <= n;start++)
        {
        waarde = waarde * start;
        }
    double faculteit = waarde;
    return faculteit;
    }
    
    public static double binomiaal(double faculteit,double k)
    {
    double fack = faculteit(n - k) * faculteit(k);
    double binomiaal = faculteit(n)/fack;
    return binomiaal;
    }
    
    
    public static void newton (double binomiaal, double macht)
    
    {
    for (k = 2; k <= n; k++)
        {
        double antwoord = binomiaal(faculteit(n),k) * macht(a,k);
        newton += antwoord;
        }

    System.out.println("newton = " +newton);
    }

}

Het enige probleem is nu dat hij nog steeds bij de methodes (faculteit en macht) k berekend met een vaste waarde. Terwijl die juist elke keer verhoogd moet worden. Erg vervelend als je het gevoel hebt dat je er bijna bent, maar net dat laatste stukje waar je niet uitkomt.

[ Voor 53% gewijzigd door battler op 21-10-2008 20:10 ]

[Glorificationer426]

battler schreef op dinsdag 21 oktober 2008 @ 18:57:
Over het expliciet meegeven van argumenten bij een methode (ik hoop dat ik je goed begrijp).
Ik kan A en K meegeven, omdat die ten alle tijden zo worden aangeroepen. Maar bij B gebeurd dat niet.
Volgens mij heeft dit te maken met overloading, dat wanneer ik 3 variabelen verwacht dat ik er ook daadwerkelijk 3 moet geven. Zou jij kunnen aangeven hoe je dit zou oplossen?

Euhhh, dat is toch gewoon een kwestie van de signature van 'macht' aanpassen? Je snapt hoe je 'a' en 'k' mee kunt geven, waarom lukt het dan niet voor 'b'?

En inderdaad, waarom doubles retourneren als het resultaat altijd een int is?

[battler]

omdat de variabelen a en k altijd nodig zijn. maar b niet.
dus wanneer ik dit doe "public static double macht(int a, double k, int b)".
Dan moet ik elke keer als ik die methode aanspreek 3 waardes meegeven?

[Glorificationer426]

Waarom is 'b' niet altijd nodig dan? Je gebruikt 'm toch iedere keer bij je methode 'macht'?

[Soultaker]

Ik begrijp niet echt wat je hier mee bedoelt:

battler schreef op dinsdag 21 oktober 2008 @ 18:57:
Over het expliciet meegeven van argumenten bij een methode (ik hoop dat ik je goed begrijp).
Ik kan A en K meegeven, omdat die ten alle tijden zo worden aangeroepen. Maar bij B gebeurd dat niet.
Volgens mij heeft dit te maken met overloading, dat wanneer ik 3 variabelen verwacht dat ik er ook daadwerkelijk 3 moet geven. Zou jij kunnen aangeven hoe je dit zou oplossen?

Als ik een functie wil schrijven die a^kb^n-k uitrekent, voor willekeurige a, b, n en k, dan schrijf ik dat ongeveer zo:

Java:

public static double f(int a, int b, int n, int k)
{
    // neem aan dat 0 <= a; 0 <= b; 0 <= n; 0 <= k <= n
    return Math.pow(a, k)*Math.pow(b, n - k);
}

Los van de vraag of het zinnig is daar een aparte functie voor te schrijven, is het punt dat zo alle variabelen waar de berekening van afhangt, expliciet als argumenten meegegeven zijn. De berekening is dus niet afhankelijk van externe factoren. Dit is meestal wenselijk (maar niet altijd mogelijk; en soms ook niet wenselijk), omdat het zo eenvoudiger is om functies te combineren, omdat je alleen hoeft na te denken over de berekening die elke afzonderlijke functie uitvoert, en niet de globale toestand van het programma in je achterhoofd te houden.

Misschien moet je voordat je aan het programmeren slaat eens goed op een rijtje zetten hoe je zo'n binomium met de hand uit zou schrijven. Naar verwachting begin je dan met een for-lus waarin k loopt van 0 tot en met n.

[battler]

Bedankt voor je tip soultaker. Ik ben nu gelukkig al een stukje verder (o.a door jouw hulp).
Helaas is de code nog niet 100% kloppend).

code:

public class app
{
    //fields
    private static int a = 1;
    private static int b = 2;
    private static double n = 2;
    private static int k = 0;
    private static int ab;
    private static int cd;
    //constructor
    
    //methode
    public static void main(String[] args) 
    {
        for (k = 0; k <= n;k++)
        {
        ab += macht(a,k,b);
        cd += binomiaal(faculteit(n),k);
        }
        int alles = ab + cd;
        System.out.println("alles = "+alles);
        
        /*
    System.out.println("ab"+ ab + cd);
    System.out.println("cd"+cd);
    System.out.println("macht = "+ab);
    System.out.println("binomiaal = "+cd);
    System.out.println("a"+a);
    System.out.println("b"+b);
    System.out.println("n"+n);
    System.out.println("k"+k);
    System.out.println("faculteit"+faculteit(n));
    System.out.println("binomiaal"+binomiaal(faculteit(n),k));
    */
    }
    
    public static double macht(int a, int k, int b)
    {
    double macht = Math.pow(a, k)* Math.pow(b,n-k);
    return macht;
    }
    
    public static double faculteit(double n)
    {
    int waarde = 1;
    for (int start = 1;start <= n;start++)
        {
        waarde = waarde * start;
        }
    double faculteit = waarde;
    return faculteit;
    }

    public static double binomiaal(double faculteit,int k)
    {
    double fack = faculteit(n - k) * faculteit(k);
    double binomiaal = faculteit(n)/fack;
    return binomiaal;
    }

}

Zou jij kunnen aangeven welke dingen een "echte" programmeur anders zou doen?
Uiteraard mag iemand anders dat ook doen

[NetForce1]

Zonder het inhoudelijk over je algoritme te hebben een paar puntjes:

1. Je houd allerlei dingen static bij die je alleen in de main-methode gebruikt (of doorgeeft aan andere methoden). Het gevaar hiervan is dat je side-effects kan krijgen doordat een van de andere methoden die variabelen aanpast. Je kunt daarom het best de scope van een variabele zoveel mogelijk beperken, hier alles binnen main declareren dus.
2. de return-waarde van een methode hoeft niet dezelfde naam te hebben als de methode (het is java, geen basic / pascal)
3. zorg voor consistente en duidelijke inspringing
4. de variabelen ab en cd in de main-methode zijn overbodig, je kunt het net zo goed gelijk in een som-variabele stoppen
5. iha is het niet handig om alles in static methoden te doen, dat is nogal procedureel in plaats van object georienteerd, en dat laatste is nu juist waar java goed in is.
6. de functies macht, faculteit en binomiaal accepteren en geven een double terug, dat gaat natuurlijk nergens over, faculteiten en binomiaalcoefficienten zijn altijd natuurlijke getallen (integers).

[ Voor 24% gewijzigd door NetForce1 op 24-10-2008 01:11 . Reden: puntje over doubles en scope ]

[Verwijderd]

Dat met die doubles is inderdaad best wel belangrijk.

double d = 1;

is geen 1. Bij bepaalde berekeningen zal je erachter komen dat het ongeveer 1 is. Het wordt benaderd door een ingewikkelde methode (zoekterm: IEEE floating point), maar zal altijd een kleine afwijking hebben. Als je geen decimale getallen wilt gebruiken, dan kan je het beste integers gebruiken. Een integer "int i = 1;" is wel exact 1. Het wordt in het geheugen opgeslagen als een rij bits met 31 nullen en één 1.

[RobIII]

Verwijderd schreef op vrijdag 24 oktober 2008 @ 02:35:
Dat met die doubles is inderdaad best wel belangrijk.

double d = 1;

is geen 1. Bij bepaalde berekeningen zal je erachter komen dat het ongeveer 1 is. Het wordt benaderd door een ingewikkelde methode (zoekterm: IEEE floating point), maar zal altijd een kleine afwijking hebben. Als je geen decimale getallen wilt gebruiken, dan kan je het beste integers gebruiken. Een integer "int i = 1;" is wel exact 1. Het wordt in het geheugen opgeslagen als een rij bits met 31 nullen en één 1.

We hebben daar een hele mooie Getallen en talstelsels FAQ voor

[Verwijderd]

NetForce1 schreef op vrijdag 24 oktober 2008 @ 00:57:
iha is het niet handig om alles in static methoden te doen, dat is nogal procedureel in plaats van object georienteerd, en dat laatste is nu juist waar java goed in is.

In normale programma's zou dat het geval zijn, omdat je dan classes gebruikt. Maar ik zou hier zo gauw niet weten welke class je wilt instantiëren. Je zou de app-class kunnen doen, maar als de TS je andere tip opvolgt door alle variabelen te declareren in de main methode, dan valt er bar weinig te instantiëren.

Ik zou trouwens het programma "andersom" schrijven. Jij (TS) gebruikt je functies nu als subroutines die bepaalde taken doen, en uiteindelijk voeg je het allemaal samen in je main functie. Ik zou de functies elkaar laten aanroepen, en slechts 1 call doen vanuit je main functie. Naarmate je programma groter wordt zou je main-methode belachelijk groot worden op jouw manier.

Java:

public class App
{
    public App()
    {
        //niks te doen
    }
    
    public int newton(int a, int b, int n, int k)
    {
        return binomiaal(n, k) * macht(a, b, n, k);
    }
    
    public static void main(String[] args)
    {
        App app = new App();
        
        int a = 4;
        int b = 6;
        int n = 5;
        int k = 3;
        
        System.out.println("binomium: " + app.newton(a, b, n, k));
    }

    private int macht(int a, int b, int n, int k)
    {
        return Math.pow(a, k)* Math.pow(b,n-k);
    }
    
    private int fac(int n)
    {
        if(n <= 1)
        {
            return 1;
        }
        else
        {
            return n * fac(n - 1); // recursief kadootje
        }
    }

    private int binomiaal(int n, int k)
    {
        return fac(n) / (fac(n - k) * fac(k));
    }
}

RobIII schreef op vrijdag 24 oktober 2008 @ 02:53:
[...]

We hebben daar een hele mooie Getallen en talstelsels FAQ voor

Hoe had ik dat heilig schrift kunnen vergeten. Maar daar wordt de IEEE floating point methode ook niet uitgelegd. Als zelfs de GoT FAQ het niet uitlegt, dan weet je zeker dat het te ingewikkeld is.

[farlane]

Er staat toch echt een stukje over floats in : Programming FAQ - Getallen en talstelsels

[NetForce1]

Verwijderd schreef op vrijdag 24 oktober 2008 @ 03:36:
[...]

In normale programma's zou dat het geval zijn, omdat je dan classes gebruikt. Maar ik zou hier zo gauw niet weten welke class je wilt instantiëren. Je zou de app-class kunnen doen, maar als de TS je andere tip opvolgt door alle variabelen te declareren in de main methode, dan valt er bar weinig te instantiëren.

Klopt helemaal, daarom staat er ook iha (in het algemeen) voor. Maar dat had ik wel wat verder uit kunnen werken.

Java:

public class App
{
    // lap code
}

[...]

Je vergeet alleen de sommatie, dat is dan weer jammer

[Verwijderd]

farlane schreef op vrijdag 24 oktober 2008 @ 08:58:
Er staat toch echt een stukje over floats in : Programming FAQ - Getallen en talstelsels

Ik doelde op de uitleg van de methode, waarvoor verwezen wordt naar andere pagina's. Er staat letterlijk:
"De complete uitleg hiervan is te lang voor deze FAQ". Maar het is natuurlijk onzin dat het te ingewikkeld is. Zoals Einstein zei: "Maak alles zo simpel mogelijk, maar niet simpeler."

NetForce1 schreef op vrijdag 24 oktober 2008 @ 09:09:
[...]

Klopt helemaal, daarom staat er ook iha (in het algemeen) voor. Maar dat had ik wel wat verder uit kunnen werken.

Oh, ja, ik begreep niet wat "iha" betekende. Maar dat dus.

[...]

Je vergeet alleen de sommatie, dat is dan weer jammer

Ja, ik had me in eerste instantie gebaseerd op het eerste stuk code, en ik had op dat tijdstip geen zin meer om te kijken wat er veranderd was in de loop van het topic. De TS mag dat zelf oplossen.

[battler]

Ik heb al jullie tips geprobeerd te gebruiken.
//Alleen die van DOT niet m.b.t het alles laten berekenen in methodes en 1x aanroepen in de main methode.
De reden dat ik dit niet heb gedaan, is vanwege tijd gebrek. Ik moet nog 1 code schrijven. En ik denk dat dit al een gehele vooruitgang is met de code waarmee ik begon. Ik zal uiteraard wel alle tips meenemen met het maken van de volgende opdracht.

De code zoals hij nu is:

code:

public class app
{
    //fields
    private static int a = 1;
    private static int b = 2;
    private static int n = 2;
    
    //constructor
    
    //methode
    public static void main(String[] args) 
    {
    int k = 0;
    int newton = 0; 
    for (k = 0; k <= n;k++)
        {
        newton += macht(a,k,b) + binomiaal(faculteit(n),k);
        }
    System.out.println("newton = "+newton);
    }
    
    public static double macht(int a, int k, int b)
    {
    double macht = Math.pow(a, k) * Math.pow(b,n-k);
    return macht;
    }
    
    public static int faculteit(int n)
    {
    int waarde = 1;
    for (int start = 1;start <= n;start++)
        {
        waarde = waarde * start;
        }
    int faculteit = waarde;
    return faculteit;
    }
    
    public static int binomiaal(int faculteit,int k)
    {
    int fack = faculteit(n - k) * faculteit(k);
    int binomiaal = faculteit(n)/fack;
    return binomiaal;
    }
    
}