autoConfiguration Configuration_create (long numberOfPoints, long numberOfDimensions) { try { autoConfiguration me = Thing_new (Configuration); TableOfReal_init (me.peek(), numberOfPoints, numberOfDimensions); my w = NUMvector<double> (1, numberOfDimensions); TableOfReal_setSequentialRowLabels (me.peek(), 0, 0, nullptr, 1, 1); TableOfReal_setSequentialColumnLabels (me.peek(), 0, 0, U"dimension ", 1, 1); my metric = 2; Configuration_setDefaultWeights (me.peek()); Configuration_randomize (me.peek()); return me; } catch (MelderError) { Melder_throw (U"Configuration not created."); } }
FujisakiPitch FujisakiPitch_create (double tmin, double tmax, double baseFrequency, double alpha, double beta, double gamma) { try { autoFujisakiPitch me = Thing_new (FujisakiPitch); Function_init (me.peek(), tmin, tmax); my baseFrequency = baseFrequency; my alpha = alpha; my beta = beta; my gamma = gamma; my phraseCommands = SortedSetOfDouble_create (); my accentCommands = SortedSetOfDouble_create (); return me.transfer(); } catch (MelderError) { Melder_throw ("FujisakiPitch not created."); } }
autoCategories Strings_to_Categories (Strings me) { try { if (my numberOfStrings < 1) { Melder_throw (U"Empty strings."); } autoCategories thee = Thing_new (Categories); thy _grow (my numberOfStrings); for (long i = 1; i <= my numberOfStrings; i++) { autoSimpleString s = SimpleString_create (my strings [i]); thy addItem_move (s.move()); } return thee; } catch (MelderError) { Melder_throw (me, U": not converted."); } }
Strings espeakdata_voices_getNames (Table me, long column) { try { if (column < 0 || column > 2) { Melder_throw (U"Illegal columnn."); } autoStrings thee = Thing_new (Strings); thy strings = NUMvector <char32 *> (1, my rows -> size); thy numberOfStrings = 0; for (long irow = 1; irow <= my rows -> size; irow++) { thy strings[irow] = Melder_dup (Table_getStringValue_Assert (me, irow, column)); thy numberOfStrings++; } return thee.transfer(); } catch (MelderError) { Melder_throw (U"Espeakdata: voices not initialized."); } }
autoSPINET SPINET_create (double tmin, double tmax, long nt, double dt, double t1, double minimumFrequency, double maximumFrequency, long nFilters, double excitationErbProportion, double inhibitionErbProportion) { try { autoSPINET me = Thing_new (SPINET); double minErb = NUMhertzToErb (minimumFrequency); double maxErb = NUMhertzToErb (maximumFrequency); double dErb = (maxErb - minErb) / nFilters; SampledXY_init (me.peek(), tmin, tmax, nt, dt, t1, minErb - dErb / 2.0, maxErb + dErb / 2.0, nFilters, dErb, minErb); my y = NUMmatrix<double> (1, nFilters, 1, nt); my s = NUMmatrix<double> (1, nFilters, 1, nt); my gamma = 4; my excitationErbProportion = excitationErbProportion; my inhibitionErbProportion = inhibitionErbProportion; return me; } catch (MelderError) { Melder_throw (U"SPINET not created."); } }
autoStrings Categories_to_Strings (Categories me) { try { if (my size < 1) { Melder_throw (U"No elements."); } autoStrings thee = Thing_new (Strings); thy strings = NUMvector<char32 *> (1, my size); thy numberOfStrings = my size; for (long i = 1; i <= my size; i ++) { SimpleString s = my at [i]; thy strings [i] = Melder_dup (s -> string); } return thee; } catch (MelderError) { Melder_throw (me, U": not converted to Strings."); } }
static autoStrings IntervalTier_to_Strings_withOriginData (IntervalTier me, long *from) { try { autoStrings thee = Thing_new (Strings); thy strings = NUMvector<char32 *> (1, my intervals.size); for (long i = 1; i <= my intervals.size; i ++) { TextInterval ti = my intervals.at [i]; if (ti -> text && ti -> text [0] != U'\0') { thy strings [++ thy numberOfStrings] = Melder_dup (ti -> text); if (from) { from [thy numberOfStrings] = i; } } } return thee; } catch (MelderError) { Melder_throw (me, U": no Strings created."); } }
autoKlattGrid_FormantGridEditor KlattGrid_FormantGridEditor_create (const char32 *title, KlattGrid data, int formantType) { try { Melder_assert (data); autoFormantGrid* fg = KlattGrid_getAddressOfFormantGrid (data, formantType); if (! fg) { Melder_throw (U"Formant type unknown."); } if (FormantGrid_isEmpty (fg -> get())) { Melder_throw (U"Cannot edit an empty formant grid."); } autoKlattGrid_FormantGridEditor me = Thing_new (KlattGrid_FormantGridEditor); my klattgrid = data; FormantGridEditor_init (me.peek(), title, fg->get()); return me; } catch (MelderError) { Melder_throw (U"KlattGrid formant window not created."); } }
Ltas Spectrum_to_Ltas (Spectrum me, double bandWidth) { try { long numberOfBands = ceil ((my xmax - my xmin) / bandWidth); if (bandWidth <= my dx) Melder_throw ("Bandwidth must be greater than ", my dx, "."); autoLtas thee = Thing_new (Ltas); Matrix_init (thee.peek(), my xmin, my xmax, numberOfBands, bandWidth, my xmin + 0.5 * bandWidth, 1, 1, 1, 1, 1); for (long iband = 1; iband <= numberOfBands; iband ++) { double fmin = thy xmin + (iband - 1) * bandWidth; double meanEnergyDensity = Sampled_getMean (me, fmin, fmin + bandWidth, 0, 1, FALSE); double meanPowerDensity = meanEnergyDensity * my dx; // as an approximation for a division by the original duration thy z [1] [iband] = meanPowerDensity == 0.0 ? -300.0 : 10.0 * log10 (meanPowerDensity / 4.0e-10); } return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": not converted to Ltas."); } }
RunnerMFC RunnerMFC_create (const wchar_t *title, Ordered experiments) { try { autoRunnerMFC me = Thing_new (RunnerMFC); Editor_init (me.peek(), 0, 0, 2000, 2000, title, NULL); my experiments = experiments; my graphics = Graphics_create_xmdrawingarea (my d_drawingArea); struct structGuiDrawingAreaResizeEvent event = { my d_drawingArea, 0 }; event. width = my d_drawingArea -> f_getWidth (); event. height = my d_drawingArea -> f_getHeight (); gui_drawingarea_cb_resize (me.peek(), & event); my iexperiment = 1; RunnerMFC_startExperiment (me.peek()); return me.transfer(); } catch (MelderError) { Melder_throw ("Experiment window not created."); } }
autoPitch Pitch_create (double tmin, double tmax, long nt, double dt, double t1, double ceiling, int maxnCandidates) { try { autoPitch me = Thing_new (Pitch); Sampled_init (me.peek(), tmin, tmax, nt, dt, t1); my ceiling = ceiling; my maxnCandidates = maxnCandidates; my frame = NUMvector <structPitch_Frame> (1, nt); /* Put one candidate in every frame (unvoiced, silent). */ for (long it = 1; it <= nt; it ++) { Pitch_Frame_init (& my frame [it], 1); } return me; } catch (MelderError) { Melder_throw (U"Pitch not created."); } }
static Strings Strings_insertAndExpand (Strings me, long position, const char32 *newstring) { try { if (position == 0) position = my numberOfStrings + 1; Melder_assert (position >= 1); Melder_assert (position <= my numberOfStrings + 1); autoStrings thee = Thing_new (Strings); thy strings = NUMvector<char32 *> (1, my numberOfStrings + 1); for (long i = 1, from = 1; i <= my numberOfStrings + 1; i++, from++) { const char32 *to_copy = my strings[from]; if (i == position) { to_copy = newstring; from--; } thy strings[i] = Melder_dup (to_copy); } thy numberOfStrings = my numberOfStrings + 1; return thee.transfer(); } catch (MelderError) { Melder_throw (me, U" not expanded."); } }
void Matrix_eigen (Matrix me, autoMatrix *out_eigenvectors, autoMatrix *out_eigenvalues) { try { if (my nx != my ny) Melder_throw (U"(Matrix not square."); autoEigen eigen = Thing_new (Eigen); Eigen_initFromSymmetricMatrix (eigen.peek(), my z, my nx); autoMatrix eigenvectors = Data_copy (me); autoMatrix eigenvalues = Matrix_create (1.0, 1.0, 1, 1.0, 1.0, my ymin, my ymax, my ny, my dy, my y1); for (long i = 1; i <= my nx; i ++) { eigenvalues -> z [i] [1] = eigen -> eigenvalues [i]; for (long j = 1; j <= my nx; j ++) eigenvectors -> z [i] [j] = eigen -> eigenvectors [j] [i]; } *out_eigenvectors = eigenvectors.move(); *out_eigenvalues = eigenvalues.move(); } catch (MelderError) { Melder_throw (me, U": eigenstructure not computed."); } }
autoVDSmagtMinimizer VDSmagtMinimizer_create (long nParameters, Daata object, double (*func) (Daata object, const double x[]), void (*dfunc) (Daata object, const double x[], double dx[])) { try { autoVDSmagtMinimizer me = Thing_new (VDSmagtMinimizer); Minimizer_init (me.peek(), nParameters, object); my dp = NUMvector<double> (1, nParameters); my pc = NUMvector<double> (1, nParameters); my gc = NUMvector<double> (1, nParameters); my g0 = NUMvector<double> (1, nParameters); my s = NUMvector<double> (1, nParameters); my srst = NUMvector<double> (1, nParameters); my grst = NUMvector<double> (1, nParameters); my func = func; my dfunc = dfunc; my lineSearchGradient = 0.9; my lineSearchMaxNumOfIterations = 5; return me; } catch (MelderError) { Melder_throw (U"VDSmagtMinimizer not created."); } }
autoMovie Movie_openFromSoundFile (MelderFile file) { try { autoMovie me = Thing_new (Movie); autoSound sound = Sound_readFromSoundFile (file); autoMelderString fileNameHead; MelderString_copy (& fileNameHead, Melder_fileToPath (file)); char32 *extensionLocation = str32rchr (fileNameHead.string, U'.'); if (! extensionLocation) extensionLocation = & fileNameHead.string [fileNameHead.length]; *extensionLocation = U'\0'; fileNameHead.length = extensionLocation - fileNameHead.string; autoStrings strings = Strings_createAsFileList (Melder_cat (fileNameHead.string, U"*.png")); struct structMelderDir folder; MelderFile_getParentDir (file, & folder); Movie_init (me.peek(), sound.transfer(), Melder_dirToPath (& folder), strings.transfer()); return me; } catch (MelderError) { Melder_throw (U"Movie object not read from file ", file, U"."); } }
EditDistanceTable EditDistanceTable_create (Strings target, Strings source) { try { autoEditDistanceTable me = Thing_new (EditDistanceTable); long numberOfSourceSymbols = source -> numberOfStrings, numberOfTargetSymbols = target -> numberOfStrings; TableOfReal_init (me.peek(), numberOfTargetSymbols + 1, numberOfSourceSymbols + 1); TableOfReal_setColumnLabel (me.peek(), 1, U""); for (long j = 1; j <= numberOfSourceSymbols; j++) { my columnLabels[j + 1] = Melder_dup (source -> strings[j]); } TableOfReal_setRowLabel (me.peek(), 1, U""); for (long i = 1; i <= numberOfTargetSymbols; i++) { my rowLabels[i + 1] = Melder_dup (target -> strings[i]); } my warpingPath = WarpingPath_create (numberOfTargetSymbols + numberOfSourceSymbols + 1); my editCostsTable = EditCostsTable_createDefault (); EditDistanceTable_findPath (me.peek(), 0); return me.transfer(); } catch (MelderError) { Melder_throw (U"EditDistanceTable not created."); } }
autoFeatureWeights FeatureWeights_create ( /////////////////////////////// // Parameters // /////////////////////////////// long nweights // number of weights ) { try { autoFeatureWeights me = Thing_new (FeatureWeights); my fweights = TableOfReal_create (1, nweights); for (long i = 1; i <= nweights; i ++) { my fweights -> data [1] [i] = 1; } return me; } catch (MelderError) { Melder_throw (U"FeatureWeights not created."); } }
autoSpeechSynthesizerVoice SpeechSynthesizerVoice_create (long numberOfFormants) { try { autoSpeechSynthesizerVoice me = Thing_new (SpeechSynthesizerVoice); my d_numberOfFormants = numberOfFormants; my d_freq = NUMvector<int> (0, numberOfFormants); my d_height = NUMvector<int> (0, my d_numberOfFormants); // 100% = 256 my d_width = NUMvector<int> (0, my d_numberOfFormants); // 100% = 256 my d_freqadd = NUMvector<int> (0, my d_numberOfFormants); // Hz // copies without temporary adjustments from embedded commands my d_freq2 = NUMvector<int> (0, my d_numberOfFormants); // 100% = 256 my d_height2 = NUMvector<int> (0, my d_numberOfFormants); // 100% = 256 my d_width2 = NUMvector<int> (0, my d_numberOfFormants); // 100% = 256 my d_breath = NUMvector<int> (0, my d_numberOfFormants); // amount of breath for each formant. breath[0] indicates whether any are set. my d_breathw = NUMvector<int> (0, my d_numberOfFormants); // width of each breath formant SpeechSynthesizerVoice_setDefaults (me.get()); return me; } catch (MelderError) { Melder_throw (U"SpeechSynthesizerVoice not created."); } }
Strings WordList_to_Strings (WordList me) { try { unsigned char *word = (unsigned char *) my string; autoStrings thee = Thing_new (Strings); thy numberOfStrings = WordList_count (me); if (thy numberOfStrings > 0) { thy strings = NUMvector <wchar *> (1, thy numberOfStrings); } for (long i = 1; i <= thy numberOfStrings; i ++) { unsigned char *kar = word; for (; *kar != '\n'; kar ++) { } long length = kar - word; thy strings [i] = Melder_calloc (wchar, length + 1); wcsncpy (thy strings [i], Melder_peekUtf8ToWcs ((const char *) word), length); thy strings [i] [length] = '\0'; word += length + 1; } return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": not converted to Strings."); } }
void Transition_eigen (Transition me, autoMatrix *out_eigenvectors, autoMatrix *out_eigenvalues) { bool transposed = false; try { autoEigen eigen = Thing_new (Eigen); Transition_transpose (me); Eigen_initFromSymmetricMatrix (eigen.peek(), my data, my numberOfStates); Transition_transpose (me); transposed = true; autoMatrix eigenvectors = Matrix_createSimple (my numberOfStates, my numberOfStates); autoMatrix eigenvalues = Matrix_createSimple (my numberOfStates, 1); for (long i = 1; i <= my numberOfStates; i ++) { eigenvalues -> z [i] [1] = eigen -> eigenvalues [i]; for (long j = 1; j <= my numberOfStates; j ++) eigenvectors -> z [i] [j] = eigen -> eigenvectors [j] [i]; } *out_eigenvectors = eigenvectors.move(); *out_eigenvalues = eigenvalues.move(); } catch (MelderError) { if (transposed) Transition_transpose (me); Melder_throw (me, U": eigenvectors not computed."); } }
Graphics Graphics_create_postscriptprinter () { autoGraphicsPostscript me = Thing_new (GraphicsPostscript); my postScript = true, my languageLevel = 2; my job = false, my eps = false, my printer = true; my d_printf = Printer_postScript_printf; Graphics_init (me.get(), thePrinter. resolution); // virtual resolution my photocopyable = thePrinter. spots == kGraphicsPostscript_spots_PHOTOCOPYABLE; if (my photocopyable) { my spotsDensity = 85; my spotsAngle = 35; } else { my spotsDensity = 106; my spotsAngle = 46; } my paperWidth = (double) thePrinter. paperWidth / my resolution; my paperHeight = (double) thePrinter. paperHeight / my resolution; my landscape = thePrinter. orientation == kGraphicsPostscript_orientation_LANDSCAPE; my magnification = thePrinter. magnification; my includeFonts = true; my d_x1DC = my d_x1DCmin = my resolution / 2; my d_x2DC = my d_x2DCmax = (my paperWidth - 0.5) * my resolution; my d_y1DC = my d_y1DCmin = my resolution / 2; my d_y2DC = my d_y2DCmax = (my paperHeight - 0.5) * my resolution; Graphics_setWsWindow (me.get(), 0, my paperWidth - 1.0, 13.0 - my paperHeight, 12.0); downloadPrologAndSetUp (me.get()); initPage (me.get()); return me.transfer(); }
WordList Strings_to_WordList (Strings me) { try { long totalLength = 0; /* * Check whether the strings are generic and sorted. */ for (long i = 1; i <= my numberOfStrings; i ++) { wchar *string = my strings [i], *p; for (p = & string [0]; *p; p ++) { if (*p > 126) Melder_throw ("String \"", string, "\" not generic.\nPlease convert to backslash trigraphs first."); } if (i > 1 && wcscmp (my strings [i - 1], string) > 0) { Melder_throw ("String \"", string, L"\" not sorted.\nPlease sort first."); } totalLength += wcslen (string); } autoWordList thee = Thing_new (WordList); thy length = totalLength + my numberOfStrings; thy string = Melder_calloc (wchar, thy length + 1); /* * Concatenate the strings into the word list. */ wchar *q = thy string; for (long i = 1; i <= my numberOfStrings; i ++) { long length = wcslen (my strings [i]); wcscpy (q, my strings [i]); q += length; *q ++ = '\n'; } *q = '\0'; Melder_assert (q - thy string == thy length); return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": not converted to WordList."); } }
Strings Distributions_to_Strings_exact (Distributions me, long column) { try { long total = 0; long istring = 0; if (column > my numberOfColumns) Melder_throw ("No column ", column, "."); if (my numberOfRows < 1) Melder_throw ("No candidates."); for (long irow = 1; irow <= my numberOfRows; irow ++) { double value = my data [irow] [column]; if (value != floor (value)) Melder_throw ("Non-integer value ", value, " in row ", irow, "."); if (value < 0.0) Melder_throw ("Found a negative value ", value, " in row ", irow, "."); total += value; } if (total <= 0) Melder_throw ("Column total not positive."); autoStrings thee = Thing_new (Strings); thy numberOfStrings = total; thy strings = NUMvector <wchar*> (1, total); for (long irow = 1; irow <= my numberOfRows; irow ++) { long number = my data [irow] [column]; wchar *string = my rowLabels [irow]; if (! string) Melder_throw ("No string in row ", irow, "."); for (long i = 1; i <= number; i ++) { thy strings [++ istring] = Melder_wcsdup (string); } } Strings_randomize (thee.peek()); return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": Strings not generated."); } }
GuiForm GuiForm_createInScrolledWindow (GuiScrolledWindow parent) { autoGuiForm me = Thing_new (GuiForm); my d_shell = parent -> d_shell; my d_parent = parent; #if gtk my d_widget = gtk_fixed_new (); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (parent -> d_widget), GTK_WIDGET (my d_widget)); #elif cocoa #elif motif //my d_widget = XmCreateRowColumn (parent -> d_widget, "menu", nullptr, 0); my d_widget = XmCreateForm (parent -> d_widget, "menu", nullptr, 0); #endif GuiThing_show (me.get()); #if gtk g_signal_connect (G_OBJECT (my d_widget), "destroy", G_CALLBACK (_guiGtkForm_destroyCallback), me.get()); #elif cocoa #elif motif XtAddCallback (my d_widget, XmNdestroyCallback, _guiMotifForm_destroyCallback, me.get()); #endif return me.releaseToAmbiguousOwner(); }
ERP ERPTier_to_ERP_mean (ERPTier me) { try { long numberOfEvents = my events -> size; if (numberOfEvents < 1) Melder_throw ("No events."); ERPPoint firstEvent = my event (1); long numberOfChannels = firstEvent -> erp -> ny; long numberOfSamples = firstEvent -> erp -> nx; autoERP mean = Thing_new (ERP); firstEvent -> erp -> structSound :: v_copy (mean.peek()); for (long ievent = 2; ievent <= numberOfEvents; ievent ++) { ERPPoint event = my event (ievent); for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) { double *erpChannel = event -> erp -> z [ichannel]; double *meanChannel = mean -> z [ichannel]; for (long isample = 1; isample <= numberOfSamples; isample ++) { meanChannel [isample] += erpChannel [isample]; } } } double factor = 1.0 / numberOfEvents; for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) { double *meanChannel = mean -> z [ichannel]; for (long isample = 1; isample <= numberOfSamples; isample ++) { meanChannel [isample] *= factor; } } mean -> channelNames = NUMvector <wchar_t *> (1, mean -> ny); for (long ichan = 1; ichan <= mean -> ny; ichan ++) { mean -> channelNames [ichan] = Melder_wcsdup (my channelNames [ichan]); } return mean.transfer(); } catch (MelderError) { Melder_throw (me, ": mean not computed."); } }
Any Activation_create (long ny, long nx) { Activation me = Thing_new (Activation); if (! me || ! Activation_init (me, ny, nx)) forget (me); return me; }
autoGraphics Graphics_create (int resolution) { autoGraphics me = Thing_new (Graphics); Graphics_init (me.get(), resolution); return me; }
static void Diagonalizer_and_CrossCorrelationTable_qdiag (Diagonalizer me, CrossCorrelationTables thee, double *cweights, long maxNumberOfIterations, double delta) { try { CrossCorrelationTable c0 = (CrossCorrelationTable) thy item[1]; double **w = my data; long dimension = c0 -> numberOfColumns; autoEigen eigen = Thing_new (Eigen); autoCrossCorrelationTables ccts = Data_copy (thee); autoNUMmatrix<double> pinv (1, dimension, 1, dimension); autoNUMmatrix<double> d (1, dimension, 1, dimension); autoNUMmatrix<double> p (1, dimension, 1, dimension); autoNUMmatrix<double> m1 (1, dimension, 1, dimension); autoNUMmatrix<double> wc (1, dimension, 1, dimension); autoNUMvector<double> wvec (1, dimension); autoNUMvector<double> wnew (1, dimension); autoNUMvector<double> mvec (1, dimension); for (long i = 1; i <= dimension; i++) // Transpose W for (long j = 1; j <= dimension; j++) { wc[i][j] = w[j][i]; } // d = diag(diag(W'*C0*W)); // W = W*d^(-1/2); NUMdmatrix_normalizeColumnVectors (wc.peek(), dimension, dimension, c0 -> data); // scale eigenvectors for sphering // [vb,db] = eig(C0); // P = db^(-1/2)*vb'; Eigen_initFromSymmetricMatrix (eigen.peek(), c0 -> data, dimension); for (long i = 1; i <= dimension; i++) { if (eigen -> eigenvalues[i] < 0) { Melder_throw (U"Covariance matrix not positive definite, eigenvalue[", i, U"] is negative."); } double scalef = 1 / sqrt (eigen -> eigenvalues[i]); for (long j = 1; j <= dimension; j++) { p[dimension - i + 1][j] = scalef * eigen -> eigenvectors[i][j]; } } // P*C[i]*P' for (long ic = 1; ic <= thy size; ic++) { CrossCorrelationTable cov1 = (CrossCorrelationTable) thy item[ic]; CrossCorrelationTable cov2 = (CrossCorrelationTable) ccts -> item[ic]; NUMdmatrices_multiply_VCVp (cov2 -> data, p.peek(), dimension, dimension, cov1 -> data, 1); } // W = P'\W == inv(P') * W NUMpseudoInverse (p.peek(), dimension, dimension, pinv.peek(), 0); NUMdmatrices_multiply_VpC (w, pinv.peek(), dimension, dimension, wc.peek(), dimension); // initialisation for order KN^3 for (long ic = 2; ic <= thy size; ic++) { CrossCorrelationTable cov = (CrossCorrelationTable) ccts -> item[ic]; // C * W NUMdmatrices_multiply_VC (m1.peek(), cov -> data, dimension, dimension, w, dimension); // D += scalef * M1*M1' NUMdmatrices_multiplyScaleAdd (d.peek(), m1.peek(), dimension, dimension, 2 * cweights[ic]); } long iter = 0; double delta_w; autoMelderProgress progress (U"Simultaneous diagonalization of many CrossCorrelationTables..."); try { do { // the standard diagonality measure is rather expensive to calculate so we compare the norms of // differences of eigenvectors. delta_w = 0; for (long kol = 1; kol <= dimension; kol++) { for (long i = 1; i <= dimension; i++) { wvec[i] = w[i][kol]; } update_one_column (ccts.peek(), d.peek(), cweights, wvec.peek(), -1, mvec.peek()); Eigen_initFromSymmetricMatrix (eigen.peek(), d.peek(), dimension); // Eigenvalues already sorted; get eigenvector of smallest ! for (long i = 1; i <= dimension; i++) { wnew[i] = eigen -> eigenvectors[dimension][i]; } update_one_column (ccts.peek(), d.peek(), cweights, wnew.peek(), 1, mvec.peek()); for (long i = 1; i <= dimension; i++) { w[i][kol] = wnew[i]; } // compare norms of eigenvectors. We have to compare ||wvec +/- w_new|| because eigenvectors // may change sign. double normp = 0, normm = 0; for (long j = 1; j <= dimension; j++) { double dm = wvec[j] - wnew[j], dp = wvec[j] + wnew[j]; normp += dm * dm; normm += dp * dp; } normp = normp < normm ? normp : normm; normp = sqrt (normp); delta_w = normp > delta_w ? normp : delta_w; } iter++; Melder_progress ((double) iter / (double) (maxNumberOfIterations + 1), U"Iteration: ", iter, U", norm: ", delta_w); } while (delta_w > delta && iter < maxNumberOfIterations); } catch (MelderError) { Melder_clearError (); } // Revert the sphering W = P'*W; // Take transpose to make W*C[i]W' diagonal instead of W'*C[i]*W => (P'*W)'=W'*P NUMmatrix_copyElements (w, wc.peek(), 1, dimension, 1, dimension); NUMdmatrices_multiply_VpC (w, wc.peek(), dimension, dimension, p.peek(), dimension); // W = W'*P: final result // Calculate the "real" diagonality measure // double dm = CrossCorrelationTables_and_Diagonalizer_getDiagonalityMeasure (thee, me, cweights, 1, thy size); } catch (MelderError) { Melder_throw (me, U" & ", thee, U": no joint diagonalization (qdiag)."); } }
int Praat_tests (int itest, char32 *arg1, char32 *arg2, char32 *arg3, char32 *arg4) { int64 n = Melder_atoi (arg1); double t = 0.0; (void) arg1; (void) arg2; (void) arg3; (void) arg4; Melder_clearInfo (); Melder_stopwatch (); switch (itest) { case kPraatTests_TIME_RANDOM_FRACTION: { for (int64 i = 1; i <= n; i ++) (void) NUMrandomFraction (); t = Melder_stopwatch (); } break; case kPraatTests_TIME_RANDOM_GAUSS: { for (int64 i = 1; i <= n; i ++) (void) NUMrandomGauss (0.0, 1.0); t = Melder_stopwatch (); } break; case kPraatTests_TIME_SORT: { long m = Melder_atoi (arg2); long *array = NUMvector <long> (1, m); for (int64 i = 1; i <= m; i ++) array [i] = NUMrandomInteger (1, 100); Melder_stopwatch (); for (int64 i = 1; i <= n; i ++) NUMsort_l (m, array); t = Melder_stopwatch (); NUMvector_free (array, 1); } break; case kPraatTests_TIME_INTEGER: { int64 sum = 0; for (int64 i = 1; i <= n; i ++) sum += i * (i - 1) * (i - 2); t = Melder_stopwatch (); MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_FLOAT: { double sum = 0.0, fn = n; for (double fi = 1.0; fi <= fn; fi = fi + 1.0) sum += fi * (fi - 1.0) * (fi - 2.0); t = Melder_stopwatch (); MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_FLOAT_TO_UNSIGNED_BUILTIN: { uint64_t sum = 0; double fn = n; for (double fi = 1.0; fi <= fn; fi = fi + 1.0) sum += (uint32) fi; t = Melder_stopwatch (); // 2.59 // 1.60 MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_FLOAT_TO_UNSIGNED_EXTERN: { uint64_t sum = 0; double fn = n; for (double fi = 1.0; fi <= fn; fi = fi + 1.0) sum += (uint32) ((int32) (fi - 2147483648.0) + 2147483647L + 1); t = Melder_stopwatch (); // 1.60 MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_UNSIGNED_TO_FLOAT_BUILTIN: { double sum = 0.0; uint32 nu = (uint32) n; for (uint32 iu = 1; iu <= nu; iu ++) sum += (double) iu; t = Melder_stopwatch (); // 1.35 MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_UNSIGNED_TO_FLOAT_EXTERN: { double sum = 0.0; uint32 nu = (uint32) n; for (uint32 iu = 1; iu <= nu; iu ++) sum += (double) (int32) (iu - 2147483647L - 1) + 2147483648.0; t = Melder_stopwatch (); // 0.96 MelderInfo_writeLine (sum); } break; case kPraatTests_TIME_STRING_MELDER_32: { autoMelderString string; char32 word [] { U"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { MelderString_copy (& string, word); for (int j = 1; j <= 30; j ++) MelderString_append (& string, word); } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_MELDER_32_ALLOC: { char32 word [] { U"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { autoMelderString string; MelderString_copy (& string, word); for (int j = 1; j <= 30; j ++) MelderString_append (& string, word); } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_S: { std::string s = ""; char word [] { "abc" }; word [2] = (char) NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_C: { std::basic_string<char> s = ""; char word [] { "abc" }; word [2] = (char) NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_WS: { std::wstring s = L""; wchar_t word [] { L"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_WC: { std::basic_string<wchar_t> s = L""; wchar_t word [] { L"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_32: { std::basic_string<char32_t> s = U""; char32 word [] { U"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRING_CPP_U32STRING: { std::u32string s = U""; char32 word [] { U"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { s = word; for (int j = 1; j <= 30; j ++) s += word; } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STRCPY: { char buffer [100]; char word [] { "abc" }; word [2] = (char) NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { strcpy (buffer, word); for (int j = 1; j <= 30; j ++) strcpy (buffer + strlen (buffer), word); } t = Melder_stopwatch (); MelderInfo_writeLine (Melder_peek8to32 (buffer)); } break; case kPraatTests_TIME_WCSCPY: { wchar_t buffer [100]; wchar_t word [] { L"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { wcscpy (buffer, word); for (int j = 1; j <= 30; j ++) wcscpy (buffer + wcslen (buffer), word); } t = Melder_stopwatch (); } break; case kPraatTests_TIME_STR32CPY: { char32 buffer [100]; char32 word [] { U"abc" }; word [2] = NUMrandomInteger ('a', 'z'); for (int64 i = 1; i <= n; i ++) { str32cpy (buffer, word); for (int j = 1; j <= 30; j ++) str32cpy (buffer + str32len (buffer), word); } t = Melder_stopwatch (); MelderInfo_writeLine (buffer); } break; case kPraatTests_TIME_GRAPHICS_TEXT_TOP: { autoPraatPicture picture; for (int64 i = 1; i <= n; i ++) { Graphics_textTop (GRAPHICS, false, U"hello world"); } t = Melder_stopwatch (); } break; case kPraatTests_THING_AUTO: { int numberOfThingsBefore = theTotalNumberOfThings; { Melder_casual (U"1\n"); autoDaata data = Thing_new (Daata); Thing_setName (data.get(), U"hello"); Melder_casual (U"2\n"); testData (data.get()); testAutoData (data.move()); autoDaata data18 = Thing_new (Daata); testAutoData (data18.move()); fprintf (stderr, "3\n"); autoDaata data2 = newAutoData (); fprintf (stderr, "4\n"); autoDaata data3 = newAutoData (); fprintf (stderr, "5\n"); //data2 = data; // disabled l-value copy assignment from same class fprintf (stderr, "6\n"); autoOrdered ordered = Thing_new (Ordered); fprintf (stderr, "7\n"); //data = ordered; // disabled l-value copy assignment from subclass data = ordered.move(); //ordered = data; // disabled l-value copy assignment from superclass //ordered = data.move(); // assignment from superclass to subclass is rightfully refused by compiler fprintf (stderr, "8\n"); data2 = newAutoData (); fprintf (stderr, "8a\n"); autoDaata data5 = newAutoData (); fprintf (stderr, "8b\n"); data2 = data5.move(); fprintf (stderr, "9\n"); //ordered = data; // rightfully refused by compiler fprintf (stderr, "10\n"); //autoOrdered ordered2 = Thing_new (Daata); // rightfully refused by compiler fprintf (stderr, "11\n"); autoDaata data4 = Thing_new (Ordered); // constructor fprintf (stderr, "12\n"); //autoDaata data6 = data4; // disabled l-value copy constructor from same class fprintf (stderr, "13\n"); autoDaata data7 = data4.move(); fprintf (stderr, "14\n"); autoOrdered ordered3 = Thing_new (Ordered); autoDaata data8 = ordered3.move(); fprintf (stderr, "15\n"); //autoDaata data9 = ordered; // disabled l-value copy constructor from subclass fprintf (stderr, "16\n"); autoDaata data10 = data7.move(); fprintf (stderr, "17\n"); autoDaata data11 = Thing_new (Daata); // constructor, move assignment, null destructor fprintf (stderr, "18\n"); data11 = Thing_new (Ordered); fprintf (stderr, "19\n"); testAutoDataRef (data11); fprintf (stderr, "20\n"); //data11 = nullptr; // disabled implicit assignment of pointer to autopointer fprintf (stderr, "21\n"); } int numberOfThingsAfter = theTotalNumberOfThings; fprintf (stderr, "Number of things: before %d, after %d\n", numberOfThingsBefore, numberOfThingsAfter); #if 1 MelderCallback<void,structDaata>::FunctionType f; typedef void (*DataFunc) (Daata); typedef void (*OrderedFunc) (Ordered); DataFunc dataFun; OrderedFunc orderedFun; MelderCallback<void,structDaata> dataFun2 (dataFun); MelderCallback<void,structOrdered> orderedFun2 (orderedFun); MelderCallback<void,structDaata> dataFun3 (orderedFun); //MelderCallback<void,structOrdered> orderedFun3 (dataFun); // rightfully refused by compiler autoDaata data = Thing_new (Daata); dataFun3 (data.get()); #endif } break; } MelderInfo_writeLine (Melder_single (t / n * 1e9), U" nanoseconds"); MelderInfo_close (); return 1; }
static autoDaata newAutoData () { autoDaata data (Thing_new (Daata)); return data; }