416 lines
18 KiB
C++
416 lines
18 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2004, University in Hagen, Department of Computer Science,
|
|
Database Systems for New Applications.
|
|
|
|
SECONDO is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
SECONDO is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
----
|
|
|
|
//characters [1] verbatim: [\verb@] [@]
|
|
//paragraph [1] title: [{\Large \bf ] [}]
|
|
|
|
|
|
[1] OperatorsInfo.hpp
|
|
|
|
1. defines information on operators for secondo user
|
|
|
|
*/
|
|
|
|
#ifndef SECONDO_ALGEBRAS_CHESS_OPERATORS_INFO_HPP
|
|
#define SECONDO_ALGEBRAS_CHESS_OPERATORS_INFO_HPP
|
|
|
|
const OperatorInfo field_ctor_info( "field", "string -> field",
|
|
"field ( _ )", "Constructs field", "query field( \"a1\" )" );
|
|
|
|
const OperatorInfo equals_field_info( "=", "field x field -> bool",
|
|
"_ = _", "Checks for equality", "query a1 = a1" );
|
|
|
|
const OperatorInfo less_field_info( "<", "field x field -> bool",
|
|
"_ < _", "Field comparision", "query a1 < a2" );
|
|
|
|
const OperatorInfo greater_field_info( ">", "field x field -> bool",
|
|
"_ > _", "Field comparision", "query a1 > d6" );
|
|
|
|
const OperatorInfo iswhite_field_info( "iswhite", "field -> bool",
|
|
"iswhite ( _ )", "Return color of the field",
|
|
"query iswhite( a1 )" );
|
|
|
|
const OperatorInfo file_info( "column", "field -> string", "column ( _ )",
|
|
"Return column of the field", "query column( a1 )" );
|
|
|
|
const OperatorInfo row_info( "row", "field -> int", "row ( _ )",
|
|
"Return row of the field", "query row( a1 )" );
|
|
|
|
const OperatorInfo north_info( "north", "field -> field", "north ( _ )",
|
|
"Return field to the north", "query north( a1 )" );
|
|
|
|
const OperatorInfo east_info( "east", "field -> field", "east ( _ )",
|
|
"Return field to the east", "query east( a1 )" );
|
|
|
|
const OperatorInfo south_info( "south", "field -> field", "south ( _ )",
|
|
"Return field to the south", "query south( a1 )" );
|
|
|
|
const OperatorInfo west_info( "west", "field -> field", "west ( _ )",
|
|
"Return field to the west", "query west( a1 )" );
|
|
|
|
const OperatorInfo northwest_info( "northwest", "field -> field",
|
|
"northwest ( _ )", "Field to the northwest",
|
|
"query northwest( a1 )" );
|
|
|
|
const OperatorInfo northeast_info( "northeast", "field -> field",
|
|
"northeast ( _ )", "Field to the northeast",
|
|
"query northeast( a1 )" );
|
|
|
|
const OperatorInfo southwest_info( "southwest", "field -> field",
|
|
"southwest ( _ )", "Field to the southwest",
|
|
"query southwest( a1 )" );
|
|
|
|
const OperatorInfo southeast_info( "southeast", "field -> field",
|
|
"southeast ( _ )", "Field to the southeast",
|
|
"query southeast( a1 )" );
|
|
|
|
const OperatorInfo is_neighbor_info( "is_neighbor", "field x field -> bool",
|
|
"_ is_neighbor _", "Are two fields neighbors",
|
|
"query a1 is_neighbor a2" );
|
|
|
|
const OperatorInfo left_info( "left", "field x field -> bool", "_ left _",
|
|
"Is first field to the left of the second",
|
|
"query a1 left b1" );
|
|
|
|
const OperatorInfo right_info( "right", "field x field -> bool", "_ right _",
|
|
"Is first field to the right of the second",
|
|
"query d1 right d2" );
|
|
|
|
const OperatorInfo above_info( "above", "field x field -> bool",
|
|
"_ above _", "Is first field above of the second",
|
|
"query a1 left a1" );
|
|
|
|
const OperatorInfo below_info( "below", "field x field -> bool",
|
|
"_ below _", "Is first field below of the second",
|
|
"query a1 below a1" );
|
|
|
|
const OperatorInfo neighbors_info( "neighbors", "field -> stream( field )",
|
|
"_ neighbors", "Produce stream of neighbors",
|
|
"query a1 neighbors printstream count" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo piece_ctor_info( "piece", "string -> piece",
|
|
"piece ( _ )", "Constructs piece", "query piece( \"Pawn\" )" );
|
|
|
|
const OperatorInfo iswhite_piece_info( "iswhite", "piece -> bool",
|
|
"iswhite ( _ )", "Return piece color.",
|
|
"query iswhite( Pawn )" );
|
|
|
|
const OperatorInfo equals_piece_info( "=", "piece x piece -> bool",
|
|
"_ = _", "Checks for equality",
|
|
"query Pawn = king" );
|
|
|
|
const OperatorInfo is_info( "is", "piece x piece -> bool", "_ is _",
|
|
"Checks for the equal piece type",
|
|
"query Pawn is pawn" );
|
|
|
|
const OperatorInfo samecolor_info( "samecolor", "piece x piece -> bool",
|
|
"_ samecolor _", "Checks for equal piece color",
|
|
"query Pawn samecolor Queen" );
|
|
|
|
const OperatorInfo piecevalue_info( "piecevalue", "piece -> real",
|
|
"piecevalue ( _ )", "Return value of the piece.",
|
|
"query piecevalue( Pawn ) = 1" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo equals_ply_info( "=", "chessmove x chessmove -> bool",
|
|
"_ = _", "Checks for equality",
|
|
"query query wjc feed filter[.No = 5] extract[elem] getmove[7] = "
|
|
"query wjc feed filter[.No = 5] extract[elem] getmove[6]" );
|
|
|
|
const OperatorInfo startfield_info( "startfield", "chessmove -> field",
|
|
"startfield ( _ )", "Returns the start field.",
|
|
"query startfield(wjc feed filter[.No = 5] extract[elem] getmove[7])" );
|
|
|
|
const OperatorInfo endfield_info( "endfield", "chessmove -> field",
|
|
"endfield ( _ )", "Returns destination field.",
|
|
"query endfield(wjc feed filter[.No = 5] extract[elem] getmove[7])" );
|
|
|
|
const OperatorInfo agent_info( "agent", "chessmove -> piece", "_ agent",
|
|
"Returns the moving piece.",
|
|
"query wjc feed filter[.No = 5] extract[elem] getmove[7] agent" );
|
|
|
|
const OperatorInfo captures_info( "captures", "chessmove -> bool",
|
|
"_ captures", "Check for a capture.",
|
|
"query wjc feed filter[.No = 5] extract[elem] getmove[7] captures" );
|
|
|
|
const OperatorInfo captured_info( "captured", "chessmove -> piece",
|
|
"_ captured", "Returns captured piece.",
|
|
"query wjc feed filter[.No = 5] extract[elem] getmove[7] captured" );
|
|
|
|
const OperatorInfo check_info( "check", "chessmove -> bool", "_ check",
|
|
"Checks for the check.",
|
|
"query wjc feed filter[.No = 5] extract[elem] getmove[7] check" );
|
|
|
|
const OperatorInfo is_mate_info( "is_mate", "chessmove -> bool",
|
|
"is_mate ( _ )", "Checks for the mate.",
|
|
"query is_mate( wjc feed filter[.No = 5] extract[elem] getmove[7] )" );
|
|
|
|
const OperatorInfo is_stalemate_info( "is_stalemate", "chessmove -> bool",
|
|
"is_stalemate ( _ )", "Checks for stalemate.",
|
|
"query is_stalemate(wjc feed filter[.No = 5] extract[elem] getmove[7])" );
|
|
|
|
const OperatorInfo is_castling_info( "is_castling", "chessmove -> bool",
|
|
"is_castling ( _ )", "Check for a castling.",
|
|
"query is_castling( wjc feed filter[.No = 5] extract[elem] getmove[7] )" );
|
|
|
|
const OperatorInfo is_enpassant_info( "is_enpassant", "chessmove -> bool",
|
|
"is_enpassant ( _ )", "Checks for an enpassant.",
|
|
"query is_enpassant(wjc feed filter[.No = 5] extract[elem] getmove[7])" );
|
|
|
|
const OperatorInfo enpassant_field_info( "enpassant_field",
|
|
"chessmove -> field", "enpassant_field ( _ )",
|
|
"Returns the enpassant field.",
|
|
"query enpassant_field(wjc feed filter[.No = 5] extract[elem] getmove[7])" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo piececount_material_info( "piececount",
|
|
"material x piece -> int", " _ piececount [ _ ]", "Count of pieces",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[1] pieces"
|
|
" piececount[Queen]" );
|
|
|
|
const OperatorInfo equals_material_info( "=", "material x material -> bool",
|
|
"_ = _", "Checks for equality",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] pieces = "
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] pieces" );
|
|
|
|
const OperatorInfo less_material_info( "<", "material x material -> bool",
|
|
"_ < _", "material comparision",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] pieces < "
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] pieces" );
|
|
|
|
const OperatorInfo greater_material_info( ">", "material x material -> bool",
|
|
"_ > _", "material comparision",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] pieces > "
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] pieces" );
|
|
|
|
const OperatorInfo approx_material_info("~","material x material -> bool",
|
|
"_ ~ _", "Approx. equality",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] pieces ~ "
|
|
"wjc feed filter[.No = 2] extract[elem] getposition[7] pieces" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo pieces_info( "pieces", "position -> material",
|
|
"pieces _ ", "Material",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] pieces" );
|
|
|
|
const OperatorInfo moveNo_info( "moveNo", "position -> int",
|
|
"_ moveNo", "Move number",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[5] moveNo" );
|
|
|
|
const OperatorInfo checkmate_info( "checkmate", "position -> bool",
|
|
"checkmate ( _ )", "Mate check",
|
|
"query checkmate(wjc feed filter[.No = 2] extract[elem] getposition[6])" );
|
|
|
|
const OperatorInfo stalemate_info( "stalemate", "position -> bool",
|
|
"stalemate ( _ )", "Stalemate check",
|
|
"query stalemate(wjc feed filter[.No = 2] extract[elem] getposition[6])" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo includes_info( "includes", "position x position -> bool",
|
|
"_ includes [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[34] includes"
|
|
" [ wjc feed filter[.No = 2] extract[elem] getposition[34] ]" );
|
|
|
|
const OperatorInfo piececount_spos_info( "piececount",
|
|
"position x string -> int", "_ piececount [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[34] "
|
|
"piececount[\"KING\"]" );
|
|
|
|
const OperatorInfo piececount_position_info( "piececount",
|
|
"position x piece -> int", "_ piececount [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[34] "
|
|
"piececount[Pawn]" );
|
|
|
|
const OperatorInfo equals_position_info( "=", "position x position -> bool",
|
|
"_ = _", "Position equality",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] = "
|
|
"wjc feed filter[.No = 2] extract[elem] getposition[6]" );
|
|
|
|
const OperatorInfo less_position_info( "<", "position x position -> bool",
|
|
"_ < _", "position comparision",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] < "
|
|
"wjc feed filter[.No = 2] extract[elem] getposition[7]" );
|
|
|
|
const OperatorInfo greater_position_info( ">", "position x position -> bool",
|
|
"_ > _", "position comparision",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[7] > "
|
|
"wjc feed filter[.No = 2] extract[elem] getposition[6]" );
|
|
|
|
const OperatorInfo approx_position_info( "~", "position x position -> bool",
|
|
"_ ~ _", "Position material comparision", "query wjc feed filter[.No = 2]"
|
|
" extract[elem] getposition[6] ~ wjc feed filter[.No = 2]"
|
|
" extract[elem] getposition[6]" );
|
|
|
|
const OperatorInfo attackcount_info("attackcount", "position x field -> int",
|
|
"_ attackcount [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem]"
|
|
" getposition[6] attackcount [e4]" );
|
|
|
|
const OperatorInfo protectcount_info("protectcount","position x field -> int",
|
|
"_ protectcount [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem]"
|
|
" getposition[6] protectcount [e4]" );
|
|
|
|
const OperatorInfo apply_ply_info( "apply_ply",
|
|
"position x chessmove -> position", "_ apply_ply[ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6] "
|
|
"apply_ply[wjc feed filter[.No = 2] extract[elem] getmove[7] ]" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo posrange_info( "posrange_b",
|
|
"position x field x field -> position", "_ posrange [ _, _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6] "
|
|
"posrange[a1, c3]" );
|
|
|
|
const OperatorInfo attacked_by_p_info( "attackedby",
|
|
"position x piece x piece -> bool", "_ _ attackedby [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" queen attackedby[Queen]" );
|
|
|
|
const OperatorInfo attacked_by_f_info( "attackedby",
|
|
"position x field x piece -> bool", "_ _ attackedby [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" d4 attackedby [Queen]" );
|
|
|
|
const OperatorInfo attacked_from_p_info( "attackedfrom",
|
|
"position x piece x field -> bool", "_ _ attackedfrom [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" Queen attackedfrom [d4]" );
|
|
|
|
const OperatorInfo attacked_from_f_info( "attackedfrom",
|
|
"position x field x field -> bool", "_ _ attackedfrom [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" c4 attackedfrom [d4]" );
|
|
|
|
const OperatorInfo protected_by_p_info( "protectedby",
|
|
"position x piece x piece -> bool", "_ _ protectedby [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" queen protectedby [Queen]" );
|
|
|
|
const OperatorInfo protected_by_f_info( "protectedby",
|
|
"position x field x piece -> bool", "_ _ protectedby [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" c4 protectedby [Queen]" );
|
|
|
|
const OperatorInfo protected_from_p_info( "protectedfrom",
|
|
"position x piece x field -> bool", "_ _ protectedfrom [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" Queen protectedfrom [d4]" );
|
|
|
|
const OperatorInfo protected_from_f_info( "protectedfrom",
|
|
"position x field x field -> bool", "_ _ protectedfrom [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" c4 protectedfrom [d4]" );
|
|
|
|
const OperatorInfo apply_move_info( "apply_move",
|
|
"position x field x field -> position", "_ apply_move[_, _]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" apply_move[c4, d4]" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo pos_fields_info( "pos_fields",
|
|
"position -> stream( tuple( [Field: field, Piece: piece] ) )",
|
|
"_ pos_fields", "...", "query wjc feed filter[.No = 2] extract[elem]"
|
|
" getposition[6] pos_fields consume" );
|
|
|
|
const OperatorInfo pos_moves_info( "pos_moves",
|
|
"position x piece -> stream(tuple([SPiece: piece, SField: field, EPiece: "
|
|
"piece, EField: field]))", "_ pos_moves", "...", "query wjc feed "
|
|
"filter[.No = 2] extract[elem] getposition[6] pos_moves consume" );
|
|
|
|
const OperatorInfo pos_moves_blocked_info( "pos_moves_blocked",
|
|
"position -> stream(tuple([SPiece: piece, SField: field, BPiece: piece, "
|
|
"BField: field, EPiece: piece, EField: field]))", "_ pos_moves_blocked",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6] "
|
|
"pos_moves_blocked consume" );
|
|
|
|
const OperatorInfo piece_moves_info( "piece_moves",
|
|
"position x piece -> stream(tuple([SPiece: piece, SField: field,"
|
|
"EPiece: piece, EField: field]))", "_ piece_moves [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getposition[6]"
|
|
" piece_moves [Queen] consume" );
|
|
|
|
const OperatorInfo p_moves_blocked_info( "piece_moves_blocked",
|
|
"position x piece -> stream(tuple([SPiece: piece, SField: field, "
|
|
"BPiece: piece, BField: field, EPiece: piece, EField: field]))",
|
|
"_ piece_moves_blocked[ _ ]", "..", "query wjc feed filter[.No = 2] "
|
|
"extract[elem] getposition[6] piece_moves_blocked[Pawn]" );
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo getkey_info( "getkey", "chessgame x string -> string",
|
|
"_ getkey [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getkey [\"Event\"]" );
|
|
|
|
const OperatorInfo getposition_info( "getposition",
|
|
"chessgame x int -> position", "_ getposition [ _ ]",
|
|
"...", "query wjc feed filter[.No = 2] extract[elem] getposition[6]" );
|
|
|
|
const OperatorInfo getmove_info( "getmove", "chessgame x int -> chessmove",
|
|
"_ getmove [ _ ]", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] getmove [3]" );
|
|
|
|
const OperatorInfo lastmove_info( "lastmove", "chessgame -> int",
|
|
"lastmove ( _ )", "...",
|
|
"query lastmove( wjc feed filter[.No = 2] extract[elem] )" );
|
|
|
|
const OperatorInfo readpgn_info( "readpgn", "text -> stream(chessgame)",
|
|
"readpgn ( _ )", "Read chessgames from PGN-file",
|
|
"query readpgn('wjc.pgn') printstream count" );
|
|
|
|
const OperatorInfo positions_info( "positions", "chessgame->stream(position)",
|
|
"_ positions", "...", "query wjc feed filter[.No = 2] extract[elem] "
|
|
"positions transformstream head[3] consume" );
|
|
|
|
const OperatorInfo moves_info( "moves", "chessgame -> stream(chessmove)",
|
|
"_ moves", "...", "query wjc feed filter[.No = 2] extract[elem] moves"
|
|
" transformstream head[3] consume" );
|
|
|
|
const OperatorInfo history_info( "history",
|
|
"chessgame -> stream(tuple([No: int, Pos: position, Move: chessmove]))",
|
|
"_ history", "...",
|
|
"query wjc feed filter[.No = 2] extract[elem] history head[3] consume" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const OperatorInfo even_info( "is_even", "int -> bool",
|
|
"is_even ( _ )", "...", "query is_even(2)" );
|
|
|
|
const OperatorInfo odd_info( "is_odd", "int -> bool",
|
|
"is_odd ( _ )", "...", "query is_odd(2)" );
|
|
|
|
const OperatorInfo exists_info( "exists",
|
|
"stream(ANY) x (ANY -> bool) -> bool",
|
|
"_ exists [ funlist ]", "...", "query r feed exists[p]" );
|
|
|
|
const OperatorInfo forall_info( "forall",
|
|
"stream(ANY) x (ANY -> bool) -> bool",
|
|
"_ forall [ funlist ]", "...", "query r feed forall[p]" );
|
|
|
|
const OperatorInfo twotuples_info( "twotuples",
|
|
"stream(tuple(X)) -> stream(tuple([X1, X2]))",
|
|
"_ twotuples", "...", "query g1 twotuples consume" );
|
|
|
|
const OperatorInfo ntuples_info( "ntuples",
|
|
"stream(tuple(X)) -> stream(tuple([X1, X2, ...]))",
|
|
"_ ntuples [ _ ]", "...", "query g1 ntuples[n_is_4] consume" );
|
|
|
|
#endif // SECONDO_ALGEBRAS_CHESS_OPERATORS_INFO_HPP
|