What is a standard library?
Ep's definition of a standard library, is as follows; any libraries that are always available, standardized, meaning they follow certain code standards, however implementation may wary from implementer to implementer, and always available with the newest release of ep.

What are the standard libraries?
  • bo
  • ios
  • vector
  • math


What do they provide?
bo
bo, is short for Basic operations, and bo is one of the fundamental extensions for ep, without bo the language is functionally useless. It provides all of the operators used in ep, to mention a few; operator +, operator -, operator *, and operator /. It provides a lot more operators that can be overloaded inside of types, and actually by default, any of the bo operator methods will invoke the left hand side's method for said operator.
Example:
Code:
a + b;
Stack Frame (Where a is integral, and b is integral):
Code:
integral::operator+
bo::operator+
The above code isn't neccessarily important for you to understand.

ios
ios, is short for Input/Output Stream, and ios is the input output stream manipulation extension. It provides functionality to use an abstraction called streams specially designed to perform input and output operations on files and consoles.
Types:
  • ostream
  • istream
  • fstream
  • endl


ostream:
Code:
ostream::operator<<
ostream::put
ostream::putln
istream:
Code:
ostream::operator>>
ostream::getln
fsream:
Code:
fstream::close
fstream::eof
fstream::getln
fstream::putln
fstream::put
fstream::operator<<
endl:
Code:
Has no methods, use only for ostream/fstream operator<< to mark the end of a line.
Global variables and their values:
Code:
istream cin = console input stream (std::cin)
ostream cout = console output stream (std::cout)
integral ios_binary = (std::ios::binary)
integral ios_in = (std::ios::in)
integral ios_out = (std::ios::out)
integral ios_app = (std::ios::app)
integral ios_trunc = (std::ios::trunc)
std::endl endl = (std::endl)
vector
Vector is the only container extension available in the standard library. It provides an abstract proxy type working with a dynamic std::vector of variables, meaning each and every single element in said vector can have it's own type; and as such it is a vector with dynamic elements.

Types:
Code:
---->> vector
-------->> vector::emplace_back( elem )
-------->> vector::erase( it )
-------->> vector::begin
-------->> vector::end
-------->> vector::for_each( &first, &last, &method )
-------->> vector::pop_back
-------->> vector::clear
-------->> vector::empty
-------->> vector::size
-------->> vector::capacity

---->> vector::iterator
-------->> vector::iterator::operator<
-------->> vector::iterator::operator>
-------->> vector::iterator::increment
-------->> vector::iterator::decrement
-------->> vector::iterator::access
Examples:
Code:
auto vector = vector(); // Creating the vector
vector->emplace_back( fstream( "file.txt", ios_out ) ); // emplace a file handle to the back of it.
vector->pop_back(); // Pop back, the previous item is deleted and hence fstream's destructor is called, closing the file handle.
vector->size(); // returns 0
vector->capacity(); // implementation defined, it depends on the implementator of std::vector
vector->empty(); // returns 1 (true)
vector->clear(); // does nothing, but if it had any number of items they would all be cleared and deleted.

auto i = 0;
while( i < 10 )
{
     vector->emplace_back( i );
     i = i + 1;
}
// vector now contains [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], it's size is 10, and the capacity is >= 10

auto begin = vector->begin( );
auto end = vector->end( );
while( begin < end )
{
     cout << begin->access( ) << " ";
     begin->increment( );
};
// prints "0 1 2 3 4 5 6 7 8 9 "

vector->clear( ); // size of vector is now 0, and the capacity is possibly 0.
math
Math is the floating point math extension. It provides methods that can perform basic mathmetical operations such as cos, sin, and other methods.

All math methods:
Code:
---->> MATH_PI( )
---->> sin( x )
---->> cos( x )
---->> pow( x, am )
---->> tan( x )
---->> acos( x )
---->> asin( x )
---->> abs( x )
---->> hypot( x, y )
---->> sqrt( x )
---->> pow10( x )
---->> ceil( x )
---->> floor( x )
---->> fabs( x )
---->> atan( x )
---->> cosh( x )
---->> sinh( x )
---->> tanh( x )
---->> exp( x )
---->> log( x )
---->> log10( x )
---->> fmod( a, b )
Please read the <math.h> library documentation to find out what they do.

Thanks,
Yamiez