Programmation AS3

1 2 suivant

Mardi 24 février 2009 2 24 /02 /2009 00:09

[AS3] La programmation ActionScript 3 [/AS3]

Petit prélude pour ceux qui découvre ce langage.

La langage actionscript 3 est basé sur la spécification ECMAScript (ECMA 262) ainsi que partiellement sur l'ECMAScript 4. Ces derniers constituent le coeur du langage et englobent des types natifs tels que Array, Date, Object, String etc. Adossé à l'ECMAScript on trouve l'API du lecteur Flash regroupé dans un package "flash". Les classes de ce package sont importées automatiquement au sein de l'environnement auteur de Flash CS3 ou Flash CS4. Le developpement AS est possible gratuitement grâce à Flash developp ou au SDK de Flex ou via des softs (payants) tels que Flex Builder ou Flash Pro. Les différents lecteurs AS3 sont, Flash (application destinée au web), AIR (application de bureau), et Flash Lite (application destinée au téléphone Mobile). Les applications peuvent donc être portées sur de nombreux supports pour de nombreux usages. La présence d'un IDE (Flash CS3 ou CS4) permet une prise en main rapide du langage et permet à des non-développeurs de profiter d'outils d'animations graphiques puissants! L'AVM 2, la machine virtuelle de l'AS, transcrit le bytecode en langage machine (compiation just-in-time). J'ai personnellement découvert ce langage après avoir tenter quelques expériences en Java ce qui m'a facilité l'apprentissage. J'ai du faire un site web et je me suis tourné vers Flash, je suis depuis resté fidèle à ce langage... J'espère que les sources que vous trouverez ici pourrons vous être utiles...

Par Gilles De Truchis - Publié dans : Programmation AS3
Ecrire un commentaire - Voir les commentaires - Recommander

Mercredi 25 février 2009 3 25 /02 /2009 22:58

[AS3] Analyse Combinatoire [/AS3]

Cette article fait partie d'une series de pré-requis nécessaire à la programmation d'un Pricer d'Option

Dans l'article sur le modèle binomial on cherche à resoudre:

résultat de l'analyse combinatoire entre j et N. L'implémentation en AS3 peut être réalisée ainsi:

package fx.bidesign.maths
{
    import fx.bidesign.maths.Factorial;

    public class Combination
    {

        public function Combination()
        {

        }
        public static function evaluate( n:int, k:int ):Number
        {
            return Factorial.evaluate( n ) / ( Factorial.evaluate( k ) * Factorial.evaluate( n - k ) );
        }
    }
}

Cette classe appartient au package fx.bidesign.maths. Les sources seront mises à dispositions lorsques l'ensemble des tutoriaux concernant le pricer seront publiés Voici la classe factoriel:

package fx.bidesign.maths
{
    public class Factorial
    {
        public function Factorial()
        {

        }
        public static function evaluate( d:int )
        {
            var ret:Number = 1;
            for (var i:int = 2; i <= d; i++)
                ret *= i;
            return ret;
        }
    }
}

Cette classe appartient au package fx.bidesign.maths. Les sources seront mises à dispositions lorsques l'ensemble des tutoriaux concernant le pricer seront publiés

Par Gilles De Truchis - Publié dans : Programmation AS3
Ecrire un commentaire - Voir les commentaires - Recommander

Mercredi 25 février 2009 3 25 /02 /2009 23:05

[AS3] Loi Normale [/AS3]

Cette article fait partie d'une series de pré-requis nécessaire à la programmation d'un Pricer d'Option

Dans la formule de BS avec dividende continue on note N la fonction de répartition de la loi normale:

L'implémentation peut être faite de 2 manière. La 1ère, approximative, est présentée en commentaire. La seconde est celle de la fonction de répartition.

