Maths : : La logique est un module de Perl qui fournit 2, 3 ou logique purs de multi-valeur.

SYNTHÈSE

maths d'utilisation : : Qw de logique ($TRUE $FALSE $UNDEF $STR_TRUE $STR_FALSE $STR_UNDEF) ;
# 1 0 -1 VÉRITABLES UNDEF TROMPEURS

maths d'utilisation : : logique : NUMÉRIQUE ; # $TRUE $FALSE $UNDEF -- ce que vous voulez normalement

maths d'utilisation : : logique : TOUS ; # toutes les constantes

maths d'utilisation : : logique : STREPTOCOQUE ; # $STR_TRUE $STR_FALSE $STR_UNDEF

de # logique 2 degrés
mon $true = maths : : Logic->new (- => $TRUE de valeur, - => de degré 2) ;
mon $false = maths : : Logic->new (- => $FALSE de valeur, - => de degré 2) ;
mon $x = maths : : Logic->new_from_string (RECTIFIER, 2) ;

estamper « vrai » si $true ;

de # logique 3 degrés (non-propagation)
mon $true = maths : : Logic->new (- => $TRUE de valeur, - => de degré 3) ;
mon $false = maths : : Logic->new (- => $FALSE de valeur, - => de degré 3) ;
mon $undef = maths : : Logic->new (- => $UNDEF de valeur, - => de degré 3) ;
mon $x = maths : : Logic->new_from_string (TROMPEUR, 3) ;

impression « vraie » si ($true | == $TRUE de $undef) ;

de # logique 3 degrés (propagation)
mon $true = maths : : Logic->new (- => $TRUE de valeur, - => 3 de degré, - => de propagation 1) ;
mon $false = maths : : Logic->new (- => $FALSE de valeur, - => 3 de degré, - => de propagation 1) ;
mon $undef = maths : : Logic->new (- => $UNDEF de valeur, - => 3 de degré, - => de propagation 1) ;
mon $x = maths : : Logic->new_from_string ((UNDEF, 3, - propagation)) ;

impression « undef » si ($true | == $UNDEF de $undef) ;

# logique de multi-degré
mon $True = 100 ; # définir notre propre vrai
mon $False = $FALSE ;
mon $true = maths : : Logic->new (- => $True de valeur, - => $True de degré) ;
mon $very = maths : : Logic->new (- => 67 de valeur, - => $True de degré) ;
mon $fairly = maths : : Logic->new (- => 33 de valeur, - => $True de degré) ;
mon $false = maths : : Logic->new (- => $False de valeur, - => $True de degré) ;
mon $x = maths : : Logic->new_from_string (« 25, $True ») ;

impression « peut-être » si ($very | $fairly) > 50 ;

# nous pouvons avoir arbitrairement des expressions complexes ; le résultat est des maths : : logique
# objectif ; tous les arguments doivent être des maths : : Objectifs ou choses de logique qui peuvent être
# introduit dans tels et doit tout être compatible. Le résultat dépend en circuit
# que le genre de logique est employé.
mon $xor = ($x | $y) et (! ($x et $y)) ;
# c'est identique à :
mon ^ $y de $xor = de $x ;

Conducteurs logiques inhérents de Perls, et, ou, xor et ne pas supporter la logique de 2 valeurs. Ceci signifie qu'ils produisent toujours un résultat qui est vrai ou trompeur. En fait le Perl renvoie parfois 0 et renvoie parfois l'undef pour trompeur selon le conducteur et la commande des arguments. Pour le Perl « vrai » renvoie généralement la première valeur qui a évalué pour rectifier qui s'avère être extrêmement utile dans la pratique. Donnés au Perls bien choisi les conducteurs logiques inhérents sont être preferred -- mais quand vous voulez réellement la logique pure de 2 degrés ou logique de 3 degrés ou logique de multi-degré ils sont procurables par ce module.

Les seules valeurs de logique de 2 degrés sont 1 (VRAI) et 0 (TROMPEUR).

Les seules valeurs de logique de 3 degrés sont 1 (VRAI), 0 (TROMPEUR) et -1 (UNDEF). Noter qu'UNDEF est pas l'undef -1 !

Les seules valeurs de logique de multi-degré sont de 0. - degrés (TROMPEURS) -- la valeur de VRAI est égale au degré, habituellement 100.

