[critor]

Casio fournit officiellement sous forme d'un add-in (application chez TI) un tableau périodique dénommé Physium pour ses calculatrices Casio Prizm fx-CG10/20, mais aussi Graph 75/85/95 et compatibles.

Ce tableau était ressorti en couleurs lors de la sortie de la Casio Prizm:

Peut-être dans l'optique des examens qui approchent, Casio vient de mettre à jour les deux add-in en question.

• l'add-in pour Graph 75/85/95 et compatibles passe en version 1.11
• l'add-in pour Prizm fx-CG10/20 passe en version 1.01

Ce n'est pas une mise à jour de fonctionnalités mais une mise à jour des données utilisées par l'application, puisque plusieurs choses ont été découvertes depuis sur les derniers éléments du tableau de numéro atomique 112 et suivants.


Liens:
Physium (pour Casio Prizm fx-CG10/20)
Physium (pour Casio Graph 75/85/95 et compatibles)


( Rappelons que pour TI-Nspire, le meilleur tableau périodique est probablement MultiPeriodic, disponible ici )

[critor]

Dans une news précédente, nous te proposions de survoler les fonctionnalités logicielles et mathématiques du nouveau ClassPad II fx-CP400 que Casio prévoit pour la rentrée 2013.

Matériellement, il sera doté d'un écran 4,8 pouces en 320x528 pixels, contre 3,6 pouces en 160x240 pixels pour ses prédécesseurs les Casio ClassPad 300/330.

Il conserve l'écran tactile de ses prédécesseurs, rendant nombre de manipulations intuitives et enfantines via de simples toucher/glisser.

Une nouveauté déjà annoncée par rapport à ses prédécesseurs est son écran couleur!

Ce format d'écran portrait est assez inhabituel pour une calculatrice, et peut-être est-ce une des raisons qui a limité le succès de ses prédécesseurs.

Et bien Casio a cette fois-ci tout prévu avec un nouveau bouton 'Rotate' (rotation):

Une toute petite pression et tu bascules instantanément du mode portrait vers un mode paysage 528x320 explosant littéralement tous les écrans de calculatrices actuels!

Source:
https://edu.casio.com/products/classpad/cp2/index.html

In a previous news, we were showing you the mathematical and software features of the new ClassPad II fx-CP400 which Casio plans for back to school 2013.

Physically, it will have a 4.8 inch 320x528 pixels screen, against a 3.6 inch pixels 160x240 for its predecessors the Casio ClassPad 300/330.

It keeps the touch screen of its predecessors, making many manipulations intuitive and childish via simple touch/slide.

An already announced novelty compared to its predecessors was its color screen!

This portrait screen mode is quite unusual for a calculator, and perhaps this is one of the reasons which limited its predecessors success.

This time Caso lets you choose with a new 'Rotate' button:

A small pressure and you instantly flip from portrait to a 528x320 landscape mode, literally exploding all current calculators displays!

Source:
https://edu.casio.com/products/classpad/cp2/index.html

[critor]

Dans une news précédente, nous te proposions un nouveau concours TI-Planet pour gagner une TI-Nspire CX mais aussi une TI-84 Plus C Silver Edition, avec une chasse au trésor Dragon Ball Z sur Internet dans le contexte de la programmation en langage BASIC!

Le BASIC fut un langage de programmation de référence dans les années 70-80, et il fut fourni d'origine sur la plupart des ordinateurs 8-bits et 16-bits des années 80-90.

Alors certes, nombre d'entre vous n'y êtes probablement pas familiarisés, mais nous allons y remédier de suite afin de vous donner les meilleures chances de gagner!



Peut-être plusieurs d'entre vous ont vu ou entendu parler des dessins animés de vulgarisation scientifique et historique "Il était une fois..." d'Albert Barillé, personnage qui nous a hélas quittés en 2009.
L'Homme, l'Espace, la Vie, les Amériques, les Explorateurs, les Découvreurs, notre Terre... De 1978 à 2008, pas moins de 7 séries vous ont compté les aventures de Maestro, Pierrot, Psi...



Ce qui est moins connu, c'est que dès 1983, les japonais ont répliqué avec un dessin animé du même style, "Ordy ou les grandes découvertes".

127 épisodes furent produits mais seulement 52 diffusés en France.

Ordy, petite créature rose, sort de l'ordinateur de deux frère et soeur japonais de 8-9 ans, et leur explique tout un tas de choses sur l'histoire et la science, pouvant à loisir projeter des images des événements en question et même y téléporter les enfants.

Des épisodes 9 à 12 nous avons droit à une petite séquence d'aventures sur les ordinateurs, et dans l'épisode 10 on a même le droit à un mini tutoriel de programmation utilisant le langage BASIC, et couvrant les instructions d'entrée, d'affectation et de sortie!

Les épisodes sont disponibles en français en bonne qualité sur DailyMotion, mais dans une version où les caractères japonais ont été censurés; soit tout simplement effacés, soit remplacés par de l'anglais surimprimé dans une police inappropriée faisant assez amateur.
Et dans le cas de nos programmes BASIC, c'est assez embêtant...