package fx.bidesign.maths
{
    import fx.bidesign.maths.Factorial;
    import fx.bidesign.maths.GammaEuler;

    public class ProbabilityTools
    {
        public function ProbabilityTools()
        {

        }

        public static function normalDistribution( p:Number ):Number
        {
            var f:Number;
            var u:Number;
            var s:Number;
            var t:Number;
            var s1:Number;

            u = p * p;

            if (u > 55.5)
            {
                if (p > 0) return 1;
                else return 0;
            }
            else
            {
                s = 0;
                t = 1;
                f = 3;

                while ( s != s1 )
                {
                    s1 = s;
                    s = s + t;
                    t = t * u / f;
                    f = f + 2;
                }
                return p * s / ( Math.sqrt( 8 * Math.atan(1) * Math.exp(u) ) ) + 0.5;
            }
        }
        public static function normalDensity( p:Number ):Number
        {
            return ( 1 / 2 * Math.PI ) * Math.exp( - ( p * p / 2 ) );
        }
        public static function chiDistribution( p:Number, deg:int )
        {

        }
        public static function chiDensity( p:Number, deg:int )
        {
            /*var result:Number = Math.pow( 0.5, deg/ 2 ) / GammaEuler( deg / 2 );

            result *= Math.pow( p, ( deg / 2 ) - 1 ) * Math.exp( - p / 2 );

            return result;*/
        }
        public static function tDistribution( p:Number, deg:int )
        {

        }
        public static function tDensity( p:Number, deg:int )
        {
            /*var result:Number = 1 / Math.sqrt( deg * Math.PI );

            result *= GammaEuler( ( deg + 1 ) / 2 ) / GammaEuler( deg / 2 );

            result *= 1 / Math.pow( 1 + ( p * p / deg ), ( deg + 1 ) / 2 );

            return result;*/
        }
    }
}

Cette classe appartient au package fx.bidesign.maths. Les sources seront mises à dispositions lorsques l'ensemble des tutoriaux concernant le pricer seront publiés

Par Gilles De Truchis - Publié dans : Programmation AS3
Ecrire un commentaire - Voir les commentaires - Recommander

Samedi 28 février 2009 6 28 /02 /2009 23:47

[AS3] Black&Scholes [/AS3]

Avant d'attaquer les greeks voici la classe BlackScholes qui prend donc comme paramètre le spot, le strike price, taux sans risque, la maturité, la volatilité, le dividende et la maturité dont nous aurons l'occasion de reparler.

package fx.bidesign.maths
{
    import fx.bidesign.maths.ProbabilityTools;

    public class BlackScholes
    {

        public function BlackScholes()
        {

        }
        public static function value( s:Number, k:Number, t:Number, v:Number, r:Number, c:Number, p:Number = 1 ):Array
        {
            var d1:Number = ( Math.log( s / k ) + ( r + Math.pow( v, 2 ) / 2 ) * t ) / ( v * Math.sqrt( t ) );
            var d2:Number = d1 - ( v * Math.sqrt( t ) );

            var call:Number = s * Math.exp( - c * t ) * ProbabilityTools.normalDistribution( d1 ) - k * Math.exp( - r * t ) * ProbabilityTools.normalDistribution( d2 );
            var put:Number = - s * Math.exp( - c * t ) * ProbabilityTools.normalDistribution( - d1 ) + k * Math.exp( - r * t ) * ProbabilityTools.normalDistribution( - d2 );

            return [call / p, put / p ];
        }
    }
}

Cette classe appartient au package fx.bidesign.maths. Les sources seront mises à dispositions lorsques l'ensemble des tutoriaux concernant le pricer seront publiés

Par Gilles De Truchis - Publié dans : Programmation AS3
Ecrire un commentaire - Voir les commentaires - Recommander

Dimanche 5 avril 2009 7 05 /04 /2009 15:29

[AS3] Encoder un Wave en AS3 [/AS3]

Qu'il me soit permis de m'éloigner un peu de la finance et de présenter, dans un registre bien plus léger, un tutoriel sur l'utilisation des nouvelles fonctionnalités de la classe Sound sous le flash player 10.

