3. Wie breit sollte Quellcode sein?

Wie breit sollte Quellcode sein?

  • ?

    die frage ist doch wieso sollte man 80 zeichen verwenden, wenn man bei 1024 schon 120 schreiben kann ohne horizontal scrollenzu müssen?

    Hängt doch von der IDE ab. Ich kann auch links oder rechts ne fette Klassen-Übersicht haben. Oder ne größere Schriftgröße. Ich komm bei 1024 nicht über 80 raus. Hab zwar 1280, aber 80 sind wahrscheinlich ein gutes Maß. Bei der Süddeutschen schreiben sie auch nicht über die 1,5m Breite sondern machen Spalten. Ist manchmal einfach lesbarer, wenn man sein Auge nicht von ganz links nach ganz rechts rollen muss.

    0
  • V

    Optimizer schrieb:

    Und immer wenn ich Platz-Probleme hab, kann ich bestimmt irgendwas noch schöner schreiben.

    das gefällt mir 🙂

    0
  • V

    Gerard schrieb:

    man kann ja die funktion-sollte-nicht-über-einen-bildschirm-gehen-regel gegen eine funktion-sollte-nicht-über-1/3-des-bildschirm-gehen anpassen

    ein if sollte nicht mehr als ein && oder || haben. wein while sollte gar keins haben. for sollte nur die laufvariable behandlen und nur innen anhand der daten break oder continue machen, falls das nötig ist. funktionen sollten nicht 5 parameter brauchen. und schwupps, ist der code schmal. oder?

    0
  • ?

    wenn man vernünftige variablennamen nimmt ist es schwer mit 80 zeichen auszukommen.

    0
  • V

    nope. schrieb:

    wenn man vernünftige variablennamen nimmt ist es schwer mit 80 zeichen auszukommen.

    eigentlich fürchte ich mich nicht vor langen bezeichnern.
    wenn man was langes auszudrücken hat damit, muss der name auch lang sein.

    bool isPrime(u32 p);
u32 nextPrime(u32 last);
u32 nextPrimeTwin(u32 last);

////////////////////////////////////////////////////////////////////////////////
//Ab hier privat

inline bool isPrimeCheckBelow32(u32 p)
{//bei p<=6 einfach nachschauen. 
	//Das Bitmuster ersetzt ein ArrayOfBool.
	// 3         2         1         0
	//10987654321098765432109876543210
	//10100000100010100010100010101100
	return getBit(0xa08a28ac,p);//Nur die Bits 2,3,5 sind gesetzt.
};

inline bool isPrimeCheckFactorsBelow6(u32 p)
{//Teiler 2,3 und 5 mit einer Division testen
	return getBit(0x208A2882,p%30);//Nur die Bits 1,7,11... sind gesetzt.
};

inline bool isPrime(u32 p)
{
	bool isPrimeCheckFactorsAbove5(u32 p);
	if(p<32) return isPrimeCheckBelow32(p);
	if(!isPrimeCheckFactorsBelow6(p)) return false;
	return isPrimeCheckFactorsAbove5(p);
};

u32 powMod(u32 base,u32 exp,u32 modul)
{//rechnet 'base hoch exp mod modul'
	u32 a1=base,z1=exp,x=1,m=modul;
	while(z1!=0)
	{
		while((z1%2)==0)
		{
			z1/=2;
			a1=mulMod(a1,a1,m);
		};
		--z1;
		x=mulMod(x,a1,m);
	};
	return x;
}

bool isSPRP(u32 n,u32 a)
{
// Zitat: "One way to make the Fermat probable primality test more 
//	accurate is to write n-1=2sd where d is odd and s is nonnegative. 
//	Then n is a strong probable-prime base a (an a-SPRP) if either 
//	ad = 1 (mod n) or (ad)2r = -1 (mod n) for some nonnegative r 
//	less than s."
//	Quelle: http://www.utm.edu/research/primes/glossary/StrongPRP.html 
//	
//	Zitat: "Millers Test: Assume the generalized Riemann hypothesis 
//	is true. If n is an a-SPRP for all integers a with 
//	1 < a < 2(log n)2, then n is prime.
//	Quelle: http://www.utm.edu/research/primes/glossary/MillersTest.html
	u32 o=n-1;
	u32 e=findFirstBitTrue(o);
	o>>=e;
	u32 x=powMod(a,o,n);
	if(x==1) return true;
	if(x==n-1) return true;
	for(u32 i=0;i<e;++i)
	{
		x=mulMod(x,x,n);
		if(x==n-1) return true;
	};
	return false;
}

