Linear Code Puns

Hi all,

I have a few DTC codes that I get from my cheap OBDII scan tool that I'm hoping some of you can shed some light on, as when doing some quick research pulls up mixed results from forums, although some are helpful and informative. The codes are: P2228, P0171, P0691, P1682, P2142 and B3057. I know the basics of what some of these codes represent but what is my course of action in eliminating them?

One of the biggest fields of application of Python these days is machine learning, and one of the first things anyone learns about machine learning is how to do linear regression. Linear regression is attractive because it is very simple to understand (at least compared to other learning models). We also know how to implement it efficiently, and more importantly, we can make sense of the results.

I made a 2 minutes video exactly about this topic.

https://youtu.be/CtsRRUddV2s

By design, a 2 minutes is never exhaustive, but hopefully this will serve as a good intro to the topic and will give you the motivation to dive deeper if it sounds like something you are interested in. I know that when I started out I wished there were resources like that available, so I would love to hear what you think about this format.

My textbook provides two classes, one for linear probing and one for separate chaining. I've successfully made a spell checker using one. My next step for extra credit is to implement the other and compare/describe performance differences. How exactly do I go about doing this? I have no idea how to prove anything.

I've been learning coding as a hobby and I'm really enjoying it. I like solving problems and automating stuff, it's a really fun past time that I think is both productive and enjoyable.

I am running into a plateau with my math skills though. Every time I try to dabble in Machine Learning I run into math problems. I don't know much about Linear Algebra or anything like that, but I'm willing to learn.

I've found a lot of classes like this: https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/ which are great, but the coursework is all done without coding. I'd like something where I can practice both my coding and learn the math at the same time.

Any suggestions?

Missing data could be there at the source itself or may get introduced while we resample it to a higher frequency. Interpolation solves the problem in both contexts. It provides the best possible estimation that fits into the polynomial graph. The graph is drawn by using all other available values.

This means to say, the available values are used to the best possible extent in this methodology. I've tried to explain this complex technique in simple terms using a retail use case and code examples.

https://additionalsheet.com/understanding-python-pandas-dataframe-resampler-interpolate-with-example-retail

The camera's maximum limit in terms of Dynamic Range is 2000% Scene Reflectance. What would the code value of 18% scene reflectance gray be in a 16bit Linear Raw File? Thanks

If you work a lot with GLMs, and you need a good review + explanation, I really like these two resources. They have a focus on application, but the second one will also walk you through some of the math of how these models work:

1. The UCLA IDRE data analysis examples page. When I was learning R + GLMs, this page was a lifesaver. I'd copy code from here to teach myself the workflow for various models: https://stats.idre.ucla.edu/other/dae/

2. Generalized Linear Models at Princeton's Woodrow Wilson School. A nice discussion of the math of various GLM examples (including survival and discrete choice models), and code in R and STATA to use them: https://data.princeton.edu/wws509/notes

https://imgur.com/a/2W6JD1Q\

edit:

sorry already knew the answer to the main question, but not below one:

line 401250

Is edx*4 weird? I mean edx stored a address, right?

Hi,

I am learning multiple linear regression. Can anybody provide me some simple use cases with Python code?

Thanks,

Eswar

I have an excel file with multiple data observations, I want a tool where I can filter the data by solvent and by solute and then plot 2 particular columns against each other. I would also like linear regression line and a Y value predictor. Can anybody help? Here is where I have got to so far and it nicely plots the filtered data:

#Reading the file

df = pd.read_excel(r'C:\Users\pickl\Desktop\Local.xlsx', sheet_name='Solubility')

solv_and_sol= df[(df["Solute"]=="Lamivudine") & (df["Solvent"]=="Methanol")]

Y = solv_and_sol['lnx']

X = solv_and_sol['1overT']

#Plot

plt.scatter(X, Y, color='black')

plt.title('Vant Hoff')

plt.xlabel('1 over T')

plt.ylabel('ln x')

plt.show()

For a pendulum on a cart, already linearised about its upper fixed point, we have:m = 1;M = 5;L = 2;g = 10;d = 1;A = [0 1 0 0;0 -d/M m*g/M 0;0 0 0 1;0 -d/(M*L) (m+M)*g/(M*L) 0];B = [0; 1/M; 0; 1/(M*L)];

The purpose is to measure all states and feed them back in order to stabilise the system at the reference point r=[0;0;pi;0].

One possible way was to use ode45:x0 = [0; 0; pi+0.1; 0.5];tspan = 0:0.001:10;r = [0; 0; pi; 0];p = [-1.5;-1.6;-1.7;-1.8];K = place(A,B,p);[t,y] = ode45(@(t,y)model(y,m,M,L,g,d,-K*(y-r)),tspan,x0);x = y(:,1);x_dot = y(:,2);theta = y(:,3);theta_dot = y(:,4);

where the model function is the linearised system about the upper point:function dydt = model(y,m,M,L,g,d,u)dydt(1,1) = y(2);dydt(2,1) = (-d/M)*y(2) + (m*g/M)*(y(3)-pi) + (1/M)*u;dydt(3,1) = y(4);dydt(4,1) = (-d/(M*L))*y(2) + ((m+M)*g/(M*L))*(y(3)-pi) + (1/(M*L))*u;end

