Writing Assignment 1 SOC Humanities Assignment Help

Hello so for my job I’ll be doing a lot of cold calling I want to create a system for me that we’ll help be successful

Should included

Company

First and Last Name

Title

Phone number

Email

Notes

I am going to divided the accounts by sections

Potentials..

Follow ups

And can’t touch list but may be good for future

for sure sales:

I don’t want to title them this way but want to see what way you can section it off for me and make it organized

Must be more than just typing I need a system to do cold calling what do you recommend m

Initial Setup

Both you and your partner will need to get the starter code for your group using Git.

Method 1 – get your GitHub account set up and load a key first

1. In VS Code, open the command palette and select the “Git Clone” option.
2. When prompted for the repository URL, enter the following:git@github.com:comp110-sp19/psa2.git
3. Choose the “Open Repository” option in the window that pops up in the lower-right corner of the screen.

Method 2

1. Follow this link to go to the assignment repo:https://github.com/comp110-sp19/psa2
2. Choose the “Clone or download” green button in the right portion of the window. Download the ZIp file and extract it wherever you want using the unzipper of your choice. You could also clone from here instead of from vscode, but again, you would need to have a valid GitHub account for that to work.

The repository should contain a file named comp110_psa2.py, which is where you will put all of the code you write for this assignment.

Next, you will need to install a few extra modules using Python’s “pip” installer.

1. In VS Code, open up a Terminal window if you don’t already have one open. Recall that you can go to “View” and then “Terminal” to open the terminal.
2. Make sure that your VS Code terminal is NOT running a Python REPL. If it is, exit the REPL using the “exit()” function.
3. In the terminal, enter the following commands. Note that if you are using Windows, replace “python3” with “python”.

   python3 -m pip install -U numpy
    python3 -m pip install -U scipy
    python3 -m pip install -U sounddevice

4. Test that it worked by starting a Python REPL (using the python or python3 command, depending on whether you are using Windows or macOS). In the REPL, test out the following imports to make sure you don’t get any errors.

    import numpy
    import scipy
    import sounddevice

   If you run into any problems, check Piazza to see if you can find the solution there. Otherwise, post a new question or see me in office hours.

Note that for this assignment, it is strongly recommended that you do the coding only on one of your computers. You may “Sync” on the other computers, but to avoid headaches with conflicting changes, which we haven’t learned to deal with in Git, you should only make changes to the code using one computer.

Also, remember when VS Code closes your repository when you exit and restart it. Use the “Open Recent” option (in the “File” menu) to reopen it if you can’t find it.

We also recommend that you stage changes, commit those changes, and sync the changes every time you finish one of the functions you write. This ensures that you won’t lose any of your work in case your computer gets lost or a file gets accidentally deleted.

Background

Sounds are waves of air pressure. When a sound is generated, a sound wave consisting of compressions (increases in pressure) and rarefactions (decreases in pressure) moves through the air. This is similar to what happens if you throw a stone into a pond: the water rises and falls in a repeating wave.

When a microphone records sound, it takes a measure of the air pressure and returns it as a value. These values are called samples and can be positive or negative corresponding to increases or decreases in air pressure. Each time the air pressure is recorded, we are sampling the sound. Each sample records the sound at an instant in time; the faster we sample, the more accurate is our representation of the sound. The sampling rate refers to how many times per second we sample the sound. Sampling rates of 11025 (bad quality; e.g. for VOIP conversations), 22050, and 44100 (CD quality) are common; the higher the sample rate, the better the sound quality.

For sounds recorded in mono, a sample is simply a positive or negative integer that represents the amount of compression in the air at the point the sample was taken. For sounds recorded in stereo (which we use in this assignment), a sample is made up of two integer values: one for the left speaker and one for the right.

The sound module (given as part of the starter code) contains functions for working with sound files.

Some of the sound files in this assignment are modified versions of sounds from acoustica.com.

Using the sound Module

During the lab, you should have already encountered all the functions and methods you need from the sound module.

The following table is a list of all functions in the sound module:

---

Function Explanation sound.load_sound(filename) Returns a new sound object from file filename sound.create_sound(length) Returns a silent sound of length samples sound.copy(snd) Returns a copy of sound snd sound.play(snd) Plays sound snd sound.stop(snd) Stops playing sound snd len(snd) Returns the number of samples in sound snd

---

The following table lists the methods in the Sound class.

Method	Explanation
Sound(filename)	Returns a new sound object from the filename.
copy()	Returns a copy of the sound object
play()	Plays the sound object
stop()	Stops playing the sound object
get_sample(index)	Returns the Sample found at index index.

---

Finally, the following table shows methods in the StereoSample class.

