Полезные задачи, упражнения, тесты по ..., делимся интересными задачами по программированию и не только Опции Подписка на тему Сообщить другу Версия для печати Скачать тему Подписка на этот форум Режимы отображения Переключить на: Древовидный Стандартный Переключить на: Линейный

[AD]

То есть самая первая подзадача - это найти критерий определения шума. Ну то есть, тот предел, по которому можно будет ориентироваться является ли число в последовательности шумом или нет!

[Алексей1153]

Я правильно понимаю, что __acc, n_acc - пределы, по которым определяются "шумы"?

да, __acc - это точность (1000 ~ 3 порядка) , а n_acc - величина, обратная к __acc . Это далее для сравнения "больше на 3 порядка" или "меньше на 3 порядка". Поскольку деление - операция "тяжёлая", я вынес её за цикл

Сильно ли усложнит задачку следующее добавление, что пределы должны определяться в зависимости от массива/вектора?

да ни грамма не усложнит Надо сделать: перед вычислением пройтись по данным, определить максимум и минимум. В зависимости от них выбрать __acc.

Как поведет себя предложенный метод если к примеру первые 2 значения числа больше 1000 и 2000, а остальные 1 2 3 4 5. - какие значения удалятся из интервала?

я код не тестировал. А по алгоритму, щас посмотрим:

__acc=1000;
n_acc=0.001;

исходные данные:
1055, 2055, 1, 2, 3, 4, 5

с болванками:
1055, 1055, 2055, 1, 2, 3, 4, 5, 5
       |                      |
     отсюда начинаем       здесь стоп

1)
число 1055
k1=1055/1055 ==1  , n_acc<k1<__acc> - оставляем
k2=1055/2055 ==0.513  , n_acc<k2<__acc  - оставляем

2)
число 2055
k1=1055/2055 ==0.513  , n_acc<k1<__acc> - оставляем
k2=2055/1 ==2055  , n_acc<__acc<k2  - удаляем

...

ага, дебаг показал уже два косяка:
1) условие проверяется по 2 раза. Сократить до одного раза
2) значение нельзя просто удалять. Его надо заменять на следующее, а затем шагнуть один шаг назад и продолжить оттуда:

1055, 1055, 2055, 1, 2, 3, 4, 5, 5
             |
        сейчас проверяется

1055, 1055, <2055>, 1, 2, 3, 4, 5, 5
             |
        надо удалить (заменить на следующее)

1055, 1055, <1>, 1, 2, 3, 4, 5, 5
             |
           заменили

1055, 1055, <1>, 1, 2, 3, 4, 5, 5
       |
    шаг назад. Продолжаем отсюда

и ещё один баг: если сканировать с начала, приоритет отдаётся последним значениям. И "низкая волна" в конце перекроет "высокую " в начале. Тут можно попробовать заранее просмотреть данные и ориентироваться на некий уровень.

а ещё, кстати! я у себя делал сглаживание ступенчатого сигнала, наверное такой метод тоже может подойти, сейчас скрины для примера сделаю, прикреплю

без сглаживания

Уменьшено до 76% 1067 x 283 (18.15 килобайт)

одна итерация

Уменьшено до 75% 1062 x 237 (14.44 килобайт)

10 итераций

Уменьшено до 76% 1065 x 165 (8.58 килобайт)

Сообщение отредактировал Алексей1153 - 20.10.2010, 9:33

[kwisp]

Тут можно попробовать заранее просмотреть данные и ориентироваться на некий уровень.

уже интереснее.
а потом еще окажется что нужно учитывать тенденцию роста функции.

[Алексей1153]

kwisp, а как ты хотел Чтоб без отладки оно всё взяло и заработало ? Представь себе меандр с амплитудой 2000 у.е. По какому критерию будешь отбрасывать значения ? Ноль или амплитудные ?

[kwisp]

вот моя попытка.
к сожалению определить полностью автоматически лишние значения для меня оказалось очень сложно. Все же нужен критерий оценки от пользователя. Понятно что можно расширить и улучшить.
находим мат. ожидание(в данном случае = ср.арифметическому), к примеру, так:
upthrow.h

# ifndef UPTHROW_H_
# define UPTHROW_H_

# include <algorithm>
# include <numeric>

template <class InputIterator, class T>
T expectation(InputIterator first, InputIterator last, T init)
{
 return std::accumulate(first,last,init)/std::distance<InputIterator>(first,last);
}

# endif // UPTHROW_H_

или просто с использованием accumulate и distance неважно

пример использования следующий:
main.cpp

Раскрывающийся текст

# include <iostream>
# include <vector>
# include <iterator>
# include <functional>
# include <ext/functional>
# include <fstream>
# include <cmath>
# include "upthrow.h"

int main()
{
 std::vector<double> V1;
 std::ifstream inputFile("values");
 std::copy(std::istream_iterator<double>(inputFile), std::istream_iterator<double>(), std::back_inserter(V1));
 std::copy(V1.begin(), V1.end(), std::ostream_iterator<double>(std::cout, " "));// ostreambuf_iterator ???
 std::cout << std::endl;

 double Mx = expectation<std::vector<double>::iterator, double>(V1.begin(), V1.end(), 0.0 );
  
 std::cout << "expectation: " << Mx << '\n';

 V1.erase(std::remove_if(V1.begin(),V1.end(), __gnu_cxx::compose1(std::bind2nd(std::greater<double>(), 
                         Mx*2.5), __gnu_cxx::compose1(std::ptr_fun(abs),
                               std::bind2nd(std::minus<double>(),
                                 Mx)))), V1.end()); // вот непосредственно и всё удаление выбросов

 std::copy(V1.begin(), V1.end(), std::ostream_iterator<double>(std::cout, " "));
 std::cout<< std::endl;  
 return 0;
}

в данном примере критерий удаления - это разница значения элемента с мат.ожиданием больше чем 2,5 мат.ожидания, взят для примера. на самом деле придется хоть немного знать о хранимых значениях чтобы выбрать критерий правильно для своей задачи.

[Алексей1153]

[offtop]
kwisp, кстати, специализацию можно не указывать тут

std::distance<InputIterator>(first,last);

- она очевидна. Можно вот так

std::distance(first,last);
[/offtop]

[kwisp]

самому себе для наглядности написал.