[Java] Delen door 0 geeft geen fout

[dejoma]

Ik heb een programma geschreven over de Gauss Jordan Eliminatie van matrices, daarbij heb ik de methods
try en catch geimplementeerd. Als er dus iets fout gaat doet hij alsnog wat ik wil in plaats van er mee stoppen.
Maar, in mijn code staan een aantal breuken. Wanneer er gedeeld wordt door 0 doet hij het gewoon nog... Hoe kan dit?

Dit is de code:

Java: GaussJordan

import java.util.Scanner;
public class clean {
    public static void main(String[] args){
        
        double a,b,c,d,e,f,g,h,i,j,k,l;
        int x=1;
        int counter=1;
        String MRX[][]={{"a","b","c","d"},{"e","f","g","h"},{"i","j","k","l"}};
    
        System.out.println("Standard matrix layout: ");
        display(MRX);
        System.out.println();
do{ 
    try{
        System.out.println("Enter the values in alfabetical order ("+counter+")");
        Scanner input = new Scanner(System.in);
    
        //Setting the values
        System.out.print("a = ");
        a = input.nextDouble();
        
        System.out.print("b = ");
        b = input.nextDouble();
        
        System.out.print("c = ");
        c  = input.nextDouble();
        
        System.out.print("d = ");
        d = input.nextDouble();
        
        System.out.print("e = ");
        e = input.nextDouble();
        
        System.out.print("f = ");
        f = input.nextDouble();
        
        System.out.print("g = ");
        g = input.nextDouble();
        
        System.out.print("h = ");
        h = input.nextDouble();
        
        System.out.print("i = ");
        i = input.nextDouble();
        
        System.out.print("j = ");
        j = input.nextDouble();
        
        System.out.print("k = ");
        k = input.nextDouble();
        
        System.out.print("l = ");
        l = input.nextDouble();
    
        //Matrix which is going to be cleared
        double MRXX[][]={{a,b,c,d},{e,f,g,h},{i,j,k,l}};
        
        
        System.out.println("Your matrix equals: ");
        display2(MRXX);
        //THE MATH PART (GAUSS ELIMINATION)
        
        b = b/a;
        c = c/a;
        d = d/a;
        a = a/a;        
                        
        f = f - (b*e);
        g = g - (c*e);
        h = h - (d*e);      //e will now equal zero, the rest will be subtracted by e times the value above
        e = e - (a*e);              //this is done last else all the other values will just be the same..
        
                            // The first column of the matrix now equals 1,0,0
        j = j - (b*i);
        k = k - (c*i);
        l = l - (d*i);
        i = i-(a*i);    
        
        g = g/f;
        h = h/f;
        f=f/f;
        
        c = c - (b*g);
        d = d - (h*b);
        b = 0;
        
        k = k - (g*j);
        l = l - (h*j);
        j = j - (f*j);
        
        l = l/k;
        k=k/k;
        
        h= h - (g*l);
        g = 0;
        d = d - (c*l);
        c = 0;
                
        System.out.println();
        double MRX2[][]={{a,b,c,d},{e,f,g,h},{i,j,k,l}};
        System.out.println("Your matrix after Gauss Jordan elimination: ");
        display2(MRX2);
        x++;}
    catch(Exception q){
        System.out.println("You typed number.decimal, try using a comma instead.");
        counter++;
    }}while(x==1);

    }
    public static void display(String x[][]){
        for(int row=0;row<x.length;row++){
            for(int column=0;column<x[row].length;column++){
            System.out.print(x[row][column]+"\t");  
            }
            System.out.println();
            
}}
        public static void display2(double y[][]){
            for(int row=0;row<y.length;row++){
                for(int column=0;column<y[row].length;column++){
                System.out.print(y[row][column]+"\t");  
                }
                System.out.println();
                
    }
}
}

Anyone?
Ik ben nu ongeveer een maandje bezig met Java, ik leer het via YouTube: thenewboston/ , hij heeft
ongeveer 150 tutorials en heb er zo'n 100 gevolgd nu, vind het best leuk

Bij voorbaat dank

[pedorus]

Dat is niet alleen in java zo, maar in elke taal met doubles. Delen door 0 levert +/- oneindig of Not a Number op, en niet een exception waardoor de code stopt. De code gaat dus gewoon door (met mogelijk incorrecte resultaten zoals -Inf of NaN).