- Le degré est les valeurs maximales (excepté la logique de 2 et 3 degrés) ; c.-à-d. la logique du n-degré est logique de n+1-value, par exemple la logique de 100 degrés a 101 valeurs, 0..100.

Bien que quelques constantes utiles puissent être exportées, c'est un module résultant et les résultats des comparaisons logiques sont des maths : : Objectifs de logique.

La logique de partition est outil de gestion libre de division et de caractéristiques d'un disque dur. Elle peut produire, effacer, formater, et déplacer des partitions et modifier leurs attributs. Elle peut copier les disques durs entiers d'un à l'autre.

La logique de partition est logiciel gratuit, basé sur le Visopsys du système d'exploitation. Elle amorce d'un CD ou à disque souple et fonctionne comme système autonome, indépendant de votre militaire de carrière du système d'exploitation.

La logique de partition se destine pour devenir un libre choix à des régimes commerciaux tels que la magie de partition, l'image d'entraînement, et le collaborateur anonyme de Norton…

Maths : : logique : : Affirmer est un module de Perl pour gérer et questionner une base de données de revendication d'attribut.

SYNTHÈSE

maths d'utilisation : : logique : : Attribut ;

$db = maths neuves : : logique : : Attribut ;

# écrire quelques attributs dans la base de données
$db->add (<<EOA) ;
humain (listeuse).
humain (kochanski).
pièces (listeuse, guitare).
sec (houx).
sec (rimmer).
nom (listeuse, listeuse de Dave).
nom (kochanski, Kristine Kochanski).
nom (rimmer, Arnold Rimmer).
EOA

# rétracter un attribut
$db->retract (pièces (listeuse, guitare)) ;
# ou basé sur une configuration
$db->retract (sec (_)) ;

# effectuer une requête
$query = $db->parse (être humain (H) et nom (H, X) ? ) ;
$iter = $db->match ($query, $iter) ;

# obtenir les résultats
$name = $db->get ($iter, X) ;

# mémoire il dans une règle
$db->add (human_name (H, N) : = être humain (H) et nom (H, N). ) ;

# utilisation il dans une requête
$iter = $db->match (human_name (listeuse, N) ? ) ;

# sauf lui à un dossier
employer entreposable ;
enregistrer ($db->rules, red_dwarf) ;

AI : : Le Prolog est une prolonge de Perl pour la programmation de logique.

Cours : : AbstractLogic est un module de Perl pour traiter des abstractions de logique.

SYNTHÈSE

# la définition de classe de logique
empaqueter le mon : : logique : : Foo ;
classe d'utilisation : : AbstractLogic-base ;

# une action de logique
l'action ajoutent,
les nécessités [qw (un b)],
vérifier {un sous-marin de => {/^d+$/}, sous-marin de => de b {/^d+$/}},
sous-marin {$_ {a} + $_ {b}} ;

1 ;
…

# création de gestionnaire de module de logique
classe d'utilisation : : AbstractLogic ;
mon $calm = cours : : AbstractLogic : : Manager->new ;

# chargeant une classe de logique
$calm->load_logic (=> de Foo mon : : logique : : Foo) ;

# demandant un résultat d'une méthode de logique
mon $result = $calm->logic (Foo) - >add (un => 11, => 12 de b) ;

# $result sera trompeur si une exception était recueillie
si ($result) {
le résultat d'impression était. $result->value. « n » ;
}
autrement {
l'exception d'impression a augmenté : . $result->key. « n » ;
message d'erreur d'impression : . $result->error. « n » ;
}

Le projet de GtkBalls est un jeu simple de logique.

GtkBalls est un jeu simple mais impressionnant de logique, où vous essayez de retirer autant de billes de l'inducteur de jeu comme vous pouvez.

Est le clone du jeu bien connu « lignes » de DOS.

Ce qu'il y a de neuf dans ce desserrage :

· Rendre le chevron mettant en valeur des paramètres configurable
· Thème neuf de 5ball - 5balls-Big

Dossier : : Repl est un module de Perl qui fournit des utilitaires de réplique de dossier.

SYNTHÈSE

dossier d'utilisation : : Repl ;

%con = {
=> C de dira : /perl,
=> M de dirb : /perl,
=> bavard 1,
=> 10 d'âge,
} ;

