As for me, I can advise here to watch "Criminal Minds". At least I like it very much and I always wait for new series.

What can you say about it?

Skip to content
# Tag: series

## What TV series do you watch right now?

## calculus and analysis – Why can’t mathematica expand my expression in a taylor series?

## data – Artificial Neural Networks For Long Term Time Series Predictions

## Poll: Have you enjoyed our Q/A Interview Series?

## calculus and analysis – Series of inverse functions, unclear numerical constant

## object oriented – Library Management System OOP with c++( Part2 of a series )

## proof writing – Is pattern matching an appropriate way to show that two infinite series are equal?

## ❕NEWS – Nintendo has suffered from a series of leaks | Proxies-free

## Help design a db for multiple experiments of time series features

## real analysis – Series of functions vanishing at a sequence in the region of convergence

Proxies-free.com: 100% Free Daily Proxy Lists Every Day!

Get Free Proxies Every Day

Share interesting TV series. What are you watching right now? What TV series are you waiting for?

As for me, I can advise here to watch "Criminal Minds". At least I like it very much and I always wait for new series.

What can you say about it?

As for me, I can advise here to watch "Criminal Minds". At least I like it very much and I always wait for new series.

What can you say about it?

I want to expand k3 in taylor series around x = 0 until second order

```
k3 = 8/7 (1 - 2 x)^2 x^7 (2 x (a - 1) - a +
2)/(2 x (4 (a + 1) x^4 + (6 a - 4) x^3 + (26 - 22 a) x^2 +
3 (5 a - 8) x - 3 a + 6) -
3 (1 - 2 x)^2 (2 x (a - 1) - a + 2) log (1/(1 - 2 x)))
Series(k3, {x,0,2})
```

but wolfram just give me my input back, can somebody explain me what’s wrong?

I have developed a ANNs model to make time series predictions, I was successful in developing an algo for ‘one-step ahead’ predictions (e.g., using data of today datapoint to make tomorrow’s prediction datapoint).

Now, I would like to make a more long term prediction (e.g., next week datapoints predictions, or next month datapoints predictions).

Would anyone advise a good source/paper/tutorial for this?

Thank you!

Starting earlier this year in April we began interviewing industry leaders in the hosting and software verticals as part of our LowEndBox Q/A Interview Series.

Now that we have published approximately a dozen interviews over the past few months we thought it would be a good opportunity to check in with our readers for some feedback.

If you’ve read the interviews, and we hope you have, are you enjoying them? If not, what are we missing? Please vote and then leave your comments below, we will be reading every comment and every vote in our continuous effort to improve.

I was answering another question here and came up with this simple illustrative example that should have an analytic solution. Indeed it has, but I do not understand it. In particular, where 85 is coming from?

```
g[x_]:=BesselJ[0,x]
f[x_]:=Exp[x]
Series[f[InverseFunction[g][y]],{y,0,0}]
Out[1]= E^-BesselJZero[0,85]+O[y]^1
```

I don’t know if this is acceptable, but I would love to thank the community for their advice concerning my previous post on this project

**This is a beginner’s project**.

Library management system aims to handle the basic housekeeping of a functional library, so far I have implemented the BookItem class and with advice from the community, also implemented a Date class( not with full funtionalities )

Librarian class though not completed yet is also functional…

I used a list to store the books in the library. I saw some post where vectors are suggested as the goto data structure, I feel list best suit this case, If vectors would be better I would appreciate if you highlight the reasons.

Note am a beginner and have no knowledge about C++ advanced topics yet.

Here is the code

**Date.hh**