Aan de code valt ook duidelijk te zien dat je nog aan het leren bent (witruimtegebruik, repeterende code, onbekendheid met debuggen en datatypes, generieke exception-handling), dus succes met leren

[NMe]

Sowieso moet je defensief programmeren zodat je niet door 0 probeert te delen in plaats van het als uitzondering afhandelen. Door 0 delen is namelijk meestal mogelijk met valide input, en exceptions misbruiken om valide input te invalideren is zeker voor een beginner meestal een slecht plan.

[Creepy]

Ik heb overigens je topic titel iets beschrijvender gemaakt. "Java vraagje" kan echt vanalles zijn

[steveman]

En let ook op met Doubles, 0 is meestal niet zomaar 0, maar iets als 0.0000001. Waardoor je dus effectief ook niet door 0 deelt.

Hele volkstammen zijn hier al mee op hun plaat gegaan door dingen te doen als "doubleWaarde == 2.0"
Vandaar dat je dus met een epsilon waarde moet werken. (Of Doubles moet omzeilen ...)

Helaes kan ik een link hierover niet terugvinden, met als conclusie dat er een hoop wetenschappelijk werk regelrecht de prullenmand in kan. But I digress.

[Herko_ter_Horst]

De link: http://docs.oracle.com/cd...06-3568/ncg_goldberg.html

[dejoma]

pedorus schreef op woensdag 10 april 2013 @ 13:13:
Dat is niet alleen in java zo, maar in elke taal met doubles. Delen door 0 levert +/- oneindig of Not a Number op, en niet een exception waardoor de code stopt. De code gaat dus gewoon door (met mogelijk incorrecte resultaten zoals -Inf of NaN).

Aan de code valt ook duidelijk te zien dat je nog aan het leren bent (witruimtegebruik, repeterende code, onbekendheid met debuggen en datatypes, generieke exception-handling), dus succes met leren

Ik vind dat ik het nog niet slecht doe voor iemand die zo kort bezig is

[dejoma]

NMe schreef op woensdag 10 april 2013 @ 13:48:
Sowieso moet je defensief programmeren zodat je niet door 0 probeert te delen in plaats van het als uitzondering afhandelen. Door 0 delen is namelijk meestal mogelijk met valide input, en exceptions misbruiken om valide input te invalideren is zeker voor een beginner meestal een slecht plan.

Ja maar als een matrix bijvoorbeeld oneindig veel oplossing heeft, dan is het logisch dat welk script dan ook
het niet kan oplossen, dus dan zou hij juist als hij door nul deelt moeten zeggen van onoplosbaar o.i.d.

Maar het komt er dus een beetje op neer dat ik of bepaalde methods nog niet geleerd heb of dat je het veel
uitgebreider moet doen om alle exceptions te omzeilen?

[NMe]

josephusmarinus schreef op donderdag 11 april 2013 @ 13:51:
[...]

Ja maar als een matrix bijvoorbeeld oneindig veel oplossing heeft, dan is het logisch dat welk script dan ook
het niet kan oplossen, dus dan zou hij juist als hij door nul deelt moeten zeggen van onoplosbaar o.i.d.

En dat kun je niet doen met een simpele if (variabele > 0)-check?

Maar het komt er dus een beetje op neer dat ik of bepaalde methods nog niet geleerd heb of dat je het veel uitgebreider moet doen om alle exceptions te omzeilen?

Je hebt bepaalde technieken niet onder de knie. Methods zou ik me minder druk om maken op dit moment. Om te beginnen het hierboven genoemde DRY, maar ook op het gebied van arrays en/of matrices heb je zo te zien nog wat te leren. Functienamen met nummering zijn meestal ook een slecht idee.

[ Voor 3% gewijzigd door NMe op 11-04-2013 14:04 ]

[Kwistnix]

NMe schreef op donderdag 11 april 2013 @ 14:04:

Methods zou ik me minder druk om maken op dit moment. Om te beginnen het hierboven genoemde DRY...

Huh, maar hoe ga je DRY verwezenlijken zonder gebruik van methodes dan?

[NMe]

FallenAngel666 schreef op donderdag 11 april 2013 @ 14:23:
[...]

Huh, maar hoe ga je DRY verwezenlijken zonder gebruik van methodes dan?