Les développeurs AS3 que vous êtes auront bien-sûr constaté que la classe Sound diffuse, depuis la sortie de flash player 10, un nouvel événement: SampleData. Cet événement est distribué lorsque le lecteur demande de nouvelles données audio et permet de gérer le son généré dynamiquement ou lu. Dans cet environnement, l'objet Sound ne contient pas vraiment de données audio. Il agit en fait en tant que socket pour les données audio qui lui sont distribuées en continu par l'intermédiaire de la fonction écouteur. On va ainsi être en mesure de collecter, via des BytesArray, des échantillons du son généré ou lu. Le flash player 10 inclus parmi ses nouveautés une nouvelle fonctionnalité qui manquait cruellement aux anciennes versions: la méthode FileReference.save( data:*, defaultFileName:String = null). Les données collectées, qui en cet instant sont au format RAW (Real Audio Wrapper), vont alors pouvoir être encodées puis écrites en dur, via cette méthode, sur le disque. Pour plus de précision sur le format des données, on pourra se tourner vers les PCM (Modulation d'impulsion codée). Enfin présentons la méthode star de ce tutoriel: Sound.extract(target:ByteArray, length:Number, startPosition:Number = -1):Number. Cette méthode doit être employée lorsque l'on gére un son généré dynamiquement ou lu, à l'aide d'une fonction que l'on affecte à l'événement SampleData pour un autre objet Sound. En d'autres termes, on va utiliser cette méthode pour extraire les données audio d'un objet Sound. Le flash player autorise un fourchette pour le nombre d'échantillons à fournir: [2048, 8192]. La qualité sera bien-sûr maximal avec 8192.

Pour commencer, nous allons déclarer les objets dont nous avons besoins:

var sound:Sound = new Sound();
var dynamicSound:Sound = new Sound();
var soundChannel:SoundChannel = new SoundChannel();
var samples:ByteArray = new ByteArray();
var sndBytes:ByteArray = new ByteArray();
var myFileRefSave:FileReference = new FileReference();

Sur la scène nous disposons de 2 boutons, l'un de label "Record" et d'occurence "record" sert à lancer le son et collecter les échantillons et l'autre de label "Save" et d'occurence "save" sert à appeler la méthode save de FileReference.

record.addEventListener( MouseEvent.MOUSE_DOWN, startRecord );

function startRecord( pEvt:MouseEvent )
{
    sound = new Track();

    dynamicSound.addEventListener( SampleDataEvent.SAMPLE_DATA, sampleData );
    soundChannel = dynamicSound.play();

    save.addEventListener( MouseEvent.MOUSE_DOWN, stopRecord );
}

function sampleData( pEvt:SampleDataEvent ):void
{
    samples.position = 0;

    var len:Number = sound.extract( samples, 8192 );

    var left:Number;
    var right:Number;

    samples.position = 0;

    sndBytes.writeBytes( samples );

    for ( var c:int=0; c < len; c++ )
    {
        left = samples.readFloat();
        right = samples.readFloat();

        pEvt.data.writeFloat( left );
        pEvt.data.writeFloat( right );
    }
}

function stopRecord( pEvt:MouseEvent )
{
    myFileRefSave.save( FxWaveEncoder.encoder( sndBytes ), "snd.wav" );
}

Notons que Track est le nom de classe (ou liaison pour les anciens d'AS2) d'un son placé dans la librairie.
Avant d'être écrit on converti le son via la méthode static:
FxWaveEncoder.encoder( pSamples:ByteArray, channels:int = 2, bits:int = 16, rate:int = 44100 ):ByteArray

Voici la classe FxWaveEncoder qui permet d'encoder le format. Je remercie les membres de Médiabox qui m'ont aidé à calibrer cette classe:

package
{
    import flash.utils.Endian;
    import flash.utils.ByteArray;

    import flash.events.Event;

    public class FxWaveEncoder
    {

        // writeHeader ( 2, 16, 44100 )
        static public function encoder( pSamples:ByteArray, channels:int = 2, bits:int = 16, rate:int = 44100 ):ByteArray
        {
            var samples:ByteArray = new ByteArray();

            samples.writeBytes( FxWaveEncoder.convert( pSamples ) );

            var bytes: ByteArray = new ByteArray();

            bytes.endian = Endian.LITTLE_ENDIAN;

            bytes.writeUTFBytes( 'RIFF' );

            bytes.writeInt( samples.length - 8 );

            bytes.writeUTFBytes( 'WAVE' );

            bytes.writeUTFBytes( 'fmt ' );

            bytes.writeInt( int( 16 ) );

            bytes.writeShort( int( 1 ) );

            bytes.writeShort( channels );

            bytes.writeInt( rate );

            bytes.writeInt( int( rate * channels * ( bits / 8 ) ) );

            bytes.writeShort( int( channels * ( bits / 8 ) ) );

            bytes.writeShort( bits );

            bytes.writeUTFBytes( 'data' );

            bytes.writeInt( samples.length - 44 );

            bytes.writeBytes( samples );

            bytes.position = 0;

            return bytes;
        }
        static private function convert( pBytes:ByteArray ):ByteArray
        {
            var ba:ByteArray = new ByteArray ( ) ;

            ba.endian = Endian.LITTLE_ENDIAN;

            pBytes.position = 0;

            while( pBytes.position < pBytes.length ) ba.writeShort( pBytes.readFloat() * 32767 );

            return ba;
        }
    }
}

Pour les détails des chunks on pourra se référer aux liens de bas de page de cette article: WAVE
Ce n'est pas très sexy mais bien pratique.

Et voici le résultat:

Télécharger les sources

Par Gilles De Truchis - Publié dans : Programmation AS3
Ecrire un commentaire - Voir les commentaires - Recommander

1 2 suivant

Un problème d'affichage...?

Certaines pages de ce site contiennent des animations Flash qui nécessitent la dernière version du flash player.

haut de page