Sungorus 1.4

[swami]

Thanks Jorge , but I don't know if there will be much of an elo increase, because I couldn't find the time to work on the evaluation and only made some search tweaks. Dann's test with the pvs version was very positive, though.

Just for fun, I am adding piece square tables

Here is a sungorus with pst:
http://cap.connx.com/chess-engines/new- ... -1.4pst.7z

It beat the other in a short contest, but I do not know if it is better or even if my implementation is correct.

When I load the exe in Arena 2.01, I get "Error: Create process"

It's a 64 bit binary. Do you have a 64 bit operating system?

Oh I see. I do only have a 32bit though.

[Dann Corbit]

Thanks Jorge , but I don't know if there will be much of an elo increase, because I couldn't find the time to work on the evaluation and only made some search tweaks. Dann's test with the pvs version was very positive, though.

Just for fun, I am adding piece square tables

Here is a sungorus with pst:
http://cap.connx.com/chess-engines/new- ... -1.4pst.7z

It beat the other in a short contest, but I do not know if it is better or even if my implementation is correct.

When I load the exe in Arena 2.01, I get "Error: Create process"

It's a 64 bit binary. Do you have a 64 bit operating system?

Oh I see. I do only have a 32bit though.

Here is a 32 bit version:
http://cap.connx.com/chess-engines/new- ... us.exe.bz2

[swami]

Here is a 32 bit version:
http://cap.connx.com/chess-engines/new- ... us.exe.bz2

Thanks for making a compile, Dann. Will test it soon.

[PK]

IIRC, this slight modification of eval() brought an Elo increase in a short test. I also have a bit of king safety code, but I have yet to come up with the right numbers to fill the relevant table.

Code: Select all