Ik bedoelde het leren van standaardmethods.

[roy-t]

steveman schreef op woensdag 10 april 2013 @ 14:29:
En let ook op met Doubles, 0 is meestal niet zomaar 0, maar iets als 0.0000001. Waardoor je dus effectief ook niet door 0 deelt.

Hele volkstammen zijn hier al mee op hun plaat gegaan door dingen te doen als "doubleWaarde == 2.0"
Vandaar dat je dus met een epsilon waarde moet werken. (Of Doubles moet omzeilen ...)

Helaes kan ik een link hierover niet terugvinden, met als conclusie dat er een hoop wetenschappelijk werk regelrecht de prullenmand in kan. But I digress.

Je hebt gelijk dat floating point variables (waaronder doubles) niet elke waarde kunnen representeren, maar 0.0 natuurlijk juist wel (in alle schema's die ik ken iig) .

[windwarrior]

Om even verder te gaan op het vernetten van je code

Het aangegeven DRY principe kan je bijvoorbeeld toepassen door het lezen van input in een methode te stoppen

Java:

public double readDoubleFromScanner(Scanner scan, String msg){
    System.out.println(msg);
    return scan.nextDouble();
}

maar zoals je gemerkt hebt kan dit een exception throwen, nu zijn er twee opties, het vangen van de exceptie, of het voorkomen ervan. Mijn persoonlijke voorkeur gaat naar het voorkomen ervan. Scanner kan gelukkig checken of de volgende token een double is.

Java:

public double readDoubleFromScanner(Scanner scan, String msg){
    System.out.println(msg);
    while(!scan.hasNextDouble()){
        scan.next(); // blijkbaar was de volgende token niet een nummer
        System.out.println(msg); // Blijf vooral zeuren bij de gebruiker voor een nummer, vervelende gebruikers ook altijd.
    }
    // op dit punt weten we dus dat het volgende token een double is, anders zou de while niet getermineerd zijn
    return scanner.nextDouble(); // dit kan daarmee geen exceptie meer gooien.
}

En voor de rest, probeer je implementatie van je algoritme eens te vatten in een methode (of een set methoden), en probeer eens te kijken naar het generiek maken van je input. Ik ken je algoritme niet, maar misschien werkt het ook wel op 5x4 matrices, of n+1xn matrices? Dan is een methode die alle cases omvat natuurlijk het mooist.

//Just my 2 cents, gewoon om je wat verder te helpen

[dejoma]

windwarrior schreef op donderdag 11 april 2013 @ 20:29:
En voor de rest, probeer je implementatie van je algoritme eens te vatten in een methode (of een set methoden), en probeer eens te kijken naar het generiek maken van je input.

Was net aangekomen bij de tutorial "Generic methods", dus moet nog ff kijken hoe dat zit ^^

[ Voor 11% gewijzigd door dejoma op 12-04-2013 13:07 ]

[dejoma]

Huh wtf? ik heb dus die code van jou geprobeerd (van windwarrior) maar ik heb geen idee hoe ik het aan de praat krijg met die readDoubleFromScanner methode..

beetje hulp pls?

(P.S. bedankt voor alle reacties^^)

[windwarrior]

Java:

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        
        double a = readDoubleFromScanner(scan, "Variabele a:");
        
    }
    
    public static double readDoubleFromScanner(Scanner scan, String msg){ 
        System.out.println(msg); 
        while(!scan.hasNextDouble()){ 
            scan.next(); // blijkbaar was de volgende token niet een nummer 
            System.out.println(msg); // Blijf vooral zeuren bij de gebruiker voor een nummer, vervelende gebruikers ook altijd. 
        } 
        // op dit punt weten we dus dat het volgende token een double is, anders zou de while niet getermineerd zijn 
        return scan.nextDouble(); // dit kan daarmee geen exceptie meer gooien. 
    }

Ik had overigens ook een klein foutje gemaakt, bij de return staat "scanner.nextDouble", maar mijn Scanner heet "scan"

[NMe]

josephusmarinus schreef op vrijdag 12 april 2013 @ 13:05:
[...]

Was net aangekomen bij de tutorial "Generic methods", dus moet nog ff kijken hoe dat zit ^^

Het "generiek maken van je input" heeft niet per se iets te maken met generic methods en ik denk dat het voor jou nog wat te vroeg is om je in generics te verdiepen.