```
#ifndef DATE_HH
#define DATE_HH
/*****************************************************************
* Name: Date.hh
* Author: Samuel Oseh
* Purpose: Date class method-function prototype
* ***************************************************************/
#include <iostream>
class Date {
friend std::ostream &operator<<( std::ostream &, const Date & );
private:
/* data-member */
unsigned int month;
unsigned int day;
unsigned int year;
// utility function
unsigned int checkDay( int ) const;
public:
static const unsigned int monthsPerYear = 12;
// ctors
Date() : Date( 1, 1, 1970 ){}
Date( int m, int d, int y ) { setDate( m, d, y );}
Date( int m ) : Date( m, 1, 1970 ){}
Date( int m, int d ) : Date( m, d, 1970 ) {}
// copy operations
Date( const Date &d ) { *this = std::move(d); }
Date &operator=( const Date &d ) { month = d.month; day = d.day; year = d.year; return *this; }
/* method-functions */
void setDate( int m, int d, int y );
void setMonth( int m );
void setDay( int d );
void setYear( int y );
unsigned int getMonth() const;
unsigned int getDay() const;
unsigned int getYear() const;
void nextDay();
// dtor
~Date(){};
};
#endif
```

**Date.cc**

```
/*****************************************************************
* Name: Date.cc
* Author: Samuel Oseh
* Purpose: Date class method-function definitions
* ***************************************************************/
#include <iostream>
#include <stdexcept>
#include <array>
#include "Date.hh"
void Date::setDate( int m, int d, int y) {
setMonth( m );
setDay( d );
setYear( y );
}
void Date::setDay( int d ) {
day = checkDay( d );
}
void Date::setMonth( int m ) {
if ( m >= 1 && m < 13 )
month = m;
else
throw std::invalid_argument( "Month must be between 1-12" );
}
void Date::setYear( int y ) {
if ( y >= 1970 )
year = y;
else
throw std::invalid_argument( "year must be greater than 1969" );
}
void Date::nextDay() {
day += 1;
try {
checkDay( day );
} catch ( std::invalid_argument &e ) {
month += 1;
day = 1;
}
if ( month % 12 == 0 ) {
year += 1;
month = 1;
}
}
std::ostream &operator<<( std::ostream &os, const Date &d ) {
os << d.month << "/" << d.day << "/" << d.year << " ";
return os;
}
// utility function
unsigned int Date::checkDay( int testDay ) const {
static const std::array < int, monthsPerYear + 1 > daysPerMonth = { 0,31,28,31,30,31,30,31,31,30,32,30,31};
if ( testDay > 0 && testDay <= daysPerMonth( month ) )
return testDay;
if ( month == 2 && testDay == 29 && ( year % 400 == 0 || ( year % 4 == 0 && year % 100 != 0 ) ) )
return testDay;
throw std::invalid_argument( "Invalid day for current month and year" );
}
```

**BookItem.hh**

```
#ifndef BOOKITEM_HH
#define BOOKITEM_HH
/*****************************************************************
* Name: BookItem.hh
* Author: Samuel Oseh
* Purpose: BookItem class method-function prototype
* ***************************************************************/
#include <string>
#include "Date.hh"
enum class BookStatus : unsigned { RESERVED, AVAILABLE, UNAVAILABLE, REFERENCE, LOANED, NONE };
enum class BookType : unsigned { HARDCOVER, MAGAZINE, NEWSLETTER, AUDIO, JOURNAL, SOFTCOPY };
class BookItem {
private:
/* data-members */
std::string title;
std::string author;
std::string category;
Date pubDate;
std::string isbn;
BookStatus status;
BookType type;
public:
// ctor
BookItem() = default;
BookItem( const std::string &title, const std::string &author, const std::string &cat, const Date &pubDate,
const std::string &isbn, const BookStatus status, const BookType type );
// copy operations
const BookItem& operator=( const BookItem &bookItem );
BookItem( const BookItem &bookItem ) { *this = std::move(bookItem); }
/* method-functions */
void setStatus( BookStatus s ) { status = s; };
void setType( BookType t ) { type = t;};
std::string getStatus() const;
std::string getType() const;
std::string getTitle() const { return title; }
std::string getAuthor() const { return author; }
Date &getPubDate() { return pubDate; }
void printPubDate() const { std::cout << pubDate; }
std::string getIsbn() const { return isbn; }
void setCategory( const std::string &c ) { category = c; }
std::string getCategory() const { return category; };
// dtor
~BookItem(){}
};
#endif
```

