Wataru

Понятия не имею, что за смешанный способ вам нужен, но сумму этого ряда можно найти два раза взяв производную.

Пусть f(x) - ваш ряд. Тогда f'(x) = sum (-1)^n x^(2n-2) / (2n+1)

Чтобы совсем избавиться от знаменателя надо бы, чтобы степень была 2n+1. Можно этого добиться, домножив все на x^3. Потом можно опять взять производную.

(x^3 f'(x))' = sum (-1)^n x^2n = sum (-x^2)^n = 1/(1+x^2)

Теперь назад проинтегрировав это можно получить:
x^3 f'(x) = arctg(x)+C

При x=0 слева 0 - значит C=0.

f'(x) = arctg(x) / x^3

Отсюда можно найти f'(x): Зайдите на wolframalpha и введите integrate arctg(x)/x^3 dx (не могу дать прямую ссылку с запросом на wolfram, потому что мат-фильтр почему-то срабатывает на ссылку и не дает отправить ответ).

Чтобы найти константу, придется подставить, например, x=1 и найти сумму ряда a_n = (-1)^n/(4N^2-1). Это какой-то известный сходящийся рад, похоже. Опять, посмотрите на wolframalpha, введите там sum (-1)^n/(4*n^2-1), n=0 to infinity. В итоге получится, что там константа тоже 0.

Вот и получится, что f(x) =- (x^2 * arctan(x) + arctan(x) + x) / (2x^2)

Поскльку у вас уже жестко задан вид функции, то это задача на минимизацию функции ошибки (от n и k). Обычно мнимизируют сумму квадратов ошибок по всем примерам.

Аналитически, как в методе наименьших квадратов, приравнять производные по n и k к 0 похоже не очень получается. Придется использовать какой-то численный метод минимизации функции. Например, градиентный спуск или метод ньютона. Если похоже, что функция имеет множество локальных минимумов, то будет работать что-то более хитрое, как например, метод отжига.

У вас нет проблем с перегрузкой. У вас там проблема с логикой программы. Для начала объясните себе, что хранит в себе класс Array (зачем там 2 массива a и b?), что должен делать опреатор += для двух экземпляров Array?

180-градусов вдоль оси вдоль зеленой детальки (вправо), а потом 90 градусов вдоль оси перендикулярной деталькам (ось к нам). Ну или в обратном порядке - сначала 90 градусов вдоль перпендикулярной оси, потом 180 вдоль продольной оси (вверх).

Не так почти в каждой строчке.

Во-первых, зачем вам структура из четырех строк? Зачем вам массив из нее на 1000 элементов.

Вот это вообще что за хрень?
for (i; i < 1; i++) {

Вас этот цикл из одной итерации нисколько не напрягает?

Далее, в задании четко сказано

Разработать функцию, которая вставляет в предложение заданное слово. Новое слово должно стать в предложении n-м (n задается как третий параметр функции)

Т.е. вам надо взять одну функцию, и вызвать ее 3 раза с передавая туда то 1, то 2, то 5, а не писать 3 Poshuk'а.

Далее, во всех ваших функциях вы обращаетесь к list[] по разным индексам, но у вас только один первый элемент массива вводится (опять, нахрена вам целый массив структур, если в задаче дано ровно 3 строки и одно слово?!)

Ну и последнее, логика искомой функции должна быть такой: Проходимся по переданной строке, считатем, сколько пробелов встретили. Как только встречаем пробел с заданным номером, сдвигаем все символы за этим пробелом вправо на длину вставляемого слова, потом копируем слово в пустое место.

Чтобы сдвигать символы в строке вам надо сначала найти ее длину, потом с длина+k циклом пройтись назад до крайнего сдвигаемого индекса и присваивать текущему символу значение символа по индексу i-k.

Если вызвать exit какой-нибудь, то программа завершится и система прибъет все потоки.

Хватит и метода наименьших квадратов.

Я так понял, что вам надо отслеживать общий сдвиг и поворот так, что бы индивидуальные изменения в точках были минимальны.

Сначала для каждой точки в прошлом снимке найдите положение в следующем. Можно брать ближайшую точку, если там изменения от кадра к кадру небольшие. Иначе придется городить какой-нибудь градиентный спуск. Если изменение превосходит некоторое пороговое значение - считаете, что точка пропала и не включаете эту пару в рассмотрение.

Когда для каждой точки вы знаете где ее прошлое и следующее положение, у вас задача найти минимум функции
sum_i (xp_i-xp'_i)^2+(yp_i-yp'_i)^2, где
xp' = xn*cosa - yn*sina + dx
yp' = xn*sina + yn*cosa + dy.

Тут (xp, yp) - координаты i-ой точки в прошлом кадре, (xn, yn) - координаты в следующем кадре, cosa,sina,dx,dy - неизвестные. Берете производные по dx, dy и a приравниваете к 0. Получаете 3 уравнения с 3 неизвестными. Их двух первых элементарно выразить dx, dy через cosa/sina. Подставив в последнее вы получите уравнение вида cosa^2 A + sina cosa B + sina^2C + D = 0. Можно домножить D на cosa^2+sina^2, потом поделить все на sin^2 и решать квадратное уравнение относительно тангенса. Потом через арктангенс найти решение.

Если изменения от кадра к кадру могут быть большими, то надо минимизировать чуть чуть другую функцию:

sum_i min_j ((xp_j-xp'_i)^2+(yp_j-yp'_i)^2) - для каждой точки берем минимум по всем возможным прообразам и это суммируем. Поскольку оно уже не диффиренцируемо, придется использовать какой-то более хитрый метод оптимизации по dx, dy, a.

Диалоговое окно-то появляется?

Я подозреваю, что MessageBox возвращает 0, что происходит происходит при ошибке:

If the function fails, the return value is zero.

Поэтому цикл while завершается. Т.е. проблема не с GetKeyState, а логикой программы.

Сам класс хранит умный указатель на буфер данных.

Нужен счетчик ссылок на буфер. Перед записью проверяйте, что счетчик равен 1. Иначе копируете данные и в текущем объекте заменяете указатель на новый буфер.

Счетчик должен храниться где-то вместе с буфером и является частью умного указателя.

Можно использовать std::shared_ptr - там уже этот счетчик реализован (use_count).

Пройтись по списку, добавляя элементы в конец нового списка.
Только не надо использовать вашу функцию add - она каждый раз проходится по всему списку. Заведите отдельную переменную, которая будет указывать на конец создаваемого списка и добавляйте новый элемент к ней.

Определите какую-то метрику. Или количество общих слов у человека и документа или как-то оно нормализованное, вроде какая часть их слов у них общая. После построения матрицы растояния уже можно решать вашу задачу.

Если документы можно распределять ненормированно, то просто давайте каждый документ ближайшему человеку.

Если надо как-то нормировать нагрузку, то тут возникает задача назначения, которая может решаться алгоритмом максимального потока минимальной стоимости. Можно вводить штрафы на перегрузку каждого человека и тогда алгоритм может выдавать документы не ближайшим людям, у которых мало работы.

Я бы посоветовал делать абстракцию не на уровне пикселя, а на уровне картинки. Ибо так можно оптимальнее организовывать расположение пикселей в памяти да и обрабатывать изображение быстрее. Вместо функции, которая для каждого пикселя проверяет, а что там у него брать R или Y, используют функции, которым передается plane - один канал. Что там конкретно R, G, Y, V - обычно не важно. Если вы ищете контур или сглаживаете изображение, то работа идет абсолютно одинаково в каждом канале.

В качестве примера можно посмортреть вот тут или тут.

char str = 0, *pStr = &str;

Очень, очень не правильно так делать. Строка - это массив char в памяти. Указатель указывает на начало этого куска в пямяти. Вы же берете одну переменную, и потом работаете с ней как с массивом.

Надо выделять память под строку. Или статический массив, или malloc.