$ref=File : : Repl->New (%con) ;
$r1 = $ref->Update (.p (l|m), a<>b, 1) ;
$r2 = $ref->Update (.t.*, a<>b, 1, .tmp$) ;

Le dossier : Repl fournit des utilitaires simples de réplique et de management de dossier. Ses fonctionnements principaux sont

Réplique de dossier

Permettre à deux structures de répertoire d'être mises à jour, assurant les dossiers qui répondent à des critères de logique de sélection sont reflétées et autrement synchronisées.

Renommer en bloc

Laisser lime dans une structure de répertoire à renommer selon la logique de sélection.

Comprimer

Laisser lime dans une structure de répertoire à comprimer selon une logique donnée.

Procédé

Exécuter un procédé courant de Perl contre des dossiers dans une structure de répertoire selon la logique de sélection.

Blanc

Laisser lime dans une structure de répertoire à effacer selon la logique de sélection.

OpenSwarm traite votre modèle d'UML 2.0 pour produire d'une application serveur de python.

Il fournit facilement la logique personnalisable d'affaires basée sur le python et le PostgreSQL. Selon les exigences de la norme de MDA, OpenSwarm emploie UML (version 2.0 enregistrée en tant que XMI 2.1).

FLASH-PLAICE est un instrument de développement en circuit puissant qui combine les caractéristiques d'un programmeur instantané, d'un émulateur, et d'un analyseur de logique multivoie à grande vitesse dans un dispositif. Le projet exécute l'uClinux.

L'analyseur de logique comporte jusqu'aux régimes de prélèvement 200MHz et à jusqu'à 32 glissières d'entrée. Le soutien de caractéristiques de client java d'analyseur de logique jusqu'derrière des régimes de prélèvement 200MHz, des fonctionnements de filtrage dépendants de l'utilisateur, de la ligne de temps dans le tableau, des méta-données (taille, régime, et position de déclenchement) enregistrées dans les dossiers, d'une commande d'identification pour l'identification de dispositif, du taux de transfert configurable de port série, des modes configurables de retrait d'usager (niveau logique, valeur hex, et étendue), et de l'accès de client java par l'intermédiaire de presque tout PC avec un port série.

Le client java emploie la bibliothèque séquentielle de RXTX avec le support pour 34 plates-formes comprenant Linux, Windows, et Solaris. Les connexions de client java analyseur de protocole comprennent de SPI et d'I2C bus, analyse de calage à la conversion d'analyse de condition, et fonctionnements de post-traitement.

Molle est un tireur d'epreuves de cross platform pour la logique modale. Il exploite la méthode sémantique modale de tableaux.

Le projet de Molle comporte une surface adjacente graphique très utilisable, avec une représentation interactive des modèles produits.

TCLP est un type préscriptif système pour la programmation de logique de contrainte, actuel :

OIN-Prolog
GNU-Prolog
Prolog de Sicstus et ses bibliothèques
Bibliothèques de programmes de Contraints de Prolog de Sicstus

Basé sur des régimes tapants de logique de contrainte par François Fages et Emmanuel Coquery. Tourillon de théorie et de pratique de la programmation de logique TPLP 1 (6)., Pp. 751-777. Novembre 2001. Procurable comme picoseconde.

TCLP emploie le genre 3 de polymorphisme :

polymorphisme paramétrique (par exemple : liste (A))
subtyping (par exemple : liste (A) < condition)
surcharge (également appelée le polymorphisme ad-hoc)
par exemple : - /2 peut avoir le type international * international - > international et taper A * B - > les paires (A, B)

Utilisable :

Aucun type déclaration n'a exigé !
taper l'inférence pour des attributs
types de défaut pour des symboles de fonctionnement
Extensible à d'autres dialectes par la fourniture tape pour établir-Institut central des statistiques

TCLP est mis en application dans Prolog/CHR.

Ce qu'il y a de neuf dans ce desserrage :

· Ce desserrage a ajouté la possibilité pour ajouter le type pseudonymes.
· C'est-à-dire, pour déclarer et employer des noms comme les raccourcis pour saisit le type déclarations.

Le projet de QWPython est un serveur Python-actionné de QuakeWorld.

L'engine de faisceau a été enveloppée vers le haut de comme un module de python et modifiée pour appeler de nouveau au python pour accomplir la logique de jeu de tremblement.

