Hypercube en 3,4,...,10 dimensions !!

Soyez le premier à donner votre avis sur cette source.

Vue 7 145 fois - Téléchargée 550 fois

Description

Voila un programme marrant qui fait reflechir.
Qu'est ce qu'une hypercube en 4 dimensions ? comment le construire ? et bien pareil que le cube avec des carres (patron d'un cube) ... mais en dimension 4 !

Ce programme montre la projection d'hypercube sur le plan-ecran de votre ordinateur.
Pour avoir des informations sur les hypercubes cliquer avec la souris sur la fenetre (sur le blanc ou le noir), mais il faut attendre l'ouverture de la boite de message ( c'est un peu long).

Si vous avez des questions ... n'hesitez pas.

Source / Exemple :


#ifndef _UTIL_H_
	#include "util.h"
#endif // _UTIL_H_

#ifndef _MATH_H_
	#include "math.h"
#endif // _MATH_H_

#ifndef _LIST_H_
	#include "list.h"
#endif // _LIST_H_

#ifndef _WINUTIL_H_
	#include "winutil.h"
#endif // _WINUTIL_H_

//-------------------------------------------------
// VERTEX
//-------------------------------------------------
typedef struct tagVERTEX
  {
  DBL_LIST  other;

  P_VECTND  p0;
  P_VECTND  p1;

  COLORREF  color;
  }VERTEX,*P_VERTEX,**PP_VERTEX;

//-------------------------------------------------
void PushVertex(P_VERTEX first,P_VECTND p0,P_VECTND p1,COLORREF color)
{
P_VERTEX p;

AssertPointer(first);
AssertGoodVectND(p0);
AssertGoodVectND(p1);

p         = Malloc(VERTEX,1);
p->color  = color;
p->p0     = p0;
p->p1     = p1;

InsertItemDblList(&first->other,&p->other);
} // PushVertex()

//-------------------------------------------------
BOOL DrawVertex(P_MY_HDC hdc,P_MY_GRAPH graph,P_VERTEX vertex,P_VECTND u,P_VECTND v)
{
P_DBL_LIST L;

L = &vertex->other;

AssertPointer(hdc);
AssertPointer(graph);
AssertPointer(vertex);
AssertGoodVectND(u);
AssertGoodVectND(v);

while(&vertex->other != (L = GetNextItemDblList(L)))
  {
  double    x0,y0,x1,y1;
  P_VERTEX  cur;

  cur = FROM_TO(VERTEX,other,L);

  x0 = DotProductVectND(u,cur->p0);
  y0 = DotProductVectND(v,cur->p0);

  x1 = DotProductVectND(u,cur->p1);
  y1 = DotProductVectND(v,cur->p1);

  myPushPen(hdc,PS_SOLID,0,cur->color);
  MoveToEx(GetHdc(hdc),myConvXFromViewToWindowGraph(graph,x0),myConvYFromViewToWindowGraph(graph,y0),FALSE);
  LineTo(GetHdc(hdc),myConvXFromViewToWindowGraph(graph,x1),myConvYFromViewToWindowGraph(graph,y1));
  myPopPen(hdc);
  }

return TRUE;
} // DrawVertex()

//-------------------------------------------------
BOOL PopVertex(P_VERTEX first)
{
P_DBL_LIST  L;

L = GetNextItemDblList(&first->other);
if(L == &first->other)
  {
  return FALSE;
  }
else
  {
  BOOL      r;
  P_VERTEX  p;
  
  p = FROM_TO(VERTEX,other,L);
  r = RemoveItemDblList(&first->other,L);
  Free(p->p0);
  Free(p->p1);
  Free(p);
  return r;
  }
} // PopVertex()