The results in this case are the following:

https://preview.redd.it/1hbnf7cf19d61.png?width=1120&format=png&auto=webp&s=96b637d43cc92681cace9e70758b77cab028b891

In an effort to only use the linear systems analysis without ode45 (u/Patbott)

C = eye(size(A));
D = [0;0;0;0];
x0 = [0; 0; pi+0.1; 0.5];
tspan = 0:0.001:10;

r = [0; 0; pi; 0];
r_t = [r;1]*ones(size(tspan));

p = [-1.5;-1.6;-1.7;-1.8];
K = place(A,B,p);

Sys = ss(A-B*K*C,[B*K -A*x0],C,0);
[y,tspan,x] = lsim(Sys,r_t,tspan,x0);

https://preview.redd.it/w7uu5mrgzhd61.png?width=1120&format=png&auto=webp&s=c7753558ac1e9206922e8dd641a622baa6abe919

I wrote this code:

def lfsr(p,s,n):
    def gen(p,s):
        n=0
        for i in range(len(p)):
            n=n+p[i]*s[len(s)-i-1]
        np.append(s,n%2)
        return s
    while len(s)<=n-1:
        gen(p,s)
    return s

Here, p is the list of coefficients of the primitive polynomial in GF(2) i.e. a list of 0's and 1's. 's', is the list of the initial state of LFSR which is also in 0s and 1s. 'n' is the length of the bitstream that we want. So, if the list of initial states has 7 elements, we can pass say 64, to get a random bitstream of 64 length. But this takes a really long time for larger n's. Is there a way to make this faster? Also, other suggestions related to the code would be very helpful too.

EDIT: I am dumb and forgot to give the filter the correct state vector.

Other than that I just needed to flip the sign of the coefficients (which is now in the code I put here), now it works perfectly

I've implemented Burg's method for getting reflection coefficients, and an IIR lattice filter that is supposed to use them to filter a signal, however it doesn't seem to work the same as my reference, which uses a regular IIR filter and a different implementation of Burg's method.

My expected result (according to the reference) is that filtering a saw wave with the acquired filter makes it sound quite close to the signal the filter was extracted from, but this isn't the case for the IIR lattice filter version

If someone can look at the code and see if I did anything wrong, that would be nice

Thanks in advance.

Code for the filter (Rust):

// k are the reflection coefficients
// g is the state vector
// both are of length N
let y = k.iter().rev() // rev here loops over it back to front
		.zip(g.iter_mut())
                // edit: accumulate gets called for each iteration, and the result is used for as acc for the next iteration
                // x is the input signal (100hz saw wave in my case, and is used as the initial state for acc
		.fold(x, |acc, (coeff, delay)| {

			// first add the delayed value into the accumulator
			let new_acc = acc - *delay * *coeff;

			// then add the accumulated value into the delay
			*delay = *delay + new_acc * *coeff; 

			// and put the accumulated value into the next step
			new_acc
		});

// then we add the result into the delay register
g[0] = y;
g.rotate_left(1);

y // returns y

(My source for this implementation: https://zone.ni.com/reference/en-XX/help/371325F-01/lvdfdtconcepts/lattice_ar_specs/)

And here's my implementation for Burg's method

// reflection coeffs
	let mut refl_coeffs = [S::zero(); N];

	// these are copies of the signal at the start, so initialize them as that
	forward.copy_from_slice(signal);
	backward.copy_from_slice(signal);

	// now we apply burg's method for getting the reflection coefficients
	// the reflection coefficients can be calculated as -2 * numerator / denominator
	// the denominator here is sum of the squares of the forward error + sum of the squares of

The repair function is the one updating the weights. I did the math on paper and i think it is alright. But can't get no where to a good fit. It's a single feature model. Using sq feet of the house for the prices. Feature scaling is done in the data function itself. Ignore the thread. I kept it there to just print the weight values. A great thank you to whoever responds. Just need a small nudge to where I am getting wrong.

import math

import time

import pandas as pd

import threading

import matplotlib.pyplot as plt

import numpy

theta0 = 0

theta1 = 0

l = 0.3

df = pd.read_csv("house.csv")

def data():

global x

global y

global xx

x = df['SqFt']

y = df['Price']

xx = []

for i in range(x.size):

print(x[i])

xx.append(x[i]/numpy.amax(x))

print(xx)

def repair():

global theta0

global theta1

global l

i = 0

sum = 0

for i in range(x.size):

sum = sum + ((theta0 + (theta1*xx[i])) - y[i])

sum1 = sum/xx.size;

sum = 0

i = 0

for i in range(x.size):

sum = sum + (((theta0+(theta1*xx[i]))-y[i]) * xx[i])

sum = sum/xx.size;

if abs(l*sum) > 1:

theta0 = int(theta0 - (l*sum1))

theta1 = int(theta1 - (l*sum))

return 1

return 2

def the():

while True:

print(theta0)

print(theta1)

def run():

i = 0

try:

threading.Thread(target=the).start()

except:

print("error stating thread")

while True:

r = repair()

if r==2:

break;

print(theta0+(theta1*1000))

data()

run()

Edit : An sincere apology and a huge thanks to u/supreme_blorgon. Guys make your code readable or you won't understand it yourself. I learnt my lesson.