Method	Explanation
get_left()	Returns the left channel of the sample
get_right()	Returns the right channel of the Sample.
set_left(value)	Sets the left channel of the sample to value
set_right(value)	Sets the right channel of the sample to value
get_index()	Returns the index of the sample

---

You can also use the looping syntax for sample in snd to iterate over all samples in snd, as demonstrated below.

# print all of the samples in the sound object
 for sample in snd:
 print(sample)

For this assignment, you are not allowed to use the crop function. Other than crop, all the functions in the sound module are available for your use. However, it’s not necessary to go searching for other functions. You can write a perfect solution using only the functions in the table above!

If you want to save any of your sounds as wav files, you can do so using the sound.save_as function. However, make sure you don’t use this function in the code that you hand in.

You may be more familiar with MP3 files than wav files. The major difference between the two is that wav files don’t use any compression, whereas MP3 files use lossy compression. Lossy compression results in MP3 files that are poorer quality, but much smaller, than wav files.

Problems

Problem 1: Removing Vocals

Listen to the wav file with vocals (love.wav) in your repository folder. (Note: You can play WAV files in Windows Media Player (Windows 10) or iTunes (macOS) after you download them. You’ll also find it convenient to play sounds from within Python itself.)

The function you write for this problem, remove_vocals will be able to take a sound object created from that file, and produce a new sound object that is the same as the original sound but with vocals removed. The header for this function is given below.

def remove_vocals(snd):

The remove_vocals function takes a sound object snd as a parameter, and creates and returns a new sound with vocals removed using the algorithm described below. The new sound has the same number of samples as snd. (Remember: The original sound, snd, should NOT be modified.)

The algorithm works as follows. Any given sample in snd contains two integer values, one for the left channel and one for the right. Call these values left and right. For each sample in snd, compute (left – right) / 2, and use this value for both the left and right channels of the corresponding sample in the new sound you are creating.

Here’s an example. Let’s say that snd contains the following three samples, each composed of two values:

• (1010, 80)
• (1500, -4200)
• (-65, 28132)

Your program will produce a new sound consisting of the following three samples:

• (465, 465)
• (2850, 2850)
• (-14098, -14098)