Un QuakeC - le traducteur de python est également compris, avec des versions pré-traduites de Deathmatch et de Capter-Le-Indicateur.

Est pas à pas un jeu simple de logique où vous devez libérer toutes les tuiles colorées par la progression au-dessus de elles.

Selon la couleur de la tuile, ceci prend une à trois mesures. Le projet par étages contient 99 niveaux et un éditeur de niveau séparé.

le projet kpictorial est un jeu de logique pour le KDE.

Le but du jeu est de reconstruire une illustration noire et blanche par le nombre de blocs contigus de noir donnés pour chaque rangée et fléau. Semble facile mais n'est pas.

Vous pouvez également employer des dossiers de xmp et de xbm de palete de la couleur 1bit répertoriée produits par la ganse.

Le GNOME Sudoku est un jeu de casse-tête Gnome-basé. Sudoku est un jeu japonais de logique de puzzle populaire. Le GNOME Sudoku destine pour fournir une surface adjacente simple pour se produire, jouer, sauvegarder, impression et résoudre des puzzles de Sudoku.

Actuellement, le GNOME Sudoku supporte infini défont, rétablissement des puzzles symétriques avec de seules solutions, et fonctionnalités de base pour aider gameplay.

La giraffe est un simulateur simple de circuit logique. La giraffe peut charger, sauf, et importe des circuits et les simule avec des chronogrammes.

COMMENT EXÉCUTER ?

Pour la simplicité, le régime est déjà compilé (vous pouvez le recompiler using le fichier makefile fourni). Juste exécuter giraffe.sh et ne pas s'inquiéter du reste.

XZero est une carte et un logique-jeu simples.

Le gagnant du jeu est le premier joueur qui complète une ligne continue au moins de cinq éléments.

Une ligne peut avoir un des sens suivants : vertical, horizontal, diagonalement montant, ou diagonalement descendant.

Le système de conception électrique d'ITGE est un système complet (EDA) de Conception assistée par ordinateur électronique qui peut traiter beaucoup de formes de modèle de circuit, comprenant :

* Disposition faite sur commande d'IC
* Saisie graphique (digital et analogique)
* Langages textuels tels que VHDL et Verilog
* logique programmable (FPGA)
*… et beaucoup plus.

Système : : AlarmCall est un ensemble de mesures pour traiter la logique en calant à l'extérieur appelle avec l'alarme () et un dérouleur d'ALRM, permettant des appels emboîtés aussi bien.

SYNTHÈSE

système d'utilisation : : AlarmCall ;

$result = alarm_call ($timeout1, $func1, @args1) ;
@result = alarm_call ($timeout2, $func2, @args2) ;

Système : : AlarmCall fournit un appel de fonctionnement droit pour employer le dérouleur d'alarme. Il traite également la logique qui permet des appels emboîtés de temps à l'extérieur si les appels de minuterie sont thorugh exécuté les fonctionnements d'alarm_call ().

Les principaux avantages du système : : AlarmCall sont celui :

1. appels simples, par exemple.

@result = &func (@args) ; appel de fonctionnement #Normal avec et
$result = fonctionnel (@args) ; ; appel de fonctionnement #Normal
@result = &$code_reference (@args) ;
@result = $obj->func (@args) ; appel de méthode de #Object

sont les appels simples :

@result = alarm_call ($timeout, &func, @args) ;
$result = alarm_call ($timeout, fonctionnel, @args) ;
@result = alarm_call ($timeout, $code_reference, @args) ;
@result = alarm_call ($timeout, - >func, $obj, @args) ;

LM-Résoudre le projet est un résolveur de problèmes pour des labyrinthes de logique.

LM-Résoudre est un résolveur de problèmes pour plusieurs types des puzzles actuels sur le site de labyrinthes de logique.

Il supporte actuel des labyrinthes d'Alice, labyrinthes de numéro, planche déconcerte, Theseus et les labyrinthes de Minotaur, et des labyrinthes d'inclinaison.

Ils sont sauvés dans le Perl et devraient être très portatifs.

Utiliser le module de CPAN.pm montent des jeux : : La commande de LMSolve de monter LM-Résolvent. Par exemple, invoquer la commande suivante sur la ligne commande :

# Perl - MCPAN - e montent des jeux : : LMSolve