**BookItem.cc**

```
/*****************************************************************
* Name: BookItem.cc
* Author: Samuel Oseh
* Purpose: BookItem class method-function definitions
* ***************************************************************/
#include <iostream>
#include "BookItem.hh"
BookItem::BookItem( const std::string &t, const std::string &a, const std::string &c, const Date &d,
const std::string &i, const BookStatus s, const BookType ty ) {
title = t, author = a, category = c, pubDate = d, isbn = i;
setStatus( s );
setType( ty );
}
const BookItem &BookItem::operator=( const BookItem &bookItem ) {
title = bookItem.title;
author = bookItem.author;
category = bookItem.category;
pubDate = bookItem.pubDate;
isbn = bookItem.isbn;
status = bookItem.status;
type = bookItem.type;
return *this;
}
std::string BookItem::getStatus() const {
if ( status == BookStatus::AVAILABLE )
return "AVAILABLE";
else if ( status == BookStatus::REFERENCE )
return "REFERENCE";
else if ( status == BookStatus::UNAVAILABLE )
return "UNAVAILABLE";
else if ( status == BookStatus::LOANED )
return "LOANED";
else if ( status == BookStatus::RESERVED )
return "RESERVED";
else
return "NONE";
}
std::string BookItem::getType() const {
if ( type == BookType::AUDIO )
return "AUDIO";
if ( type == BookType::HARDCOVER )
return "HARDCOVER";
if ( type == BookType::JOURNAL )
return "JOURNAL";
if ( type == BookType::MAGAZINE )
return "MAGAZINE";
if ( type == BookType::NEWSLETTER )
return "NEWSLETTER";
if ( type == BookType::SOFTCOPY )
return "SOFTCOPY";
else
return "NONE";
}
```

**Librarian.hh**

```
#ifndef LIBRARIAN_HH
#define LIBRARIAN_HH
/*****************************************************************
* Name: Librarian.hh
* Author: Samuel Oseh
* Purpose: Librarian class method-function prototype
* ***************************************************************/
#include <iostream>
#include <string>
#include "BookItem.hh"
#include <list>
class Librarian {
private:
/* data-member */
std::string name;
Date dateOfHire;
std::list<BookItem> *books = new std::list<BookItem>;
public:
// ctor
Librarian() = default;
Librarian( const std::string &name, const Date &dateOfHire );
/* basic method-functions */
void setName( const std::string &name );
void setDateOfHire( const Date &date );
std::string getName() const { return name; };
Date &getDateOfHire() { return dateOfHire; }
void printDateOfHire() const { std::cout << dateOfHire; }
/* core functionalities */
void addBook( const BookItem &book );
void auditLibrary() const;
// dtor
~Librarian(){}
};
#endif
```

**Librarian.cc**

```
/*****************************************************************
* Name: Librarian.cc
* Author: Samuel Oseh
* Purpose: Librarian class method-function definitions
* ***************************************************************/
#include <iostream>
#include "Librarian.hh"
Librarian::Librarian( const std::string &n, const Date &d ) {
name = n;
dateOfHire = d;
}
void Librarian::setName( const std::string &n ) {
name = n;
}
void Librarian::setDateOfHire( const Date &d) {
dateOfHire = d;
}
void Librarian::addBook( const BookItem &book ) {
if ( books->empty() ) {
books->push_front( book );
return;
}
for ( auto bk = books->begin(); bk != books->end(); ++bk ) {
if( book.getTitle() <= bk->getTitle() ) {
books->insert(bk, book);
return;
}
}
books->push_back( book );
}
void Librarian::auditLibrary() const {
std::cout << "Librarian: " << name << ", Date of hire: " << dateOfHire;
std::cout << "nnBooks:";
for ( auto bk = books->begin(); bk != books->end(); ++bk ) {
std::cout << "nName of book: " << bk->getTitle();
std::cout << "nAuthor of book: " << bk->getAuthor();
std::cout << "nBook category: " << bk->getCategory();
std::cout << "nPublication date: ";
bk->printPubDate();
std::cout << "nISBN number: " << bk->getIsbn();
std::cout << "nStatus of book: " << bk->getStatus();
std::cout << "nType of book: " << bk->getType();
std::cout << "nn";
}
}
```