Et bien je vous offre l'extrait original non saccagé que je viens de numériser depuis une vieille cassette VHS:

Tu as maintenant les bases du langage BASIC, alors viens-vite participer à notre concours Dragon Ball Z!

Liens:
Concours TI-Planet 2013: Chasse au Trésor Dragon Ball Z
Ordy ou les grandes découvertes - épisode 9 "les ordinateurs" - partie 1
Ordy ou les grandes découvertes - épisode 9 "les ordinateurs" - partie 2
Ordy ou les grandes découvertes - épisode 10 "les ordinateurs" - partie 1
Ordy ou les grandes découvertes - épisode 10 "les ordinateurs" - partie 2
Ordy ou les grandes découvertes - épisode 11 "les ordinateurs" - partie 1
Ordy ou les grandes découvertes - épisode 11 "les ordinateurs" - partie 2
Ordy ou les grandes découvertes - épisode 12 "les ordinateurs" - partie 1
Ordy ou les grandes découvertes - épisode 12 "les ordinateurs" - partie 2

[Excale]

Bonjour à tous,

Suite à ma participation au concours Palprem qui allait étrangement trop vite par rapport à ce qu'il est possible de faire en Basic, beaucoup de personnes m'ont demandé d'expliquer comment j’avais fait pour calculer si rapidement le 5000è palindrome premier.

La réponse est pourtant simple, j'ai utilisé ndless.
Le classeur est en fait un programme ndless qui va lui-même ouvrir un "vrai" classeur Nspire.

En pratique voilà ce qu'il se passe:

• L'utilisateur ouvre le faux classeur, qui est en fait un programme ndless
• Le programme copie le vrai classeur dans un fichier bidon
• Le programme demande à l'OS d'ouvrir le classeur bidon en question
• Le programme va créer un hook dans la fonction qui évalue une expression mathématique (c'est à dire qu'il prend la main dans cette fonction, fait quelque chose, et laisse la fonction continuer à s’exécuter normalement).
• L'utilisateur voit un classeur Nspire ouvert
• Il tape palprem(42)
• L'OS arrive dans la fonction qui évalue l'expression mathématique, ce qui donne la main à mon programme
• Le programme regarde si l'expression rentrée est de la forme palprem(nombre) (si il ne trouve pas ça, il ne fait rien et redonne la main à l'OS qui va évaluer le calcul)
• Si il trouve le motif, il récupère le nombre et calcule le nombrième palindrome premier, et ce bien plus rapidement qu'en Basic
• Le programme place ensuite le nombrième palindrome à la place de "palprem(nombre)", et redonne la main à l'OS
• L'OS se retrouve alors avec un nombre à évaluer, et renvoie tout simplement ce nombre
• L'utilisateur voit ce nombre et va alors pouvoir l'utiliser pour.... (zut, ça sert à quoi les palindromes premiers?)

Le code pour ceux que ça intéresse:

Show/Hide spoilerAfficher/Masquer le spoiler

Quelques définitions dont l'adresse du hook

Code: Select all

#include <os.h>
#include <libndls.h>
#include <stdint.h>
#include <inttypes.h>

static const unsigned int addr_exdoc_openclass[] = {0x10009B48, 0x10009B20, 0x10009AE8, 0x10009AE8};
#define EXDOC_OPENCLASS ((int(*)(char*, char*, int))nl_osvalue((int*)addr_exdoc_openclass, sizeof(addr_exdoc_openclass)/sizeof(addr_exdoc_openclass[0])))
static const unsigned int hook_addr_newclass[] =   {0x10027558, 0x100274C4, 0x10026C54, 0x10026BEC};
#define HOOK_NEWCLASS nl_osvalue((int*)hook_addr_newclass, sizeof(hook_addr_newclass)/sizeof(hook_addr_newclass[0]))
static const unsigned int hook_addr_calc[] =       {0x1006CBBC, 0x1006CAEC, 0x1006C2B8, 0x1006C210};
#define HOOK_ADDR_CALC nl_osvalue((int*)hook_addr_calc, sizeof(hook_addr_calc)/sizeof(hook_addr_calc[0]))


Le "vrai" classeur, qu'on inclut directement dans le binaire

Code: Select all

extern void* __file_start__;
extern void* __file_end__;
asm(".globl __file_start__          \n"
    ".globl __file_end__            \n"
    "__file_start__:                \n"
    ".incbin \"palprem_class.tns\"  \n"
    "__file_end__:                  \n");


Code pour trouver le n-ième palindrome premier. Adapté de : http://www.programmingsimplified.com/c/source-code/c-program-find-next-prime-palindrome

Code: Select all