[dejoma]

windwarrior schreef op vrijdag 12 april 2013 @ 13:40:
Ik had overigens ook een klein foutje gemaakt, bij de return staat "scanner.nextDouble", maar mijn Scanner heet "scan"

Ja dat zag ik ^^ maar nu heb je maar 1 variabele toch is het misschien slim om al die variabelen te dumpen in een array?

Ik dacht aan dit maar krijg de errors niet weg.... (al een uur zitten pingelen ^^)

EDIT: Yay! heb het werkende (zie comment hier onder)

[ Voor 53% gewijzigd door dejoma op 13-04-2013 10:50 ]

[dejoma]

NMe schreef op vrijdag 12 april 2013 @ 13:47:
[...]

Het "generiek maken van je input" heeft niet per se iets te maken met generic methods en ik denk dat het voor jou nog wat te vroeg is om je in generics te verdiepen.

ik volg gewoon die filmpjes ik weet anders niet wat ik moet doen om verder te komen ^^
Misschien nog tips waar ik aan moet werken/hoe ik dat doe (bijvoorbeeld boeken downloaden o.i.d. ?)
Thanks!

[dejoma]

Holy fak het werkt!

Java:

import java.util.*;
public class apples{
public static void main(String[] args) { 
    double[] vArray = new double[12];
    String[] sArray = {"a: ","b: ","c: ","d: ","e: ","f: ","g: ","h: ","i: ","j: ","k: ","l: ","Your array equals:"};
    int counter = 0;
        Scanner scan = new Scanner(System.in); 
         String msg = "Kleautzak voer het eens goed in!";
      while(counter<=11){
         vArray[counter] = readDoubleFromScanner(scan, "Variabele ", counter, sArray); 
         counter++;
      }
      System.out.println("And we're done!");
    } 
     
    public static double readDoubleFromScanner(Scanner scan, String msg, int counter, String[] sArray){
        System.out.println(msg + sArray[counter]);  
        while(!scan.hasNextDouble()){  
            System.out.println("Kleautzak voer het eens goed in!");
            scan.next(); // blijkbaar was de volgende token niet een nummer  
            System.out.println(msg); // Blijf vooral zeuren bij de gebruiker voor een nummer, vervelende gebruikers ook altijd.  
        }  
        // op dit punt weten we dus dat het volgende token een double is, anders zou de while niet getermineerd zijn  
               return scan.nextDouble(); // dit kan daarmee geen exceptie meer gooien.       
    }
}

Bedankt!!!!

[boreus]

Volgens mij ben je het inderdaad best snel aan het leren. (Hoewel ik natuurlijk geen idee heb hoe lang je hier over gedaan hebt, je programma gaat steeds een stap de goede kant op lijkt het.)

Wat ik nog aan je laatste programma zou doen:

Java:

// vArray initialisatie na de sArray met dezelfde grootte als sArray:
double[] vArray = new double[sArray.length];

// Deze regel in je main method doet niets:
// String msg = "Kleautzak voer het eens goed in!";

// In plaats van int counter = 0; do { (...); counter++; } while (counter < ...);
for( int counter = 0; counter < sArray.length; ++counter ) { ... }

[dejoma]

@Boreus, als je nog een kwartiertje wacht show ik je de "laatste versie" , ben nu bezig met
een universele method voor alle soorten dus ipv double[][] T[][] , maar krijg wat errors

Java:

import java.util.*;
public class apples{
public static void main(String[] args) { 
    
    double[] vArray = new double[11];
    double[][] xArray = {{vArray[0],vArray[1],vArray[2],vArray[3]},{vArray[4],vArray[5],vArray[6],vArray[7]},{vArray[8],vArray[9],vArray[10],vArray[11]}};
    String[] sArray = {"a: ","b: ","c: ","d: ","e: ","f: ","g: ","h: ","i: ","j: ","k: ","l: ","Your array equals:"};
    int counter = 0;
    Scanner scan = new Scanner(System.in); 
    String msg = "Kleautzak voer het eens goed in!";
    
    while(counter<=11){
         vArray[counter] = readDoubleFromScanner(scan, "Variabele ", counter, sArray); 
         counter++;
      }
      System.out.println("And we're done!");
      System.out.println(sArray[11]);
      display(xArray);
} 
    public static double readDoubleFromScanner(Scanner scan, String msg, int counter, String[] sArray){
        System.out.println(msg + sArray[counter]);  
        while(!scan.hasNextDouble()){  
            System.out.println("Kleautzak voer het eens goed in!");
            scan.next();  
            System.out.println(msg);
        }  
                  return scan.nextDouble();     
    }
    