//-------------------------------------------------
// HYPER_CUBE
//-------------------------------------------------
typedef struct tagHYPER_CUBE
  {
  int         dim;        // dimension de l'hypercube
  MY_GRAPH    graph;      // graphique
  VERTEX      vertex;     // les lignes formants l'hypercube
  HRGN        region;     // region GDI (correspond au <rcWindow> de <graph>
  P_VECTND    u,v;        // deux vecteurs formant un plan (ce sont les "yeux")
  P_VECTND    du,dv;
  }HYPER_CUBE,*P_HYPER_CUBE,**PP_HYPER_CUBE;

//-------------------------------------------------
void FillVectND(P_VECTND u,double d)
{
int     dim,i;
double  *p;

dim = u->dim;
p   = u->coord;

for(i=0;i<dim;i++)
  {

  • p = d;
p ++; } } // FillVectND() //------------------------------------------------- void RandomVectND(P_VECTND u,double min,double max) { int dim,i; double *p; dim = u->dim; p = u->coord; for(i=0;i<dim;i++) {
  • p = RandomDouble(min,max);
p ++; } } // RandomVectND() //------------------------------------------------- COLORREF getColor(int n) { static COLORREF tab[] = { RGB(255,0,0), RGB(0,255,0), RGB(0,0,255), RGB(255,255,0), RGB(255,0,255), RGB(0,255,255), RGB(255,125,125), RGB(125,255,125), RGB(125,125,255), RGB(255,255,255) }; Assert(n >= 0); if(n >= COUNT(tab)) { return RGB_WHITE; } else { return tab[n]; } } // getColor() //------------------------------------------------- void BuildHyperCube(P_HYPER_CUBE p) { int dim,nVertex,i; dim = p->dim; nVertex = 1 << (dim - 1); for(i=0;i<dim;i++) // balaye tous les groupes d'aretes paralleles a un1 vecteur de base { int j; for(j=0;j<nVertex;j++) // balaye toutes les aretes paralleles a un vecteur de base { int k,mask; P_VECTND p0,p1; // point de depart et d'arriver de l'arete double *pP0,*pP1; p0 = CreateVectND(dim); p1 = CreateVectND(dim); pP0 = p0->coord; pP1 = p1->coord; mask = 1; for(k=0;k<dim;k++) // initialise l'arete en question { if(k != i) {
  • pP0 = *pP1 = (j & mask) ? -1. : +1.;
