Boolean EntityApp::makeSystemId(int nFiles, AppChar *const *files,
StringC &result)
{
Vector<StringC> filenames(nFiles == 0 ? 1 : nFiles);
int i;
for (i = 0; i < nFiles; i++)
filenames[i] = convertInput(tcscmp(files[i], SP_T("-")) == 0
? SP_T("<OSFD>0")
: files[i]);
if (nFiles == 0)
filenames[0] = convertInput(SP_T("<OSFD>0"));
return entityManager()->mergeSystemIds(filenames,
mapCatalogDocument_,
systemCharset_,
*this,
result);
}
std::vector<WordAnalysis> Vabamorf::analyze(
StringVector const& sentence,
const bool disambiguate,
const bool guess,
const bool phonetic,
const bool propername) {
applyMorfSettings(linguistic, guess, phonetic, propername);
CFSArray<CFSVar> words = convertInput(sentence);
addAnalysis(linguistic, disambiguator, words, disambiguate);
return convertOutput(words);
}
/********************************************** MAIN FUNCTION *************************************************/
int main()
{
int v, i, j, index1, index2, integers1[1000] = {0}, integers2[1000] = {0}, number1, number2;
char start[100], key[100], s[100];
scanf("%s", s);
v = checkFloat(s);
getchar();
if(v < 0 || v > 1000 || v == -1)
{
printf("INVALID INPUT\n");
return 0;
}
struct Graph *graph = makeGraph(v);
for(i = 0; i < 10000; i++)
{
visited[i] = 0;
}
char input[1000][1000], weight[1000][1000];
for(i = 0; i < v; i++)
{
scanf("%[^\n]s", input[i]);
getchar();
}
for(i = 0; i < v; i++)
{
scanf("%[^\n]s", weight[i]);
getchar();
}
for(i = 0; i < v; i++)
{
index1 = convertInput(input[i], integers1);
index2 = convertInput(weight[i], integers2);
if(index1 == -1 || index2 == -1)
{
printf("INVALID INPUT\n");
return 0;
}
for(j = 0; j < index2; j++)
{
if(integers2[j] < 0 || integers2[j] > 10000)
{
printf("INVALID INPUT\n");
return 0;
}
}
if(index1 > 0)
{
if(isSorted(integers1, index1) == 0)
{
printf("INVALID INPUT\n");
return 0;
}
}
for(j = 0; j < index1; j++)
{
if(integers1[j] < 0 || integers1[j] > (v - 1))
{
printf("INVALID INPUT\n");
return 0;
}
makeEdge(graph, i, integers1[j], integers2[j]);
}
}
while(1)
{
char choice[5];
scanf("%s", choice);
if(strcmp(choice, "apsp") == 0)
{
scanf("%s", start);
number1 = checkFloat(start);
if(number1 < 0 || number1 > (v - 1))
{
printf("INVALID INPUT\n");
return 0;
}
dijkstra(graph, number1);
for(i = 0; i < graph->v; i++)
{
if(min_dist_array[i] != 50000)
{
printf("%d ", min_dist_array[i]);
}
else
{
printf("INF ");
}
}
printf("\n");
}
else if(strcmp(choice, "sssp") == 0)
{
scanf("%s %s", start, key);
number1 = checkFloat(start);
if(number1 < 0 || number1 > (v - 1))
{
printf("INVALID INPUT\n");
return 0;
}
number2 = checkFloat(key);
if(number2 < 0 || number2 > (v - 1))
{
printf("INVALID INPUT\n");
return 0;
}
dijkstra(graph, number1);
if(min_dist_array[number2] != 50000)
{
printf("%d", min_dist_array[number2]);
}
else
{
printf("UNREACHABLE");
}
printf("\n");
}
else if(strcmp(choice, "stop") == 0)
{
break;
}
else
{
printf("ENTER CORRECT CHOICE\n");
}
}
}
std::vector<SpellingResults>
Vabamorf::spellcheck(StringVector const& sentence, const bool suggest) {
CFSArray<CFSVar> words = convertInput(sentence);
addSuggestions(linguistic, words, suggest);
return convertSpellingOutput(words);
}
// Ambisonic to binaural render
void AudioFOA::render(int16_t* input, float* output, int index, float qw, float qx, float qy, float qz, float gain, int numFrames) {
assert(index >= 0);
assert(index < FOA_TABLES);
assert(numFrames == FOA_BLOCK);
ALIGN32 float fftBuffer[FOA_NFFT]; // in-place FFT buffer
ALIGN32 float accBuffer[2][FOA_NFFT] = {}; // binaural accumulation buffers
ALIGN32 float inBuffer[4][FOA_BLOCK]; // deinterleaved input buffers
float* in[4] = { inBuffer[0], inBuffer[1], inBuffer[2], inBuffer[3] };
float rotation[4][4];
// convert input to deinterleaved float
convertInput(input, in, FOA_GAIN, FOA_BLOCK);
// convert quaternion to 4x4 rotation
quatToMatrix_4x4(qw, qx, qy, qz, rotation);
// apply gain as uniform scale
scaleMatrix_4x4(gain, rotation);
// disable interpolation from reset state
if (_resetState) {
memcpy(_rotationState, rotation, sizeof(_rotationState));
}
// rotate and scale the soundfield
rotate_4x4(in, _rotationState, rotation, crossfadeTable, FOA_BLOCK);
// new parameters become old
memcpy(_rotationState, rotation, sizeof(_rotationState));
//
// Accumulate the contribution of each spherical harmonic into binaural output buffers.
// Performed in the frequency domain, using overlap-save FFT.
//
for (int n = 0; n < 4; n++) {
// fill with overlapped input
memcpy(fftBuffer, _fftState[n], FOA_OVERLAP * sizeof(float)); // old input
memcpy(&fftBuffer[FOA_OVERLAP], in[n], FOA_BLOCK * sizeof(float)); // new input
// input history update
memcpy(_fftState[n], &fftBuffer[FOA_BLOCK], FOA_OVERLAP * sizeof(float));
// forward transform
rfft512(fftBuffer);
// multiply-accumulate with filter kernels
rfft512_cmadd_1X2(fftBuffer, foa_table_table[index][n][0], foa_table_table[index][n][1], accBuffer[0], accBuffer[1]);
}
// inverse transform
rifft512(accBuffer[0]);
rifft512(accBuffer[1]);
//
// Mix into the interleaved output buffer.
// The first FOA_OVERLAP samples are discarded, due to overlap-save FFT.
//
for (int i = 0; i < FOA_BLOCK; i++) {
output[2*i+0] += accBuffer[0][i + FOA_OVERLAP];
output[2*i+1] += accBuffer[1][i + FOA_OVERLAP];
}
_resetState = false;
}
Ptr<ExtendEntityManager> &EntityApp::entityManager()
{
if (!entityManager_.isNull())
return entityManager_;
PosixStorageManager *sm
= new PosixStorageManager("OSFILE",
systemCharset_.desc(),
#ifndef SP_WIDE_SYSTEM
codingSystem(),
#endif
5);
size_t i;
for (i = 0; i < searchDirs_.size(); i++)
sm->addSearchDir(convertInput(searchDirs_[i]));
{
const AppChar *e = tgetenv(SP_T("SGML_SEARCH_PATH"));
if (!e)
e = SGML_SEARCH_PATH_DEFAULT;
if (*e) {
StringC str(convertInput(e));
size_t i = 0;
size_t start = 0;
for (;;) {
if (i == str.size() || str[i] == FILE_SEP) {
sm->addSearchDir(StringC(str.data() + start,
i - start));
if (i == str.size())
break;
start = ++i;
}
else
i++;
}
}
}
entityManager_ = ExtendEntityManager::make(sm, codingSystem());
entityManager_
->registerStorageManager(new PosixFdStorageManager("OSFD",
systemCharset_.desc()));
entityManager_->registerStorageManager(new URLStorageManager("URL"));
entityManager_->registerStorageManager(new LiteralStorageManager("LITERAL"));
for (i = 0;; i++) {
const char *s;
const CodingSystem *p = codingSystem(i, s);
if (!p)
break;
entityManager_->registerCodingSystem(s, p);
}
#ifdef SP_MULTI_BYTE
for (i = 0; i < SIZEOF(inputCodingSystems); i++)
entityManager_->registerCodingSystem(inputCodingSystems[i].name,
inputCodingSystems[i].cs);
#endif
Vector<StringC> v;
for (i = 0; i < catalogSysids_.size(); i++)
// filenames specified on command-line must exist
v.push_back(convertInput(catalogSysids_[i]));
{
const AppChar *e = tgetenv(SP_T("SGML_CATALOG_FILES"));
if (!e)
e = SGML_CATALOG_FILES_DEFAULT;
if (*e) {
StringC str(convertInput(e));
size_t i = 0;
size_t start = 0;
for (;;) {
if (i == str.size() || str[i] == FILE_SEP) {
v.push_back(StringC(str.data() + start,
i - start));
if (i == str.size())
break;
start = ++i;
}
else
i++;
}
}
}
entityManager_->setCatalogManager(SOCatalogManager::make(v,
catalogSysids_.size(),
systemCharset_,
systemCharset_));
return entityManager_;
}