  public static <T> void display(T[][] x){
        for(int row=0;row<x.length;row++){
            for(int column=0;column<x[row].length;column++){
            System.out.print(x[row][column]+"\t");  
            }
            System.out.println();
}}}

En dan krijg ik de errors bij display(xArray),
the method display of the type apples is not applicable for the arguments double[][] .. hmm?

[ Voor 5% gewijzigd door dejoma op 14-04-2013 13:01 ]

[Raynman]

Je kunt de primitieve types niet gebruiken met generics. Je moet subtypes van Object hebben, daarvoor kun je Double (met hoofdletter) gebruiken. Er is wel iets van automatische (un)boxing (omzetting double<->Double), maar het is even geleden dat ik met Java gespeeld heb, dus dat mag je zelf opzoeken

[NMe]

Modbreak:

josephusmarinus, als je iets toe te voegen hebt aan je bericht en je bent zelf de laatste poster, kun je dan asjeblieft gewoon je bericht wijzigen in plaats van een nieuw bericht posten? Dit leest vervelend en onnodig schoppen van je eigen topics stellen we niet zo op prijs.

[dejoma]

Raynman schreef op zaterdag 13 april 2013 @ 13:03:
Je kunt de primitieve types niet gebruiken met generics. Je moet subtypes van Object hebben, daarvoor kun je Double (met hoofdletter) gebruiken. Er is wel iets van automatische (un)boxing (omzetting double<->Double), maar het is even geleden dat ik met Java gespeeld heb, dus dat mag je zelf opzoeken

Inderdaad, een simpele hooftletter 'D' i.p.v. de kleine letter 'd' op regel 15 lost het hele probleem op!
Primitieve types en subtypes, wat zijn dat uberhaupt? Ik wist alleen dat je int had, en integer hetzelfde was..

[windwarrior]

Dat is dus niet helemaal waar, een "int" is een primitief type en wordt als zodanig opgeslagen (bijvoorbeeld een 32 bits int, wordt ook daadwerkelijk als 32 bits int opgeslagen), "Integer" daarentegen is een Object en bevat ook methoden, een Integer is dus een schil om het int primitieve type heen

Wat Raynman bedoeld is dat "Integer i = 5;" valide java is, terwijl hier strict gezien een int (dus het primitieve type) aan een referentie naar een object toegewezen wordt, dat wordt boxing genoemd.

[Herko_ter_Horst]

windwarrior schreef op zaterdag 13 april 2013 @ 16:28:
Dat is dus niet helemaal waar, een "int" is een primitief type en wordt als zodanig opgeslagen (bijvoorbeeld een 32 bits int, wordt ook daadwerkelijk als 32 bits int opgeslagen), "Integer" daarentegen is een Object en bevat ook methoden, een Integer is dus een schil om het int primitieve type heen

Wat Raynman bedoeld is dat "Integer i = 5;" valide java is, terwijl hier strict gezien een int (dus het primitieve type) aan een referentie naar een object toegewezen wordt, dat wordt boxing genoemd.

Autoboxing (en -unboxing) zelfs.

Het idee is dat de Java runtime primitive types automatisch "in- en uitpakt" in hun corresponderende object (dus int <=> Integer, float <=> Float, boolean <=> Boolean, etc.), voor zover dat kan. Op die manier lijkt het net alsof je primitive types in collections kunt stoppen, of bijv. een int literal value kunt toewijzen aan een Integer reference variabele. Maar zoals de documentatie zegt:

An Integer is not a substitute for an int; autoboxing and unboxing blur the distinction between primitive types and reference types, but they do not eliminate it.

[ Voor 4% gewijzigd door Herko_ter_Horst op 13-04-2013 17:11 ]

[dejoma]

Hey jongens rustig aan! Door de laatste 2 comments begrijp ik er niets meer van haha,
ik heb nu een bijna laatste versie. Ik wil nu nog wat aanpassingen maken met een if statement,
waarin staat: als x = NaN dan moet hij iets anders doen maar hoe krijg je dit voor elkaar?