bool isPrimeCheckFactorsAbove5BySPRPCheck(u32 p)
{
// If n < 4,759,123,141 is a 2, 7, and 61-SPRP, then n is prime.
//	Quelle: http://www.utm.edu/research/primes/glossary/StrongPRP.html
//
//	Diese drei Tests reichen also, um alle Zahlen im Bereich bis 
//	2^32 zu testen. Besser sind die folgenden Zahlen, weil bis 
//	n<45559729 nur zwei Tests ben®tigt werden. 
//	Die Zahlen habe ich mit einem eigens daf¬r geschriebenen Programm 
//	gesucht. 
	if(!isSPRP(p,7252)) return false;//die 7252 deckt ab hier den gr®+ten Bereich Fehlerfrei ab
	if(p<13747) return true;//bis p<13747 ist das Ergebnis sicher
	if(!isSPRP(p,1607438)) return false;//die 1607438 deckt ab hier den gr®+ten Bereich Fehlerfrei ab
	if(p<45559729) return true;//bis p<45559729 ist das Ergebnis sicher
	if(!isSPRP(p,9786)) return false;//die 9786 deckt den Rest bis 2^32 ab
	return true;
}

namespace
{
	u32 primes[]={0,7,7*7,11,11*11,13,13*13,17,17*17,19,19*19,23,23*23,29,29*29,31,u32(-1)};
}

bool isPrimeCheckFactorsAbove5(u32 p)
{
	{//Zuerst die kleinen Teiler checken
		u32 *t=primes;
		do
		{
			if(p%*++t==0) return false;//teilt, also keine Primzahl
		}
		while(*++t<=p);
		if(*t!=-1) return true;
	}
	return isPrimeCheckFactorsAbove5BySPRPCheck(p);
};

//Zitat: "Rather than divide by just the primes, it is sometimes 
//more practical to divide by 2, 3 and 5; then by all the numbers 
//congruent to 1, 7, 11, 13, 17, 19, 23, and 29 modulo 30--again 
//stopping when you reach the square root. This type of factorization 
//is sometimes called wheel factorization. Look in most any elementary 
//text on number theory for information about these tests. 
//Quelle: http://www.utm.edu/research/primes/prove/prove2.html

//Die Idee, da+ Primzahlen-Kandidaten p nur dann ¬berhaupt als 
//Primzahlen in Frage kommen, wenn p mod 30 nicht durch 2,3,5 
//teilbar ist, wird in den folgenden Verfahren ®fters zur Anwendung 
//kommen. Bitte behalten Sie diesen Satz stehts im Ged║chtnis!

//Position der nºchsten Primzahl
u32 firstPrimeNext[11]={2,2,3,5,5,7,7,11,11,11,11};

//Offset zur n║chstm®glichen Primzahlenposition
u32 diffPrime[30]={1,6,5,4,3,2,1,4,3,2,1,2,1,4,3,2,1,2,1,4,3,2,1,6,5,4,3,2,1,2};
//Selber Offset zyklisch in Z30 erspart: if(m>30)m-=30
//Zweck: Sprªnge sind auf modernen Prozessoren zu teuer.
u32 diffPrimeM[30]={1,6,5,4,3,2,1,4,3,2,1,2,1,4,3,2,1,2,1,4,3,2,1,6,5,4,3,2,1,u32(2-30)};

u32 nextPrime(u32 last)
{
	if(last<11) return firstPrimeNext[last];
	u32 p=last;
	u32 mp=p%30;
	do
	{
		p+=diffPrime[mp];
		mp+=diffPrimeM[mp];
	}while(!isPrimeCheckFactorsAbove5(p));
	return p;
};

//Offset zur nºchstm©glichen Primzahlenzwillings-Position
u32 diffPrimeTwin[30]={11,10,9,8,7,6,5,4,3,2,1,6,5,4,3,2,1,12,11,10,9,8,7,6,5,4,3,2,1,12};
//Selber Offset zyklisch in Z30 erspart: if(m>30)m-=30
//Zweck: Sprªnge sind auf modernen Prozessoren zu teuer.
u32 diffPrimeTwinM[30]={11,10,9,8,7,6,5,4,3,2,1,6,5,4,3,2,1,12,11,10,9,8,7,6,5,4,3,2,1,u32(12-30)};
//Position des n║chsten Primzahlenzwillings
u32 firstPrimeNextTwin[11]={3,3,3,5,5,11,11,11,11,11,11};

