De n-mening is een netwerkmonitor voor kleine en middelgrote netwerken. Het kenmerkt automatisch aftasten van subnets voor gastheeradressen, toezicht op reacties ICMP van alle gastheren, het signaleren van onderbrekingen en vertragingen in GUI en per post, een portscanner, een cliënt van SNMP (browser MIB en valontvanger), een grafische vertoning van netwerkverkeer voor netwerkinterfaces, connectiviteit aan gastheren door Telnet, browser van HTTP, of een willekeurig extern programma (zoals ssh), druk van netwerkdiagrammen, automatische generatie van HTML- pagina's, en meer.

Hier zijn sommige zeer belangrijke eigenschappen van de „Mening van N“:

Eenvoudige configuratie:

· automatisch die aftasten voor gastheren, op ICMP („ping“) wordt gebaseerd,
· configureerbare grenzen voor reactievertraging, onderbreking en het interval van het havenaftasten,
· de individuele configuratie kan in een configuratiedossier worden opgeslagen;

Grafische vertoning:

· het automatische schikken van pictogrammen voor (facultatieve) gastheren en subnets,
· willekeurige beelden als achtergrond voor het elk scherm,
· signalerende vertraging en onderbreking van gastheren en subnets met gekleurde pictogrammen,
· grafische vertoning van verkeerslading voor geselecteerde netwerkinterfaces,
· willekeurige etikettering voor alle pictogrammen en vensters;

Signaleren van akoestisch statusveranderingen op vertoning, en per (facultatieve) e-mail:

· op onderbreking of vertraagd antwoord van een gastheer,
· op veranderingen van de open havenstatus,
· bij het ontvangen van de vallen van SNMP;

De interface van het beheer, verbindingen aan gastheren:

· via externe browser,
· via interne Telnet cliënt,
· via de interne cliënt/browser van SNMP;

Flexibele vertoning:

· tonend Subnets zoals van labels voorzien of gedrapeerde vensters,
· gekleurde printeroutput van netwerkdiagrammen,
· de netwerk diagrammen kunnen van browsers van HTML van binnenuit het netwerk (de externe vereiste server van HTML) worden betreden;

Dit is een pictogram-Thema van de Gnoom 2.X van Tux n Tosh iconset. Tux n Tosh gebruikt ook sommige pictogrammen van het Kristal om min of meer volledig te zijn.

Het schuine stand-n-broodje is een raadselspel waar u uw marmer door het 3d labyrint aan de uitgang moet rollen.

Dit spel is een ingang in de wedstrijd van de Manifestatie 2007 van het Spel Intels. Gelieve te vergen de tijd om mijn spel te schatten en me te helpen een prijs winnen!

Hel het 3d labyrint over en rol uw marmer aan de uitgang. De definitieve versie zal laptop volledig sensoren SMS/HDAPS steunen om spelers toe te staan om laptop over te hellen om te spelen! (De Steun is gedeeltelijk daar nu - de gebruikers Linux krijgen een flard SDL en de gebruikers van MAC kunnen met Unimotion ruzie maken).

Hier zijn sommige zeer belangrijke eigenschappen van het „Broodje van de Schuine stand n“:

· Veelvoudige powerups, monsters, schakelaars, raadsels, vallen…
· Ingebouwde niveauredacteur: het ontwerp en deelt uw labyrinten met vrienden!
· De controle van het toetsenbord of van de muis voor niet gestaafde laptops
· Overvloed van geluidseffecten en boeiende muziek
· De berekeningen van de fysica worden in werking gesteld in een tweede draad: multicore gebruikers zouden een verhoging van zowel framerate als simulatienauwkeurigheid moeten zien
· Looppas op Vensters, MAC OS of Linux.
· Volledig open-bronsoftware onder GNU GPL!

Emporium van MUNGE Uid n Gid is de authentificatiedienst voor het creëren van en het bevestigen van geloofsbrieven. Het wordt ontworpen om hoogst te zijn - scalable voor gebruik in een de clustermilieu van HPC.