mask <<= 1; } else {
  • pP0 = -1.;
  • pP1 = +1.;
} pP0 ++; pP1 ++; } PushVertex(&p->vertex,p0,p1,getColor(i)); } } } // BuildHyperCube() //------------------------------------------------- // re-arrange les vecteurs <u> et <v> de la bonne facon (en changeant <v>) void Ortho(P_VECTND u,P_VECTND v) { double k; k = DotProductVectND(u,v); AddVectND(v,v,u,1.,-k); // on rend les deux vecteurs orthogonaux } // Ortho() //------------------------------------------------- void ValidateUVHyperCube(P_HYPER_CUBE p) { UnitVectND(p->u); Ortho(p->u,p->v); UnitVectND(p->v); } // ValidateUVHyperCube() //------------------------------------------------- #define MAX_DIM 20 P_HYPER_CUBE CreateHyperCube(int dim) { P_HYPER_CUBE p; P_VERTEX vertex; Assert(dim >= 2 && dim <= MAX_DIM); // on se limite a MAX_DIM dimensions p = Malloc(HYPER_CUBE,1); p->dim = dim; p->region = myCreateEmptyRegion(); p->u = CreateVectND(dim); p->v = CreateVectND(dim); p->du = CreateVectND(dim); p->dv = CreateVectND(dim); InitDblList(&p->vertex.other); vertex = &p->vertex; RandomVectND(p->u,-1.,+1.); SetCoordVectND(p->u,0,1.); // pour s'assuer que le vecteur ne sera pas nul RandomVectND(p->v,-1.,+1.); SetCoordVectND(p->v,1,1.); // pour s'assuer que le vecteur ne sera pas nul ValidateUVHyperCube(p); FillVectND(p->du,0.); FillVectND(p->dv,0.); BuildHyperCube(p); return p; } // CreateHyperCube() //------------------------------------------------- P_HYPER_CUBE ResizeHyperCube(P_HYPER_CUBE p,RECT *pRect) { RECTD rc; double k; AssertPointer(p); AssertPointer(pRect); AssertGDIObject(p->region); DeleteObject(p->region); p->region = myCreateRectRegion(pRect); // longueur de la grande arete d'un hypercube de dimension N : sqrt(N) // pour le carre c'est sqrt(2) // pour le cube c'est sqrt(3) // pour trouver la formule ... utilisez N-1 fois le theoreme de Pythagore k = 1.01*sqrt((double)p->dim); // on rajoute 1% de marge rc.left = -k; rc.top = +k; rc.right = +k; rc.bottom = -k; mySetWindowGraph(&p->graph,pRect); mySetViewGraph(&p->graph,&rc,myMinAspectRatio,NULL); return p; } // ResizeHyperCube() //------------------------------------------------- BOOL DrawHyperCube(P_MY_HDC hdc,P_HYPER_CUBE p) { AssertPointer(p); AssertPointer(hdc); AssertGDIObject(p->region); myPushRegionIndirect(hdc,p->region); DrawVertex(hdc,&p->graph,&p->vertex,p->u,p->v); myPopRegionIndirect(hdc,FALSE); return TRUE; } // DrawHyperCube() //------------------------------------------------- // change l'angle de vu void MoveEyesHyperCube(P_HYPER_CUBE p) { P_VECTND du,dv; int dim; double k,d; AssertPointer(p); dim = p->dim; du = CreateVectND(dim); dv = CreateVectND(dim); RandomVectND(du,-1.,+1.); RandomVectND(dv,-1.,+1.); // coefficient de l'influence du nouveau <du> (ou <dv>) k = 0.05; // longeur du deplacement d = 0.1; //Ortho(p->u,du); //Ortho(p->v,dv); AddVectND(p->du,p->du,du,1.-k,k*d); AddVectND(p->dv,p->dv,dv,1.-k,k*d); AddVectND(p->u,p->u,p->du,1.,1.); AddVectND(p->v,p->v,p->dv,1.,1.); ValidateUVHyperCube(p); Free(du); Free(dv); } // MoveEyesHyperCube() //------------------------------------------------- void DeleteHyperCube(P_HYPER_CUBE p) { AssertPointer(p); AssertGDIObject(p->region); while(PopVertex(&p->vertex)); DeleteObject(p->region); Free(p->du); Free(p->dv); Free(p->u); Free(p->v); Free(p); } // DeleteHyperCube() //------------------------------------------------- // WND_PROC //------------------------------------------------- #define ID_MOVE_EYES 1000 #define FRAME 20 //------------------------------------------------- void Info(HWND hwnd,P_HYPER_CUBE p) { if(NULL == p) { myWarning(hwnd,"Informations sur le programme ...", "HyperCube\r\n" "\r\n" "Un carré c'est en 2 dimensions\r\n" "Un cube c'est en 3 dimensions\r\n" "Un hypercube c'est en N dimensions\r\n" "\r\n" "Cliquez sur les hypercubes pour avoir des informations\r\n" "\r\n" "Programmé par JCDjcd\r\n" ); } else { AssertPointer(p); myWarning(hwnd,"Informations sur l'hypercube ...", "HyperCube de dimension %d\r\n" "\r\n" "Nombre de sommets (2^n) : %d\r\n" "Nombre d' arêtes (n.2^(n-1)) : %d\r\n" "\r\n", p->dim, 1 << p->dim, p->dim * (1 << (p->dim - 1)) ); } } // Info() //------------------------------------------------- int WndProc(P_MY_WINDOW myWindow,HWND hwnd,UINT iMsg,WPARAM wParam,LPARAM lParam) { static HWND hwndStatusBar; static P_HYPER_CUBE hyperCube1,hyperCube2,hyperCube3,hyperCube4; static RECT rcHyperCube1,rcHyperCube2,rcHyperCube3,rcHyperCube4; switch(iMsg) { case WM_CREATE: { int allWidth[5]; // style de fenetre myWindow->bResizedWindow = TRUE; myWindow->bUseBackBuffer = TRUE; myWindow->colorBackGround = RGB_WHITE; // la bar hwndStatusBar = CreateStatusWindow(WS_VISIBLE | WS_CHILD,"",hwnd,100); allWidth[0] = 100; allWidth[1] = 200; allWidth[2] = 300; allWidth[3] = 400; allWidth[4] = -1; SendMessage(hwndStatusBar,SB_SETPARTS,(WPARAM)COUNT(allWidth),(LPARAM)allWidth); SendMessage(hwndStatusBar,SB_SETTEXT,(WPARAM)0,(LPARAM)"\tDimension 3"); SendMessage(hwndStatusBar,SB_SETTEXT,(WPARAM)1,(LPARAM)"\tDimension 4"); SendMessage(hwndStatusBar,SB_SETTEXT,(WPARAM)2,(LPARAM)"\tDimension 5"); SendMessage(hwndStatusBar,SB_SETTEXT,(WPARAM)3,(LPARAM)"\tDimension 10"); SendMessage(hwndStatusBar,SB_SETTEXT,(WPARAM)4,(LPARAM)"\tProgrammé par JCDjcd"); hyperCube1 = CreateHyperCube(3); hyperCube2 = CreateHyperCube(4); hyperCube3 = CreateHyperCube(5); hyperCube4 = CreateHyperCube(10); SetTimer(hwnd,ID_MOVE_EYES,0,NULL); break; } case WM_SIZE: { int cx,cy,cxRect,cyRect; double dx,dy; RECT rcStatusBar,rc; GetWindowRect(hwndStatusBar,&rcStatusBar); cx = LOWORD(lParam); cy = HIWORD(lParam) - myHeightRect(&rcStatusBar); mySetRectWH(&rc,0,0,cx,cy); cxRect = (cx - 3 * FRAME)/2; cyRect = (cy - 3 * FRAME)/2; dx = (1.+((double)cxRect)/((double)cx))/3.; dy = (1.+((double)cyRect)/((double)cy))/3.; mySetRectWH(&rcHyperCube1,0,0,cxRect,cyRect); mySetRectWH(&rcHyperCube2,0,0,cxRect,cyRect); mySetRectWH(&rcHyperCube3,0,0,cxRect,cyRect); mySetRectWH(&rcHyperCube4,0,0,cxRect,cyRect); myCenterRect(&rcHyperCube1,1.,1.,&rc,1.*dx,1.*dy); myCenterRect(&rcHyperCube2,1.,1.,&rc,2.*dx,1.*dy); myCenterRect(&rcHyperCube3,1.,1.,&rc,1.*dx,2.*dy); myCenterRect(&rcHyperCube4,1.,1.,&rc,2.*dx,2.*dy); ResizeHyperCube(hyperCube1,&rcHyperCube1); ResizeHyperCube(hyperCube2,&rcHyperCube2); ResizeHyperCube(hyperCube3,&rcHyperCube3); ResizeHyperCube(hyperCube4,&rcHyperCube4); SendMessage(hwndStatusBar,iMsg,0,lParam); break; } case WM_TIMER: { switch(LOWORD(wParam)) { case ID_MOVE_EYES: { MoveEyesHyperCube(hyperCube1); MoveEyesHyperCube(hyperCube2); MoveEyesHyperCube(hyperCube3); MoveEyesHyperCube(hyperCube4); myRepaintWindow(hwnd); break; } } break; } case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: { POINT pt; pt.x = LOWORD(lParam); pt.y = HIWORD(lParam); if(PtInRect(&rcHyperCube1,pt)) Info(hwnd,hyperCube1); else if(PtInRect(&rcHyperCube2,pt)) Info(hwnd,hyperCube2); else if(PtInRect(&rcHyperCube3,pt)) Info(hwnd,hyperCube3); else if(PtInRect(&rcHyperCube4,pt)) Info(hwnd,hyperCube4); else Info(hwnd,NULL); break; } // on dessine case WM_PAINT: { P_MY_HDC hdc; int cx,cy; cx = LOWORD(lParam); cy = HIWORD(lParam); hdc = (P_MY_HDC)wParam; myPushPen(hdc,PS_NULL,0,0); myPushBrush(hdc,BS_SOLID,RGB_BLACK,0); { myRectangle(hdc,&rcHyperCube1); myRectangle(hdc,&rcHyperCube2); myRectangle(hdc,&rcHyperCube3); myRectangle(hdc,&rcHyperCube4); } myPopBrush(hdc); myPopPen(hdc); DrawHyperCube(hdc,hyperCube1); DrawHyperCube(hdc,hyperCube2); DrawHyperCube(hdc,hyperCube3); DrawHyperCube(hdc,hyperCube4); myRepaintWindow(hwndStatusBar); break; } // destruction de la fenetre case WM_DESTROY: { KillTimer(hwnd,ID_MOVE_EYES); DeleteHyperCube(hyperCube1); DeleteHyperCube(hyperCube2); DeleteHyperCube(hyperCube3); DeleteHyperCube(hyperCube4); // on quitte le programme PostQuitMessage(0); break; } } return 0; } // WndProc() //------------------------------------------------- // WIN MAIN //------------------------------------------------- int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpszCmdLine,int iCmdShow) { WNDCLASSEX wc; RECT rc; HWND hwnd; int wParamResult; // le programme vient de commencer, on initialise les librairies InitializationLibUtil(); InitializationLibWinutil(hInstance); SetRandom(GetTickCount()); mySetDefaultWindowClass(&wc,hInstance); wc.lpszClassName = "JCD_HyperCube"; SetRect(&rc,0,0,800,600); hwnd = myCreateWindow(&wc, "HyperCube (JCD)", WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN, &rc, TRUE, NULL, NULL, 0, NULL, WndProc ); // on commence la boucle de messages SetDefaultHwnd(hwnd); wParamResult = myRunWindow(hwnd,SW_SHOW); SetDefaultHwnd(NULL); // on a fini le programme, on ferme les librairies CloseLibUtil(); CloseLibWinutil(); CheckingClosingLibUtil(); CheckingClosingLibWinutil(); return wParamResult; } // WinMain()

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
1138
Date d'inscription
mardi 10 juin 2003
Statut
Membre
Dernière intervention
25 janvier 2009
4
Je n'en sais trop rien, je mets toutes mes sources en débutant. De toute maniere ici il ne faut pas se fier a la categorie, quand je vois certaine source "experte" je me marre...
Messages postés
2
Date d'inscription
jeudi 11 juin 2009
Statut
Membre
Dernière intervention
11 novembre 2009

Bonjour,

je suis désolé si la remarque n'apporte pas grand-chose, mais c'est vraiment du code de débutant? :s

merci
Messages postés
215
Date d'inscription
mercredi 30 juillet 2003
Statut
Membre
Dernière intervention
25 septembre 2010

Hey les gars, vous posez vos exos de maths sur la source ?
Messages postés
82
Date d'inscription
vendredi 20 mai 2005
Statut
Membre
Dernière intervention
24 octobre 2005

moi par contre , je voudrais savoir comment calculer la distance minimale est maximale qui sépare l'ypercube de dimension 10 à un point dans l'espace 10D?
Messages postés
3
Date d'inscription
jeudi 17 février 2005
Statut
Membre
Dernière intervention
21 juin 2005

bonjour,moi je voudrai si quelqu'un a un algorithme pour la construction de tous les possibilitées d'hypercubes qu'on peut construire a partir de n point telque n s'ecrit n=2^p merci
Afficher les 13 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.