[ Voor 53% gewijzigd door dejoma op 14-04-2013 11:49 ]

[Herko_ter_Horst]

Ok, wat meer uitleg m.b.t. primitive types en reference types en autoboxing.

Primitive types: eigenlijk alles wat geen object referentie is.
"Primitive" slaat op het feit dat waardes van zo'n type niet verder op te delen zijn in kleinere stukken, m.a.w. iets als een int heeft geen verdere interne structuur. Je kunt er dus ook geen methodes op aanroepen of iets dergelijks.

Er is een vaste lijst van primitive types in Java. Om ze makkelijk te kunnen onderscheiden van reference types, worden ze met kleine letters geschreven:

Java:

byte, short, int, long, float, double, boolean, char

Reference types: verwijzingen naar een object van een bepaald type (class).
Om gebruik te kunnen maken van een object, heb je een referentie ernaar nodig. Een variabele van het type String bevat dus niet de waarde van die String, maar een referentie naar een object van het type String. Een variabele van het type MijnClass, bevat geen object van het type MijnClass, maar een referentie naar zo'n object. Omdat je zelf classes kunt definiëren, is er een oneindig grote verzameling reference types.

Type mismatch: types zijn niet compatible
Omdat Java sterk-getypeerd is, is het in principe niet mogelijk om een waarde van het ene type toe te kennen aan een variabele van een ander type. Dat geldt voor primitive types:

Java:

int count = 0.0d; // kan niet: "Type mismatch, cannot convert from double to int"

en ook voor reference types:

Java:

String name = new MyClass(); // kan niet: "Type mismatch, cannot convert from MyClass to String"

Eigenlijk kan dit dus ook niet:

Java:

Integer count = 0; // huh? Dit werkt tóch?

In oudere versies van Java kon dit inderdaad niet.

"Wrapper" classes: de object-georienteerde manier om met primitive types om te gaan.
Sommige standaardclasses in Java kunnen niet omgaan met primitive types. Bijvoorbeeld de collections in het java.util package (List, Map, Set e.d.) kunnen slechts omgaan met reference types, m.a.w. je kunt er alleen objecten (eigenlijk: object referenties) in opslaan. Voor dat soort situaties zijn er zogenaamde "wrapper" classes gemaakt die corresponderen met elk van de primitive types:

Java:

Byte, Short, Integer, Long, Float, Double, Boolean, Character

In oudere versies van Java moest de programmeur zelf de conversie doen van bijvoorbeeld Integer naar int en vice-versa (dit werkt overigens nog steeds en is soms ook nog echt nodig):

Java:

int count = 0; // een int primitive
Integer countObject = Integer.valueOf(count); // "conversie" naar een Integer reference type
int count2 = countObject.intValue(); // terug van reference type naar primitive type

Autoboxing en -unboxing: automatisch "in- en uitpakken" van primitives in wrapper classes.
Om het voor de programmeur makkelijker te maken met primitive types te werken i.c.m. classes die reference types verwachten, is in Java 5 autoboxing geïntroduceerd. Hiermee vindt bovenstaande conversie automatisch plaats wanneer dat kan. Daardoor werkt deze code nu wel:

Java:

Integer countObject = 0; // een int primitive waarde toekennen aan een variabele van het type Integer
int count = countObject; // een Integer reference toekennen aan een variabele van het type int

Hopelijk helpt dit.

[Herko_ter_Horst]

josephusmarinus schreef op zondag 14 april 2013 @ 11:19:
Hey jongens rustig aan! Door de laatste 2 comments begrijp ik er niets meer van haha,
ik heb nu een bijna laatste versie. Ik wil nu nog wat aanpassingen maken met een if statement,
waarin staat: als x = NaN dan moet hij iets anders doen maar hoe krijg je dit voor elkaar?

M.b.t. je vraag: ik zou niet wachten tot er "NaN" uitkomt, maar voorkomen dat je NaN krijgt door de input te checken.

Oh en als je code post, gebruik dan even [code=java] om syntax-highlighting te krijgen, maakt het wat makkelijker leesbaar.

[ Voor 11% gewijzigd door Herko_ter_Horst op 14-04-2013 12:43 ]

[dejoma]

@Herko_ter_Horst
Bedankt voor je reacties, het heeft heel erg geholpen!