If you do the math, you’ll notice that the values in the third sample should have both been the fractional number -14098.5; but sample values must be integers. Make sure you use the “floor division” operator in (i.e. “//”) to produce an integer rather than a floating point number. Keep this in mind for all of the functions you write in this assignment.

Example Usage

Below is a short bit of Python code that shows how you could use the function you just wrote. This code is written assuming you are using the Python REPL, which you started while in your repository directory.

import sound
 import comp110_psa2
 
 love = sound.Sound("love.wav")
 love.play()
 love_no_vocals = comp110_psa2.remove_vocals(love)
 love.stop()
 love_no_vocals.play()

Why This Algorithm Works

For the curious, a brief explanation of the vocal-removal algorithm is in order. As you noticed from the algorithm, we are simply subtracting one channel from the other and then dividing by 2 (to keep the volume from getting too loud). So why does subtracting the right channel from the left channel magically remove vocals?

When music is recorded, it is sometimes the case that vocals are recorded by a single microphone, and that single vocal track is used for the vocals in both channels. The other instruments in the song are recorded by multiple microphones, so that they sound different in both channels. Subtracting one channel from the other takes away everything that is “in common” between those two channels which, if we’re lucky, means removing the vocals.

Of course, things rarely work so well. Try your vocal remover on this badly-behaved wav file (cartoon.wav). Sure, the vocals are gone, but so is the body of the music! Apparently some of the instruments were also recorded “centred,” so that they are removed along with the vocals when channels are subtracted. When you’re tired of that one, try this harmonized song (harmony.wav). Can you hear the difference once you remove the vocals? Part of the harmony is gone!

Grading remove_vocals

The remove_vocals function is worth <#points 7 pts>, broken down as follows.

• Vocals correctly removed using specified algorithm. <#points 3 pts>
• Effect works on all samples in sound. <#points 1 pts>
• Original sound not modified. <#points 2 pts>
• Correct docstring comment at beginning of function and appropriate comments in the body of the function. <#points 1 pt>

Problem 2: Fading In and Out

For this problem, you will be writing three functions that will produce fade-in and fade-out effects. As with Problem 1, these functions should not modify the original sound object: they should create a copy of that original, modify the copy, then return that copy.

Fade-in

Start this problem by implementing the fade_in function, whose function header is given below.

def fade_in(snd, fade_length):

This function takes a sound object and an integer indicating the number of samples to which the fade-in will be applied. For example, if fade_length is 88200, the fade-in should not affect any sample numbered 88200 or higher. (Reminder: The first sample in a sound is numbered 0.)

Before we discuss how to accomplish fade-in, let’s get acquainted with some fading-in. Listen to this monotonous sound of water bubbling (waver.wav). The volume is stable throughout. Now, with the call fade_in(water, 88200) (where water is a sound object loaded with the water sound), we get water with a short fade-in. Notice how the water linearly fades in over the first two seconds, then remains at maximum volume throughout. (88200 corresponds to two seconds, because we’re using sounds recorded at 44100 samples per second.) Finally, with the call fade_in(water, len(water)), we get water with a long fade-in. The fade-in is slowly and linearly applied over the entire duration of the sound, so that the maximum volume is reached only at the very last sample.

To apply a fade-in to a sound, we multiply successive samples by larger and larger fractional numbers between 0 and 1. Multiplying samples by 0 silences them, and multiplying by 1 (obviously) keeps them the same. Importantly, multiplying by a factor between 0 and 1 scales their volume by that factor.

Here’s an example. Assume fade_length is 4, meaning that I apply my fade-in over the first four samples (samples numbered 0 to 3). Both channels of those samples should be multiplied by the following factors to generate the fade-in:

Sample Number	Multiply By...
0	0.0
1	0.25
2	0.5
3	0.75

3 | Do Not Modify the sample

---

Grading fade_in

The fade_in function is worth <#points 6 pts>, broken down as follows.

• Correct fading in effect. <#points 2 pts>
• Fading effect only for the specified number of samples. <#points 2 pts>
• Original sound not modified. <#points 1 pts>
• Correct docstring comment at beginning of function and appropriate comments in the function body. <#points 1 pt>

Fade-out

Now you will need to write a fade_out function, with header given below.

def fade_out(snd, fade_length):

This function again takes a sound object and an integer indicating the length of the fade. However, this time, the fade is a fade-out (from loud to quiet), and the fade-out begins fade_length samples from the end of the sound rather than from the beginning. For example, if fade_length is 88200 and the length of the sound is samp samples, the fade-out should only affect samples numbered samp-88200 up to samp-1.

Let’s use a raining sound to demonstrate (rain.wav). As with the water bubbling above, the volume is stable throughout. Now, with the call fade_out(rain, 88200) (where rain is a sound object loaded with the rain sound), we get rain with a short fade-out. The first few seconds of the rain are as before. Then two seconds before the end the fade-out starts, with the sound progressing toward zero volume. The final sample of the sound has value 0.

The multiplicative factors for fade_out are the same as for fade_in, but are applied in the reverse order. For example, if fade_length were 4, the channels of the fourth-last sample would be multiplied by 0.75, the channels of the third-last sample would be multiplied by 0.5, the channels of the second-last sample would be multiplied by 0.25, and the channels of the final sample in the sound would be multiplied by 0.0.

Grading fade_out

The fade_out function is worth <#points 6 pts>, broken down as follows.

• Correct fading out effect. <#points 2 pts>
• Fading effect only for the specified number of samples. <#points 2 pts>
• Original sound not modified. <#points 1 pts>
• Correct docstring comment at beginning of function and appropriate comments in the function body. <#points 1 pt>

Fade

For the last part of this problem, you will write a function named fade.

def fade(snd, fade_length):

This one combines both fading-in and fading-out. It applies a fade-in of fade_length samples to the beginning of the sound, and applies a fade-out of fade_length samples to the end of the sound. Don’t be concerned about what to do when the fades would overlap; don’t do anything special to try to recognize or fix this.

To avoid duplication of code, your implementation of fade must make calls to your fade_in and fade_out function.

Try out your fade on one more wav file (grace.wav). This one has a particularly abrupt beginning and end, which your fade function should be able to nicely finesse. This is a large file and can take a minute or two to process on a slow computer; test with smaller files first.

Grading fade

The fade function is worth <#points 4 pts>, broken down as follows.

• Correct fading out effect. <#points 1 pt>
• Fading effect only for the specified number of samples. <#points 1 pt>
• Uses fade_in and fade_out functions to implement this function. <#points 1 pt>
• Correct docstring comment at beginning of function and appropriate comments in the function body. <#points 1 pt>

Problem 3: Panning from Left to Right

In this problem, you will write a single function that creates a panning effect, where sound moves from the left speaker to the right speaker. As in the previous problems, the function in this part should not modify the sound object it is passed; it should create and return a new sound object.

def left_to_right(snd, pan_length):

This function takes a sound object and an integer indicating the number of samples to which the pan will be applied. For example, if pan_length is 88200, the pan should not affect any sample numbered 88200 or higher.

Let’s listen to what panning sounds like. Here’s an airplane sound (airplane.wave). The entire sound is centred, and does not move in the stereo field as you listen. Now, with the call left_to_right(airplane, len(airplane)) (where airplane is a sound object loaded with the airplane sound), we get this airplane panning from left to right sound. The sound starts completely at the left, then slowly moves to the right, reaching the extreme right by the final sample.

Getting a sound to move from left to right like this requires a fade-out on the left channel and a fade-in on the right channel.

Here’s an example. Assume pan_length is 4. The following table indicates the factors by which the channels of these samples should be multiplied:

Sample Number	Multiply Left Channel By…	Multiply Right Channel By…
0	0.75	0.0
1	0.5	0.25
2	0.25	0.5
3	0.0	0.75

3 | Do Not Modify the sample | Do Not Modify the sample

---

If you run left_to_right on only a prefix of a sound (i.e. you use a pan_length that is less than the length of snd), you’ll get strange (though expected) results. For example, if you pan the first 441000 samples of love.wav, you’ll hear it pan from left to right over the first ten seconds, then you’ll hear a click followed by the remainder of the song played in the centre.

To understand how this function works, it might help to think of changing the volume using two volume controls: one for the left channel and one for the right. To make the sound seem like it’s moving from left to right, you slowly lower the volume in the left ear and raise the volume in the right ear. There is no copying going on between the two channels. And for the record, this technique only works when corresponding samples of both channels are the same: experiment with this dog and lake sound (doglake.wav) to see what happens when channels contain different sounds.

Grading left_to_right

The left_to_right function is worth <#points 4 pts>, broken down as follows.

• Correct panning effect. <#points 2 pts>
• Panning effect only for the specified number of samples. <#points 1 pts>
• Correct docstring comment at beginning of function and appropriate comments in the function body. <#points 1 pt>

Hi there, i have this homework that i need it to be done. Please keep it very simple and simple language.

This is the instructions

For this assignment, you are to watch selections from the 2003 Canadian documentary The Corporation. You only need to watch chapters 1-5, 7, 10-13, 17, though you of course can watch and refer to the whole documentary if you find it interesting.

This is a very biased and agenda driven documentary. We are not watching it for accuracy in its portrayal of modern day corporations (it paints them only in a negative light), but instead as a portrayal of what Sophistic practices might look like in our contemporary world.

Link to documentary: https://www.youtube.com/playlist?list=PLCDF6B02DFD948794

watch chapters 1-5, 7, 10-13, 17

You will recall from our class discussion that the Sophists use arguments for Epistemological Skepticism to lay claim to Epistemological Relativism and Moral/Ethical Relativism. If, they argue, we have no access to Good and Just, but only good-as-x-sees it or justice-according-to-y, then how do we navigate the field of opinions? How should we seek out what is in our best advantage?

Protagoras argued we should just go along with our community’s morality. Why make trouble for yourself? The Sophists we meet in the reading, however, propose more radical answers to these questions.

Answers each of the questions below. You will need to draw from the Sophists pdf, as well as our class discussions, to answer these questions. You will be handing a hard copy of this in on Tuesday 2/19

1) The Sophist Thrasymachus argues that “justice is really the good of another, the advantage of the stronger and the ruler, and harmful to the one who obeys and serves” (pgs 19-20). What does this mean? Why then does it follow that a “just man always gets less than an unjust man?” In what ways might these ideas be at work in The Corporation? (be specific)