Het staat een proces toe om UID en GID van een ander lokaal of ver proces binnen een groep gastheren voor authentiek te verklaren die gemeenschappelijke gebruikers en groepen hebben. Deze gastheren vormen een veiligheidskoninkrijk dat door een gedeelde cryptografische sleutel wordt bepaald.

De cliënten binnen dit veiligheidskoninkrijk kunnen geloofsbrieven zonder het gebruik van wortelvoorrechten, gereserveerde havens, of platform-specifieke methodes tot stand brengen en bevestigen.

Reden

De behoefte aan MUNGE kwam uit het de clustermilieu van HPC voort. Overweeg het scenario waarin een lokale daemon die op een login knoop lopen een cliëntverzoek ontvangt en het op het verre daemons lopen gegevens verwerkt knopen binnen de cluster door:sturen. Aangezien de gebruiker reeds aan de login knoop het programma heeft geopend, vergt lokale daemon enkel een betrouwbaar middel om UID en GID van het cliëntproces na te gaan. Voorts vergen verre daemons een mechanisme om te verzekeren het verstuurde authentificatiegegeven niet later is veranderd.

Een gemeenschappelijke oplossing voor dit probleem is het domeincontactdozen van Unix te gebruiken om de identiteit van de lokale cliënt te bepalen, en dan deze informatie op verre gastheren via vertrouwde op rsh verbindingen door:sturen. Maar dit geeft verscheidene nieuwe problemen. Eerst, zijn er geen draagbare API voor het bepalen van de identiteit van een cliënt over een het domeincontactdoos van Unix. Ten tweede, rsh moeten de verbindingen uit een gereserveerde haven voortkomen; het beperkte aantal gereserveerde havens beschikbaar op een bepaalde gastheer beperkt direct scalability. Ten derde, worden de wortelvoorrechten vereist aan een gereserveerde haven te binden. Tot slot hebben verre daemons geen middelen om te bepalen of de cliëntidentiteit authentiek is.

Overzicht

Een proces leidt tot geloofsbrieven door bij de lokale dienst te vragen MUNGE. De gecodeerde geloofsbrieven bevatten UID en GID van het voortkomende proces. Dit proces verzendt de geloofsbrieven naar een ander proces binnen het veiligheidskoninkrijk als test zijn identiteit. Het ontvangende proces bevestigt de geloofsbrieven met het gebruik van zijn lokale dienst MUNGE. De gedecodeerde geloofsbrieven voorzien het ontvangende proces van een betrouwbaar middel om UID en GID van het voortkomende proces na te gaan. Deze informatie kan voor boekhouding of toegangsbeheerbesluiten worden gebruikt.

De inhoud van de geloofsbrieven (met inbegrip van om het even welke facultatieve die nuttige ladingsgegevens) wordt met een sleutel gecodeerd door allen wordt gedeeld munged daemons binnen het veiligheidskoninkrijk. De integriteit van de geloofsbrieven wordt verzekerd door een code van de berichtauthentificatie (MAC). De geloofsbrieven zijn geldig voor een beperkte die tijd door zijn tijd-aan-levend wordt bepaald (TTL). Daemon verzekert unexpired geloofsbrieven niet op een bepaalde gastheer worden overgespeeld. Het decoderen van geloofsbrieven kan tot een bepaalde gebruiker en/of groepsidentiteitskaart worden beperkt. De nuttige ladingsgegevens kunnen voor doeleinden worden gebruikt zoals het inbedden van het te verzekeren bestemmingenadres de geloofsbrieven op een specifieke gastheer slechts geldig zijn. Het interne formaat van de geloofsbrieven wordt gecodeerd op een platform-onafhankelijke manier. En die de geloofsbrieven zelf zijn base64 wordt gecodeerd om het toe te staan om over vrijwel om het even welk vervoer worden overgebracht.

Wat in Deze Versie Nieuw is:

· Een insect werd bevestigd dat stapelcorruptie op amd-64 toen het gebruiken van Libgcrypt veroorzaakte.

Het Dossier van Métamorphose - de nOmslag Renamer is een massadossier die programma anders noemen dat grote flexability met een intuïtieve interface combineert.