I want to show that

$$e^{a}e^{b} = e^{(a+b)}$$ using their infinite series representation ${displaystyle exp x:=sum _{k=0}^{infty }{frac {x^{k}}{k!}}=1+x+{frac {x^{2}}{2}}+{frac {x^{3}}{6}}+{frac {x^{4}}{24}}+cdots }$

“Proof”:

LHS $= (1+ a + a^2/2! + ldots) (1+b + b^2/2! + ldots) = (1 + a + b + a^2/2! + b^2/2! + ab + ldots) $

RHS $= (1 + a+b + (a+b)^2/2! + ldots ) = (1+ a + b + a^2/2! + b^2/2! + ab + ldots)$

These terms seem to match up, so that LHS = RHS.

Can anyone offer a critique to the above method?

My use case is something like the following:

- There are
`n`

medical cases today. - Every day
`0`

to`10`

new cases arrive. - Each case is a time series of varying length, of measurements of raw data. Assume a bunch of ecg signals.
- Raw data comes from various
`1<k<5`

sources - Each source has its own sampling rate (between
`1`

and`100`

per second), and can have`na`

values. - Data sources are not necessarily exactly syncronized
- Each data source has ‘c_k’ columns
- A
`case`

is an`.h5`

file with ~`180000`

to ~`540000`

samples, in the highest sampling rate (100HZ). - Data is mostly sampled into matrices, and columns will be those matrices flattened into their respective indices.
- The code base has to be in Python.

For example, `n=5`

, `k=2`

, `c_1=1`

, `c_2=2`

, sampling rate of `1`

: “every row”, sampling rate of `2`

: “every 2 rows”. There is no “time” column. (should there be?)

```
Sample | 1_1 | 2_1 | 2_2
1 | 1.0 | 10.0| 100.0
2 | 2.0 | |
3 | 3.0 | 30.0| 300.0
4 | 4.0 | |
5 | 5.0 | 50.0| 500.0
```

I would like to have the ability to query in an SQL-like manner, over any intersection of cases, samples, data, with the most flexibility, for research purposes.

This is not for production. Both querying and adding data doesn’t happen often, and there are no scale-related constraints.

What would be a good design for this?

I assume some information may be missing, so please ask and I will add in whatever is needed.

Let $f(x)=sum_{n=0}^{infty} a_{n} x^{n},$ where the series converges for $|x|<r, r>0$ Assume that there exists a sequence $x_{n} rightarrow 0,left|x_{n}right|<r,$ such that $fleft(x_{n}right)=0$ for all $n$. Prove that $f(x)=0$ for all $x in(-r, r)$

Here, can we use the uniform convergence of $sum_{n=0}^{infty} a_{n} x^{n}$ on $|x|<r$?

DreamProxies - Cheapest USA Elite Private Proxies
100 Private Proxies
200 Private Proxies
400 Private Proxies
1000 Private Proxies
2000 Private Proxies
ExtraProxies.com - Buy Cheap Private Proxies
Buy 50 Private Proxies
Buy 100 Private Proxies
Buy 200 Private Proxies
Buy 500 Private Proxies
Buy 1000 Private Proxies
Buy 2000 Private Proxies
ProxiesLive
Proxies-free.com
New Proxy Lists Every Day
Proxies123