uint32_t palprime(uint32_t m)
{
    uint32_t n, t, r = 0, c, z = 0;

    if(m<=5)
    {
        const int y[] = {0,2,3,5,7,11};
        return y[m];
    }
    else
    {
        n = 101-2;
        z = 5;
    }

    while(z<m)
    {
        printf("%" PRId32 " %" PRId32 "\n",z,n);
        while (TRUE)
        {
            n+=2;
            t = n;

            /* Calculating reverse of number */

            while(t)
            {
                r *= 10;  /* Compound assignment operator r*=10 => r=r*10 */
                r += t%10;
                t /= 10;
            }

            /* if reverse equals original then it is palindrome */

            if (r == n)
            {
                /* Checking prime */

                if ((n%2 == 0) || (n%3 == 0) || (n%5 == 0))
                goto suite;
                c = 7;
                while( c*c<=n)
                {
                    if ((n%c == 0) || (n%(c+4) == 0))
                    break;
                    c+=6;
                }
                if (c*c>n)
                break;
            }
            suite:
            r = 0;
        }
        z++;
    }

    return n;
}


Ce bout permet d'enlever le hook quand on quitte le classeur

Code: Select all

HOOK_DEFINE(newclass) {

    HOOK_UNINSTALL(HOOK_ADDR_CALC, calc_change);
    HOOK_UNINSTALL(HOOK_NEWCLASS , newclass);
    HOOK_RESTORE_RETURN(newclass);
}


Vérifie si l'utilisateur a tapé palstring(nombre), et appelle si besoin palprime()

Code: Select all

char resultstring[0x100];
const unsigned char palstring[] = {0x70, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x70, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6D, 0x00, 0x28, 0x00};

HOOK_DEFINE(calc_change) {

    char* calcul = (char *) HOOK_SAVED_REGS(calc_change)[2];
    if( !memcmp( calcul, &palstring, sizeof(palstring) ) )
    {
        uint32_t input = 0;
        int offset = 0;
        unsigned char currentn = calcul[sizeof(palstring)];
        while( currentn>=0x30 && currentn<=0x39 )
        {
            input = input*10 + (currentn-0x30);
            offset+=2;
            currentn = calcul[sizeof(palstring)+offset]; 
        }
        if( offset!=0 && calcul[sizeof(palstring)+offset]==')' && calcul[sizeof(palstring)+offset+2]==0)
        {
            uint32_t result = palprime(input);
            char resultstringbuf[0x80];
            memset(resultstring   , 0x0, 0x100);
            memset(resultstringbuf, 0x0, 0x80);
            sprintf(resultstringbuf, "%" PRId32 "", result);
            int i;
            for( i=0; i<0x80; i++ )
            {
                resultstring[2*i] = resultstringbuf[i];
            }
            HOOK_SAVED_REGS(calc_change)[2] = (int) resultstring;
        } else
        {
            HOOK_SAVED_REGS(calc_change)[2] = (int) palstring;
        }
    } else
    {
        int i;
        for( i=0; i<0x100; i++ )
        {
            if( calcul[2*i]=='p' && !memcmp( calcul+2*i, &palstring, sizeof(palstring)-2 ))
            {
                HOOK_SAVED_REGS(calc_change)[2] = (int) palstring;
                break;
            }
        }
    }
    HOOK_RESTORE_RETURN(calc_change);
}


Ouvre le classeur et définit les hooks.

Code: Select all

int main()
{
   nl_set_resident();
    FILE *tns_file;
    tns_file = fopen("/logs/palprem.tns","wb");
    fwrite (&__file_start__ , sizeof(char) , 4*(&__file_end__-&__file_start__), tns_file );
    fclose(tns_file);
    EXDOC_OPENCLASS("/logs","palprem.tns",1);
    HOOK_INSTALL(HOOK_ADDR_CALC, calc_change);
    HOOK_INSTALL(HOOK_NEWCLASS, newclass);
    return 0;
}


Je suis ouvert à toutes questions si besoin .

...et si vous voulez télécharger le programme, c'est par ici: http://tiplanet.org/forum/archives_voir.php?id=14699

[mdr1]

Bonjour à tous !

J'ai l'honneur de vous faire part d'un tutoriel de ma composition pour récupérer un programme perdu par un RAM Cleared !

wabbitemu08.gif

Les conditions suivantes devront toutefois être vérifiées :

• Vous possédez une TI-83+/84+.
• Votre programme était archivé juste avant de le mettre en RAM et de le perdre avec un RAM Cleared.
• L'application Calcsys doit être sur votre calculatrice.

Ces trois conditions réunies, vos chances de récupérer votre programme sont environ de 100% si vous suivez bien le tutoriel ! Aucune connaissance sur la calculatrice n'est exigée, tout est détaillé.

Si j'ai pensé à faire ce tutoriel, c'est qu'il m'est déjà arrivé de désarchiver un programme, l'utiliser/l'éditer (ce peut être un programme assembleur aussi), puis pour n'importe quelle raison de me prendre un effacement de RAM, perdant ainsi des heures et des heures de dur labeur de programmation. J'avais donc tout fait en triturant la mémoire de ma calculatrice avec Calcsys... pour finalement réussir à tout récupérer !

Mettez donc dès maintenant Calcsys sur votre calculatrice pour éviter le pire.

Lien : Récupérer un programme perdu par un RAM Cleared