Het Dossier van Métamorphose - de nOmslag Renamer staat velen bevellijn toe die verrichtingen in één enkel nut, passend voor zij anders noemen die grote aantallen dossiers en/of omslagen moeten periodiek anders noemen.

Nochtans, zorgt het gemak van de interface ervoor dat een first-time gebruiker het niet ook zal vinden frustrerend om te gebruiken

Hier zijn sommige zeer belangrijke eigenschappen van „veranderen de Omslag Renamer van het Dossier n“:

· Noemt tezelfdertijd dossiers en omslagen anders.
· Voorproef elk anders te noemen punt alvorens te begaan verandert.
· Laad alle dossiers in folder en in subdirectories (het recursieve anders noemen).
· Maak het anders noemen van verrichting in het geval van fouten ongedaan.
· Noem MP3 dossiers volgens hun ID3 markeringen anders.
· Gebruik van alle toegestane karakters onder Vensters en OSX, allen behalve: in Linux.
· Sparen alle programmamontages voor recenter gebruik in te dienen!
· Het anders noemen van verrichtingen:
· Prefix
· Achtervoegsel
· Vastgestelde dossieruitbreiding.
· Vervanging, wijziging, of beweging door: Karakter, positie, of regelmatige uitdrukking.
· Toevoeging door: Positie of elk (aantal) karakters.
· De wijzigingen van de lengte (het opvullen, het beknotten, of allebei).
· Het anders noemen van stijlen: combinatie van: gebruikers tekst, nummering, id3 markeringen, datum, tijd.
· Wijzigingen: IN HOOFDLETTERS, in kleine letters, kapitaliseer eerst, de Stijl van de Titel, ruilmiddelgeval, DoRkIfY
· Beweging door positie, tekst, of regelmatige uitdrukking.
· Opeenvolgende nummerings (het opsommen) opties:
· De gehelen van het gebruik, alfabetische, of roman cijfers
· Stootkussen met om het even welk geldig karakter aan om het even welke breedte. (gehelen slechts)
· De stapgrootte van de controle, beginnend aantal, teruggestelde telling.
· De vastgestelde datum en de tijd manueel of krijgen van systeem.
· Het gebruik leverde gebreken of specificeert uw eigen datum en tijdformaten.
· Het modulaire ontwerp staat grote flexability en controle toe, terwijl het houden van het gemakkelijke materiaal eenvoudig.

Youre een leuk klein konijntje en u moet de andere konijntjes vermijden van het stampen op u en tezelfdertijd proberen om zoveel mogelijk tegenstanders te stampen.

De sprong & de buil zijn multiplayer gelijktijdig slechts met maximaal vier spelers. Verzamel de lokale bemanning en hebben een ontploffing.

Math:: De combinatoriek is een module Perl die combinaties en permutaties op lijsten kan uitvoeren.

SYNOPSIS

Beschikbaar als voorwerp - georiënteerde API.

gebruik Math:: Combinatoriek;

mijn @n = qw (B c);
mijn $combinat = Math:: Combinatorics->new (telling => 2,
gegevens => [@n],
);

druk „combinaties van 2 van: “ .join („„, @n). „n“;
druk „“. („--“ scalair x (@n)). „n“;
terwijl (mijn @combo = $combinat->next_combination) {
de druk treedt toe (, @combo). „n“;
}

druk „n“;

druk „permutaties van 3 van: “ .join („„, @n). „n“;
druk „“. („--“ scalair x (@n)). „n“;
terwijl (mijn @permu = $combinat->next_permutation) {
de druk treedt toe (, @permu). „n“;
}

output:

Of beschikbaar via uitgevoerde functies herschik, combineer, en factor.

gebruik Math:: Combinatoriek;

