void VLCControlsWnd::SyncVideoPosScrollPosWithVideoPos() { if( VP() ){ libvlc_time_t pos = VP()->get_time(); SetVideoPosScrollPosByVideoPos(pos); } }
void VLCHolderWnd::LibVlcDetach() { if( VP() ) libvlc_media_player_set_hwnd( VP()->get_mp(), 0); MouseHook( false ); }
void ProcessesLocal::Private::readProcStat(struct kinfo_proc *p, Process *ps) { ps->setUserTime(LP(p, uticks) / 10000); ps->setSysTime((LP(p, sticks) + LP(p, iticks)) / 10000); ps->setNiceLevel(PP(p, nice)); ps->setVmSize(VP(p, map_size) / 1024); /* convert to KiB */ ps->setVmRSS(VP(p, prssize) * getpagesize() / 1024); /* convert to KiB */ // "idle","run","sleep","stop","zombie" switch( LP(p, stat) ) { case LSRUN: ps->setStatus(Process::Running); break; case LSSLEEP: ps->setStatus(Process::Sleeping); break; case LSSTOP: ps->setStatus(Process::Stopped); break; default: ps->setStatus(Process::OtherStatus); break; } if (PP(p, stat) == SZOMB) ps->setStatus(Process::Zombie); }
void fusion(objet *t,int d,int m,int f) { int i1=d,i2=m+1,i3=0; objet *temp=(objet *)malloc((f-d+1)*sizeof(objet)); while((i1<=m)&&(i2<=f)) { if(VP(t[i1])<= VP(t[i2])) { temp[i3]=t[i1]; i1++; } else { temp[i3]=t[i2]; i2++; } i3++; } for(;i2<f;i2++,i3++) temp[i3]=t[i2]; for(;i1<m;i1++,i3++) temp[i3]=t[i1]; for(i1=0;i1<i3;i1++) t[i1+d]=temp[i1]; }
void MatrixMultT(Matrix*mtD,Matrix*mtA,Matrix*mtB){ // D = A B^T int i,j; for(i=0;i<mtA->H;i++) for(j=0;j<mtB->H;j++) Elem(mtD,i,j) = VP( Row(mtA,i), Row(mtB,j), mtA->W); }
void MatrixQRDecompColMajor(Matrix*mtR,Matrix*mt){ // gram-schmidt orthonormalization (Lt and Q) double t, *aT[mt->W]; int W = mt->W; int i,j; MatrixClear(mtR); for (i = 0; i < W;i++) { aT[i] = Row(mt,i); for (j = 0; j < i; j++) { Elem(mtR,j,i) = t = VP(aT[j], aT[i], W); VSA(aT[i], aT[j], -t, W); } Elem(mtR,i,i) = t = sqrt(VP(aT[i],aT[i],W)); VSS(aT[i], 1/t, W); } /* Elem(mtR,0,0) = t = sqrt(VP(aT[0],aT[0],W)); VSS(aT[0], 1/t, W); Elem(mtR,0,1) = t = VP(aT[0], aT[1], W); VSA(aT[1], aT[0], -t, W); Elem(mtR,1,1) = t = sqrt(VP(aT[1],aT[1],W)); VSS(aT[1], 1/t, W); /////////// Elem(mtR,0,2) = t = VP(aT[0], aT[2], W); VSA(aT[2], aT[0], -t, W); Elem(mtR,1,2) = t = VP(aT[1], aT[2], W); VSA(aT[2], aT[1], -t, W); Elem(mtR,2,2) = t = sqrt(VP(aT[2],aT[2],W)); VSS(aT[2], 1/t, W); ////// 以下略 */ }
CoordBox NativeRenderDialog::boundingBox() { CoordBox VP(Coord( ui.sbMinLon->value(), ui.sbMinLat->value() ), Coord( ui.sbMaxLon->value(), ui.sbMaxLat->value() )); return VP; }
void VLCWindowsManager::VlcEvents( bool Attach ) { if( !VP() ) return; vlc_player& vp = *VP(); libvlc_event_manager_t* em = libvlc_media_player_event_manager( vp.get_mp() ); if( !em ) return; for( int e = libvlc_MediaPlayerMediaChanged; e <= libvlc_MediaPlayerVout; ++e ) { switch( e ) { //case libvlc_MediaPlayerMediaChanged: //case libvlc_MediaPlayerNothingSpecial: //case libvlc_MediaPlayerOpening: //case libvlc_MediaPlayerBuffering: case libvlc_MediaPlayerPlaying: //case libvlc_MediaPlayerPaused: //case libvlc_MediaPlayerStopped: //case libvlc_MediaPlayerForward: //case libvlc_MediaPlayerBackward: //case libvlc_MediaPlayerEndReached: //case libvlc_MediaPlayerEncounteredError: //case libvlc_MediaPlayerTimeChanged: case libvlc_MediaPlayerPositionChanged: //case libvlc_MediaPlayerSeekableChanged: //case libvlc_MediaPlayerPausableChanged: //case libvlc_MediaPlayerTitleChanged: //case libvlc_MediaPlayerSnapshotTaken: //case libvlc_MediaPlayerLengthChanged: //case libvlc_MediaPlayerVout: if( Attach ) libvlc_event_attach( em, e, OnLibVlcEvent_proxy, this ); else libvlc_event_detach( em, e, OnLibVlcEvent_proxy, this ); break; } } }
void VLCControlsWnd::SetVideoPosScrollRangeByVideoLen() { if( VP() ){ libvlc_time_t MaxLen = VP()->get_length(); VideoPosShiftBits = 0; while(MaxLen>0xffff){ MaxLen >>= 1; ++VideoPosShiftBits; }; SendMessage(hVideoPosScroll, (UINT)PBM_SETRANGE, 0, MAKELPARAM(0, MaxLen)); } }
void VLCWindowsManager::StartFullScreen() { if( !_HolderWnd || ( PO() && !PO()->get_enable_fs() ) ) return; //VLCWindowsManager::CreateWindows was not called if( VP() && !IsFullScreen() ) { if( !_FSWnd ) { _FSWnd= VLCFullScreenWnd::CreateFSWindow( this ); } RECT FSRect = { 0, 0, GetSystemMetrics( SM_CXSCREEN ), GetSystemMetrics( SM_CYSCREEN ) }; HMONITOR hMonitor = MonitorFromWindow( _hWindowedParentWnd, MONITOR_DEFAULTTONEAREST ); MONITORINFO MonInfo; memset( &MonInfo, 0, sizeof( MonInfo ) ); MonInfo.cbSize = sizeof( MonInfo ); if( GetMonitorInfo( hMonitor, &MonInfo ) ) { FSRect = MonInfo.rcMonitor; } #ifdef _DEBUG //to simplify debugging in fullscreen mode UINT FSFlags = SWP_NOZORDER; #else UINT FSFlags = 0; #endif SetParent( _HolderWnd->hWnd(), _FSWnd->getHWND() ); SetWindowPos( _FSWnd->getHWND(), HWND_TOPMOST, FSRect.left, FSRect.top, FSRect.right - FSRect.left, FSRect.bottom - FSRect.top, FSFlags ); ShowWindow( _FSWnd->getHWND(), SW_SHOW ); } }
LRESULT VLCControlsWnd::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg){ case WM_CREATE:{ const int ControlsHeight = 21+3; const int ButtonsWidth = ControlsHeight; int HorizontalOffset = xControlsSpace; int ControlWidth = ButtonsWidth; hPlayPauseButton = CreateWindow(TEXT("BUTTON"), TEXT("Play/Pause"), WS_CHILD|WS_VISIBLE|BS_BITMAP|BS_FLAT, HorizontalOffset, xControlsSpace, ControlWidth, ControlsHeight, hWnd(), (HMENU)ID_FS_PLAY_PAUSE, 0, 0); SendMessage(hPlayPauseButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)RC().hPauseBitmap); HorizontalOffset+=ControlWidth+xControlsSpace; ControlWidth = 200; int VideoPosControlHeight = 10; hVideoPosScroll = CreateWindow(PROGRESS_CLASS, TEXT("Video Position"), WS_CHILD|WS_DISABLED|WS_VISIBLE|SBS_HORZ|SBS_TOPALIGN|PBS_SMOOTH, HorizontalOffset, xControlsSpace+(ControlsHeight-VideoPosControlHeight)/2, ControlWidth, VideoPosControlHeight, hWnd(), (HMENU)ID_FS_VIDEO_POS_SCROLL, 0, 0); HMODULE hThModule = LoadLibrary(TEXT("UxTheme.dll")); if(hThModule){ FARPROC proc = GetProcAddress(hThModule, "SetWindowTheme"); typedef HRESULT (WINAPI* SetWindowThemeProc)(HWND, LPCWSTR, LPCWSTR); if(proc){ ((SetWindowThemeProc)proc)(hVideoPosScroll, L"", L""); } FreeLibrary(hThModule); } HorizontalOffset+=ControlWidth+xControlsSpace; ControlWidth = ButtonsWidth; hMuteButton = CreateWindow(TEXT("BUTTON"), TEXT("Mute"), WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX|BS_PUSHLIKE|BS_BITMAP, //BS_FLAT HorizontalOffset, xControlsSpace, ControlWidth, ControlsHeight, hWnd(), (HMENU)ID_FS_MUTE, 0, 0); SendMessage(hMuteButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)RC().hVolumeBitmap); HorizontalOffset+=ControlWidth+xControlsSpace; ControlWidth = 100; hVolumeSlider = CreateWindow(TRACKBAR_CLASS, TEXT("Volume"), WS_CHILD|WS_VISIBLE|TBS_HORZ|TBS_BOTTOM|TBS_AUTOTICKS, HorizontalOffset, xControlsSpace, ControlWidth, ControlsHeight - 4, hWnd(), (HMENU)ID_FS_VOLUME, 0, 0); HorizontalOffset+=ControlWidth+xControlsSpace; SendMessage(hVolumeSlider, TBM_SETRANGE, FALSE, (LPARAM) MAKELONG (0, 100)); SendMessage(hVolumeSlider, TBM_SETTICFREQ, (WPARAM) 10, 0); ControlWidth = ButtonsWidth; DWORD dwFSBtnStyle = WS_CHILD|BS_BITMAP|BS_FLAT; if( !PO() || PO()->get_enable_fs() ){ dwFSBtnStyle |= WS_VISIBLE; } hFSButton = CreateWindow(TEXT("BUTTON"), TEXT("Toggle fullscreen"), dwFSBtnStyle, HorizontalOffset, xControlsSpace, ControlWidth, ControlsHeight, hWnd(), (HMENU)ID_FS_SWITCH_FS, 0, 0); SendMessage(hFSButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)RC().hDeFullscreenBitmap); HorizontalOffset+=ControlWidth+xControlsSpace; RECT rect; GetClientRect(GetParent(hWnd()), &rect); int ControlWndWidth = HorizontalOffset; int ControlWndHeight = xControlsSpace+ControlsHeight+xControlsSpace; SetWindowPos(hWnd(), 0, 0, (rect.bottom - rect.top) - ControlWndWidth, rect.right-rect.left, ControlWndHeight, SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOACTIVATE); //new message blinking timer SetTimer(hWnd(), 2, 500, NULL); CreateToolTip(); break; } case WM_SHOWWINDOW:{ if(FALSE!=wParam){ //showing UpdateButtons(); } break; } case WM_LBUTTONUP:{ POINT BtnUpPoint = {LOWORD(lParam), HIWORD(lParam)}; RECT VideoPosRect; GetWindowRect(hVideoPosScroll, &VideoPosRect); ClientToScreen(hWnd(), &BtnUpPoint); if(PtInRect(&VideoPosRect, BtnUpPoint)){ SetVideoPos(float(BtnUpPoint.x-VideoPosRect.left)/(VideoPosRect.right-VideoPosRect.left)); } break; } case WM_TIMER:{ switch(wParam){ case 1:{ POINT MousePoint; GetCursorPos(&MousePoint); RECT ControlWndRect; GetWindowRect(hWnd(), &ControlWndRect); if(PtInRect(&ControlWndRect, MousePoint)||GetCapture()==hVolumeSlider){ //do not allow control window to close while mouse is within NeedShowControls(); } else{ NeedHideControls(); } break; } case 2:{ UpdateButtons(); break; } } break; } case WM_SETCURSOR:{ RECT VideoPosRect; GetWindowRect(hVideoPosScroll, &VideoPosRect); DWORD dwMsgPos = GetMessagePos(); POINT MsgPosPoint = {LOWORD(dwMsgPos), HIWORD(dwMsgPos)}; if(PtInRect(&VideoPosRect, MsgPosPoint)){ SetCursor(LoadCursor(NULL, IDC_HAND)); return TRUE; } else{ return VLCWnd::WindowProc(uMsg, wParam, lParam); } break; } case WM_NCDESTROY: break; case WM_COMMAND:{ WORD NCode = HIWORD(wParam); WORD Control = LOWORD(wParam); switch(NCode){ case BN_CLICKED:{ switch(Control){ case ID_FS_SWITCH_FS: WM().ToggleFullScreen(); break; case ID_FS_PLAY_PAUSE:{ if( VP() ){ if( IsPlaying() ) VP()->pause(); else VP()->play(); } break; } case ID_FS_MUTE:{ if( VP() ){ VP()->audio().set_mute( IsDlgButtonChecked(hWnd(), ID_FS_MUTE) != FALSE ); SyncVolumeSliderWithVLCVolume(); } break; } } break; } } break; } case WM_SIZE:{ if( (GetWindowLong(hWnd(), GWL_STYLE) & WS_VISIBLE) && ( !PO() || ( !WM().IsFullScreen() && !PO()->get_show_toolbar() ) || ( WM().IsFullScreen() && !PO()->get_show_fs_toolbar() ) ) ) { //hide controls when they are not allowed NeedHideControls(); } const int new_client_width = LOWORD(lParam); bool isFSBtnVisible = (GetWindowLong(hFSButton, GWL_STYLE) & WS_VISIBLE) != 0; HDWP hDwp = BeginDeferWindowPos(4); int VideoScrollWidth = new_client_width; POINT pt = {0, 0}; RECT rect; GetWindowRect(hPlayPauseButton, &rect); pt.x = rect.right; ScreenToClient(hWnd(), &pt); VideoScrollWidth -= pt.x; VideoScrollWidth -= xControlsSpace; RECT VideoSrcollRect; GetWindowRect(hVideoPosScroll, &VideoSrcollRect); RECT MuteRect; GetWindowRect(hMuteButton, &MuteRect); VideoScrollWidth -= xControlsSpace; VideoScrollWidth -= (MuteRect.right - MuteRect.left); RECT VolumeRect; GetWindowRect(hVolumeSlider, &VolumeRect); VideoScrollWidth -= xControlsSpace; VideoScrollWidth -= (VolumeRect.right - VolumeRect.left); RECT FSRect = {0, 0, 0, 0}; if( isFSBtnVisible ) { GetWindowRect(hFSButton, &FSRect); VideoScrollWidth -= xControlsSpace; VideoScrollWidth -= (FSRect.right - FSRect.left); VideoScrollWidth -= xControlsSpace; } pt.x = VideoSrcollRect.left; pt.y = VideoSrcollRect.top; ScreenToClient(hWnd(), &pt); hDwp = DeferWindowPos(hDwp, hVideoPosScroll, 0, pt.x, pt.y, VideoScrollWidth, VideoSrcollRect.bottom - VideoSrcollRect.top, SWP_NOACTIVATE|SWP_NOOWNERZORDER); int HorizontalOffset = pt.x + VideoScrollWidth + xControlsSpace; pt.x = 0; pt.y = MuteRect.top; ScreenToClient(hWnd(), &pt); hDwp = DeferWindowPos(hDwp, hMuteButton, 0, HorizontalOffset, pt.y, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER); HorizontalOffset += MuteRect.right - MuteRect.left + xControlsSpace; pt.x = 0; pt.y = VolumeRect.top; ScreenToClient(hWnd(), &pt); hDwp = DeferWindowPos(hDwp, hVolumeSlider, 0, HorizontalOffset, pt.y, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER); HorizontalOffset += VolumeRect.right - VolumeRect.left + xControlsSpace; if( isFSBtnVisible ) { pt.x = 0; pt.y = FSRect.top; ScreenToClient(hWnd(), &pt); hDwp = DeferWindowPos(hDwp, hFSButton, 0, HorizontalOffset, pt.y, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER); } EndDeferWindowPos(hDwp); break; } case WM_HSCROLL: case WM_VSCROLL: { if( VP() ){ if(hVolumeSlider==(HWND)lParam){ LRESULT SliderPos = SendMessage(hVolumeSlider, (UINT) TBM_GETPOS, 0, 0); SetVLCVolumeBySliderPos(SliderPos); } } break; } default: return VLCWnd::WindowProc(uMsg, wParam, lParam); } return 0L; }
void CMineView::InterpModelData(UINT8 *p) { assert(p); assert(gModel.polys); while (W(p) != OP_EOF) { switch (W(p)) { // Point Definitions with Start Offset: // 2 UINT16 n_points number of points // 4 UINT16 start_point starting point // 6 UINT16 unknown // 8 VMS_VECTOR pts[n_points] x,y,z data case OP_DEFP_START: { pt0 = W(p+4); n_points = W(p+2); gModel.n_points += n_points; assert(W(p+6)==0); assert(gModel.n_points < MAX_POLY_MODEL_POINTS); assert(pt0+n_points < MAX_POLY_MODEL_POINTS); for (pt=0;pt< n_points;pt++) { gModel.points[pt+pt0].x = VP(p+8)[pt].x + gOffset.x; gModel.points[pt+pt0].y = VP(p+8)[pt].y + gOffset.y; gModel.points[pt+pt0].z = VP(p+8)[pt].z + gOffset.z; } SetModelPoints(pt0,pt0+n_points); p += W(p+2)*sizeof(VMS_VECTOR) + 8; break; } // Flat Shaded Polygon: // 2 UINT16 n_verts // 4 VMS_VECTOR vector1 // 16 VMS_VECTOR vector2 // 28 UINT16 color // 30 UINT16 verts[n_verts] case OP_FLATPOLY: { panel = &gModel.polys[gModel.n_polys]; panel->n_verts = W(p+2); panel->offset = *VP(p+4); panel->normal = *VP(p+16); for (pt=0;pt<panel->n_verts;pt++) { panel->verts[pt] = WP(p+30)[pt]; } assert(panel->n_verts>=MIN_POLY_POINTS); assert(panel->n_verts<=MAX_POLY_POINTS); assert(gModel.n_polys < MAX_POLYS); DrawPoly(panel); p += 30 + ((panel->n_verts&~1)+1)*2; break; } // Texture Mapped Polygon: // 2 UINT16 n_verts // 4 VMS_VECTOR vector1 // 16 VMS_VECTOR vector2 // 28 UINT16 nBaseTex // 30 UINT16 verts[n_verts] // -- UVL uvls[n_verts] case OP_TMAPPOLY: { panel = &gModel.polys[gModel.n_polys]; panel->n_verts = W(p+2); assert(panel->n_verts>=MIN_POLY_POINTS); assert(panel->n_verts<=MAX_POLY_POINTS); assert(gModel.n_polys < MAX_POLYS); panel->offset = *VP(p+4); panel->normal = *VP(p+16); panel->color = -1; panel->nBaseTex = W(p+28); panel->glow_num = glow_num; for (pt=0;pt<panel->n_verts;pt++) { panel->verts[pt] = WP(p+30)[pt]; } p += 30 + ((panel->n_verts&~1)+1)*2; DrawPoly(panel); p += panel->n_verts * 12; break; } // Sort by Normal // 2 UINT16 unknown // 4 VMS_VECTOR Front Model normal // 16 VMS_VECTOR Back Model normal // 28 UINT16 Front Model Offset // 30 UINT16 Back Model Offset case OP_SORTNORM: { /* = W(p+2); */ /* = W(p+4); */ /* = W(p+16); */ assert(W(p+2)==0); assert(W(p+28)>0); assert(W(p+30)>0); if ( m_matrix.CheckNormal(gpObject, VP(p+4),VP(p+16)) ) { InterpModelData(p + W(p+28)); InterpModelData(p + W(p+30)); } else { InterpModelData(p + W(p+30)); InterpModelData(p + W(p+28)); } p += 32; break; } // Call a Sub Object // 2 UINT16 n_anims // 4 VMS_VECTOR offset // 16 UINT16 model offset case OP_SUBCALL: { assert(W(p+16)>0); /* = VP(p+4) */ gOffset.x += VP(p+4)->x; gOffset.y += VP(p+4)->y; gOffset.z += VP(p+4)->z; InterpModelData(p + W(p+16)); gOffset.x -= VP(p+4)->x; gOffset.y -= VP(p+4)->y; gOffset.z -= VP(p+4)->z; p += 20; break; } // Glow Number for Next Poly // 2 UINTW Glow_Value case OP_GLOW: { glow_num = W(p+2); p += 4; break; } default: { assert(0); } } } return; }
void Jacobi(const SymmetricMatrix& X, DiagonalMatrix& D, SymmetricMatrix& A, Matrix& V, bool eivec) { Real epsilon = FloatingPointPrecision::Epsilon(); Tracer et("Jacobi"); REPORT int n = X.Nrows(); DiagonalMatrix B(n), Z(n); D.resize(n); A = X; if (eivec) { REPORT V.resize(n,n); D = 1.0; V = D; } B << A; D = B; Z = 0.0; A.Inject(Z); bool converged = false; for (int i=1; i<=50; i++) { Real sm=0.0; Real* a = A.Store(); int p = A.Storage(); while (p--) sm += fabs(*a++); // have previously zeroed diags if (sm==0.0) { REPORT converged = true; break; } Real tresh = (i<4) ? 0.2 * sm / square(n) : 0.0; a = A.Store(); for (p = 0; p < n; p++) { Real* ap1 = a + (p*(p+1))/2; Real& zp = Z.element(p); Real& dp = D.element(p); for (int q = p+1; q < n; q++) { Real* ap = ap1; Real* aq = a + (q*(q+1))/2; Real& zq = Z.element(q); Real& dq = D.element(q); Real& apq = A.element(q,p); Real g = 100 * fabs(apq); Real adp = fabs(dp); Real adq = fabs(dq); if (i>4 && g < epsilon*adp && g < epsilon*adq) { REPORT apq = 0.0; } else if (fabs(apq) > tresh) { REPORT Real t; Real h = dq - dp; Real ah = fabs(h); if (g < epsilon*ah) { REPORT t = apq / h; } else { REPORT Real theta = 0.5 * h / apq; t = 1.0 / ( fabs(theta) + sqrt(1.0 + square(theta)) ); if (theta<0.0) { REPORT t = -t; } } Real c = 1.0 / sqrt(1.0 + square(t)); Real s = t * c; Real tau = s / (1.0 + c); h = t * apq; zp -= h; zq += h; dp -= h; dq += h; apq = 0.0; int j = p; while (j--) { g = *ap; h = *aq; *ap++ = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau); } int ip = p+1; j = q-ip; ap += ip++; aq++; while (j--) { g = *ap; h = *aq; *ap = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau); ap += ip++; } if (q < n-1) // last loop is non-empty { int iq = q+1; j = n-iq; ap += ip++; aq += iq++; for (;;) { g = *ap; h = *aq; *ap = g-s*(h+g*tau); *aq = h+s*(g-h*tau); if (!(--j)) break; ap += ip++; aq += iq++; } } if (eivec) { REPORT RectMatrixCol VP(V,p); RectMatrixCol VQ(V,q); Rotate(VP, VQ, tau, s); } } } } B = B + Z; D = B; Z = 0.0; } if (!converged) Throw(ConvergenceException(X)); if (eivec) SortSV(D, V, true); else SortAscending(D); }
void gmm_fisher_save_soft_assgn(int n, const float *v, const gmm_t * g, int flags, float *dp_dlambda, float *word_total_soft_assignment) { long d=g->d, k=g->k; float *p = fvec_new(n * k); long i,j,l; long ii=0; float * vp = NULL; /* v*p */ float * sum_pj = NULL; /* sum of p's for a given j */ gmm_compute_p(n,v,g,p,flags | GMM_FLAGS_W); #define P(j,i) p[(i)*k+(j)] #define V(l,i) v[(i)*d+(l)] #define MU(l,j) g->mu[(j)*d+(l)] #define SIGMA(l,j) g->sigma[(j)*d+(l)] #define VP(l,j) vp[(j)*d+(l)] // Save total soft assignment per centroid if (word_total_soft_assignment != NULL) { for (j=0; j<k; j++) { double sum=0; for (i=0; i<n; i++) { sum += P(j,i); } if (n != 0) { word_total_soft_assignment[j] = (float)(sum/n); } else { word_total_soft_assignment[j] = 0.0; } } } if(flags & GMM_FLAGS_W) { for(j=1; j<k; j++) { double accu=0; for(i=0; i<n; i++) accu+= P(j,i)/g->w[j] - P(0,i)/g->w[0]; /* normalization */ double f=n*(1/g->w[j]+1/g->w[0]); dp_dlambda[ii++]=accu/sqrt(f); } } if(flags & GMM_FLAGS_MU) { float *dp_dmu=dp_dlambda+ii; #define DP_DMU(l,j) dp_dmu[(j)*d+(l)] if(0) { /* simple and slow */ for(j=0; j<k; j++) { for(l=0; l<d; l++) { double accu=0; for(i=0; i<n; i++) accu += P(j,i) * (V(l,i)-MU(l,j)) / SIGMA(l,j); DP_DMU(l,j)=accu; } } } else { /* complicated and fast */ /* precompute tables that may be useful for sigma too */ vp = fvec_new(k * d); fmat_mul_tr(v,p,d,k,n,vp); sum_pj = fvec_new(k); for(j=0; j<k; j++) { double sum=0; for(i=0; i<n; i++) sum += P(j,i); sum_pj[j] = sum; } for(j=0; j<k; j++) { for(l=0; l<d; l++) DP_DMU(l,j) = (VP(l,j) - MU(l,j) * sum_pj[j]) / SIGMA(l,j); } } /* normalization */ if(!(flags & GMM_FLAGS_NO_NORM)) { for(j=0; j<k; j++) for(l=0; l<d; l++) { float nf = sqrt(n*g->w[j]/SIGMA(l,j)); if(nf > 0) DP_DMU(l,j) /= nf; } } #undef DP_DMU ii+=d*k; } if(flags & (GMM_FLAGS_SIGMA | GMM_FLAGS_1SIGMA)) { if(flags & GMM_FLAGS_1SIGMA) { /* fast not implemented for 1 sigma */ for(j=0; j<k; j++) { double accu2=0; for(l=0; l<d; l++) { double accu=0; for(i=0; i<n; i++) accu += P(j,i) * (sqr(V(l,i)-MU(l,j)) / SIGMA(l,j) - 1) / sqrt(SIGMA(l,j)); if(flags & GMM_FLAGS_SIGMA) { double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*n*g->w[j]/SIGMA(l,j); dp_dlambda[ii++]=accu/sqrt(f); } accu2+=accu; } if(flags & GMM_FLAGS_1SIGMA) { double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*d*n*g->w[j]/SIGMA(0,j); dp_dlambda[ii++]=accu2/sqrt(f); } } } else { /* fast and complicated */ assert(flags & GMM_FLAGS_SIGMA); float *dp_dsigma = dp_dlambda + ii; if(!vp) { vp = fvec_new(k * d); fmat_mul_tr(v,p,d,k,n,vp); } if(!sum_pj) { sum_pj = fvec_new(k); for(j=0; j<k; j++) { double sum=0; for(i=0; i<n; i++) sum += P(j,i); sum_pj[j] = sum; } } float *v2 = fvec_new(n * d); for(i = n*d-1 ; i >= 0; i--) v2[i] = v[i] * v[i]; float *v2p = fvec_new(k * d); fmat_mul_tr(v2,p,d,k,n,v2p); free(v2); #define V2P(l,j) v2p[(j)*d+(l)] #define DP_DSIGMA(i,j) dp_dsigma[(i)+(j)*d] for(j=0; j<k; j++) { for(l=0; l<d; l++) { double accu; accu = V2P(l, j); accu += VP(l, j) * (- 2 * MU(l,j)); accu += sum_pj[j] * (sqr(MU(l,j)) - SIGMA(l,j)); /* normalization */ double f; if(flags & GMM_FLAGS_NO_NORM) { f = pow(SIGMA(l,j), -1.5); } else { f = 1 / (SIGMA(l,j) * sqrt(2*n*g->w[j])); } DP_DSIGMA(l,j) = accu * f; } } free(v2p); #undef DP_DSIGMA #undef V2P ii += d * k; } } assert(ii==gmm_fisher_sizeof(g,flags)); #undef P #undef V #undef MU #undef SIGMA free(p); free(sum_pj); free(vp); }
int S() { NP(); VP(); }
void selfie(libmaus2::util::ArgParser const & arg, std::string const & fn) { std::string const compactfn = fn + ".compact"; std::string const compactmetafn = compactfn + ".meta"; if ( ! libmaus2::util::GetFileSize::fileExists(compactfn) || libmaus2::util::GetFileSize::isOlder(compactfn,fn) ) { libmaus2::fastx::FastAToCompact4BigBandBiDir::fastaToCompact4BigBandBiDir( std::vector<std::string>(1,fn), &(std::cerr), false /* single strand */, compactfn ); } uint64_t const numthreads = arg.uniqueArgPresent("t") ? arg.getUnsignedNumericArg<uint64_t>("t") : libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultNumThreads(); std::string const bwtfn = fn + ".bwt"; std::string const bwtmetafn = bwtfn + ".meta"; libmaus2::suffixsort::bwtb3m::BwtMergeSortResult res; if ( ! libmaus2::util::GetFileSize::fileExists(bwtmetafn) || libmaus2::util::GetFileSize::isOlder(bwtmetafn,compactfn) ) { libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions options( compactfn, 16*1024ull*1024ull*1024ull, // mem // libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultMem(), numthreads, "compactstream", false /* bwtonly */, std::string("mem:tmp_"), std::string(), // sparse bwtfn, 16 /* isa */, 16 /* sa */ ); res = libmaus2::suffixsort::bwtb3m::BwtMergeSort::computeBwt(options,&std::cerr); res.serialise(bwtmetafn); } else { res.deserialise(bwtmetafn); } //libmaus2::fastx::FastAIndex::unique_ptr_type PFAI(libmaus2::fastx::FastAIndex::load(fn+".fai")); libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::unique_ptr_type Pmeta(libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::load(compactmetafn)); libmaus2::rank::DNARank::unique_ptr_type Prank(res.loadDNARank(numthreads)); libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray BSSSA(res.loadBareSimpleSuffixArray()); uint64_t const n = Prank->size(); libmaus2::autoarray::AutoArray<char> A(n,false); libmaus2::bitio::CompactDecoderWrapper CDW(compactfn); CDW.read(A.begin(),n); assert ( CDW.gcount() == static_cast<int64_t>(n) ); uint64_t const minfreq = 2; uint64_t const minlen = 20; uint64_t const limit = 32; uint64_t const minsplitlength = 28; uint64_t const minsplitsize = 10; uint64_t const maxxdist = 1000; uint64_t const activemax = 1; uint64_t const fracmul = 95; uint64_t const fracdiv = 100; bool const selfcheck = true; uint64_t const chainminscore = arg.uniqueArgPresent("chainminscore") ? arg.getUnsignedNumericArg<uint64_t>("chainminscore") : 20; uint64_t const maxocc = 500; uint64_t const minprintlength = 1024; uint64_t const algndommul = 95; uint64_t const algndomdiv = 100; uint64_t const chaindommul = 95; uint64_t const chaindomdiv = 100; double const maxerr = arg.uniqueArgPresent("maxerr") ? arg.getParsedArg<double>("maxerr") : std::numeric_limits<double>::max(); uint64_t const cachek = arg.uniqueArgPresent("K") ? arg.getUnsignedNumericArg<uint64_t>("K") : 12; uint64_t const maxpacksize = arg.uniqueArgPresent("P") ? arg.getUnsignedNumericArg<uint64_t>("P") : 128ull*1024ull*1024ull; std::cerr << "[V] generating " << cachek << "-mer cache..."; libmaus2::rank::DNARankKmerCache::unique_ptr_type Pcache(new libmaus2::rank::DNARankKmerCache(*Prank,cachek,numthreads)); std::cerr << "done." << std::endl; std::string const deftmp = libmaus2::util::ArgInfo::getDefaultTmpFileName(arg.progname); libmaus2::util::TempFileNameGenerator tmpgen(deftmp,3); std::string const sorttmp = tmpgen.getFileName(); libmaus2::util::TempFileRemovalContainer::addTempFile(sorttmp); libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair> CPS(sorttmp); libmaus2::parallel::PosixSpinLock CPSlock; uint64_t acc_s = 0; for ( uint64_t zz = 0; zz < Pmeta->S.size(); ) { uint64_t zze = zz; uint64_t pack_s = Pmeta->S[zze++].l; while ( zze < Pmeta->S.size() && pack_s + Pmeta->S[zze].l <= maxpacksize ) pack_s += Pmeta->S[zze++].l; // std::cerr << "[V] " << zz << "-" << zze << " pack_s=" << pack_s << std::endl; zz = zze; uint64_t const low = acc_s; uint64_t const high = acc_s + pack_s; std::cerr << "[V] low=" << low << " high=" << high << " acc_s=" << acc_s << " pack_s=" << pack_s << std::endl; std::string const activefn = libmaus2::rank::DNARankSMEMComputation::activeParallel(tmpgen,*Pcache,A.begin(),low,high,minfreq,minlen,numthreads,maxxdist + 2*(minlen-1)); libmaus2::gamma::GammaIntervalDecoder::unique_ptr_type Pdec(new libmaus2::gamma::GammaIntervalDecoder(std::vector<std::string>(1,activefn),0/*offset */,1 /* numthreads */)); std::string const sortinfn = tmpgen.getFileName(true); libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::unique_ptr_type sptr( new libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>(sortinfn) ); { std::pair<uint64_t,uint64_t> P; while ( Pdec->getNext(P) ) { sptr->put( GammaInterval(P.first,P.second) ); } } libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type Pmerger( sptr->getMerger() ); struct LockedGet { libmaus2::parallel::PosixSpinLock lock; // libmaus2::gamma::GammaIntervalDecoder& dec; libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & Pmerger; LockedGet(libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & rPmerger) : Pmerger(rPmerger) { } bool getNext(std::pair<uint64_t,uint64_t> & P) { bool ok = false; { libmaus2::parallel::ScopePosixSpinLock slock(lock); GammaInterval Q; ok = Pmerger->getNext(Q); if ( ok ) { P.first = Q.first; P.second = Q.second; } } return ok; } }; libmaus2::autoarray::AutoArray < std::pair<uint64_t,uint64_t> > VP(numthreads); LockedGet LG(Pmerger); libmaus2::fastx::CoordinateCacheBiDir cocache(*Prank,*Pmeta,16 /* blockshfit */); typedef libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray sa_type; typedef libmaus2::lcs::SMEMProcessor<sa_type> smem_proc_type; libmaus2::autoarray::AutoArray < smem_proc_type::unique_ptr_type > Aproc(numthreads); for ( uint64_t i = 0; i < numthreads; ++i ) { smem_proc_type::unique_ptr_type proc(new smem_proc_type( *Pmeta,cocache,*Prank,BSSSA,A.begin(),maxxdist,activemax,fracmul,fracdiv,selfcheck,chainminscore,maxocc,algndommul,algndomdiv,chaindommul,chaindomdiv, libmaus2::lcs::NNP::getDefaultMaxWindowError(),libmaus2::lcs::NNP::getDefaultMaxBack(),false /* domsameref */ ) ); Aproc[i] = UNIQUE_PTR_MOVE(proc); } stateVec.resize(numthreads); for ( uint64_t i = 0; i < numthreads; ++i ) setState(i,"idle"); #if defined(_OPENMP) #pragma omp parallel num_threads(numthreads) #endif { uint64_t const tid = #if defined(_OPENMP) omp_get_thread_num() #else 0 #endif ; std::pair<uint64_t,uint64_t> & P = VP[tid]; smem_proc_type & proc = *(Aproc[tid]); struct SelfieVerbosity : public smem_proc_type::Verbosity { uint64_t tid; std::string prefix; SelfieVerbosity(uint64_t const rtid, std::string const & rprefix) : tid(rtid), prefix(rprefix) { } void operator()(libmaus2::rank::DNARankMEM const & smem, uint64_t const z) const { std::ostringstream ostr; ostr << prefix << "\t" << z << "\t" << smem; setState(tid,ostr.str()); printState(); } }; while ( LG.getNext(P) ) { uint64_t const smemleft = std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1)); uint64_t const smemright = std::min(P.second+minlen,n); std::ostringstream msgstr; msgstr << "[" << smemleft << "," << smemright << ")"; setState(tid,msgstr.str()); printState(); libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum( *Prank,A.begin(), smemleft, smemright, minfreq, minlen, limit, minsplitlength, minsplitsize); SelfieVerbosity SV(tid,msgstr.str()); proc.process(senum,A.begin(),n,minprintlength,maxerr,SV); // proc.printAlignments(minprintlength); std::pair<libmaus2::lcs::ChainAlignment const *, libmaus2::lcs::ChainAlignment const *> const AP = proc.getAlignments(); for ( libmaus2::lcs::ChainAlignment const * it = AP.first; it != AP.second; ++it ) { libmaus2::lcs::ChainAlignment const & CA = *it; libmaus2::lcs::NNPAlignResult const & res = CA.res; std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VA = Pmeta->mapCoordinatePairToList(res.abpos,res.aepos); std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VB = Pmeta->mapCoordinatePairToList(res.bbpos,res.bepos); if ( VA.size() == 1 && VB.size() == 1 ) { CoordinatePair CP(VA[0],VB[0],res); libmaus2::parallel::ScopePosixSpinLock slock(CPSlock); CPS.put(CP); } } setState(tid,"idle"); printState(); #if 0 std::cerr << "P=[" << P.first << "," << P.second << ")" << std::endl; { std::vector<libmaus2::rank::DNARankMEM> SMEM; libmaus2::rank::DNARankSMEMComputation::smemLimitedParallel( *Prank, *Pcache, A.begin(), P.first, P.second, n, minfreq, minlen, limit, SMEM, 1 /* threads */); std::cerr << "[V] number of SMEMs is " << SMEM.size() << std::endl; // deallocate k-mer cache // Pcache.reset(); std::vector<libmaus2::rank::DNARankMEM> SMEMsplit; libmaus2::rank::DNARankSMEMComputation::smemLimitedParallelSplit(*Prank,A.begin(),P.first,P.second,minlen,limit,minsplitlength,minsplitsize,SMEM,SMEMsplit,1 /* threads */); std::cerr << "[V] number of split SMEMs is " << SMEMsplit.size() << std::endl; // insert split SMEMs into regular SMEMs std::copy(SMEMsplit.begin(),SMEMsplit.end(),std::back_insert_iterator< std::vector<libmaus2::rank::DNARankMEM> >(SMEM)); //libmaus2::sorting::InPlaceParallelSort::inplacesort2(SMEM.begin(),SMEM.end(),numthreads,libmaus2::rank::DNARankMEMPosComparator()); std::sort(SMEM.begin(),SMEM.end(),libmaus2::rank::DNARankMEMPosComparator()); SMEM.resize(std::unique(SMEM.begin(),SMEM.end())-SMEM.begin()); libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum( *Prank,A.begin(), std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1)), std::min(P.second+minlen,n), minfreq, minlen, limit, minsplitlength, minsplitsize); libmaus2::rank::DNARankMEM smem; uint64_t c = 0; while ( senum.getNext(smem) ) { // std::cerr << "ccc=" << smem << std::endl; if ( c >= SMEM.size() || smem != SMEM[c] ) { std::cerr << "mismatch " << c << " " << smem; if ( c < SMEM.size() ) std::cerr << " != " << SMEM[c]; else std::cerr << " ???"; std::cerr << std::endl; } else { std::cerr << "match " << c << " " << smem << " " << SMEM[c] << std::endl; } ++c; } std::cerr << "c=" << c << " V=" << SMEM.size() << std::endl; } #endif } } acc_s += pack_s; } libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair>::merger_ptr_type Pmerger(CPS.getMerger()); CoordinatePair CP; while ( Pmerger->getNext(CP) ) { std::ostringstream ostr; CP.A.print(ostr); ostr << " "; CP.B.print(ostr); ostr << " "; ostr << CP.res.getErrorRate(); std::cout << ostr.str() << std::endl; } }
int S() { printf("<S>"); NP(); VP(); printf("</S>"); }
void VLCHolderWnd::LibVlcAttach() { if( VP() ) libvlc_media_player_set_hwnd( VP()->get_mp(), hWnd() ); }
void handle_events(int fd) { node_contract_t *cp; const nc_descr_t *dp; ct_evthdl_t eh; ctid_t ctid; uint_t evtype; ctevid_t evid; ctevid_t nevid; ctid_t newct; uint_t flags; nvlist_t *ap, *sap, *rp; const char *evtypename; int err; while ((err = ct_event_read(fd, &eh)) == 0) { ctid = ct_event_get_ctid(eh); cp = nc_lookup(ctid); /* * This contract has gone away. This should be possible only * if we've already abandoned it, but it may be possible to * receive events for it after that. We can't even ack here, * because we don't have the ctl fd for the contract any more. * Just keep going; there's nothing we can do. */ if (cp == NULL) { ct_event_free(eh); ++ev_failures; continue; } dp = cp->nc_type->nct_events; evtype = ct_event_get_type(eh); evtypename = nc_descr_strlookup(dp, evtype); evid = ct_event_get_evid(eh); flags = ct_event_get_flags(eh); sap = v8plus_obj( VP(ctid, NUMBER, (double)ctid), VP(evid, STRNUMBER64, (uint64_t)evid), VP(type, STRING, evtypename), VP_V(flags, INL_OBJECT), VP(info, BOOLEAN, (flags & CTE_INFO) != 0), VP(ack, BOOLEAN, (flags & CTE_ACK) != 0), VP(neg, BOOLEAN, (flags & CTE_NEG) != 0), V8PLUS_TYPE_NONE, V8PLUS_TYPE_NONE); if (sap == NULL) { ct_event_free(eh); ++ev_failures; continue; } if (evtype == CT_EV_NEGEND) { (void) ct_event_get_nevid(eh, &nevid); (void) ct_event_get_newct(eh, &newct); err = v8plus_obj_setprops(sap, VP(nevid, STRNUMBER64, (uint64_t)nevid), VP(newct, NUMBER, (double)newct), V8PLUS_TYPE_NONE); if (err != 0) { nvlist_free(sap); ct_event_free(eh); ++ev_failures; continue; } } ap = v8plus_obj( VP(0, STRING, evtypename), VP(1, OBJECT, sap), V8PLUS_TYPE_NONE); nvlist_free(sap); ct_event_free(eh); if (ap == NULL) { ++ev_failures; continue; } rp = v8plus_method_call(cp, "_emit", ap); nvlist_free(ap); nvlist_free(rp); } if (err != EAGAIN) { v8plus_panic("unexpected error from ct_event_read: %s", strerror(err)); } }