u32 nextPrimeTwin(u32 last)
{
	if(last<11)
		return firstPrimeNextTwin[last];
	u32 p=last;
	u32 mp=p%30;
	do
	{
		p+=diffPrimeTwin[mp];
		mp+=diffPrimeTwinM[mp];
	}while(!isPrimeCheckFactorsAbove5(p)||!isPrimeCheckFactorsAbove5(p+2));
	return p;
}

    naja, hab die 80 zeichen überschritten bei

    if(!isSPRP(p,7252)) return false;//die 7252 deckt ab hier den gr®+ten Bereich Fehlerfrei ab

    aber ist nicht so tragisch, der code blieb ja einfach und es war nur ein langweiliger kommentar.

    bei der tabelle

    u32 primes[]={0,7,7*7,11,11*11,13,13*13,17,17*17,19,19*19,23,23*23,29,29*29,31,u32(-1)};

    und lang wurde es bei

    }while(!isPrimeCheckFactorsAbove5(p)||!isPrimeCheckFactorsAbove5(p+2));

    zeig mir am besten, wo es unumgänglich ist, dauernd über 80 zechen zu gehen, weil du lange bezeichner verwendest. so ohne beispiel halte ich deine aussage für nicht so glaubwürdig.

    0
  • D

    Danke erstmal für die ganazen Antworten.

    volkard schrieb:

    Ich komme zwar meistens selber nicht auf 80 Zeichen, aber ein längeres if-Konstrukt o. ä. überschreitet das dann doch manchmal - es aufzutrennen wirkt unschön.

    glaub ich net.

    Dass das if-Konstrukt so lang wird oder dass es unschön wirkt es aufzutrennen?

    Aus meinem aktuellen Übungsprojeket:

    if ((Value > BestMoveValue) || ((Value == BestMoveValue) && (rand() > RAND_MAX / 2)))
        {
            BestMove = i;
            BestMoveValue = Value;
        }

    Natürlich kann man das jetzt vor/nach dem OR sinnvoll auftrennen, aber IMHO sieht es dann irgendwie hässlich aus. Ich habe meinen Editor jetzt auf 120 Zeichen umgestellt, da passt das dann auch mit Einrückung - außerdem ist für die Kommentare mehr platz ;-).

    Vielleicht ist es auch eine von diesen Wenn-man-Probleme-damit-hat-sollte-man-seinen-Code-überdenken-Sachen, von denen ich hier in der kurzen Zeit schon ein paar gesehen habe...

    EDIT: *Hand-vor-den-Kopf-Schlag* Jetzt habe ich doch tatsächlich die komplette zweite Seite des Threads übersehen...

    0
  • ?

    volkart du hast ja end die scheiss variablen namen.

    0
  • B

    was spricht dagegen auch während einer if-anweisung zeilenumbrüche zu machen?

    if(field[x+drc[i][0]*distance][y+drc[i][1]*distance] == BISHOP ||
   field[x+drc[i][0]*distance][y+drc[i][1]*distance] == QUEEN)
  return true;

    da seh ich keine möglichkeit es zu verkürzen.
    oder nehmen wir:

    if(!isThreatened(4, 0, whiteMove) &&
   !isThreatened(5, 0, whiteMove) &&
   !isThreatened(6, 0, whiteMove))

    gut da könnt ich vielleicht noch eine zusätzliche funktion schreiben

    bool checkCastling(bool whiteMove)
{
  return (!isThreatened(4, 0, whiteMove) &&
          !isThreatened(5, 0, whiteMove) &&
          !isThreatened(6, 0, whiteMove));
}

//und dann
if(checkCastling(whiteMove))

    aber ist das denn sinnvoll? ich brauchs nur einmal.

    wichtig ist nur das man nicht horizontal scrollen muss. und damit andere die den code lesen auch nicht horizontal scrollen müssen sollte man sich imo an die 80 zeichen halten.

    0
  • ?

    Ja, ist auch sinnvoll, wenn du es nur einmal brauchst. Zeilenumbrüche mach ich auch manchmal in nem if. Aber wenns zu wild wird, dann lieber ne Funktion.

    da seh ich keine möglichkeit es zu verkürzen.

    In diesem Fall sollte man IMHO den Wert von field[x+drc[i][0]*distance][y+drc[i][1]*distance] cachen. Wenn ich das if lese interessiert mich nicht, welches Feld ich da betrachte, sondern mich interessiert, dass hier auf Bishop und Queen getestet wird.

    0
  • V
     

    if((Value>BestMoveValue)||((Value==BestMoveValue)&&(rand()>RAND_MAX/2))){
	BestMove = i;
	BestMoveValue = Value;
}