mijn @n = qw (B c);
druk „combinaties van 2 van: “ .join („„, @n). „n“;
druk „“. („--“ scalair x (@n)). „n“;
de druk treedt toe („n“, kaart {treed“ „, @$_} toe combineert (2, @n)), „n“;
druk „n“;
druk „permutaties van 3 van: “ .join („„, @n). „n“;
druk „“. („--“ scalair x (@n)). „n“;
de druk treedt toe („n“, kaart {treed“ „, @$_} toe herschikt (@n)), „n“;

Output:

combinaties van 2 van: B c

B
a. c.
B c

permutaties van 3 van: B c

B c
a. c. B
B a. c.
B c a
c B
c B a

De output van beide soorten vraag is het zelfde, maar de object-oriented benadering verbruikt veel minder geheugen voor grote reeksen.

ENV:: De dreun is een uitbreiding Perl voor de toegang tot van _all_ de variabelen van het dreunmilieu.

SYNOPSIS

gebruik ENV:: Dreun;

Standaard interface:

mijn @var = get_env_var („SORCERER_MIRRORS“,
Bron => „/etc/sorcery/config“,);
druk „SORCERER_MIRRORS via get_env_var: n“,
treed („n“, @var), „ncount =“, scalaire @var, „n“ toe;

@var = ENV:: Dreun:: SORCERER_MIRRORS
(Bron => „/etc/sorcery/config“,);
druk „SORCERER_MIRRORS via naam: n“,
treed („n“, @var), „ncount =“, scalaire @var, „n“ toe;

