int main()
{
pf("\n S-eries Circuit\n P-arallel Circuit");
pf("\n\n Choose a circuit : ");
c=getche();
system("cls");
switch (c){
case 's' : case 'S':
pf("\t Series Circuit");
Value();
system("cls");
Series();
break;
case 'p' :case 'P' :
pf(" \t Parallel Circuit");
Value();
system("cls");
Parallel();
break;
default :
pf("\t %c is invalid !\n",c);
main();
break;
}
}
void SeriesListCtrl::OnDeleteSeries()
{
POSITION pos=GetFirstSelectedItemPosition(); bool upd=false; void *x;
if(pos)
{
CArray<int,const int&> ToDel; int i; CString temp;
while(pos) ToDel.Add(GetItemData(GetNextSelectedItem(pos)));
qsort(ToDel.GetData(),ToDel.GetSize(),sizeof(int),compfunc);
for(i=0;i<ToDel.GetSize();i++)
{
int n=ToDel[i];
temp.Format("Series %s contains %d points. Remove it?",Items[n].Name,Items[n].Size);
if(AfxMessageBox(temp,MB_YESNO)==IDNO) ToDel[i]=-1;
}
if((x=Series->GainAcsess(WRITE))!=0)
{
upd=true;
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
{
for(i=0;i<ToDel.GetSize();i++)
if(ToDel[i]>=0) Series.DeleteItem(ToDel[i]);
}
}
if(upd) UpdateSeriesList();
}
}
LRESULT CalcTEDialog::OnSeriesUpdate(WPARAM wParam, LPARAM lParam )
{
CString T; int n;
if(lParam!=0)
{
Series=(ProtectedSeriesArray*)lParam;
SeriesCombo.ResetContent();
void *x;
if((x=Series->GainAcsess(READ))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
SeriesSearchPattern pattern;
pattern.mode=SERIES_NAME | SERIES_TYPE;
pattern.name=CString("FinalMins"); pattern.SeriesType=SIMPLE_POINT;
TSeriesArray results(DO_NOT_DELETE_SERIES);
if( Series.FindSeries(pattern,results)!=0 )
{
for(int i=0;i<results.Series.GetSize();i++)
{
T.Format("%s (%d)",results.Series[i]->Name,results.Series[i]->GetSize());
n=SeriesCombo.AddString(T);
SeriesCombo.SetItemData(n,(DWORD)results.Series[i]);
}
}
}
}
return 0;
}
template <class T> array<T,int>& Series(const T& start, const T& end, const T& increment){
if (end < start){return Series(end, start, increment);}
else if (end == start){throw std::invalid_argument( "The inputs cannot be equivalent" );}
array<T,int>* series = new array<T,int>(1,(end-start)/increment);
T a = start;
for (int count = 0; count < series->Size(); ++count){
series->Assign(count, a);
a += increment;
}
return *series;
}
ЧебышёвSeries<Vector> ЧебышёвSeries<Vector>::ReadFromMessage(
serialization::ЧебышёвSeries const& message) {
using Serializer = DoubleOrQuantityOrMultivectorSerializer<
Vector,
serialization::ЧебышёвSeries::Coefficient>;
std::vector<Vector> coefficients;
coefficients.reserve(message.coefficient_size());
for (auto const& coefficient : message.coefficient()) {
coefficients.push_back(Serializer::ReadFromMessage(coefficient));
}
return ЧебышёвSeries(coefficients,
Instant::ReadFromMessage(message.t_min()),
Instant::ReadFromMessage(message.t_max()));
}
void SeriesListCtrl::ChangeStatus(int t)
{
POSITION pos=GetFirstSelectedItemPosition(); void *x;
if(pos)
{
if((x=Series->GainAcsess(READ_EX))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
while(pos)
{
int n=GetItemData(GetNextSelectedItem(pos));
TChartSeries *series=Series[n];
series->SetStatus(t);
}
}
UpdateSeriesList();
}
}
LRESULT TChart::OnSeriesDataImport( WPARAM wParam, LPARAM lParam )
{
MessagesInspectorSubject* msg=(MessagesInspectorSubject*)lParam; void *x;
BYTE t=0;
if(msg)
{
if((x=Series.GainAcsess(WRITE))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
for(int i=0;i<Series.GetSize();i++)
{
if(Series[i]->ImportData(msg,DO_NOT_DELETE_MSG)!=0) t++;
}
}
delete msg;
if(t) UpdateNow(REPAINT_DEFAULT);
}
return 0;
}
void SeriesListCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
ProtectedSeriesArray& Series=*(SeriesListCtrl::Series); void *x;
HitItem=HitTest(point);
if (HitItem>=0)
{
CRect rect; GetItemRect(HitItem, rect, LVIR_ICON);
if (point.x < rect.left)
{
BYTE state=GetState(HitItem);
state++; if(state>2) state=1;
SetState(HitItem,state);
if((x=Series.GainAcsess(WRITE))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
Series[GetItemData(HitItem)]->SetVisible(state-1);
}
}
}
CListCtrl::OnLButtonDown(nFlags, point);
}
/* Series */
Series DataClass::series(int size) {
return Series(size);
}
const Series Series::operator/(const Series &series) const {
return Series(*this) /= series;
}
void ImageWndCtrlsTab::OnBnClickedScan()
{
UpdateData(); ImageWnd* parent=(ImageWnd*)Parent;
parent->strips.ScanLine.curL.x=Xmin/parent->scale; parent->strips.ScanLine.curR.x=Xmax/parent->scale;
parent->strips.ScanLine.curL.y=parent->strips.ScanLine.curR.y=stroka/parent->scale;
parent->DrawScanLine(parent->strips.ScanLine.curL,parent->strips.ScanLine.curR);
CMainFrame* MainWnd=(CMainFrame*)AfxGetMainWnd();
MainWnd->TabCtrl1.ChangeTab(MainWnd->TabCtrl1.FindTab("Main control"));
void* x; CString T,T1; BYTE *dark,*cupol,*strips;
TPointVsErrorSeries *t2; //TSimplePointSeries *t1;
int midl=stroka, dd=AvrRange,w=parent->strips.org.w, Ymin=midl-dd, Ymax=midl+dd, mm=(Ymax-Ymin)/2;
MyTimer Timer1,Timer2; sec time; CString logT;
TPointVsErrorSeries::DataImportMsg *CHM2, *AdarkChartMsg, *AcupolChartMsg, *AstripsChartMsg, *ChartMsg;
TSimplePointSeries::DataImportMsg *CHM1, *darkChartMsg,*cupolChartMsg, *stripsChartMsg;
CHM2=AdarkChartMsg=AcupolChartMsg=AstripsChartMsg=ChartMsg=NULL;
CHM1=darkChartMsg=cupolChartMsg=stripsChartMsg=NULL;
LogMessage *log=new LogMessage(); log->CreateEntry("Log","Speed tests results",LogMessage::low_pr);
if(!(parent->dark.org.HasImage() && parent->cupol.org.HasImage() && parent->strips.org.HasImage())) return;
if(Xmin<0) Xmin=0;
if(Xmin>=parent->strips.org.w) Xmin=parent->strips.org.w;
if(Xmax<0) Xmax=0;
if(Xmax>=parent->strips.org.w) Xmax=parent->strips.org.w;
if(Xmax<Xmin) {int t=Xmax; Xmax=Xmin; Xmin=t;}
Timer2.Start();
T.Format("%d",midl); T1.Format("%davrg",midl);
for(int i=0;i<3;i++)
{
CHM2 =new TPointVsErrorSeries::DataImportMsg();
switch(i)
{
case 0: AdarkChartMsg=CHM2; break;
case 1: AcupolChartMsg=CHM2; break;
case 2: AstripsChartMsg=CHM2; break;
}
}
CMainFrame* mf=(CMainFrame*)AfxGetMainWnd(); TChart& chrt=mf->Chart1;
if((x=chrt.Series.GainAcsess(WRITE))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
if((t2=new TPointVsErrorSeries(T))!=0)
{
for(int i=0;i<Series.GetSize();i++) Series[i]->SetStatus(SER_INACTIVE);
Series.Add(t2);
t2->_SymbolStyle::Set(NO_SYMBOL);
ChartMsg=t2->CreateDataImportMsg();
t2->AssignColors(ColorsStyle(clRED,Series.GetRandomColor()));
t2->PointType.Set(GenericPnt);
t2->SetStatus(SER_ACTIVE); t2->SetVisible(true);
}
}
Timer1.Start();
parent->dark.org.LoadBitmapArray(Ymin,Ymax);
parent->cupol.org.LoadBitmapArray(Ymin,Ymax);
parent->strips.org.LoadBitmapArray(Ymin,Ymax);
Timer1.Stop(); time=Timer1.GetValue();
logT.Format("D C S %d lines load = %s",2*dd+1,ConvTimeToStr(time)); log->Msgs.Add(logT);
dark=parent->dark.org.arr; cupol=parent->cupol.org.arr; strips=parent->strips.org.arr;
SimplePoint pnt; pnt.type.Set(GenericPnt);
ValuesAccumulator pnteD,pnteC,pnteS; PointVsError pnte;
pnteD.type.Set(AveragePnt); pnteC.type.Set(AveragePnt); pnteS.type.Set(AveragePnt);
Timer1.Start();
for(int i = Xmin; i < Xmax; i++)
{
pnteD.Clear();pnteC.Clear();pnteS.Clear();
for(int j = 1; j <= dd; j++)
{
pnteD << dark[i+(mm+j)*w] << dark[i+(mm-j)*w];
pnteC << cupol[i+(mm+j)*w] << cupol[i+(mm-j)*w];
pnteS << strips[i+(mm+j)*w] << strips[i+(mm-j)*w];
}
pnt.x=i;
pnt.y=dark[i+mm*w]; pnteD << pnt.y;
pnt.y=cupol[i+mm*w]; pnteC << pnt.y;
pnt.y=strips[i+mm*w]; pnteS << pnt.y;
pnte=pnteD; pnte.x=i; AdarkChartMsg->Points.Add(pnte);
pnte=pnteC; pnte.x=i; AcupolChartMsg->Points.Add(pnte);
pnte=pnteS; pnte.x=i; AstripsChartMsg->Points.Add(pnte);
}
Timer1.Stop(); time=Timer1.GetValue();
logT.Format("D C S %d lines averaging time=%s",2*dd+1,ConvTimeToStr(time)); log->Msgs.Add(logT);
Timer1.Start();
for(int i=0;i<AdarkChartMsg->Points.GetSize();i++)
{
pnte=(AstripsChartMsg->Points[i]-AdarkChartMsg->Points[i])/(AcupolChartMsg->Points[i]-AdarkChartMsg->Points[i]);
pnte.type.Set(GenericPnt);
ChartMsg->Points.Add(pnte);
}
Timer1.Stop(); time=Timer1.GetValue();
logT.Format("Normalizing %d point time=%s",AdarkChartMsg->Points.GetSize(),ConvTimeToStr(time)); log->Msgs.Add(logT);
parent->dark.org.UnloadBitmapArray(); parent->cupol.org.UnloadBitmapArray(); parent->strips.org.UnloadBitmapArray();
delete AdarkChartMsg; delete AcupolChartMsg; delete AstripsChartMsg;
ChartMsg->Dispatch();
Timer2.Stop(); time=Timer2.GetValue();
logT.Format("Total processing time=%s",ConvTimeToStr(time)); log->Msgs.Add(logT);
CKSVU3App* Parent=(CKSVU3App*)AfxGetApp();
Parent->myThread.PostParentMessage(UM_GENERIC_MESSAGE,log);
}
const Series Series::operator-(const double &level) const {
return Series(*this) -= level;
}
template <class I, class T> array<T,I>& Series(const T& start, const I& n, T (*a)(I)){
return Series(start, (T) 1, n, a );
}
template <class T> array<T,int>& Series(const T& start, const T& end){
return Series(start, end, (T) 1);
}
const Series Series::operator/(const double ÷r) const {
return Series(*this) /= divider;
}
void Drawer::add(const mglData& x, const mglData& y, const mglData& z, const std::string& style, const std::string& legend)
{
m_series.push_back(Series(x, y, z, style, legend));
}
//---------------------------------------------------------------------------
bool TData::ImportPointSeries(const std::wstring &FileName, char Separator)
{
const TColor Colors[] = {clRed, clGreen, clBlue, clYellow, clPurple, clAqua, clBlack, clGray, clSkyBlue , clMoneyGreen, clDkGray};
std::ifstream Stream(FileName.c_str());
if(!Stream)
{
MessageBox(LoadRes(RES_NOT_GRAPH_FILE, FileName), LoadString(RES_FILE_ERROR), MB_ICONSTOP);
return false;
}
std::string Line;
while(Stream && Line.empty())
std::getline(Stream, Line);
if(Separator == 0)
Separator = GetSeparator(Line);
std::vector<std::pair<std::wstring, std::vector<TPointSeriesPoint> > > Points;
unsigned Row = 0;
try
{
boost::escaped_list_separator<char> Sep("", std::string(1, Separator), "");
unsigned Index = 0;
do
{
++Row;
boost::tokenizer<boost::escaped_list_separator<char> > tok(Line, Sep);
boost::tokenizer<boost::escaped_list_separator<char> >::iterator beg = tok.begin();
std::wstring xStr = ToWString(*beg);
if(!xStr.empty() && xStr[0] == L'#')
{
Index = Points.size();
Points.push_back(std::make_pair(xStr.substr(1), std::vector<TPointSeriesPoint>()));
while(++beg != tok.end())
Points.push_back(std::make_pair(ToWString(*beg), std::vector<TPointSeriesPoint>()));
}
else
{
unsigned Col = Index;
while(++beg != tok.end())
{
if(Col == Points.size())
Points.push_back(std::make_pair(L"", std::vector<TPointSeriesPoint>()));
std::wstring yStr = ToWString(*beg);
if(Property.DecimalSeparator != '.')
{
std::replace(xStr.begin(), xStr.end(), Property.DecimalSeparator, L'.');
std::replace(yStr.begin(), yStr.end(), Property.DecimalSeparator, L'.');
}
Points[Col].second.push_back(TPointSeriesPoint(xStr, yStr));
Col++;
}
}
}
while(std::getline(Stream, Line));
}
catch(Func32::EParseError &E)
{
MessageBox(LoadRes(526, FileName.c_str(), Row+1), LoadRes(RES_FILE_ERROR), MB_ICONSTOP);
return false;
}
catch(std::out_of_range &E)
{
MessageBox(LoadRes(526, FileName.c_str(), Row+1), LoadRes(RES_FILE_ERROR), MB_ICONSTOP);
return false;
}
catch(std::bad_alloc &E)
{
MessageBox(LoadRes(RES_OUT_OF_MEMORY), LoadRes(RES_FILE_ERROR), MB_ICONSTOP);
return false;
}
unsigned ColorIndex = 0;
unsigned Style = Property.DefaultPoint.Style;
unsigned LineStyle = Property.DefaultPointLine.Style;
UndoList.BeginMultiUndo();
for(unsigned I = 0; I < Points.size(); I++)
{
boost::shared_ptr<TPointSeries> Series(new TPointSeries(
clBlack, //FrameColor
Colors[ColorIndex], //FillColor
Colors[ColorIndex], //LineColor
Property.DefaultPoint.Size, //Size
Property.DefaultPointLine.Size, //LineSize
Style, //Style
static_cast<TPenStyle>(LineStyle), //LineStyle
iaLinear, //Onterpolation
false, //ShowLabels
Property.DefaultPointLabelFont, //Font
lpBelow, //LabelPosition
ptCartesian, //PointType
ebtNone, //xErrorBarType
0, //xErrorValues
ebtNone, //yErrorBarType
0 //yErrorValue
));
Series->Swap(Points[I].second);
Series->SetLegendText(Points[I].first.empty() ? CreatePointSeriesDescription() : Points[I].first);
Insert(Series);
UndoList.Push(TUndoAdd(Series));
Series->Update();
ColorIndex = ++ColorIndex % (sizeof(Colors)/sizeof(TColor));
Style = (Style+1) % 7;
LineStyle = (LineStyle+1) % 5;
}
UndoList.EndMultiUndo();
Modified = true;
return true;
}
void SeriesListCtrl::OnSaveAsText()
{
BYTE cr[3]; cr[0]=0xd;cr[1]=0xa;cr[2]=0;
int i,j, match, err=0, num;
POSITION pos=GetFirstSelectedItemPosition();
CArray<int,const int&> arr; CString temp; CString T,T1;
while(pos) arr.Add(GetItemData(GetNextSelectedItem(pos)));
for(i=0;i<arr.GetSize() && !err;i++)
{
match=0;
for(j=i+1;j<arr.GetSize();j++)
{
T=Items[arr[j]].Name; T1=Items[arr[i]].Name;
if(!(strcmp(Items[arr[j]].Name,Items[arr[i]].Name))) match++;
}
if(match>0) err=1;
}
if(!(arr.GetSize()) || err)
{
AfxMessageBox("¬Ќ»ћјЌ»≈!!! ќдин или более Series имеют одинаковые имена. ¬ыполнение операции невозможно!");
return;
}
else
{
CString temp; CFile f; err=0; num=0; void *x;
if((x=Series->GainAcsess(READ))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
for(i=0;i<arr.GetSize();i++)
{
TChartSeries *series=Series[arr[i]];
temp=GetSaveAsPath();
int t; if((t=temp.ReverseFind('\\'))>=0) temp=temp.Left(++t);
temp+=series->Name+".xls";
HANDLE SearchHandle;
WIN32_FIND_DATA FindFileData; TCHAR szError[1024];
if( (SearchHandle=FindFirstFile(LPCSTR(temp),&FindFileData) )==INVALID_HANDLE_VALUE)
{
CFileException ex;
if(f.Open(temp,CFile::modeCreate | CFile::modeWrite,&ex))
{
temp.Format("%s: points=%d",series->Name,series->GetSize());
for(int i=0;i<series->GetSize();i++)
{
series->FormatElement(i,temp);
char* fs;
while((fs=const_cast<char*>(strchr(temp,'.')))!=NULL)
(*fs)=',';
f.Write(LPCSTR(temp),temp.GetLength());
f.Write(cr,sizeof(cr));
}
f.Close(); num++;
}
else
{
ex.GetErrorMessage(szError, 1024);
}
}
else err++;
}
}
if(err)
{
temp.Format("¬Ќ»ћјЌ»≈!!! %d из %d файлов не были созданы. ‘айлы с такими именами уже существуют.",err, num+err);
AfxMessageBox(temp);
}
else
{
temp.Format("ќпераци¤ прошла успешно. —оздано %d файлов", num);
AfxMessageBox(temp);
}
}
}
void SeriesListCtrl::UpdateSeriesList()
{
int n=HitItem; LV_ITEM lvi; CString T; void *x; CBitmap * tmpbmp; BMPanvas icon;
if (Series == NULL) return;
if((x=Series->GainAcsess(READ))!=0)
{
SeriesProtector Protector(x); TSeriesArray& Series(Protector);
int n1=Series.GetSize(); if(n>=n1) n=n-1;
// if(LastN!=n1)
{
DeleteAllItems(); Items.RemoveAll();
ImageList1.Detach();
ImageList1.Create(16,16,ILC_COLOR,Series.GetSize(),1);
for(int i=0;i<Series.GetSize();i++)
{
icon.Create(CreateCompatibleDC(NULL),16,16,24);
HGDIOBJ brsh=icon.SelectObject(bckg);
icon.PatBlt(PATCOPY);
icon.SelectObject(brsh);
Series[i]->UpdateIcon(icon);
HBITMAP hbmp=icon.GetHBMP(BMP_DETACH);
tmpbmp=CBitmap::FromHandle(hbmp);
ImageList1.Add(tmpbmp,(CBitmap*)NULL);
lvi.mask = LVIF_PARAM; lvi.iItem = i;lvi.iSubItem = 0; lvi.lParam=i;
InsertItem(&lvi); Items.Add(ListItemData());
}
SetImageList(&ImageList1,LVSIL_SMALL);
}
for(int i=0;i<GetItemCount();i++)
{
int k=GetItemData(i); TChartSeries* series=Series[k];
lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
lvi.iItem = i; lvi.iSubItem = 0;
lvi.pszText = (char*)LPCTSTR(series->Name);
lvi.iImage = i;
lvi.stateMask = LVIS_STATEIMAGEMASK;
lvi.state = INDEXTOSTATEIMAGEMASK(series->IsVisible()+1);
SetItem(&lvi);
lvi.mask = LVIF_TEXT; lvi.iSubItem++;
T.Format("%d",series->GetSize()); SetItemText(i,lvi.iSubItem++,(char*)LPCTSTR(T));
series->GetStatus(T); SetItemText(i,lvi.iSubItem++,(char*)LPCTSTR(T));
T.Format("%d",series->GetPID()); SetItemText(i,lvi.iSubItem++,(char*)LPCTSTR(T));
lvi.mask=LVIF_STATE; lvi.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
lvi.state = 0; SetItemState(i,&lvi);
Items[k].Name=series->Name; Items[k].Size=series->GetSize(); Items[k].Status=series->GetStatus();
Items[k].PID=series->GetPID();
}
LastN=Series.GetSize();
if(n>=0)
{
_ms_lvi.mask=LVIF_STATE; _ms_lvi.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
_ms_lvi.state = LVIS_SELECTED | LVIS_FOCUSED;
LV_ITEM FAR * temp=&_ms_lvi;
this->PostMessage(LVM_SETITEMSTATE ,(WPARAM)(n), (LPARAM)(temp));
EnsureVisible(n, false);
}
//SortItems(CompareFunc1,(LPARAM) (this));
}
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <class T> array<T,int>& Series(const T& end){
return Series((T) 0, end, (T) 1);
}
ЧебышёвSeries<Vector> ЧебышёвSeries<Vector>::NewhallApproximation(
int const degree,
std::vector<Vector> const& q,
std::vector<Variation<Vector>> const& v,
Instant const& t_min,
Instant const& t_max) {
// Only supports 8 divisions for now.
int const divisions = 8;
CHECK_EQ(divisions + 1, q.size());
CHECK_EQ(divisions + 1, v.size());
Time const duration_over_two = 0.5 * (t_max - t_min);
// Tricky. The order in Newhall's matrices is such that the entries for the
// largest time occur first.
FixedVector<Vector, 2 * divisions + 2> qv;
for (int i = 0, j = 2 * divisions;
i < divisions + 1 && j >= 0;
++i, j -= 2) {
qv[j] = q[i];
qv[j + 1] = v[i] * duration_over_two;
}
std::vector<Vector> coefficients;
coefficients.reserve(degree);
switch (degree) {
case 3:
coefficients = newhall_c_matrix_degree_3_divisions_8_w04 * qv;
break;
case 4:
coefficients = newhall_c_matrix_degree_4_divisions_8_w04 * qv;
break;
case 5:
coefficients = newhall_c_matrix_degree_5_divisions_8_w04 * qv;
break;
case 6:
coefficients = newhall_c_matrix_degree_6_divisions_8_w04 * qv;
break;
case 7:
coefficients = newhall_c_matrix_degree_7_divisions_8_w04 * qv;
break;
case 8:
coefficients = newhall_c_matrix_degree_8_divisions_8_w04 * qv;
break;
case 9:
coefficients = newhall_c_matrix_degree_9_divisions_8_w04 * qv;
break;
case 10:
coefficients = newhall_c_matrix_degree_10_divisions_8_w04 * qv;
break;
case 11:
coefficients = newhall_c_matrix_degree_11_divisions_8_w04 * qv;
break;
case 12:
coefficients = newhall_c_matrix_degree_12_divisions_8_w04 * qv;
break;
case 13:
coefficients = newhall_c_matrix_degree_13_divisions_8_w04 * qv;
break;
case 14:
coefficients = newhall_c_matrix_degree_14_divisions_8_w04 * qv;
break;
case 15:
coefficients = newhall_c_matrix_degree_15_divisions_8_w04 * qv;
break;
case 16:
coefficients = newhall_c_matrix_degree_16_divisions_8_w04 * qv;
break;
case 17:
coefficients = newhall_c_matrix_degree_17_divisions_8_w04 * qv;
break;
default:
LOG(FATAL) << "Unexpected degree " << degree;
break;
}
CHECK_EQ(degree + 1, coefficients.size());
return ЧебышёвSeries(coefficients, t_min, t_max);
}
const Series Series::operator*(const double &multiplier) const {
return Series(*this) *= multiplier;
}
