1645128000

This algebra video tutorial provides a basic introduction into graphing linear inequalities in two variables. It explains how to graph linear inequalities in an x-y coordinate system. it discusses when you should use a solid line vs a dashed line and which region of the graph you should shade.

1624447260

Because I am continuously endeavouring to improve my knowledge and skill of the Python programming language, I decided to take some free courses in an attempt to improve upon my knowledge base. I found one such course on linear algebra, which I found on YouTube. I decided to watch the video and undertake the course work because it focused on the Python programming language, something that I wanted to improve my skill in. Youtube video this course review was taken from:- (4) Python for linear algebra (for absolute beginners) — YouTube

The course is for absolute beginners, which is good because I have never studied linear algebra and had no idea what the terms I would be working with were.

Linear algebra is the branch of mathematics concerning linear equations, such as linear maps and their representations in vector spaces and through matrices. Linear algebra is central to almost all areas of mathematics.

Whilst studying linear algebra, I have learned a few topics that I had not previously known. For example:-

A scalar is simply a number, being an integer or a float. Scalers are convenient in applications that don’t need to be concerned with all the ways that data can be represented in a computer.

A vector is a one dimensional array of numbers. The difference between a vector is that it is mutable, being known as dynamic arrays.

A matrix is similar to a two dimensional rectangular array of data stored in rows and columns. The data stored in the matrix can be strings, numbers, etcetera.

In addition to the basic components of linear algebra, being a scalar, vector and matrix, there are several ways the vectors and matrix can be manipulated to make it suitable for machine learning.

I used Google Colab to code the programming examples and the assignments that were given in the 1 hour 51 minute video. It took a while to get into writing the code of the various subjects that were studied because, as the video stated, it is a course for absolute beginners.

The two main libraries that were used for this course were numpy and matplotlib. Numpy is the library that is used to carry out algebraic operations and matplotlib is used to graphically plot the points that are created in the program.

#numpy #matplotlib #python #linear-algebra #course review: python for linear algebra #linear algebra

1645128000

This algebra video tutorial provides a basic introduction into graphing linear inequalities in two variables. It explains how to graph linear inequalities in an x-y coordinate system. it discusses when you should use a solid line vs a dashed line and which region of the graph you should shade.

1656899776

Simple scrolling events for d3 graphs. Based on stack

*graph-scroll* takes a selection of explanatory text sections and dispatches `active`

events as different sections are scrolled into to view. These `active`

events can be used to update a chart's state.

```
d3.graphScroll()
.sections(d3.selectAll('#sections > div'))
.on('active', function(i){ console.log(i + 'th section active') })
```

The top most element scrolled fully into view is classed `graph-scroll-active`

. This makes it easy to highlight the active section with css:

```
#sections > div{
opacity: .3
}
#sections div.graph-scroll-active{
opacity: 1;
}
```

To support headers and intro images/text, we use a container element containing the explanatory text and graph.

```
<h1>Page Title</div>
<div id='container'>
<div id='graph'></div>
<div id='sections'>
<div>Section 0</div>
<div>Section 1</div>
<div>Section 2</div>
</div>
</div>
<h1>Footer</h1>
```

If these elements are passed to graphScroll as selections with `container`

and `graph`

, every element in the graph selection will be classed `graph-scroll-graph`

if the top of the container is out of view.

```
d3.graphScroll()
.graph(d3.selectAll('#graph'))
.container(d3.select('#container'))
.sections(d3.selectAll('#sections > div'))
.on('active', function(i){ console.log(i + 'th section active') })
```

When the graph starts to scroll out of view, `position: sticky`

keeps the graph element stuck to the top of the page while the text scrolls by.

```
#container{
position: relative;
}
#sections{
width: 340px;
}
#graph{
margin-left: 40px;
width: 500px;
position: sticky;
top: 0px;
float: right;
}
```

On mobile centering the graph and sections while adding a some padding for the first slide is a good option:

```
@media (max-width: 925px) {
#graph{
width: 100%;
margin-left: 0px;
float: none;
}
#sections{
position: relative;
margin: 0px auto;
padding-top: 400px;
}
}
```

Adjust the amount of pixels before a new section is triggered is also helpful on mobile (Defaults to 200 pixels):

```
graphScroll.offset(300)
```

To update or replace a graphScroll instance, pass a string to `eventId`

to remove the old event listeners:

`graphScroll.eventId('uniqueId1')`

Author: 1wheel

Source Code: https://github.com/1wheel/graph-scroll

License: MIT license

1596559080

You already know about fast.ai, so I won’t bore you with yet another explanation. But while you may be familiar with fast.ai’s fantastic deep learning courses, perhaps you don’t know about their equally remarkable **Computational Linear Algebra** course.

The course, by Rachel Thomas, co-founder at fast.ai, is equal parts Jupyter notebook-based textbook — created by Rachel for the course — and a series of accompanying lecture videos — also created by Rachel. What exactly is covered within?

This course is focused on the question:

How do we do matrix computations with acceptable speed and acceptable accuracy?

What does it take to understand and utilize computational linear algebra in the wild, and why would you bother? From the course textbook’s Motivation section in Chapter 1:

It’s not just about knowing the contents of existing libraries, but knowing how they work too. That’s because often you can make variations to an algorithm that aren’t supported by your library, giving you the performance or accuracy that you need. In addition, this field is moving very quickly at the moment, particularly in areas related to

deep learning, recommendation systems, approximate algorithms, andgraph analytics, so you’ll often find there’s recent results that could make big differences in your project, but aren’t in your library.

#overviews #course #fast.ai #linear algebra #ai

1645138800

This algebra youtube video tutorial explains how to graph systems of linear inequalities in two variables. It contains plenty of examples and practice problems that will help you to master the topic.