hoper journal

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Messenger;

namespace WindowsLiveMessengerAgent
{
   public class MessengerAddIn
       : IMessengerAddIn
   {
       private MessengerClient _client;
       private void IncomingTextMessage(object sender,
     IncomingTextMessageEventArgs e)
       {
           if (_client.LocalUser.Status == UserStatus.Away)
               _client.SendTextMessage(
     "Lo siento, en este momento me encuentro ausente" +
     "\nDeja tu mensaje y me comunico más tarde\n\n" +
     _client.LocalUser.FriendlyName, e.UserFrom);

       }
       #region IMessengerAddIn Members

       public void Initialize(MessengerClient messenger)
       {
           _client = messenger;

           _client.AddInProperties.FriendlyName =
     "WindowsLiveMessengerAgent";
           _client.AddInProperties.Description =
     "Este agente responde cuando no estas en linea.";

           _client.IncomingTextMessage +=
               new EventHandler<IncomingTextMessageEventArgs>
           (this.IncomingTextMessage);
       }

       #endregion
   }
}

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

#define M_PI       3.14159265358979323846f

int _tmain(int argc, _TCHAR* argv[])
{  
  DWORD start = GetTickCount();
  const int N = 200000; 
  float a[200000] = {0};

  for (int i=0; i<N; i++)
 a[i] = (float)i;


  for (int i=0; i<N; i++)
 a[i] = 
 sqrtf(sqrtf(cosf(a[i] / 1024  * (M_PI / 180.0f))) * sinf(1.0f)) *
 sqrtf(sqrtf(cosf(a[i] / 1024  * (M_PI / 180.0f))) * sinf(1.0f)) *
 sqrtf(sqrtf(cosf(a[i] / 1024  * (M_PI / 180.0f))) * sinf(1.0f));

 
  DWORD end = GetTickCount();
  printf("Processing time: %d %d (ms) \n" , end - start);

  system("PAUSE");
  return 0;
}

#include <tchar.h>
#include <stdio.h>
#include <cuda.h>
#include <cutil.h>

#define M_PI       3.14159265358979323846

__global__ void kernel(float *a, int N)
{
 int idx = blockIdx.x * blockDim.x + threadIdx.x;
 if (idx<N) a[idx] =
 sqrtf(sqrtf(cosf(a[idx] / 1024  * (M_PI / 180.0f))) * sinf(1.0f)) *
 sqrtf(sqrtf(cosf(a[idx] / 1024  * (M_PI / 180.0f))) * sinf(1.0f)) *
 sqrtf(sqrtf(cosf(a[idx] / 1024  * (M_PI / 180.0f))) * sinf(1.0f));
}


int main(void)
{
 unsigned int timer = 0;
 CUT_SAFE_CALL(cutCreateTimer(&timer));
 CUT_SAFE_CALL(cutStartTimer(timer));

 float *a_h, *a_d; 
 const int N = 200000; 

 size_t size = N * sizeof(float);
 a_h = (float *)malloc(size); 
      

 cudaMalloc((void **) &a_d, size);  

 for (int i=0; i < N; i++)
 a_h[i] = (float)i;

 cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);


 int block_size = 4;
 int n_blocks = N/block_size + (N%block_size == 0 ? 0:1);


 kernel <<< n_blocks, block_size >>> (a_d, N);


 cudaMemcpy(a_h, a_d, sizeof(float)*N, cudaMemcpyDeviceToHost);
 CUT_SAFE_CALL(cutStopTimer(timer));


 printf("Processing time: %f (ms) \n", cutGetTimerValue(timer));
 CUT_SAFE_CALL(cutDeleteTimer(timer));

 free(a_h);
 cudaFree(a_d);
 system("PAUSE");
}

#light

#I @"C:\Program Files\XNA\v2.0\References\Windows\x86"

#r "Microsoft.Xna.Framework.dll"
#r "Microsoft.Xna.Framework.Game.dll"

open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Graphics
open System