mijn @keys = get_env_keys (Bron => „/etc/sorcery/config“,
SourceOnly => 1,);
druk „eerst 10 sleutels: n“, kaart {“ $_n "} @keys [0..9];
Voorwerp - georiënteerde interface:
mijn $be = ENV:: Bash->new (Bron => „/etc/sorcery/config“,
Sleutels => 1,);
mijn @var = $be->get („SORCERER_MIRRORS“);
de druk „SORCERER_MIRRORS via krijgt: n“,
treed („n“, @var), „ncount =“, scalaire @var, „n“ toe;

@var = $be->SORCERER_MIRRORS;
druk „SORCERER_MIRRORS via naam: n“,
treed („n“, @var), „ncount =“, scalaire @var, „n“ toe;

$be = ENV:: Bash->new (Sleutels => 1,);
@var = $be->HOSTTYPE;
druk „HOSTTYPE via naam: n“,
treed („n“, @var), „ncount =“, scalaire @var, „n“ toe;

als ($be->exists (BASH_VERSINFO)) {
druk „BASH_VERSINFO =>n“,
treed („n“, $be->BASH_VERSINFO), „n“ toe;
}

mijn %options = $be->options ([], Sleutels => 1);
De interface van de KNOEIBOEL van de band:
mijn %env = ();
band %env, „ENV:: Dreun“, Bron =>“ /etc/sorcery/config ", ForceArray => 1;

mijn $var = $env {SORCERER_MIRRORS};
druk „SORCERER_MIRRORS via gebonden knoeiboel: n“,
treed („n“, @$var), „ncount =“, scalaire @$var, „n“ toe;

$var = $env {HOSTTYPE};
druk „HOSTTYPE via gebonden knoeiboel: n“,
treed („n“, @$var), „ncount =“, scalaire @$var, „n“ toe;

terwijl (mijn ($key, $value) = elke %env) {
de druk „$key =>n“, treedt („n“, @$value), „n“ toe;
}

Top:: De speelkameraad is een module Perl om de folder van de playboyspeelkameraad voor speelkameraadinformatie te raadplegen.

SYNOPSIS

gebruiks Top:: Speelkameraad;

mijn $playmate = nieuwe Top:: Speelkameraad („2003“, „04“);

druk „Details voor speelkameraad“. $playmate-> {„Naam“}. „n“;
druk „Geboortedatum“. $playmate-> {„Geboortedatum“}. „n“;
druk „Geboorteplaats“. $playmate-> {„Geboorteplaats“}. „n“;
druk „Mislukking“. $playmate-> {„Mislukking“}. „n“;
druk „Taille“. $playmate-> {„Taille“}. „n“;
druk „Heupen“. $playmate-> {„Heupen“}. „n“;
druk „Hoogte“. $playmate-> {„Hoogte“}. „n“;
druk „Gewicht“. $playmate-> {„Gewicht“}. „n“;

Netto:: UPCDatabase is een module Perl met een eenvoudige interface OO aan UPCDatabase.com

SYNOPSIS

netto gebruik:: UPCDatabase;
mijn $upcdb = Netto:: UPCDatabase->new;

druk < pre >;

druk „n [raadpleging] n“;
mijn $upc = 035000764119;
mijn $item = $upcdb->lookup ($upc);
druk „UPC: $item-> {upc} n“;
als ($item-> {fout}) {
druk „Fout: $item-> {fout} n“;
}
anders {
druk „Product: $item-> {beschrijving} n“;
druk „Grootte: $item-> {grootte} n“;
}

druk „n [convertUpcE] n“;
mijn $upcE = 01212901;
mijn $upcA = $upcdb->convertUpcE ($upcE);
druk „UPCE: $upcA-> {upcE} n“;
als ($upcA-> {fout}) {
druk „Fout: $upcA-> {fout} n“;
}
anders {
druk „UPCA: $upcA-> {upc} n“;
}

druk „n [calculateCheckDigit] n“;
mijn $upcC = 01200000129C;
mijn $upcA = $upcdb->calculateCheckDigit ($upcE);
druk „UPCC: $upcA-> {upcC} n“;
als ($upcA-> {fout}) {
druk „Fout: $upcA-> {fout} n“;
}
anders {
druk „UPCA: $upcA-> {upc} n“;
}

druk < /pre >;

XML:: DOM:: De module van Perl van XML_Base kan van toepassing zijn xml: basis om waarden toe te schrijven.

SYNOPSIS

gebruik XML:: DOM:: XML_Base;
mijn $parser = XML:: DOM:: Parser->new ();

mijn $xml = qq (





);

# bouwstijl DOM
mijn $dom = $parser->parse ($xml);

# krijg sommige elementen
mijn $endo = $dom->getElementsByTagName (endo) - >item (0);
mijn $meso = (meso) $dom->getElementsByTagName - >item (0);
mijn $ecto = $dom->getElementsByTagName (ecto) - >item (0);

druk $endo->getBase (). „n“; # a/b/c/
druk $meso->getBase (). „n“; # a/b/
druk $ecto->getBase (). „n“; # a

druk $endo->getAttributeWithBase (x). „n“; # a/b/c/3
druk $meso->getAttributeWithBase (x). „n“; # a/b/2
druk $ecto->getAttributeWithBase (x). „n“; # a/1

Zet: om: AcrossLite is een module Perl om binaire AcrossLite raadseldossiers in tekst om te zetten.

SYNOPSIS

het gebruik zet: om: AcrossLite;

mijn $ac = Bekeerling:: AcrossLite->new ();
$ac->in_file (/home/doug/puzzles/Easy.puz);
$ac->out_file (/home/doug/puzzles/Easy.txt);
$ac->puz2text;

of

het gebruik zet: om: AcrossLite;

mijn $ac = Bekeerling:: AcrossLite->new ();
$ac->in_file (/home/doug/puzzles/Easy.puz);
mijn $text = $ac->puz2text;

of

het gebruik zet: om: AcrossLite;

mijn $ac = Bekeerling:: AcrossLite->new ();
$ac->in_file (/home/doug/puzzles/Easy.puz);
mijn $ac->parse_file;
mijn $title = $ac->get_title;
mijn $author = $ac->get_author;
mijn $copyright = $ac->get_copyright;
mijn @solution = $ac->get_solution;
mijn @diagram = $ac->get_diagram;
mijn $across_clues = $ac->get_across_clues;
mijn $down_clues = $ac->get_down_clues;

of

het gebruik zet: om: AcrossLite;

mijn $ac = Bekeerling:: AcrossLite->new ();
$ac->in_file (/home/doug/puzzles/Easy.puz);

mijn ($across_hashref, $down_hashref) = get_across_down;

mijn %across= %$across_hashref;
foreach mijn $key (soort {$a <=> $b} sleutels %across) {
druk „Richting: $across {$key} {richting} n“;
aantal van de druk het „Aanwijzing: $across {$key} {clue_number} n“;
druk „Rij: $across {$key} {rij} n“;
druk „Col.: $across {$key} {kolom} n“;
druk „Aanwijzing: $across {$key} {aanwijzing} n“;
druk „Oplossing: $across {$key} {oplossing} n“;
druk „Lengte: $across {$key} {lengte} nn“;
}

mijn %down= %$down_hashref;
foreach mijn $key (soort {$a <=> $b} sleutels %down) {
druk „Richting: $down {$key} {richting} n“;
aantal van de druk het „Aanwijzing: $down {$key} {clue_number} n“;
druk „Rij: $down {$key} {rij} n“;
druk „Col.: $down {$key} {kolom} n“;
druk „Aanwijzing: $down {$key} {aanwijzing} n“;
druk „Oplossing: $down {$key} {oplossing} n“;
druk „Lengte: $down {$key} {lengte} nn“;
}

Zet: om: AcrossLite wordt gebruikt om binaire AcrossLite raadseldossiers in tekst om te zetten.

Het Menu van de Buil van de sprong n is een grafische frontend om nBuil te springen. Het wordt geschreven in C#/Gtk#/Mono.

Dank aan iedereen wie hielp deze versie mogelijk maken.

Zaken:: GestPayCrypt is een interface Perl aan het Italiaanse online betalingssysteem GestPay.

SYNOPSIS

#
# Verzoek
#

gebruiks Zaken:: GestPayCrypt;
mijn $obj = nieuwe Zaken:: GestPayCrypt;

$obj->SetShopLogin ($ShopLogin);
$obj->SetCurrency (Currency);
$obj->SetAmount ($Amount);
$obj->SetShopTransactionID ($ShopTransationID);
$obj->SetLanguage ($Language);

$obj->Encrypt ();

als ($obj->GetErrorCode ()) {
druk Fout: , $obj->GetErrorCode (),
$objCrypt->GetErrorDescription ();
} anders {
mijn $a = $obj->GetShopLogin ();
mijn $b = $obj->GetEncryptedString ();
druk qq~




~;
}

#
# Reactie
#

gebruiks Zaken:: GestPayCrypt;
mijn $obj = nieuwe Zaken:: GestPayCrypt;

$obj->SetShopLogin ($ShopLogin);
$obj->SetEncryptedString ($b);

$obj->Decrypt ();

als ($objCrypt->GetErrorCode ()) {
druk Fout: , $obj->GetErrorCode (),
$objCrypt->GetErrorDescription ();
} anders {
druk ShopLogin: , $obj->GetShopLogin (), „n“;
druk Munt: , $obj->GetCurrency (), „n“;
druk Bedrag: , $obj->GetAmount (), „n“;
druk ShopTransactionID: , $obj->GetShopTransactionID (), „n“;
druk BuyerName: , $obj->GetBuyerName (), „n“;
druk BuyerEmail: , $obj->GetBuyerEmail (), „n“;
druk TransactionResult: , $obj->GetTransactionResult (), „n“;
druk AuthorizationCode: , $obj->GetAuthorizationCode (), „n“;
druk BankTransactionID: , $obj->GetBankTransactionID (), „n“;
druk ErrorCode: , $obj->GetErrorCode (), „n“;
druk ErrorDescription: , $obj->GetErrorDescription (), „n“;
druk AlertCode: , $obj->GetAlertCode (), „n“;
druk AlertDescription: , $obj->GetAlertDescription (), „n“;
druk CustomInfo: , $obj->GetCustomInfo (), „n“;
}

SYNOPSIS

#
# Verzoek
#

gebruiks Zaken:: GestPayCryptHS;
mijn $obj = nieuwe Zaken:: GestPayCryptHS;

$obj->SetShopLogin ($ShopLogin);
$obj->SetCurrency (Currency);
$obj->SetAmount ($Amount);
$obj->SetShopTransactionID ($ShopTransationID);
$obj->SetLanguage ($Language);

$obj->Encrypt ();

als ($obj->GetErrorCode ()) {
druk Fout: , $obj->GetErrorCode (),
$objCrypt->GetErrorDescription ();
} anders {
mijn $a = $obj->GetShopLogin ();
mijn $b = $obj->GetEncryptedString ();
druk qq~




~;
}

#
# Reactie
#

$obj->SetShopLogin ($ShopLogin);
$obj->SetEncryptedString ($b);

$obj->Decrypt ();

als ($objCrypt->GetErrorCode ()) {
druk Fout: , $obj->GetErrorCode (),
$objCrypt->GetErrorDescription ();
} anders {
druk ShopLogin: , $obj->GetShopLogin (), „n“;
druk Munt: , $obj->GetCurrency (), „n“;
druk Bedrag: , $obj->GetAmount (), „n“;
druk ShopTransactionID: , $obj->GetShopTransactionID (), „n“;
druk BuyerName: , $obj->GetBuyerName (), „n“;
druk BuyerEmail: , $obj->GetBuyerEmail (), „n“;
druk TransactionResult: , $obj->GetTransactionResult (), „n“;
druk AuthorizationCode: , $obj->GetAuthorizationCode (), „n“;
druk BankTransactionID: , $obj->GetBankTransactionID (), „n“;
druk ErrorCode: , $obj->GetErrorCode (), „n“;
druk ErrorDescription: , $obj->GetErrorDescription (), „n“;
druk AlertCode: , $obj->GetAlertCode (), „n“;
druk AlertDescription: , $obj->GetAlertDescription (), „n“;
druk CustomInfo: , $obj->GetCustomInfo (), „n“;
}

Math:: Algebra:: De symbolen is een Symbolische Algebra in Zuivere Perl.

SYNOPSIS

Voorbeeld symbols.pl
#! perl - w - I.

gebruik Math:: Algebra:: Symbolen hyper=>1;
gebruiks Test:: Eenvoudige tests=>5;

($n, $x, $y) = symbolen (qw (x-y n));

$a += ($x ** 8 - 1)/($x-1);
$b += zonde ($x) ** 2 + cos. ($x) ** 2;
$c += (zonde ($n*$x) + cos. ($n*$x))- >d->d->d->d/(zonde ($n*$x) +cos ($n*$x));
$d = tanh ($x+$y) == (tanh ($x) +tanh ($y))/(1+tanh ($x) *tanh ($y));
($e, $f) = @ {($x ** 2 eq 5*$x-6) > $x};

druk „$an$bn$cn$dn$e, $fn“;

o.k. („$a“ eq $x+$x ** 2+$x ** 3+$x ** 4+$x ** 5+$x ** 6+$x ** 7+1);
o.k. („$b“ eq 1);
o.k. („$c“ eq $n ** 4);
o.k. („$d“ eq 1);
o.k. („$e, $f“ eq 2.3);

FrameNet:: WordNet:: De omweg is een WordNet aan Omweg FrameNet.

SYNOPSIS

gebruik FrameNet:: WordNet:: Omweg;

# Zal de verwezenlijking zonder parameters, $WNHOME en $FNHOME worden gebruikt
mijn $detour = FrameNet:: WordNet:: Detour->new;

# Verwezenlijking met sommige parameters
mijn $detour2 = FrameNet:: WordNet:: Detour->new (- wnhome => /path/to/WordNet,
- fnhome => /path/to/FrameNet
- caching => 1,
- beperkte => undef);

mijn $result = $detour->query („walk#v#1“);

als ($result->is_ok) {
druk „Beste kaders: n“;
de druk treedt toe (, @ {$result->get_best_framenames}). „n“;

druk „Alle kaders: n“;
de druk treedt toe (, @ {$result->get_all_framenames}). „n“;

druk „Alle kaders met gewichten: n“;
foreach mijn $frame (@ {$result->get_all_frames}) {
druk $frame->name. „: “;
druk $frame->get_weight. „n“;
}
} anders {
druk $result->message. „n“;
}