//mal alternativen überlegen

for(;;){
	if(Value<BestMoveValue)
		break;
	if(Value==BestMoveValue)&&(rand()>RAND_MAX/2)
		break;
	BestMove = i;
	BestMoveValue = Value;
	break;
}

//nee, sindt nicht ideal aus. 

inline bool fiftyFifty(){
	return rand()%2;
}

if((Value>BestMoveValue)||((Value==BestMoveValue)&&fiftyFifty())){
	BestMove = i;
	BestMoveValue = Value;
}

//besser. 

if(Value+VIEL*fiftyFifty()>bestMoveValue){
	BestMove = i;
	BestMoveValue = Value;
}

//versteht das noch einer?

if(Value+(rand()&1024)>bestMoveValue){
	BestMove = i;
	BestMoveValue = Value;
}

//langsamer und unverständlicher als die erste version. 
//langsamer, weil rand() immer aufgerufen wird.

//also nochmal eine von oben kopieren

inline bool better(int MoveA,int MoveB){
	if(MoveA>MoveB) return true;
	if(MobeA<MoveB) return false;
	return fiftyFifty();
}

if(better(Value,BestMoveValue)){
	BestMove = i;
	BestMoveValue = Value;
}

//sehe keinenb guten trick. und vermutlich auch keinen, wenn ich die ganze 
//schleife sehen dürfte.
    0
  • V

    borg schrieb:

    was spricht dagegen auch während einer if-anweisung zeilenumbrüche zu machen?

    nix.

    if(field[x+drc[i][0]*distance][y+drc[i][1]*distance] == BISHOP ||
   field[x+drc[i][0]*distance][y+drc[i][1]*distance] == QUEEN)
  return true;

    da seh ich keine möglichkeit es zu verkürzen.

    siehe Optimizer

    Piece const& piece=field[x+drc[i][0]*distance][y+drc[i][1]*distance];
if(piece == BISHOP || piece== QUEEN)
  return true;

    aber sind BISHOP und QUEEN enums?

    PAWN=1
    ROOK=2
    HORSE=4
    BISHOP=8
    QUEEN=ROOK+BISHOP
    KING=16
    if(piece & BISHOP)
    return true;

    //und dann
if(checkCastling(whiteMove))

    aber ist das denn sinnvoll? ich brauchs nur einmal.

    ist sinnvoll. dann kannste den haupt-code besser lesen.

    <edit=kingruedi>Formatierungsfehler gefixt</edit>

    0
  • P

    Es ist schön und gut wenn man einen breiten Monitor hat, der viele Zeichen lesbar darstellen kann, aber oft will man nicht nur eine Datei offen haben. Ebenso ist es beim Vergleichen zweier Dateien via kompare, besser, wenn die beiden Zeilen ganz sichtbar sind.

    0
  • R

    Ich mach immer 80 Zeichen. Das macht den Code idr. leserlicher und außerdem ist mein Editor auf 80 Zeichen eingestellt. Dh. wenn der Code länger wird, wird die Darstellung umgebrochen.

    0
  • W

    Ich breche nach Gefühl um und auch nur wenn ich eine sinnvolle Umbruchstelle ausmachen kann.

    0
  • D

    mehr als 80 zeichen brauch ich nur sehr selten. aber nie >90 oder so. benutzt zZ eclipse, links ist package explorer, debug, rechts ist variables, expressions und outline ( als karteikarten ). dazwischen ist quellcode. bei 1280x1024.

    0
  • B

    volkard schrieb:

    //und dann
if(checkCastling(whiteMove))

    aber ist das denn sinnvoll? ich brauchs nur einmal.

    ist sinnvoll. dann kannste den haupt-code besser lesen.

    wohin steckt ihr eigentlich solche kleinen Hilfsfunktionen? Als private in die aktuelle Klasse, in einen anonymen Namespace in der aktuellen Datei oder sonstwo? 😕

    0
  • D

    in die klasse nur, wenn auf private member zugegriffen werden muss. ansonsten in den anonymen namespace.

    0
Anmelden zum Antworten