type XNAGame = class
  inherit Game as base

  val mutable graphics : GraphicsDeviceManager

  new() as this =
      {
          graphics = null
      }
      then
          this.graphics <- new GraphicsDeviceManager(this)

  override this.Draw(gameTime) =
      let gd = this.graphics.GraphicsDevice
      gd.Clear(Color.CornflowerBlue)
  end

let Main() =
  let game = new XNAGame()
  game.Run()

[<STAThread>]
do Main()

@if "%_echo%"=="" echo off
setlocal

..\..\..\bin\fsc.exe xna.fs
if ERRORLEVEL 1 goto Exit

:Exit
pause
xna.exe
endlocal

exit /b %ERRORLEVEL%

//Estas variables representan las matrices de posición de nuestro objeto
//la matriz de nuestra camara, y nuestra proyección
float4x4 World;
float4x4 View;
float4x4 Projection;


//Esta estructura indica que es lo que va a tomar el shader
//En este caso solo tomara la posición del vértice, podemos agregar
//las coordenadas de textura, normales, colores, etc.
struct VertexShaderInput
{
   float4 Position : POSITION0;
};

//Esto es muy parecido a la estructura de entrada, pero aquí­ especificamos
//que queremos que devuelva nuestro método
struct VertexShaderOutput
{
   float4 Position : POSITION0;
};

//Esta función es nuestro vertex shader
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
   VertexShaderOutput output;
  
 //Sólo aplicaremos una sencilla transormación
   float4 worldPosition = mul(input.Position, World);
   float4 viewPosition = mul(worldPosition, View);
   output.Position = mul(viewPosition, Projection);

   return output;
}

//Esta función es nuestro pixel shader
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
 //Aquí­ especificamos que queremos que para todo pí­xel
       //que se dibuje lo pinte de color rojo :)
 //podemos por ejemplo regresar el valor de una textura respecto
       //a la coordenada actual
   return float4( 1, 0, 0, 1);
}

//Aqui especificamos nuestras técnicas
//un archivo fx puede tener varias técnicas
technique Technique1
{
 //Para cada pasada especificamos que funciones vamos a llamar
 //y ademas debemos de decirle bajo que perfil se compilarán
   pass Pass1
   {
       VertexShader = compile vs_1_1 VertexShaderFunction();
       PixelShader = compile ps_1_1 PixelShaderFunction();
   }
} 

Model _model;
Effect _effect;

        protected override void LoadContent()
       {
           // Create a new SpriteBatch, which can be used to draw textures.
           spriteBatch = new SpriteBatch(GraphicsDevice);

           _model = Content.Load<Model>("model");
           _effect = Content.Load<Effect>("Effect1");

           ///Esto va a quitarle el efecto actual al modelo y establecera el que
           ///le estamos asignando
           foreach (ModelMesh mesh in _model.Meshes)
               foreach (ModelMeshPart part in mesh.MeshParts)
                   part.Effect = _effect;

           // TODO: use this.Content to load your game content here
       }
       protected override void Draw(GameTime gameTime)
       {
           graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
          
           float aspectRatio = graphics.GraphicsDevice.Viewport.Width /
graphics.GraphicsDevice.Viewport.Height;


           //Definimos la tecnica
           _effect.CurrentTechnique = _effect.Techniques["Technique1"];

           _effect.Parameters["World"].SetValue
(Matrix.CreateWorld(Vector3.Zero, Vector3.Forward, Vector3.Up));
           _effect.Parameters["View"].SetValue
(Matrix.CreateLookAt(new Vector3(0.0f, 5.0f, -10.0f), Vector3.Zero, Vector3.Up));
           _effect.Parameters["Projection"].SetValue
(Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f),
                                        aspectRatio, 1.0f, 10000.0f));
          
           //Actualizamos el shader
           _effect.CommitChanges();

           foreach (ModelMesh mesh in _model.Meshes)
               foreach (Effect effect in mesh.Effects)
                   mesh.Draw();


           base.Draw(gameTime);
       }