int sungorus::Evaluate(POS *p, int alpha, int beta)
{
    int score;

    score =  p->mat[WC] - p->mat[BC];                     // material
    score += p->pst[WC] - p->pst[BC];                     // pcsq
    score += EvaluatePawns(p, WC) - EvaluatePawns(p, BC); // pawns
    score += EvaluateKing(p, WC) - EvaluateKing(p, BC);   // endgame king pcsq

	if &#40;score > alpha - 200 && score < beta + 200&#41;        // lazy eval
        score += Mobility&#40;p, WC&#41; - Mobility&#40;p, BC&#41;;       // mobility

    if &#40;score < -MAX_EVAL&#41;                                // normalize score
        score = -MAX_EVAL;
    else if &#40;score > MAX_EVAL&#41;
        score = MAX_EVAL;

    return p->side == WC ? score &#58; -score;                // return
&#125;

[swami]

With PST:

Code: Select all

-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	|  STS1	|  STS2	|  STS3	|  STS4	|  STS5	|  STS6	|  STS7	|  STS8	|  STS9	|  STS10	|
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
Sungorus 1.4 PST	|    47	|    39	|    53	|    53	|    60	|    58	|    49	|    41	|    43	|    58	|
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
Grade	|    D	|    ?	|    C	|    C	|    B	|    C+	|    D	|    E	|    E	|    C+	|
Score / 1000	|    601	|    539	|    692	|    633	|    657	|    787	|    603	|    527	|    559	|    707	|
Grade	|    B	|    C	|    B+	|    B	|    B+	|    A	|    B	|    C	|    C+	|    A-	|
Best Move :  501 / 1000  50.1 %  Grade : C
Total :           6305 / 10000  63.05 %  Grade : B
-------------------------------------------------------------------------------------------------------------------------------------------------------------------

[Pablo Vazquez]

Thanks Jorge , but I don't know if there will be much of an elo increase, because I couldn't find the time to work on the evaluation and only made some search tweaks. Dann's test with the pvs version was very positive, though.

Just for fun, I am adding piece square tables

Here is a sungorus with pst:
http://cap.connx.com/chess-engines/new- ... -1.4pst.7z

It beat the other in a short contest, but I do not know if it is better or even if my implementation is correct.

Thanks Dann, I will look at it.

[Pablo Vazquez]

IIRC, this slight modification of eval() brought an Elo increase in a short test. I also have a bit of king safety code, but I have yet to come up with the right numbers to fill the relevant table.

Code: Select all

int sungorus::Evaluate(POS *p, int alpha, int beta)
{
    int score;

    score =  p->mat[WC] - p->mat[BC];                     // material
    score += p->pst[WC] - p->pst[BC];                     // pcsq
    score += EvaluatePawns(p, WC) - EvaluatePawns(p, BC); // pawns
    score += EvaluateKing(p, WC) - EvaluateKing(p, BC);   // endgame king pcsq

	if &#40;score > alpha - 200 && score < beta + 200&#41;        // lazy eval
        score += Mobility&#40;p, WC&#41; - Mobility&#40;p, BC&#41;;       // mobility

    if &#40;score < -MAX_EVAL&#41;                                // normalize score
        score = -MAX_EVAL;
    else if &#40;score > MAX_EVAL&#41;
        score = MAX_EVAL;

    return p->side == WC ? score &#58; -score;                // return
&#125;

Hi Pawel,

I will also try that. Including pst, pawn structure and king centralization in the lazy eval makes sense, since they are going to be computed anyway and it will be more accurate.

IIRC from my tests, using alpha and beta to check for cutoff was as good as just using material, but I will test again.

Regards

[PK]

I gave king safety one more try, this time with some funny formulas and not tables. Preliminary test shows that it just might be of some help, but please consider it a sketch rather than the real thing. Please nopte that it didn't work without those funny major_wood / minor_wood formulae, and that they are untuned. Fromwatching games I see that pawn shield code would be extremely helpful, too.

Possible improvements:

- king zone extending one layer forwards towards the enemy position, so that for Kg1 we consider squares f3-g3-h3 important (simplified idea from Rebel)

- sliders attacking through another sliders (i.e. RR on the same file) - Glass regenerates attack bb (not mobility bb) whenever a piece attacks a piece moving along the same ray

- major/minor formulae might be far more precise, even to the point of using two 2-dimensional tables of multipliers and dividers for each configuration of attackers

Code: Select all

int sungorus::Mobility(POS *p, int side)
{
    U64 pieces;
	U64 control;
	U64 king_zone;
	U64 att_zone;
    int from, mob, att, wood_minors, wood_majors;

    mob  = 0;
	att  = 0;
	wood_minors = 0;
	wood_majors = 0;

	king_zone = k_attacks[KingSq(p, side ^ 1) ];

    pieces = PcBb(p, side, N);
    while (pieces) {
        from = FirstOne(pieces);
        control = n_attacks[from] & ~OccBb(p);
		att_zone = control & king_zone;
		// mob  += PopCnt(control) * 4;
		att  += PopCnt(att_zone);
		wood_minors += 1;
        pieces &= pieces - 1;
    }

    pieces = PcBb(p, side, B);
    while (pieces) {
        from = FirstOne(pieces);
        control = BAttacks(OccBb(p), from);
		att_zone = control & king_zone;
		mob  += PopCnt(control) * 4;
        att  += PopCnt(att_zone);
		wood_minors += 1;
		pieces &= pieces - 1;
    }

	pieces = PcBb(p, side, R);
    while (pieces) {
        from = FirstOne(pieces);
		control = RAttacks(OccBb(p), from);
		att_zone = control & king_zone;
        mob  += PopCnt(control) * 2;
		att  += PopCnt(att_zone) * 3;
		wood_majors += 1;
        pieces &= pieces - 1;
    }

	pieces = PcBb(p, side, Q);
    while (pieces) {
        from = FirstOne(pieces);
        control = QAttacks(OccBb(p), from);
		att_zone = control & king_zone;
		mob  += PopCnt(control);
		att  += PopCnt(att_zone) * 4;
		wood_majors += 3;
        pieces &= pieces - 1;
    }

	// normalize for table size
    if ( wood_minors > 4 ) wood_minors = 4;
	if ( wood_majors > 5 ) wood_majors = 5;

	if ( att  > 23 ) att  = 23;
	if ( wood_majors == 0 && wood_minors < 3 ) att = 0;
	if ( wood_majors > 2 ) att = ( &#40;att * 3 ) / 2 );
	if ( wood_minors > 2 || wood_majors > 3 ) att = ( &#40;att * 5 ) / 4 );

    return mob + att;
&#125;

[bhlangonijr]

IIRC, this slight modification of eval() brought an Elo increase in a short test. I also have a bit of king safety code, but I have yet to come up with the right numbers to fill the relevant table.

Code: Select all

int sungorus::Evaluate(POS *p, int alpha, int beta)
{
    int score;

    score =  p->mat[WC] - p->mat[BC];                     // material
    score += p->pst[WC] - p->pst[BC];                     // pcsq
    score += EvaluatePawns(p, WC) - EvaluatePawns(p, BC); // pawns
    score += EvaluateKing(p, WC) - EvaluateKing(p, BC);   // endgame king pcsq

	if &#40;score > alpha - 200 && score < beta + 200&#41;        // lazy eval
        score += Mobility&#40;p, WC&#41; - Mobility&#40;p, BC&#41;;       // mobility

    if &#40;score < -MAX_EVAL&#41;                                // normalize score
        score = -MAX_EVAL;
    else if &#40;score > MAX_EVAL&#41;
        score = MAX_EVAL;

    return p->side == WC ? score &#58; -score;                // return
&#125;

Hi Pawel,

I will also try that. Including pst, pawn structure and king centralization in the lazy eval makes sense, since they are going to be computed anyway and it will be more accurate.

IIRC from my tests, using alpha and beta to check for cutoff was as good as just using material, but I will test again.

Regards

Hi Pablo,

Have you tried using LMR in the newer version?
I think it is worth trying as it won't demand much of your time and it might give Sungorus some speed up.

Always looking forward to new releases of your very nice engine.

Regards,

[bhlangonijr]

I gave king safety one more try, this time with some funny formulas and not tables. Preliminary test shows that it just might be of some help, but please consider it a sketch rather than the real thing. Please nopte that it didn't work without those funny major_wood / minor_wood formulae, and that they are untuned. Fromwatching games I see that pawn shield code would be extremely helpful, too.

Possible improvements:

- king zone extending one layer forwards towards the enemy position, so that for Kg1 we consider squares f3-g3-h3 important (simplified idea from Rebel)

- sliders attacking through another sliders (i.e. RR on the same file) - Glass regenerates attack bb (not mobility bb) whenever a piece attacks a piece moving along the same ray

- major/minor formulae might be far more precise, even to the point of using two 2-dimensional tables of multipliers and dividers for each configuration of attackers

Code: Select all

int sungorus::Mobility(POS *p, int side)
{
    U64 pieces;
	U64 control;
	U64 king_zone;
	U64 att_zone;
    int from, mob, att, wood_minors, wood_majors;

    mob  = 0;
	att  = 0;
	wood_minors = 0;
	wood_majors = 0;

	king_zone = k_attacks[KingSq(p, side ^ 1) ];

    pieces = PcBb(p, side, N);
    while (pieces) {
        from = FirstOne(pieces);
        control = n_attacks[from] & ~OccBb(p);
		att_zone = control & king_zone;
		// mob  += PopCnt(control) * 4;
		att  += PopCnt(att_zone);
		wood_minors += 1;
        pieces &= pieces - 1;
    }

    pieces = PcBb(p, side, B);
    while (pieces) {
        from = FirstOne(pieces);
        control = BAttacks(OccBb(p), from);
		att_zone = control & king_zone;
		mob  += PopCnt(control) * 4;
        att  += PopCnt(att_zone);
		wood_minors += 1;
		pieces &= pieces - 1;
    }

	pieces = PcBb(p, side, R);
    while (pieces) {
        from = FirstOne(pieces);
		control = RAttacks(OccBb(p), from);
		att_zone = control & king_zone;
        mob  += PopCnt(control) * 2;
		att  += PopCnt(att_zone) * 3;
		wood_majors += 1;
        pieces &= pieces - 1;
    }

	pieces = PcBb(p, side, Q);
    while (pieces) {
        from = FirstOne(pieces);
        control = QAttacks(OccBb(p), from);
		att_zone = control & king_zone;
		mob  += PopCnt(control);
		att  += PopCnt(att_zone) * 4;
		wood_majors += 3;
        pieces &= pieces - 1;
    }

	// normalize for table size
    if ( wood_minors > 4 ) wood_minors = 4;
	if ( wood_majors > 5 ) wood_majors = 5;

	if ( att  > 23 ) att  = 23;
	if ( wood_majors == 0 && wood_minors < 3 ) att = 0;
	if ( wood_majors > 2 ) att = ( &#40;att * 3 ) / 2 );
	if ( wood_minors > 2 || wood_majors > 3 ) att = ( &#40;att * 5 ) / 4 );

    return mob + att;
&#125;

I am doing almost the same idea in my king safety code, with the only difference that instead multiplying the attacked zone count by only a fixed constant, I also use the square distance from the attacker piece to the opposite king. What do you think about that?