2) What is the point of the story of the “Ring of Gyges” from your reading (pg 34-36))? What might the ring be a metaphor for? What examples of such ‘invisibility’ did you find in The Corporation? (be specific)

3) What, according to Callicles (in the reading!), what is the difference between the ‘law of nature’ and ‘conventional morality’ (827-828)? In what ways might corporations here be depicted as operating according to the ‘law of nature’?

4) Both Thrasymachus and Callicles would argue that ‘if the law is not to my advantage I ought not to obey it if I am too powerful to be stopped or too clever to be caught or pay serious consequences.’ In other words, whether or not you follow the rules should simply be a ‘business decision’. In what ways do you see this logic followed through in The Corporation? (be specific)

5) Socrates was very dismayed that people often appeared to be wise without actually being wise. The Sophists, however, think that it’s greatly to your advantage if you can appear to be wise, good-as-others-see-it, just-as-the-community-sees-it, while still seeking your own advantage. In what ways do you see this ‘appearing to be just’ as a business strategy at work in the documentary? (be specific)

I need help with a journal about a documentary. After watching the documentary that I will be attaching the link of it below, The proffessor asked us to choose three topics or songs from the video and relate them to our real life situations. We have to expand about each topic we choose. The professor specifall asked us to not actually summarize the stuff in the video, we just have to write about how it reflects on our lives through our past.

Here is the link to the documentary

https://archive.org/details/Morearty_GetUp#