I am working on the file "Docs/Notebooks/MolStandardize.ipynb".
The first task is:
rdMolStandardize.FragmentParent() function is similar to rdMolStandardize.LargestFragmentChooser  but first performs rdMolStandardize.Cleanup()

rdMolStandardize.FragmentRemover class filters out fragments
Can you write Python code for it?

fr = rdMolStandardize.FragmentRemover()
fr.remove(Chem.MolFromSmiles("CN(C)C.Cl.Cl.Br"))


I am working on the file "Docs/Notebooks/MolStandardize.ipynb".
The first task is:
rdMolStandardize.LargestFragmentChooser and rdMolStandardize.Remover

rdMolStandardize.LargestFragmentChooser class gets the largest fragment
Can you write Python code for it?


I am working on the file "Docs/Notebooks/MolStandardize.ipynb".
The first task is:
rdMolStandardize.MetalDisconnector
The rdMolStandardize.MetalDisconnector class disconnects metal atoms that are defined as covalently bonded to non-metals.
Can you write Python code for it?

md = rdMolStandardize.MetalDisconnector()
md.Disconnect(Chem.MolFromSmiles("CCC(=O)O[Na]"))


I am working on the file "Docs/Notebooks/MolStandardize.ipynb".
The first task is:
rdMolStandardize.Normalize
The rdMolStandardize.Normalizer class is used to apply a series of Normalization transforms to correct functional groups and recombine charges.
Can you write Python code for it?

n = rdMolStandardize.Normalizer()
n.normalize(Chem.MolFromSmiles("C[S+2]([O-])([O-])O"))


I am working on the file "Docs/Notebooks/MolStandardize.ipynb".
The first task is:
rdMolStandardize.ValidateSmiles()
The rdMolStandardize.ValidateSmiles() function is a convenience funtion that quickly validates a single SMILES string. It uses the rdMolStandardize.MolVSValidation() class with the default to do all validations.
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-DummyCores.ipynb".
The first task is:
Make the RGroup decomposition!
Can you write Python code for it?

rgroups = rdRGroupDecomposition.RGroupDecomposition(core)

for i,m in enumerate(mols):
    rgroups.Add(m)
    if i == 10:
        break


I am working on the file "Docs/Notebooks/RGroupDecomposition-DummyCores.ipynb".
The first task is:
The dummy cores are expanding into the cores found during the decomposition.
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-DummyCores.ipynb".
The first task is:
To finalize the rgroups, we need to call process after all molecules are added.
Can you write Python code for it?

rgroups.Process()

groups = rgroups.GetRGroupsAsColumns()
frame = pd.DataFrame(groups)
PandasTools.ChangeMoleculeRendering(frame)


I am working on the file "Docs/Notebooks/RGroupDecomposition-RingSubstitution.ipynb".
The first task is:
I would have preferred new cores to appear and the [:2]-N-[:2] depiction is a bit annoying...  Perhaps for round 2
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-RingSubstitution.ipynb".
The first task is:
Make RGroup decomposition!
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-RingSubstitution.ipynb".
The first task is:
We need to call process after all molecules are added to optimize the RGroups.
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-StereoChemTest.ipynb".
The first task is:
Let's try the same with stereochemistry in the core.
Note that the core has symmetry and the analysis nicely supports this during
the side chain optimization
n.b. stereo information is lost here which is fairly annoying and will be analyzed at a later date.
Can you write Python code for it?

core = Chem.MolFromSmarts("C1CCOC1")
rgroups = rdRGroupDecomposition.RGroupDecomposition(core)
for m in mols:
    rgroups.Add(m)
rgroups.Process()
frame = pd.DataFrame(rgroups.GetRGroupsAsColumns())
PandasTools.ChangeMoleculeRendering(frame)
HTML(frame.to_html())


I am working on the file "Docs/Notebooks/RGroupDecomposition-StereoChemTest.ipynb".
The first task is:
Make some example stereochemistries
Can you write Python code for it?

el = "NOPS"
mols = []
for e in el:
    smi = "C1CCO[C@@H](%s)1"%e
    print(smi)
    m = Chem.MolFromSmiles(smi)
    mols.append(m)
    smi = "C1CCO[C@H](%s)1"%e
    print(smi)
    m = Chem.MolFromSmiles(smi)
    mols.append(m)
    for e2 in el:
        if e != e2:
            smi = "C1CCO[C@@](%s)(%s)1"%(e,e2)
            m = Chem.MolFromSmiles(smi)
            if m:
                print(smi)
                mols.append(m)

from rdkit.Chem import Draw
Draw.MolsToGridImage(mols)

hmols = [Chem.AddHs(m) for m in mols]
Draw.MolsToGridImage(hmols)

core = Chem.MolFromSmarts("C1CCO[C@@](*)(*)1")


I am working on the file "Docs/Notebooks/RGroupDecomposition-StereoChemTest.ipynb".
The first task is:
Perhaps we should file a bug that smarts doesn't show stereochem here.
Can you write Python code for it?


I am working on the file "Docs/Notebooks/RGroupDecomposition-StereoChemTest.ipynb".
The first task is:
The RGroupDecomposition code is quite compatible with the python pandas integration.
Calling rg.GetRGroupsAsColumns() can be sent directly into a pandas table.
n.b. You need to call PandasTools.ChangeMoleculeRendering(frame) to allow the molecules
to be rendered properly.
Can you write Python code for it?

groups = rgroups.GetRGroupsAsColumns()
frame = pd.DataFrame(groups)
PandasTools.ChangeMoleculeRendering(frame)


I am working on the file "Docs/Notebooks/RGroupDecomposition-example-lactam.ipynb".
The first task is:
It is useful to disable logging here.  When making RGroup renderings there
are a lot of sanitization warnings.
Can you write Python code for it?

from rdkit import RDLogger
RDLogger.DisableLog("rdApp.*")


I am working on the file "Docs/Notebooks/RGroupDecomposition-example-lactam.ipynb".
The first task is:
Just show the first few (for speed and to keep the notebook small)
Can you write Python code for it?

f2 = pd.DataFrame(frame.head())
PandasTools.ChangeMoleculeRendering(f2)
HTML(f2.to_html())


I am working on the file "Docs/Notebooks/RGroupDecomposition-example-lactam.ipynb".
The first task is:
The RGroupDecomposition code is quite compatible with the python pandas integration.
Calling rg.GetRGroupsAsColumns() can be sent directly into a pandas table.
n.b. You need to call PandasTools.ChangeMoleculeRendering(frame) to allow the molecules
to be rendered properly.
Can you write Python code for it?

frame = pd.DataFrame(rg.GetRGroupsAsColumns())
PandasTools.ChangeMoleculeRendering(frame)


I am working on the file "Docs/Notebooks/RGroupDecomposition-example-lactam.ipynb".
The first task is:
To use RGroupDecomposition:

construct the class on the core rg = RGroupDecomposition(core)
Call rg.Add( mol ) on the molecules.  If this returns -1, the molecule is not
     compatible with the core
After all molecules are added, call rg.Process() to complete the rgroup
     decomposition.
Can you write Python code for it?

rg = RGroupDecomposition(core)

mols = []
count = 0
for line in open("compounds.txt"):
    sm = line.split()[-1]
    m = Chem.MolFromSmiles(sm)
    if m:
        count += 1
        idx = rg.Add(m)
rg.Process()
print ("Added %s to RGroup Decomposition out of %s"%(idx, count))


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Build a nearest neighbor model for document retrieval
We now create a nearest-neighbors model and apply it to document retrieval.
Can you write Python code for it?


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Examine the TF-IDF for the Obama article
Can you write Python code for it?

obama = people[people['name'] == 'Barack Obama']

obama[['tfidf']].stack('tfidf',new_column_name=['word','tfidf']).sort('tfidf',ascending=False)


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Exploring the entry for actor George Clooney
Can you write Python code for it?

clooney = people[people['name'] == 'George Clooney']
clooney['text']


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Is Obama closer to Clinton than to Beckham?
We will use cosine distance, which is given by
(1-cosine_similarity)
and find that the article about president Obama is closer to the one about former president Clinton than that of footballer David Beckham.
Can you write Python code for it?


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Load some text data - from wikipedia, pages on people
Can you write Python code for it?


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Most common words include uninformative words like "the", "in", "and",...
Compute TF-IDF for the corpus
To give more weight to informative words, we weigh them by their TF-IDF scores.
Can you write Python code for it?

people['word_count'] = graphlab.text_analytics.count_words(people['text'])
people.head()

tfidf = graphlab.text_analytics.tf_idf(people['word_count'])
tfidf

people['tfidf'] = tfidf['docs']


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Sort the word counts for the Obama article
Turning dictonary of word counts into a table
Can you write Python code for it?

obama_word_count_table = obama[['word_count']].stack('word_count', new_column_name = ['word','count'])


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Sorting the word counts to show most common words at the top
Can you write Python code for it?


I am working on the file "Document Retrieval/.ipynb_checkpoints/Document retrieval-checkpoint.ipynb".
The first task is:
Words with highest TF-IDF are much more informative.
Manually compute distances between a few people
Let's manually compare the distances between the articles for a few famous people.
Can you write Python code for it?

clinton = people[people['name'] == 'Bill Clinton']

beckham = people[people['name'] == 'David Beckham']


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
As we can see, president Obama's article is closest to the one about his vice-president Biden, and those of other politicians.
Other examples of document retrieval
Can you write Python code for it?

swift = people[people['name'] == 'Taylor Swift']

knn_model.query(swift)

jolie = people[people['name'] == 'Angelina Jolie']

knn_model.query(jolie)

arnold = people[people['name'] == 'Arnold Schwarzenegger']

knn_model.query(arnold)


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Examine the TF-IDF for the Obama article, this new variable with tfidf
Can you write Python code for it?


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Explore the dataset and checkout the text it contains
Exploring the entry for president Obama, Let's take subset of data as obama
Can you write Python code for it?

obama = people[people['name'] == 'Barack Obama']


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Exploring the entry for actor George Clooney, in variable clooney
Can you write Python code for it?


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Get the word counts for Obama article and store result in same data set as a new variable name word_count
Can you write Python code for it?

obama['word_count'] = graphlab.text_analytics.count_words(obama['text'])

print obama['word_count']


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Is Obama closer to Clinton than to Beckham?
We will use cosine distance, which is given by
(1-cosine_similarity) for computing the distance between the two documents
and find that the article about president Obama is closer to the one about former president Clinton than that of footballer David Beckham.
Can you write Python code for it?


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Sort the word counts for the Obama article, for sorting we use stack with new column name as word and count
Turning dictonary of word counts into a table
Can you write Python code for it?


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
Sorting the word counts to show most common words at the top
Can you write Python code for it?


I am working on the file "Document Retrieval/Document retrieval.ipynb".
The first task is:
less the distance between two document more they are similar two each other like obam and clinton are more similar then obama and beckham
Build a nearest neighbor model for document retrieval
We now create a nearest-neighbors model and apply it to document retrieval.
Can you write Python code for it?


I am working on the file "DocumentClassificationNLM.ipynb".
The first task is:
Explanation of getOptions
This is just kind of a port of a command line application where I'd use argparse to get the options.
Can you write Python code for it?

def getOptions():
    """Generates arguments for specifying database and other parameters"""
    options = {}
    options['lexical_kb'] = ["https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/lexical_kb_05042016.tsv"]
    options['domain_kb'] = ["https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/critical_findings.tsv"]
    options["schema"] = "https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/schema2.csv"
    options["rules"] = "https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/classificationRules3.csv"
    return options


I am working on the file "DocumentClassificationNLM.ipynb".
The first task is:
Explation of get_kb_rules_schema

itemData.instantiateFromCSVtoitemData: This function is a somewhat unfortunate name as it implies reading CSV files but we've moved to tab delimited files, since we sometimes have commas in the regular expressions.
Can you write Python code for it?

def get_kb_rules_schema(options):
    """
    Get the relevant kb, rules, and schema.

    """

    _radnlp_rules = rules.read_rules(options["rules"])
    _schema = schema.read_schema(options["schema"])

    modifiers = itemData.itemData()
    targets = itemData.itemData()
    for kb in options['lexical_kb']:
        modifiers.extend( itemData.instantiateFromCSVtoitemData(kb) )
    for kb in options['domain_kb']:
        targets.extend( itemData.instantiateFromCSVtoitemData(kb) )
    return {"rules":_radnlp_rules,
            "schema":_schema,
            "modifiers":modifiers,
            "targets":targets}

def analyze_report(report, modifiers, targets, rules, schema):
    """
    given an individual radiology report, creates a pyConTextGraph
    object that contains the context markup
    report: a text string containing the radiology reports
    """
    markup = utils.mark_report(split.get_sentences(report),
                         modifiers,
                         targets)

    clssfy =   classifier.classify_document_targets(markup,
                                          rules[0],
                                          rules[1],
                                          rules[2],
                                          schema)
    return classrslts(context_document=markup, exam_type="ctpa", report_text=report, classification_result=clssfy)

options = getOptions()
kb = get_kb_rules_schema(options)
#data = data.dropna()

data = \
pd.read_sql("""SELECT noteevents.subject_id,
                      noteevents.text,
                      icd9.code
               FROM noteevents INNER JOIN icd9 ON
                      noteevents.subject_id = icd9.subject_id
               WHERE (   icd9.code LIKE '415.1%'
                      )
                      AND noteevents.category = 'RADIOLOGY_REPORT'""",
            conn).drop_duplicates()
data.head(10)

doc_split=["IMPRESSION:", "INTERPRETATION:", "CONCLUSION:"]

def find_impression(text, split):
    for term in split:
        if...


I am working on the file "DocumentClassificationNLMStudent.ipynb".
The first task is:
Document Markup and Classification
We are going to be doing a lot behind the scenes here. We've got some code that is going to take our lexical and domain definitions, markup our documents according to these definitions and use pyConTextNLP to assign relationships between the concepts for each sentence int he document. Finally, we take a schema that defines how we are going to classify our documents, based on the sentence level markup. The schema we are going to use here is an ordinal schema where we account for existence, uncertainty, and acuity. The document classification is basically a maximum function: the document is assigned the maximum score of any sentence in the document.
We now need to apply our schema to the reports. Since our data is in a Pandas data frame, the easiest way to process our reports is with the DataFrame apply method.

We use lambda to create an anonymous function which basically just applies analyze_report to the "impression" column with the modifiers, targets, etc. that we have read in separately.
analyze_report returns a dictionary with keys as any identified targets defined in the "targets" file and values as a tuple with values:
The schema value that was selected for the document
The node (evidence) that was used for selecting that schema value
Can you write Python code for it?

data["pe rslt"] = \
    data.apply(lambda x: analyze_report(x["impression"],
                                         kb["modifiers"],
                                         kb["targets"],
                                         kb["rules"],
                                         kb["schema"]), axis=1)
data.head()

def view_markup(reports, colors):
    @interact(i=widgets.IntSlider(min=0, max=len(reports)-1))
    def _view_markup(i):
        markup = reports["pe rslt"][i]
        rview.markup_to_pydot(markup)
        display(Image("tmp.png"))
        mt = rview.markup_to_html(markup, color_map=colors)

        display(HTML(mt))

view_markup(data, colors)


I am working on the file "DocumentClassificationNLMStudent.ipynb".
The first task is:
Explanation of getOptions
This is just kind of a port of a command line application where I'd use argparse to get the options.
Can you write Python code for it?

def getOptions():
    """Generates arguments for specifying database and other parameters"""
    options = {}
    options['lexical_kb'] = ["https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/lexical_kb_nlm.tsv"]
    options["schema"] = "https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/schema2.csv"
    options["rules"] = "https://raw.githubusercontent.com/chapmanbe/pyConTextNLP/master/KB/classificationRules3.csv"
    return options


I am working on the file "Documentation/Algorithms/SensorOffsets/Offset Experiments.ipynb".
The first task is:
SST from TSG and EqT from GO
Can you write Python code for it?

plt.figure(figsize=(16, 9))
plt.scatter(tsg_filtered['Time'], tsg_filtered['SST'], label='SST', s=2)
plt.scatter(go_filtered['UNIXTime'], go_filtered['equ temp'], label='EqT', s=2)
plt.legend()


I am working on the file "Documentation/Gala's Watershed Introduction and Documentation.ipynb".
The first task is:
Step 2
Next load the necessary data from our 'nxp_data.npy file'. If you are using your own data, make sure you have already replaced our npy file with your own. In any case, please make sure the file you are using is named 'nxp_data.np'.
Can you write Python code for it?

# Gather images from nXp_data.npy file
print "Getting images"
membrane_images = np.load('nXp_data.npy')

# Assigning one image from array to variable pre_image
pre_image = 255 * membrane_images[0]

min_seed_size = 5 #2
connectivity = 2 #2
smooth_thresh = 0.02 #0.02


I am working on the file "Documentation/Gala's Watershed Introduction and Documentation.ipynb".
The first task is:
Step 3
The below code is for the actual watershed segmentation. The distance parameters can be modified to produce different results.
Can you write Python code for it?

########
# Watershed segmentation
########
print "Running watershed"

ws_train = morpho.watershed(pre_image,
connectivity=connectivity, smooth_thresh=smooth_thresh,
override_skimage=1,minimum_seed_size=min_seed_size) + 1
#ws_train = ws_train

fig, axes = plt.subplots(ncols=1, figsize=(8, 2.7), sharex=True, sharey=True, subplot_kw={'adjustable':'box-forced'})
ax0 = axes

ax0.imshow(ws_train)#, cmap=plt.cm.spectral, interpolation='nearest')
ax0.set_title('Overlapping objects')


I am working on the file "Documentation/Gala's Watershed Introduction and Documentation.ipynb".
The first task is:
Step 5
Finally a plot of the annotated image should pop up.
Can you write Python code for it?

fig.subplots_adjust(hspace=0.01, wspace=0.01, top=0.9, bottom=0, left=0,
                    right=1)

plt.show()


I am working on the file "Documentation/Python-based Watershed Introduction and Documentation.ipynb".
The first task is:
Step 2
Next load the necessary data from our 'nxp_data.npy file'. If you are using your own data, make sure you have already replaced our npy file with your own. In any case, please make sure the file you are using is named 'nxp_data.np'.
Can you write Python code for it?

# Gather images from nXp_data.npy file
print "Getting images"
membrane_images = np.load('nXp_data.npy')

# Assigning one image from array to variable pre_image
pre_image = membrane_images[0]


I am working on the file "Documentation/Python-based Watershed Introduction and Documentation.ipynb".
The first task is:
Step 3
Several different image processing tools are necessary to increase precision.
Can you write Python code for it?

########
# Binary closing on image
########
print "Running closing"

close_image = closing(pre_image, selem=np.ones((4,4)))

print "Running median filter"
# Remove white speckles of noise
img_med = ndi.median_filter(close_image, size=4)

print "Running threshold"
#binary_img = threshold(close_image, selem=np.ones((200,200)))
threshold = threshold_otsu(img_med)
binary_img = img_med > threshold

image = binary_img
foreground = 1 - image

# image = foreground


I am working on the file "Documentation/Python-based Watershed Introduction and Documentation.ipynb".
The first task is:
Step 5
Finally a plot of the annotated image should pop up.
Can you write Python code for it?


I am working on the file "Documentation/Python-based Watershed Introduction and Documentation.ipynb".
The first task is:
Step 6
Lastly, evaluate the data to test your parameters.
Can you write Python code for it?

########
# Evaluation
########
print "Running evaluation"

print "...Split VI Evaluation" # Want closest to [0,0] for (undersegmentation (false_merges), oversegmentation (false_splits))
split_eval = ev.split_vi(ws, membrane_ground[0])
print split_eval

print "...Adjusted Rand Index Evaluation" # Want the closest to 1.0
adjusted_rand = ev.adj_rand_index(ws, membrane_ground[0])
print adjusted_rand

print "...Fowlkes-Mallows Index Evaluation" # Want closest to 1
fm = ev.fm_index(ws, membrane_ground[0])
print fm


I am working on the file "Documentation/Tutorial SimplexSolver con Python.ipynb".
The first task is:
El siguiente comando, nos permite guardar la solución(bien con el desarrollo completo o solo con la solución) del problema en un archivo. El nombre del archivo se le indica mediante --output, y aparecerá en el directorio donde tengamos guardado SimplexSolver.py a no ser que indiquemos otra localización:
python SimplexSolver.py --input archivo.txt --expl --output out.txt

A continuación, se puede ver la salida(nótese que en su ejecución debe cambiar "%run", por python):
Can you write Python code for it?

%run ..\PySimplex\SimplexSolver.py --input  ..\Files\file1.txt --output out.txt


I am working on the file "Documentation/Tutorial SimplexSolver con Python.ipynb".
The first task is:
Mediante el siguiente comando, además de lo que nos proporcionaban las anteriores ejecuciones, se puede añadir la solución gráfica(solo se puede obtener cuando el problema tiene dos variables):
    python SimplexSolver.py --input file.txt --expl --graphic

A continuación, se puede ver la salida(nótese que en su ejecución debe cambiar "%run", por python):
Can you write Python code for it?

%matplotlib inline
%run ..\PySimplex\SimplexSolver.py --input  ..\Files\file2.txt --graphic


I am working on the file "Documentation/Tutorial SimplexSolver con Python.ipynb".
The first task is:
Mediante la siguiente ejecución, podemos obtener también las solución, pero además obtendremos el desarrollo completo del problema:
python SimplexSolver.py --input file.txt --expl

A continuación, se puede ver la salida(nótese que en su ejecución debe cambiar "%run", por python):
Can you write Python code for it?

%run ..\PySimplex\SimplexSolver.py --input  ..\Files\file1.txt --expl


I am working on the file "Documentation/Tutorial SimplexSolver con Python.ipynb".
The first task is:
Por último, también podemos pedir que se nos muestre la solución del problema dual, al que estamos resolviendo. Para ello, simplemente tendremos que incluir --dual, al final de nuestra ejecución:
python SimplexSolver.py --input file.txt --output out.txt --dual
o bien,
python SimplexSolver.py --input file.txt --dual

Aquí se muestra una ejecución de lo anterior:
Can you write Python code for it?

%run ..\PySimplex\SimplexSolver.py --input  ..\Files\file.txt --dual


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
* eliminatePoints*
Este método recibe dos listas, y devuelve una lista con los elementos de la primera lista que no están en la segunda. Se puede utilizar para eliminar puntos(tuplas) o cualquier elemento. Igual que el método anterior, con float no funciona exactamente.Si no recibe dos listas, devuelve None. Ejemplos:
Can you write Python code for it?

# Con enteros funciona perfectamente
list1=[(3,1),(4,5),(6,7)]
list2=[(2,5),(4,5),(4,8)]
Simplex.eliminatePoints(list1, list2)

# Con rational funciona perfectamente
list1=[rational(5,1),rational(2,5),rational(6,1)]
list2=[rational(8,7),rational(2,5),rational(10,8)]
Simplex.eliminatePoints(list1, list2)

# Con float no funciona exactamente
list1=[(3.0,1.0),(4.0,5.0),(6.0,7.0)]
list2=[(2.0,5.0),(4.000001,5.0),(4.0,8.0)]
Simplex.eliminatePoints(list1, list2)

# Si recibe algo que no sean dos listas, devuelve None
print(Simplex.eliminatePoints(3, list2))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
* eliminateRepeatedPoints*
Este método recibe una lista de puntos(en forma de tupla) y devuelve la misma lista, con los puntos repetidos eliminados. Con enteros y rational, funciona exactamente, no así con float si los números tienen muchos decimales, puesto que podría considerar por ejemplo 5.33333 y 5.33334 como dos números distintos, cuando podrían ser el mismo. En caso de no recibir una lista, devuelve None. Ejemplos:
Can you write Python code for it?

# Como vemos en este caso elimina un punto que está repetido
seq=[(rational(2,1),rational(3,4)),(rational(6,1),rational(7,4)),(rational(2,1),rational(3,4)),(rational(5,2),rational(3,4)),]
Simplex.eliminateRepeatedPoints(seq)

# Con enteros funciona perfectamente
seq=[(3,1),(4,5),(4,5),(2,1)]
Simplex.eliminateRepeatedPoints(seq)

# Con float no funciona exactamente
seq=[(3.0,1.1),(4.0,5.0),(4.000001,5.0),(2.0,1.0)]
Simplex.eliminateRepeatedPoints(seq)

# Si no se introduce un lista, devuelve None
print(Simplex.eliminateRepeatedPoints(4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
Método Simplex
variablesNoiteration
Este método se utiliza para calcular las variables que no están en la iteración. Recibe como parámetro, una matrix numpy, que contiene las restricciones del problema y un array numpy, que contiene las variables que ya están en la iteración(estas variables no tienen porqué aparecer ordenadas en el array). El método funciona, con matrices de tipo entero, de tipo float y de tipo rational. En caso de que los parámetros introducidos no sean correctos, devolverá None. Si todo es correcto, devolverá array numpy, con las variables que no están en la iteración. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[1,3,4,4,5],[12,45,67,78,9],[3,4,3,5,6]])
variablesIteration=np.array([1,3,4])
Simplex.variablesNoiteration(matrix,variablesIteration)

variablesIteration=np.array([3,4,1])
Simplex.variablesNoiteration(matrix,variablesIteration)

# EL método funciona con matrices con elementos rational
matrix=np.matrix([[rational(6,7),rational(4,5),rational(3,1)],[rational(2,3),rational(7,6),rational(1,3)],
                  [rational(4,1),rational(6,4),rational(9,2)]])
variablesIteration=np.array([3,4,1])
Simplex.variablesNoiteration(matrix,variablesIteration)

#Si le introduzco algo que no sea una matriz de numpy en el primer parámetro o algo que no sea un array de numpy en el segundo,me
#devuelve None
print(Simplex.variablesNoiteration(3,variablesIteration))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
Operaciones con matrices
determinant
Este método recibe una matriz de numpy, con componentes rational, y devuelve el determinante de la matriz. La matriz debe ser cuadrada. Si se introduce algo que no es una matriz cuadrada de numpy, con elementos rational, devuelve None. También admite un array de numpy bidimensional.Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
det=Simplex.determinant(matrix)
print(det)

# Si la matriz no es cuadrada, devuelve None
matrix=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(5,4),rational(3,9)]])
print(Simplex.determinant(matrix))

# También admite un array de numpy bidimensional
matrix=np.array([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
print(Simplex.determinant(matrix))

# Si recibe algo que no es una matriz cuadrada de numpy, con elementos rational, devuelve None
print(Simplex.determinant(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
Solución gráfica
convertToPlotFunction
Este método transforma una restricción en una función para ser representada. Para ello, recibe un array de numpy que contiene la restricción(todos los coeficientes deben ser rational), sin signo ni recurso,un string que contiene el signo, un rational que es el recurso que contiene los recursos, y una variable que será el linespace para su representación. Además de devolver la función, devuelve un string, con la función. Si el valor de y en la restricción es 0, devuelve un rational, en lugar de una función. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# Si se le pasa todo correcto, devuelve una función, y un string con la función
lineOfMatrix=np.array([rational(3,4),rational(2,1)])
sign="<="
resource=rational(4,1)
x = np.linspace(0, 10)
Simplex.convertToPlotFunction(lineOfMatrix, sign, resource, x)

# Si se le pasa una restricción con la segunda componente 0, devuelve un número
lineOfMatrix=np.array([rational(3,4),rational(0,1)])
sign="<="
resource=rational(4,1)
x = np.linspace(0, 10)
Simplex.convertToPlotFunction(lineOfMatrix, sign, resource, x)

# Si se le pasa una restricción que no tiene 2 componentes o tiene más de 2,devuelve None
lineOfMatrix=np.array([rational(3,4)])
print(Simplex.convertToPlotFunction(lineOfMatrix, sign,
                                            resource, x))

# Si se le pasa algo que no es un array de numpy de rational en el primer parámetro, algo que no es un string en el segundo, algo
#que no es un rational en el tercero o algo que no es un array de numpy en el tercero,devuelve None

print(Simplex.convertToPlotFunction(lineOfMatrix, sign,
                                            4, x))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
addArtificialVariablesToFunctionVector
Este método recibe un array de numpy con elementos rational, que contiene los coeficientes de la función objetivo(vector función), y un número, que será el número de variables artificiales que se desea añadir. Si se introducen los parámetros de forma correcta, devolverá un array de numpy, que contendrá el vector función completo, ya con los coeficientes de las variables artificiales añadidos. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

vector=np.array([rational(3,1),rational(4,1),rational(5,1),rational(6,1)])
numOfArtificialVariables= 2
print(Simplex.printMatrix(np.asmatrix(Simplex.addArtificialVariablesToFunctionVector
                                              (vector,numOfArtificialVariables))))

#Si se pasa algo que no es un array de numpy con elementos rational en el primer parámetro, o algo que no es un número en
# el segundo, devuelve None
print(Simplex.addArtificialVariablesToFunctionVector(vector,[2,3]))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
adjMatrix
Este método recibe una matriz de numpy, con componentes rational, y devuelve la matriz de adjuntos. La matriz debe ser cuadrada. Si se introduce algo que no es una matriz cuadrada de numpy, con elementos rational, devuelve None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
m=Simplex.adjMatrix(matrix)
print(Simplex.printMatrix(m))

# Si la matriz no es cuadrada, devuelve None
matrix=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(5,4),rational(3,9)]])
print(Simplex.adjMatrix(matrix))

# Si recibe algo que no es una matriz cuadrada de numpy, con elementos rational, devuelve None
matrix=np.array([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
print(Simplex.invertMatrix(matrix))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateCB
Este método calcula el valor del vector función, para una iteración. Para ello recibe en un array numpy, las columnas de la iteración, y en otro array numpy, el vector de función completo del problema. Si todo es correcto, se devuelve en un array numpy, el vector de la función para las columnas introducidas. En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

columnsOfIteration=np.array([0,2,3])
functionVector= np.array([0,1,2,3,5,5,6])
Simplex.calculateCB(columnsOfIteration,functionVector)

# El método también funciona con elementos rational
columnsOfIteration=np.array([0,2])
functionVector= np.array([rational(0,1),rational(2,3),rational(5,5)])
print(Simplex.printMatrix(np.asmatrix(Simplex.calculateCB(columnsOfIteration,functionVector))))

# Si meto más columnas de las que tiene el vector función, me devuelve None
columnsOfIteration=np.array([0,1,2])
functionVector= np.array([0,1])
print(Simplex.calculateCB(columnsOfIteration,functionVector))

# Si meto algo por parámetro que no es un array de numpy en cualquiera de los dos parámetros, me devuelve None
print(Simplex.calculateCB([0,1],functionVector))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateColumnsOfIteration
Este método recibe la variable que entrará en la siguiente iteración, la variable que saldrá en la siguiente iteración, y en un array de numpy, las variables de la iteración anterior. Si los parámetros son correctos, devuelve en un array de numpy, las variables de la iteración actual. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

variableWhichEnters=4
variableWhichExits=3
previousVariables=np.array([1,3,5])
Simplex.calculateColumnsOfIteration(variableWhichEnters,variableWhichExits,previousVariables)

# Si se intenta sacar una variable que no está, no saca nada
variableWhichEnters=4
variableWhichExits=6
previousVariables=np.array([1,3,5])
Simplex.calculateColumnsOfIteration(variableWhichEnters,variableWhichExits,previousVariables)

# Si se mete algo que no es un array de numpy en el tercer parámetro,o algo que no es un número en los dos primeros, devuelve
# None
print(Simplex.calculateColumnsOfIteration(variableWhichEnters,variableWhichExits,3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateExitValues
Este método recibe los valores de la regla de entrada en un array de numpy, los valores de y en otro array de numpy, y la solución de esa iteración en un array de numpy, en forma de columna. Todos los elementos de los arrays deben ser rational. Si todos los parámetros se introducen de forma correcta, se devuelven los valores de la regla de salida. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

inputRuleValues=np.array([rational(2,1),rational(-3,1),rational(-4,3)])
yValues=np.array([[rational(2,1),rational(3,1),rational(4,1)],[rational(4,1),rational(6,1),rational(8,1),],[rational(3,1),
                rational(5,1),rational(6,1)]])
sol=np.array([[rational(1,1)],[rational(0,1)],[rational(-4,2)]])
Simplex.calculateExitValues(inputRuleValues,yValues,sol)

#Si el número de valores de la regla de entrada es diferente que el número de valores de y, devuelve None
inputRuleValues=np.array([rational(2,1),rational(-3,1)])
yValues=np.array([[rational(2,1),rational(3,1),rational(4,1)],[rational(4,1),rational(6,1),rational(8,1),],[rational(3,1),
                rational(5,1),rational(6,1)]])
sol=np.array([[rational(1,1)],[rational(0,1)],[rational(-4,2)]])
print(Simplex.calculateExitValues(inputRuleValues,yValues,sol))

#Si el número de valores de la regla de entrada es diferente que el número de valores de y, devuelve None
inputRuleValues=np.array([rational(2,1),rational(-3,1),rational(-4,3)])
yValues=np.array([[rational(2,1),rational(3,1),rational(4,1)],[rational(4,1),rational(6,1),rational(8,1),]])
sol=np.array([[rational(1,1)],[rational(0,1)],[rational(-4,2)]])
print(Simplex.calculateExitValues(inputRuleValues,yValues,sol))

#Si la longitud de la solución es menor que el número de valores de algún conjunto de y, devuelve None
inputRuleValues=np.array([rational(2,1),rational(-3,1),rational(-4,3)])
yValues=np.array([[rational(2,1),rational(3,1),rational(4,1)],[rational(4,1),rational(6,1),rational(8,1),],[rational(3,1),
                rational(5,1),rational(6,1)]])
sol=np.array([[rational(1,1)],[rational(0,1)]])
print(Simplex.calculateExitValues(inputRuleValues,yValues,sol))

#Si recibe algo que no sea un array de numpy con elementos rational en cualquiera de los parámetros, devuelve None
print(Simplex.calculateExitValues(inputRuleValues,66,sol))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateFeasibleRegion
Este método recibe un conjunto de puntos en una lista, un conjunto de restricciones en un array de numpy, sin signos ni recursos,un array de numpy con los recursos y una lista de string con los signos. El método devuelve la lista de puntos introducidos, que cumplen todas las restricciones, es decir pertenecen a la región factible. El método funciona tanto con rational, como con enteros, no siendo tan exacto con float. Si ningún punto pertenece a la región factible, devolverá una lista vacía. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# El método funciona con valores rational, eliminando los puntos que no pertencen a la región factible
points=[(rational(0,1),rational(5,1)),(rational(5,1),rational(0,1)),(rational(10,1),rational(12,1)),
        (rational(-30,1),rational(1,2))]
inecuations=np.array([np.array([rational(-7,1),rational(10,1)]),np.array([rational(2,1),rational(1,1)]),
                      np.array([rational(8,1),rational(-7,1)])])

resources=np.array([rational(50,1),rational(32,1),rational(40,1)])
sign=["<=","<=","<="]
Simplex.calculateFeasibleRegion(points, inecuations, resources, sign)

# El método funciona con valores enteros, eliminando los puntos que no pertencen a la región factible
points=[(0,5),(5,0),(10,12),(-30,1)]
inecuations=np.array([np.array([-7,10]),np.array([2,1]), np.array([8,-7])])
resources=np.array([50,32,40])
sign=["<=","<=","<="]
Simplex.calculateFeasibleRegion(points, inecuations, resources, sign)

# El número de restricciones tiene que ser igual que el de signos y el de recursos
points=[(0,5),(5,0),(10,12),(-30,1)]
inecuations=np.array([np.array([-7,10]),np.array([2,1]), np.array([8,-7])])
resources=np.array([50,32])
sign=["<=","<=","<="]
print(Simplex.calculateFeasibleRegion(points, inecuations, resources, sign))

# Si se introduce algo que no es una lista, en el primer parámetro, un array de numpy en el segundo y tercer parámetro, o una
# lista de strings, en el cuarto parámetro, devuelve None
inecuations=np.matrix([np.array([2,1]),np.array([1,-1]),np.array([5,2])])
print(Simplex.calculateFeasibleRegion(points, inecuations, resources, sign))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateIntegerPoints
Este método recibe un conjunto de restricciones en un array de numpy, sin signos ni recursos,un array de numpy con los recursos, una lista de string con los signos y dos tuplas, con el mínimo y el máximo punto a representar. El método devuelve una lista con todos los puntos enteros que pertenecen a esa región factible y que son menores que el punto máximo. Todos los elementos de las restricciones, recursos y de la tupla, deben ser rational. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# Puntos calculados con rational
inecuations=np.array([np.array([rational(-7,1),rational(10,1)]),np.array([rational(2,1),rational(1,1)]),
                      np.array([rational(8,1),rational(-7,1)])])

resources=np.array([rational(50,1),rational(32,1),rational(40,1)])
sign=["<=","<=","<="]
scale1=(rational(0,1),rational(0,1))
scale=(rational(10,1),rational(10,1))
Simplex.calculateIntegerPoints(inecuations, resources, sign, scale1,scale)

# El número de restricciones tiene que ser igual que el de signos y el de recursos
inecuations=np.array([np.array([rational(-7,1),rational(10,1)]),np.array([rational(2,1),rational(1,1)]),
                      np.array([rational(8,1),rational(-7,1)])])

resources=np.array([rational(50,1),rational(32,1),rational(40,1)])
sign=["<=","<="]
scale=(rational(10,1),rational(10,1))
print(Simplex.calculateIntegerPoints(inecuations, resources, sign, scale1, scale))

# Si se introduce algo que no es un array de numpy de rational en el primer y segundo parámetro,una lista de strings, en el
# tercer parámetro,o una tupla en el último parámetro devuelve None
print(Simplex.calculateIntegerPoints(inecuations, resources, sign, scale1, 4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateIterationSolution
Este método calcula la solución de una iteración, para las variables de la misma, y la devuelve en un array de numpy. Para ello, recibe la base de la iteración, en una matriz numpy y también recibe el vector de recursos en un array de numpy. Los elementos de la matriz y el array, deben ser rational. En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

base=np.matrix([[rational(6,7),rational(4,5),rational(3,1)],[rational(2,3),rational(7,6),rational(1,3)],
                  [rational(4,1),rational(6,4),rational(9,2)]])

resourcesVector=np.array([rational(2,1),rational(33,2),rational(52,8)])
print(Simplex.printMatrix(np.asmatrix(Simplex.calculateIterationSolution(base,resourcesVector))))

#Si le paso un vector de recursos, que tenga un longitud diferente al número de filas de la matriz, me duvuelve None
resourcesVector=np.array([rational(2,1),rational(33,2)])
print(Simplex.calculateIterationSolution(base,resourcesVector))

#Si le paso algo que no es una matriz de numpy  de elementos rational en el primer parámetro o un array de numpy con elementos
# rational en el segundo, me devuelve None
print(Simplex.calculateIterationSolution(base,4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateMaxScale
Este método recibe una lista de puntos, y devuelve el máximo valor de la coordenada x y de la coordenada y. Se utiliza para saber cuál es el punto máximo que se debe representar. En caso de no recibir una lista, devuelve None. Ejemplos:
Can you write Python code for it?

points=[(4,3),(5,6),(1,-2)]
Simplex.calculateMaxScale(points)

points=[(rational(0,1),rational(5,1)),(rational(5,1),rational(0,1)),(rational(10,1),rational(12,1)),
        (rational(-30,1),rational(1,2))]
Simplex.calculateMaxScale(points)

points=[(4.6,3.7),(5.0,6.5),(1.2,-2.5)]
Simplex.calculateMaxScale(points)

# Si recibe algo que no es una lista, devuelve None
print(Simplex.calculateMaxScale(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateMinScale
Este método recibe una lista de puntos, y devuelve el mínimo valor de la coordenada x y de la coordenada y. Se utiliza para saber cuál es el punto mínimo que se debe representar. En caso de no recibir una lista, devuelve None. Ejemplos:
Can you write Python code for it?

points=[(4,3),(5,6),(1,-2)]
Simplex.calculateMinScale(points)

points=[(rational(0,1),rational(5,1)),(rational(5,1),rational(0,1)),(rational(10,1),rational(12,1)),
        (rational(-30,1),rational(1,2))]
Simplex.calculateMinScale(points)

points=[(4.6,3.7),(5.0,6.5),(1.2,-2.5)]
Simplex.calculateMinScale(points)

# Si recibe algo que no es una lista, devuelve None
print(Simplex.calculateMinScale(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateO
Este método calcula el valor de O, para un conjunto de valores de salida que recibe por parámetro como un array de numpy. Este valor será el de los valores recibidos. El cálculo de qué valores tienen denominador negativo o 0, se hace en el método calculateExitValues, luego aquí se recibirá un array con valores rational y Nan.Si todos los valores son Nan, devolverá None. En caso de que no reciba un array de numpy, devuelve None. Ejemplos:
Can you write Python code for it?

exitValues=np.array([rational(1,3),rational(-3,2),rational(0,1),rational(5,4)])
print(Simplex.calculateO(exitValues))

#Si todos los valores recibidos son Nan, se omitirán y devolverá None
exitValues=np.array([np.nan,np.nan,np.nan,np.nan])
print(Simplex.calculateO(exitValues))

#Si recibe algo que no es una array de numpy con elementos rational o Nan, devuelve None
exitValues=np.array([-1,-3,-3,-5])
print(Simplex.calculateO(exitValues))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateOrder
Este método recibe una lista de puntos, cuyas coordenadas son rational, y devuelve la misma lista de puntos, pero ordenadas en sentido horario. En caso de no introducir una lista de rational, devuelve None. Ejemplos:
Can you write Python code for it?

listPoints=[(rational(4,5),rational(1,2)),(rational(4,2),rational(3,1)),(rational(8,3),rational(3,5)),(rational(7,2),
         rational(4,5)), (rational(7,9),rational(4,9)),(rational(9,8),rational(10,7))]
Simplex.calculateOrder(listPoints)

# Si recibe algo que no es una lista de puntos con coordenadas rational
listPoints=[(4.0,5.0),(4.0,3.0),(8.0,5.0),(7.0,4.0),(7.0,9.0),(10.0,4.0)]
print(Simplex.calculateOrder(listPoints))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculatePointOfSolution
Est método recibe un array de numpy con los coeficientes de la función a optimizar(en forma de maximización),una lista de puntos cuyas coordenadas son rational, y un rational con el valor de la función objetivo optimizada. El método devuelve cuál es el punto que alcanza el valor pasado. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

functionVector=np.array([rational(2,1),rational(3,1)])
points=[(rational(4,2),rational(3,4)),(rational(5,4),rational(6,8)),(rational(1,4),rational(6,1))]
solution = rational(19,4)
Simplex.calculatePointOfSolution(functionVector, points, solution)

functionVector=np.array([rational(2,1),rational(3,1)])
points=[(rational(4,2),rational(3,4)),(rational(5,4),rational(6,8)),(rational(1,4),rational(6,1))]
solution = rational(18,3)
print(Simplex.calculatePointOfSolution(functionVector, points, solution))

# Si recibe algo que no sea un array de numpy en el primer parámetro, una lista de puntos rational en el segundo, o un rational
# en el tercero, devuelve None
print(Simplex.calculatePointOfSolution(functionVector, points, 3.0))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateVarWhichExit
Este método recibe en un array de numpy las variables o columnas que pertenecen a la iteración(deben aparecer ordenadas en función de lo que se esté realizando en el problema), y en otro array de numpy, los valores de la regla de salida, que deben ser rational o Nan. Si los parámetros introducidos son correctos, devuelve el valor de la variable que saldrá en esta iteración, o None, en caso de que todos los valores sean Nan. En caso de no recibir como parámetro un array de numpy, devolverá None. Ejemplos:
Can you write Python code for it?

outputRuleValues=np.array([rational(1,2),rational(-3,-2),rational(0,1),rational(5,7)])
columnsOfIteration=np.array([0,2,3])
Simplex.calculateVarWhichExit(columnsOfIteration,outputRuleValues)

#Si los valores de la regla de salida, son todos negativos o divididos por 0, es decir, le pasamos Nan, devuelve None
outputRuleValues=np.array([np.nan,np.nan,np.nan,np.nan])
print(Simplex.calculateVarWhichExit(columnsOfIteration,outputRuleValues))

# Si recibe algo que no es un array de numpy en ambos parámetros, devuelve None
outputRuleValues=np.array([1,-3,0,5])
print(Simplex.calculateVarWhichExit(4,outputRuleValues))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateWhichAreArtificialVariables
Este método recibe un array de numpy, que contiene los coeficientes de la función objetivo, con las variables artificiales incluidas(en orden), y un número que representa el número de variables artificiales que hay. Si los parámetros son correctos, devolverá cuáles son las variables artificiales. El método funciona tanto con elementos rational, como con enteros. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

vector=np.array([3,4,5,6,-20,-40])
numOfArtificialVariables= 2
Simplex.calculateWhichAreArtificialVariables(vector,numOfArtificialVariables)

# Si no se han incluido las variables artificiales, supone que son las últimas
vector=np.array([3,4,5,6])
numOfArtificialVariables= 2
Simplex.calculateWhichAreArtificialVariables(vector,numOfArtificialVariables)

vector=np.array([rational(3,2),rational(4,4),rational(5,6),rational(6,9),rational(-20,1),rational(-40,1)])
numOfArtificialVariables= 2
Simplex.calculateWhichAreArtificialVariables(vector,numOfArtificialVariables)

#Si se introduce algo que no es un array de numpy en el primer valor, o algo que no es un número en el segundo, devuelve None
numOfArtificialVariables= 2
print(Simplex.calculateWhichAreArtificialVariables(2,numOfArtificialVariables))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateYValues
Este método calcula los valores de y, para una iteración. Para ello recibe la base de la iteración en una matriz numpy, la matriz total que contiene todas las restricciones del problema (sin signo, ni recursos) en una matriz numpy y las variables que no pertenecen a la iteración, en un array numpy. Los elementos de ambas matrices, deben ser rational. Si todos los parámetros introducidos son correctos, se devuelve en un array de numpy los valores, de cada una de las y para la iteración. En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

variablesNoIteration=np.array([3,4])
iterationBase=np.matrix([[rational(6,7),rational(4,5),rational(3,1)],[rational(2,3),rational(7,6),
                    rational(1,3)], [rational(4,1),rational(6,4),rational(9,2)]])
totalMatrix=np.matrix([[rational(6,7),rational(4,5),rational(3,1),rational(5,3),rational(2,1)],[rational(2,3),rational(7,6),
                    rational(1,3),rational(2,5),rational(9,5)], [rational(4,1),rational(6,4),rational(9,2),rational(4,5),
                    rational(3,1)]])
print(Simplex.printMatrix(Simplex.calculateYValues(variablesNoIteration,iterationBase,totalMatrix)))

#Si el número de variables fuera de la iteración, es mayor que el número total de variables, se devuelve None
variablesNoIteration=np.array([0,1,2,3,4,5])
print(Simplex.calculateYValues(variablesNoIteration,iterationBase,totalMatrix))

#Si el la base tiene más o menos filas, que la matriz total, devuelve None
variablesNoIteration=np.array([3,4])
iterationBase=np.matrix([[rational(6,7),rational(4,5),rational(3,1)], [rational(4,1),rational(6,4),rational(9,2)]])
totalMatrix=np.matrix([[rational(6,7),rational(4,5),rational(3,1),rational(5,3),rational(2,1)],[rational(2,3),rational(7,6),
                    rational(1,3),rational(2,5),rational(9,5)], [rational(4,1),rational(6,4),rational(9,2),rational(4,5),
                    rational(3,1)]])
print(Simplex.calculateYValues(variablesNoIteration,iterationBase,totalMatrix))

#Si se introduce algo que no sea una matriz numpy de rational en el segundo y tercer parámetro, o un array numpy en el primer
# parámetro, devuelve None

print(Simplex.calculateYValues(variablesNoIteration,4,totalMatrix))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
calculateZC
Este método calcula los valores de la regla de entrada, y los devuelve en un array de numpy. Para ello recibe el vector de la función completo, en un array de numpy; las variables que no están dentro de la iteración, en un array de numpy; el vector de la función para la iteración, en un array de numpy y por último, los valores de y para la iteración, en un numpy array. Todos los arrays deben tener elementos rational, excepto en el de las variables que no están en la iteración. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

functionVector= np.array([rational(1,1),rational(3,1),rational(4,1),rational(5,1),rational(5,1)])
variablesNoIteration= np.array([0,2,3])
CB = np.array([rational(2,1),rational(0,1)])
y = np.array([[rational(2,1),rational(1,1)],[rational(-1,1),rational(-3,1)],[rational(1,1),rational(1,1)],[rational(0,1)
                                                                                ,rational(-1,1)]])
print(Simplex.printMatrix(np.asmatrix(Simplex.calculateZC(functionVector,variablesNoIteration,CB,y))))

# Si se le pasa algo que no es un array numpy en cualquiera de los parámetros, devuelve None
print(Simplex.calculateZC(89,variablesNoIteration,CB,y))

# Si el tamaño del vector de recursos para la iteración, es mayor que el tamaño de los resultados de y, devuelve None
functionVector= np.array([rational(1,1),rational(3,1),rational(4,1),rational(5,1),rational(5,1)])
variablesNoIteration= np.array([0,2,3])
CB = np.array([rational(2,1),rational(0,1),rational(3,2),rational(2,1),rational(4,3)])
y = np.array([[rational(2,1),rational(1,1)],[rational(-1,1),rational(-3,1)],[rational(1,1),rational(1,1)],[rational(0,1)
                                                                                ,rational(-1,1)]])
print(Simplex.calculateZC(functionVector,variablesNoIteration,CB,y))

# Si hay más variables fuera de la iteración que variables en el vector de función total,se devuelve None
functionVector= np.array([rational(1,1),rational(3,1),rational(4,1),rational(5,1),rational(5,1)])
variablesNoIteration= np.array([0,1,2,3,4,5,6])
CB = np.array([rational(2,1),rational(0,1)])
y = np.array([[rational(2,1),rational(1,1)],[rational(-1,1),rational(-3,1)],[rational(1,1),rational(1,1)],[rational(0,1)
                                                                                ,rational(-1,1)]])
print(Simplex.calculateZC(functionVector,variablesNoIteration,CB,y))

# Si el tamaño del vector función para la iteración es mayor que el del vector total...


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
centre
Este método recibe una lista de puntos, y devuelve el punto que está en el centro del polígono que forman dichos puntos. Las coordenadas de los puntos deben ser rational. En caso de no pasar una lista de puntos rational, devuelve None. Ejemplos:
Can you write Python code for it?

points=[(rational(4,5),rational(1,2)),(rational(4,2),rational(3,1)),(rational(8,3),rational(3,5)),(rational(7,2),rational(4,5)),
        (rational(7,9),rational(4,9)),(rational(9,8),rational(10,7))]
point=Simplex.centre(points)
print("("+str(point[0])+","+str(point[1])+")")

# Si recibe algo que no es una lista de puntos rational, devuelve None
points=[(4.0,5.0),(4.0,3.0),(8.0,5.0),(7.0,4.0),(7.0,9.0),(10.0,4.0)]
print(Simplex.centre(points))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
checkIfIsSolution
Este método recibe una restricción, con los coeficentes de la misma en una array de numpy, la solución a probar en una tupla, el signo en un string y el recurso en un número. El método devuelve True, si la solución satisface la restricción, o False si no la satisface. El método funciona con enteros y rational, perfectamente, pero con float, no es del todo exacto. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# Si cumple la inecuación
inecuation=np.array([3,4])
solution=(1,1)
sign=">="
resource=6
Simplex.checkIfIsSolution(inecuation, solution, sign, resource)

# Con rational también funciona
inecuation=np.array([rational(3,2),rational(4,3)])
solution=(rational(2,1),rational(1,1))
sign="<="
resource=rational(5,1)
Simplex.checkIfIsSolution(inecuation, solution, sign, resource)

# Si la inecuación no se cumple
inecuation=np.array([3,4])
solution=(1,1)
sign="="
resource=6
Simplex.checkIfIsSolution(inecuation, solution, sign, resource)

# No funciona exactamente con float
inecuation=np.array([3.0,4.0])
solution=(1.0,1.0)
sign="="
resource=7.00001
Simplex.checkIfIsSolution(inecuation, solution, sign, resource)

# Si se introduce algo que no se un array de numpy de longitud 2 en el primer parámetro, una tupla en el segundo, un string en el
# tercero o un número en el último, devuelve None
print(Simplex.checkIfIsSolution(inecuation, solution, sign,np.array([3,4])))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
convertFunctionToMax
Este método recibe un string que contiene la función objetivo del problema en el siguiente formato:
max/min 2 -3
El método devuelve en un array de numpy de elementos rational con los coeficientes de la función, en forma de maximización, puesto que es como se utiliza en la forma estándar, luego si introduzco una función de minimización, me devolverá los coeficientes cambiados de signo. En caso de que lo que le pase no sea un string, devuelve None. Ejemplo:
Can you write Python code for it?

function="max 2 -3"
print(Simplex.printMatrix(np.asmatrix(Simplex.convertFunctionToMax(function))))

function="min 2 -3\n"
print(Simplex.printMatrix(np.asmatrix(Simplex.convertFunctionToMax(function))))

# Si recibe algo que no es un string devuelve None
function="min 2 -3\n"
print(Simplex.convertFunctionToMax(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
convertLineToRationalArray
Este método recibe un string, que contiene un conjunto de números separados por un espacio, y devuelve los números en un array de numpy con elementos rational.Si no recibe un string, devuelve None. Ejemplos:
Can you write Python code for it?

line="3 4 5"
print(Simplex.printMatrix((np.asmatrix(Simplex.convertLineToRationalArray(line)))))

line="3 4/5 5"
print(Simplex.printMatrix((np.asmatrix(Simplex.convertLineToRationalArray(line)))))

# Si se le pasa algo que no es un string, devuelve None
print(Simplex.convertLineToRationalArray(4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
deleteLinePointsOfList
Este método recibe un conjunto de puntos en una lista, un array de numpy con un conjunto de restricciones sin signos, ni recursos, y un array de numpy con los recursos de las restricciones. El método devuelve la lista de puntos, pero sin aquellos puntos que están en la línea que representa alguna de las restricciones introducidas. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# Elimina el último punto que está en una línea
listPoints=[(rational(3,1),rational(5,7)),(rational(5,8),rational(6,2)),(rational(4,6),rational(8,9)),(rational(8,1),
                                                                                rational(2,1))]
matrix=np.array([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
Simplex.deleteLinePointsOfList(listPoints, matrix, resources)

# Si recibe algo que no es una lista de puntos con coordenadas rational,o algo que no es un array de numpy con elementos rational
# en el segundo y tercer parámetro,devuelve None
print(Simplex.deleteLinePointsOfList(listPoints, 4, resources))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
dualProblem
Este método recibe un problema de programación lineal y devuelve el problema dual del pasado por parámetro. Para ello, recibe una matriz de numpy con elementos rational que contiene las restricciones, sin signos ni recursos, un array de numpy  con elementos rational que contiene los recursos, una lista de strings, que contienen los signos de las restricciones y un string que contiene la función en el formato "max/min 2 -3". El método devuelve el problema dual en este orden una matriz de numpy que contiene las restricciones, sin signos ni recursos, un array de numpy que contiene los recursos, una lista de strings, que contienen los signos de las restricciones y un string que contiene la función en el formato "max/min 2 -3".  No es necesario que se introduzca el problema en forma estándar(tampoco en forma simétrica de maximización) puesto que el método ya realiza la transformación internamente.  En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
sign=["<=","<=",">="]
function="max 2 1"
dual=Simplex.dualProblem(matrix,resources,sign,function)
print(Simplex.printMatrix(dual[0]))
print(Simplex.printMatrix(np.asmatrix(dual[1])))
print(dual[2])
print(dual[3])

# Si la longitud del vector de recursos, es diferente del número de filas de la matriz, devuelve None
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1)])
sign=["<=","<=",">="]
function="max 2 1"
print(Simplex.dualProblem(matrix,resources,sign,function))

# Si el número de signos es diferente a la longitud del vector de recursos o diferente del número de filas de la matriz,
# devuelve None
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
sign=["<=","<=",">=","<="]
function="max 2 1"
print(Simplex.dualProblem(matrix,resources,sign,function))

# Si se pasa por parámetro algo que no es una matriz de numpy con elementos rational en el primer parámetro, algo que no es un
# array de numpy  con elementos rational en el segundo,algo que no es una lista de strings en el tercero o algo que no es un
# string en el cuarto
matrix=np.matrix([[2,1,4],[6,-4,-7],[8,12,9]])
resources=np.array([[1],[8],[10]])
sign=["<=","<=",">="]
function="min 3 10 0"
print(Simplex.dualProblem(matrix,resources,sign,function))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
eliminateNegativePoints
Este método recibe una lista de puntos cuyas coordenadas son rational, y devuelve la lista, sin aquellos puntos con coordenadas negativas. Si recibe algo que no es una lista de puntos rational, devuelve None. Ejemplos:
Can you write Python code for it?

points=[(rational(4,2),rational(-3,4)),(rational(5,4),rational(6,-8)),(rational(1,4),rational(6,1))]
Simplex.eliminateNegativePoints(points)

# Si recibe algo que no es una lista de puntos rational, devuelve None
points=[(4,2),(6,-8),(6,1)]
print(Simplex.eliminateNegativePoints(points))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
identityColumnIsInMatrix
Este método recibe una matriz de numpy con elementos rational, y un número que se corresponde, con el índice de una columna de la matriz identidad. Si todos los parámetros son correctos, devolverá el índice de la columna de la matriz pasada, donde se encuentra la columna de la matriz identidad. En caso de que la columna de la matriz identidad indicada no se encuentre en la matriz, devolverá None. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(3,2),rational(0,1),rational(1,1)],[rational(3,5),rational(4,5),rational(0,1)],[rational(5,6),
            rational(7,8),rational(0,1)]])
column=0
'''Se busca la columna 0 de la matriz identidad: [[1],
                                                  [0],
                                                  [0]]'''
Simplex.identityColumnIsInMatrix(matrix,column)

# Si la columna de la matriz identidad no está en la matriz, devuelve None
column=2
print(Simplex.identityColumnIsInMatrix(matrix,column))

# Si la columna pasada, aparece más de una vez, devolverá la primera
matrix=np.matrix([[rational(1,1),rational(0,1),rational(1,1)],[rational(0,1),rational(4,5),rational(0,1)],[rational(0,1),
            rational(7,8),rational(0,1)]])
column=0
Simplex.identityColumnIsInMatrix(matrix,column)

# Si se pasa un número mayor o igual que el número de columnas que tiene la matriz, devuelve None
matrix=np.matrix([[rational(1,1),rational(0,1),rational(1,1)],[rational(0,1),rational(4,5),rational(0,1)],[rational(0,1),
            rational(7,8),rational(0,1)]])
column=4
print(Simplex.identityColumnIsInMatrix(matrix,column))

# Si se pasa algo que no es una matriz de numpy con elementos rational en el primer parámetro o algo que no es un número en el
# segundo parámetro, devuelve None
print(Simplex.identityColumnIsInMatrix(matrix,"[2,3]"))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
initializeMatrix
Este método recibe unas dimensiones y devuelve una matriz de numpy, con elementos rational,de valor 0. Si los valores introducidos no son enteros, devuelve None. Ejemplos:
Can you write Python code for it?

m=Simplex.initializeMatrix(3, 2)
print(Simplex.printMatrix(m))

# Si se introduce algo que no son enteros, devuelve None
print(Simplex.initializeMatrix(4.0,3.0))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
invertSign
Este método recibe un string que contiene un signo (debe ser <,<=,>,>=,=) y devuelve en otro string su signo opuesto. En caso de no recibir un string por parámetro, devuelve None. Ejemplos:
Can you write Python code for it?

previousSign="<"
Simplex.invertSign(previousSign)

previousSign=">"
Simplex.invertSign(previousSign)

previousSign="<="
Simplex.invertSign(previousSign)

previousSign=">="
Simplex.invertSign(previousSign)

previousSign="="
Simplex.invertSign(previousSign)

#Si introduzco algo que no sea un string, me devuelve None
previousSign=3
print(Simplex.invertSign(previousSign))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isAListOfPoints
Este método recibe una lista, y devuelve True, si todos los elementos son puntos(tuplas) o False, si hay algún elemento que no es un punto. En caso de no pasar una lista, devuelve None. Ejemplos:
Can you write Python code for it?

# Si todos los elementos son puntos(tuplas), devuelve True
lis=[(3,4),(5,6),(7,8),(8,10)]
Simplex.isAListOfPoints(lis)

# Si recibe una lista cuyos elementos, no son todos puntos(tuplas), devuelve False
lis=[3,5,6,(6,7)]
Simplex.isAListOfPoints(lis)

# Si recibe algo que no es una lista devuelve None
print(Simplex.isAListOfPoints(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isAListOfRationalPoints
Este método recibe una lista, y devuelve True, si todos los elementos son puntos(tuplas)con coordenadas rational o False, si hay algún elemento que no es un punto cuyas coordenadas sean rational. En caso de no pasar una lista, devuelve None. Ejemplos:
Can you write Python code for it?

lis=[(rational(1,2),rational(5,7)),(rational(4,5),rational(4,6)),(rational(4,9),rational(9,8))]
Simplex.isAListOfRationalPoints(lis)

lis=[(rational(1,2),rational(5,7)),(4,rational(4,6)),(rational(4,9),rational(9,8))]
Simplex.isAListOfRationalPoints(lis)

# Si recibe algo que no es una lista devuelve None
lis=np.array([(rational(1,2),rational(5,7)),(4,rational(4,6)),(rational(4,9),rational(9,8))])
print(Simplex.isAListOfRationalPoints(lis))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isARationalArray
Este método recibe un array de numpy, y comprueba si todos los elementos del mismo, son rational, en ese caso devuelve True. En otro caso devuelve False. Si no recibe una matriz o un array de numpy, devuelve None. Ejemplos:
Can you write Python code for it?

arr=np.array([rational(1,2),rational(5,7),rational(4,5)])
Simplex.isARationalArray(arr)

arr=np.array([rational(1,2),6,rational(4,5)])
Simplex.isARationalArray(arr)

# Si recibe algo que no es una matriz o un array de numpy
arr=[rational(1,2),rational(5,7),rational(4,5)]
print(Simplex.isARationalArray(arr))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isARationalMatrix
Este método recibe una matriz de numpy o un array bidimensional de numpy, y comprueba si todos los elementos del mismo, son rational, en ese caso devuelve True. En otro caso devuelve False. Si no recibe una matriz o un array de numpy, devuelve None. Ejemplos:
Can you write Python code for it?

mat=np.matrix([[rational(1,2),rational(5,7)],[rational(5,8),rational(9,3)]])
Simplex.isARationalMatrix(mat)

mat=np.array([[rational(1,2),rational(5,7)],[rational(5,8),rational(9,3)]])
Simplex.isARationalMatrix(mat)

mat=np.matrix([[1,rational(5,7)],[rational(5,8),rational(9,3)]])
Simplex.isARationalMatrix(mat)

# Si recibe algo que no es una matriz o un array de numpy
mat=[rational(1,2),rational(5,7)]
print(Simplex.isARationalMatrix(mat))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isStringList
Este método recibe una lista y comprueba si todos los elementos de la misma son strings, en ese caso devuelve True. Si algún elemento de la lista no es un string devuelve False.Se utiliza principalmente para comprobar que los parámetros de entrada de algunos métodos son correctos. En caso de no introducir una lista, devuelve None. Ejemplos:
Can you write Python code for it?

lis=["hola","adios","hasta luego"]
Simplex.isStringList(lis)

lis=["hola",4,"hasta luego"]
Simplex.isStringList(lis)

# Si recibe algo que no es una lista, devuelve None
print(Simplex.isStringList(4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
isThePoint
Este método recibe una lista de puntos, cuyas coordenadas son rational, un valor, que es el cálculo de la distancia al centro, y el centro de los puntos de la lista. El método devuelve el punto de la lista cuya distancia al centro, es el valor introducido. Si ningún punto, cumple la distancia devuelve None. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

listPoints=[(rational(4,5),rational(1,2)),(rational(4,2),rational(3,1)),(rational(8,3),rational(3,5)),(rational(7,2)
        ,rational(4,5)),(rational(7,9),rational(4,9)),(rational(9,8),rational(10,7))]
M = (1.811574074074074,1.1288359788359787)
value =  2.7299657524245156
point=Simplex.isThePoint(listPoints, value, M)
print("("+str(point[0])+","+str(point[1])+")")

# En caso de no recibir una lista de puntos rational, en el primer parámetro, un número en el segundo o una tupla en el tercero,
# devuelve None(ver si coge float en el centro)
print(Simplex.isThePoint(listPoints, value, 4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
multMatrix
Este método recibe dos matrices de numpy, con componentes rational, y devuelve la matriz resultado del producto de las dos matrices introducidas. Si el número de columnas de la primera matriz, y el número de filas de la segunda, no son iguales, las matrices no se pueden multiplicar y devuelve None. Si se introduce algo que no es una matriz de numpy, con elementos rational, devuelve None. Ejemplos:
Can you write Python code for it?

matrix1=np.matrix([[rational(4,7),rational(8,9),rational(2,5)],[rational(2,4),rational(3,4),rational(7,5)]])
matrix2=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
m=Simplex.multMatrix(matrix1, matrix2)
print(Simplex.printMatrix(m))

# Si el número de columnas de la primera matriz, y el número de filas de la segunda, no son iguales, devuelve None
matrix1=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
matrix2=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
print(Simplex.multMatrix(matrix1, matrix2))

# Si recibe algo que no es una matriz de numpy, con elementos rational, devuelve None
matrix1=np.array([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
matrix2=np.array([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
print(Simplex.multMatrix(matrix1, matrix2))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
multNumMatrix
Este método recibe un número en forma rational y una matriz de numpy, con componentes rational, y devuelve la matriz del producto del número por  la matriz introducida.Si se introduce algo que no es un rational como número o una matriz de numpy, con elementos rational,como matriz, devuelve None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
num= rational(3,4)
m = Simplex.multNumMatrix(num, matrix)
print(Simplex.printMatrix(m))

# Si recibe algo que no es una matriz de numpy, con elementos rational, devuelve None
num = 4
print(Simplex.multNumMatrix(num, matrix))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
negativeToPositiveResources
Este método se utiliza para cambiar a positivos, los recursos que sean negativos, ya que esto no debe darse. Para ello, realiza las transformaciones necesarias, devolviendo un matriz de numpy con elementos rational que contiene las restricciones, un array de numpy con elementos rational que contiene los recursos, y una lista de strings con los signos de cada restricción, con todos los cambios ya realizados. Los parámetros de entrada son los mismos que las salidas que proporciona, pero con las transformaciones sin realizar, es decir, una matriz de numpy, un array de numpy y una lista de strings. Para los recursos que sean positivos, no se realiza transformación alguna, sino que simplemente devuelve lo que recibe. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(1,2),rational(2,3),rational(4,9)],[rational(4,3),rational(6,2),rational(7,4)],
                  [rational(3,1),rational(4,2),rational(6,4)]])
resources=np.array([rational(1,4),rational(-4,1),rational(5,2)])
sign=["<=","<",">"]
std=Simplex.negativeToPositiveResources(matrix,resources,sign)
print(Simplex.printMatrix(std[0]))
print(Simplex.printMatrix(np.asmatrix(std[1])))
print(std[2])

matrix=np.matrix([[rational(1,2),rational(2,3),rational(4,9)],[rational(4,3),rational(6,2),rational(7,4)],
                  [rational(3,1),rational(4,2),rational(6,4)]])
resources=np.array([rational(1,4),rational(4,1),rational(5,2)])
sign=["<=","<",">"]
std=Simplex.negativeToPositiveResources(matrix,resources,sign)
print(Simplex.printMatrix(std[0]))
print(Simplex.printMatrix(np.asmatrix(std[1])))
print(std[2])

# Si la longitud del vector de recursos, es diferente del número de filas de la matriz, devuelve None
matrix=np.matrix([[rational(1,2),rational(2,3),rational(4,9)],[rational(4,3),rational(6,2),rational(7,4)],
                  [rational(3,1),rational(4,2),rational(6,4)]])
resources=np.array([rational(1,4),rational(-4,1)])
sign=["<=","<",">"]
std=Simplex.negativeToPositiveResources(matrix,resources,sign)
print(Simplex.negativeToPositiveResources(matrix,resources,sign))

# Si el número de signos es diferente a la longitud del vector de recursos o diferente del número de filas de la matriz,
# devuelve None
matrix=np.matrix([[rational(1,2),rational(2,3),rational(4,9)],[rational(4,3),rational(6,2),rational(7,4)],
                  [rational(3,1),rational(4,2),rational(6,4)]])
resources=np.array([rational(1,4),rational(-4,1),rational(5,2)])
sign=["<=","<"]
std=Simplex.negativeToPositiveResources(matrix,resources,sign)
print(Simplex.negativeToPositiveResources(matrix,resources,sign))

# Si se pasa por parámetro algo que no es una matriz de numpy con elementos rational en el primer parámetro, algo que no es un
# array de numpy con elementos rational en el segundo, o algo que no es una lista de...


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
omitComments
Este método recibe una lista de strings, y lo que hace es eliminar aquellas ocurrencias que comiencen por el caracter "//" o "#". También en aquellas ocurrencias que estos caracteres aparezcan en cualquier parte de la cadena, elimina la subcadena a partir de estos caracteres. Devolverá la lista, ya con estas ocurrencias eliminadas. Se utiliza para eliminar comentarios. En caso de recibir algo que no sea una lista, devuelve None.Ejemplos:
Can you write Python code for it?

listOfstrings=["//hola","2 3 4 <=4 //first","#hola","adios"]
Simplex.omitComments(listOfstrings)

# En caso de no recibir una lista de strings, devuelve None
print(Simplex.omitComments([5,3]))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
proccessFile
Este método recibe un archivo por parámetro, que debe contener un problema de programación lineal en el siguiente formato:
Y devuelve en este orden, la matriz de restricciones en una matriz numpy,el vector de recursos en un array de numpy, los signos de las restricciones en una lista de strings y un string que contiene la función objetivo a optimizar. Para ver como abrir un archivo consultar los ejemplos. Si se le pasa algo que no es un archivo, devuelve None Ejemplos:
Can you write Python code for it?

# Introducir aquí la ruta del archivo a abrir
file = open('../Files/file2.txt','r')
problem=Simplex.proccessFile(file)
print(Simplex.printMatrix(problem[0]))
print(Simplex.printMatrix(np.asmatrix(problem[1])))
print(problem[2])
print(problem[3])

#En caso de que se le pase algo que no sea un archivo, devuelve None
print(Simplex.proccessFile(4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showBase
Este método recibe una matriz numpy con elementos rational, que se supone que será la base de una iteración, acompañado del nombre que se le quiera asignar, y la muestra por pantalla, con el nombre que se le asigna (B), dentro de la iteración. En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

base=np.matrix([[rational(6,7),rational(4,5),rational(3,1)],[rational(2,3),rational(7,6),rational(1,3)],
                  [rational(4,1),rational(6,4),rational(9,2)]])
Simplex.showBase(base,"B")

#Si se le pasa algo que no es una matriz de numpy con elementos rational en el primer parámetro, o un string en el segundo, me
# devuelve None
print(Simplex.showBase(3,"B"))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showCB
Este método, recibe un array numpy de elementos rational, que contiene el valor del vector función, y simplemente lo muestra por pantalla, con el correspondiente nombre que se le asigna("CB"). En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

CBValue= np.array([rational(0,1),rational(2,3),rational(5,5)])
Simplex.showCB(CBValue)

#Si se le pasa algo que no es un array numpy de elementos rational, devuelve None
CBValue= np.array([0,1,4,6])
print(Simplex.showCB(CBValue))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showExitValues
Este método recibe en un array de numpy con elementos rational los valores de la regla de salida, y los muestra por pantalla, acompañados de el nombre que reciben("O"), y de cuál será el criterio de elección del valor de salida(min). En caso de que no reciba un array de numpy, devuelve None. Ejemplos:
Can you write Python code for it?

exitValues=np.array([rational(1,2),rational(-3,2),rational(0,1),rational(5,2)])
Simplex.showExitValues(exitValues)

#Si recibe algo que no es una array de numpy con elementos rational, devuelve None
exitValues=np.array([1,-3,0,5])
print(Simplex.showExitValues(exitValues))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showFunctionValue
Este método recibe una matriz numpy que contiene la solución de la función, para la iteración, y la muestra por pantalla con su nombre("z"). El método funciona tambiñen si se pasa la matriz con elementos rational En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

functionValue=np.matrix([34])
Simplex.showFunctionValue(functionValue)

# El método funciona también con metrices rational
functionValue=np.matrix([rational(34,1)])
Simplex.showFunctionValue(functionValue)

#En caso de recibir algo que no es una matriz numpy, devuelve None
functionValue=np.matrix([34])
print(Simplex.showFunctionValue(4))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showIterCol
Este método recibe un array de numpy con las columnas o variables de la iteración, y simplemente las muestra por pantalla, acompañado de una indicación de que esas son las variables de la iteración. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

columnsOfIteration=np.array([3,4,5])
Simplex.showIterCol(columnsOfIteration)

# Si recibe algo que no sea un array de numpy, devuelve None
print(Simplex.showIterCol(3))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showNextIteration
Este método muestra mediante una explicación, cuál es la solución dada por el método anterior. Si recibe True, muestra la explicación para cuando el problema no ha terminado, y hay más iteraciones; si recibe False, muestra la expliación para cuando el problema ha terminado y si recibe -1, muestra la explicación para cuando hay infinitas soluciones. En caso de que reciba algo distinto a esto, devuelve None. Ejemplos:
Can you write Python code for it?

Simplex.showNextIteration(True)

Simplex.showNextIteration(False)

Simplex.showNextIteration(-1)

# Si recibe algo distinto a True,False o -1, devuelve None
print(Simplex.showNextIteration(-2))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showOValue
Este método recibe el valor de O, y simplemente lo muestra por pantalla, con su nombre asociado("O"). En caso de no recibir un número por parámetro, devuelve None. Ejemplos:
Can you write Python code for it?

O = 3
Simplex.showOValue(O)

O = rational(3,4)
Simplex.showOValue(O)

#Si lo que recibe por parámetro no es un nuúmero, devuelve None
print(Simplex.showOValue([4,3]))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showSolution
Este método recibe la solución de una iteración, y la muestra con el nombre que se le asigna en ella ("x"). La solución deberá ser pasada en un numpy array en forma de columna con elementos rational. En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

sol=np.array([[rational(2,2)],[rational(5,3)],[rational(6,1)],[rational(7,8)]])
Simplex.showSolution(sol)

#Si le paso algo que no es un array numpy con elementos rational, me devuelve None
sol=np.array([[2],[5],[6],[7]])
print(Simplex.showSolution(sol))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showStandarForm
Este método recibe una matriz de numpy con elementos rational que es la matriz de coeficientes, un array de numpy con elementos rational que es el vector de recursos y un array de numpy con elementos rational que es el vector de la función a optimizar. Todos los parámetros son introducidos en forma estándar y son mostrados, en un formato más visual. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

matrix=np.matrix([[rational(3,1),rational(2,1),rational(1,1)],[rational(2,1),rational(5,1),rational(3,1)]])
resources=np.array([rational(10,1),rational(15,1)])
function=np.array([rational(14,6),rational(25,2)])
Simplex.showStandarForm(matrix,resources,function)

# Si recibe algo que no es una matriz de numpy con elementos rational, en el primer parámetro, algo que no es un array de numpy
# con elementos rational en el segundo y tercer parámetro, devuelve None
function=np.array([3,4])
print(Simplex.showStandarForm(matrix,resources,function))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showVarWhichEnter
Este método recibe la variable que entra y la muestra por pantalla, indicando que esa es la variable que entra. En caso de no recibir un número por parámetro, devuelve None. Ejemplos:
Can you write Python code for it?

variableWhichEnter= 2
Simplex.showVarWhichEnter(variableWhichEnter)

#Si lo que recibe por parámetro no es un número, devuelve None
print(Simplex.showVarWhichEnter("adsf"))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
showYValues
Este método recibe un array numpy que contiene las variables que no pertenecen a la iteración, y los valores de y en un array de numpy con elementos rational, y los muestra por pantalla con su nombre("y"+número de la variable). En caso de que los parámetros introducidos no sean correctos, devolverá None. Ejemplos:
Can you write Python code for it?

variablesNoIteration=np.array([1,3])
y = np.array([[rational(2,3),rational(4,6)],[rational(3,2),rational(4,1)]])
Simplex.showYValues(variablesNoIteration,y)

#Si se pasa algo que no sea un array numpy en cualquiera de los dos parámetros,siendo el segundo de elementos rational,
# devuelve None
print(Simplex.showYValues(690,y))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
solveIteration
Este método recibe por parámetro la matriz completa de las restricciones del problema(sin signos ni recursos) en una matriz de numpy, y luego recibe tres arrays de numpy, que contienen el vector de recursos,el valor de todas las variables en la función, y las columnas o variables de la presente iteración. Los elementos de la matriz, los recursos y el vector de la función deben ser rational. En caso de que todos los parámetros introducidos sean correctos, muestra por pantalla el desarrollo de la iteración, y finalmente devuelve, la solución de la iteración,el valor de la función para la iteración, cuál sería la variable que entraría, cuál la variable que saldría y un valor que indica si habría más iteraciones(True),no hay más iteraciones(False) o el número de soluciones es elevado(-1). En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

totalMatrix= np.matrix([[rational(-1,1),rational(4,1),rational(5,1),rational(7,1),rational(0,1),rational(0,1)],[rational(4,1),
            rational(6,1),rational(7,1),rational(0,1),rational(1,1),rational(0,1)],[rational(7,1),rational(-2,1),rational(-3,1)
            ,rational(9,1),rational(0,1), rational(1,1)]])
functionVector =np.array([rational(2,1),rational(-3,1),rational(5,1),rational(0,1),rational(0,1),rational(1,1)])
b = np.array([rational(2,1),rational(4,1),rational(1,1)])
columnsOfIteration=np.array([3,4,5])
Simplex.solveIteration(totalMatrix,b,functionVector,columnsOfIteration)

# Si hay distinto número de recursos(b), que restricciones, devuelve None
totalMatrix= np.matrix([[rational(-1,1),rational(4,1),rational(5,1),rational(7,1),rational(0,1),rational(0,1)],[rational(4,1),
            rational(6,1),rational(7,1),rational(0,1),rational(1,1),rational(0,1)],[rational(7,1),rational(-2,1),rational(-3,1)
            ,rational(9,1),rational(0,1), rational(1,1)]])
functionVector =np.array([rational(2,1),rational(-3,1),rational(5,1),rational(0,1),rational(0,1),rational(1,1)])
b = np.array([[rational(2,1)],[rational(4,1)]])
columnsOfIteration=np.array([3,4,5])
print(Simplex.solveIteration(totalMatrix,b,functionVector,columnsOfIteration))

# Si la función tiene diferente número de variables que las restricciones, devuelve None
totalMatrix= np.matrix([[rational(-1,1),rational(4,1),rational(5,1),rational(7,1),rational(0,1),rational(0,1)],[rational(4,1),
            rational(6,1),rational(7,1),rational(0,1),rational(1,1),rational(0,1)],[rational(7,1),rational(-2,1),rational(-3,1)
            ,rational(9,1),rational(0,1), rational(1,1)]])
functionVector =np.array([rational(2,1),rational(-3,1),rational(5,1),rational(0,1)])
b = np.array([[rational(2,1)],[rational(4,1)],[rational(1,1)]])
columnsOfIteration=np.array([3,4,5])
print(Simplex.solveIteration(totalMatrix,b,functionVector,columnsOfIteration))

# Si el número de columnas o variables de la iteración, no se corresponde con el número de restricciones, devuelve...


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
solveProblem
Este método resuelve el problema de programación lineal que se le pasa por parámetro. Para ello, recibe una matriz de numpy con elementos rational que contiene las restricciones, sin signos ni recursos, un array de numpy con elementos rational que contiene los recursos, una lista de strings, que contienen los signos de las restricciones, un string que contiene la función en el formato "max/min 2 -3" y un valor True o False, que determina si se quiere obtener también la solución del problema dual al introducido. El método devuelve en este orden la solución del problema(valor de las variables),el valor de la función objetivo para esa solución, una explicación del tipo de problema y el valor de las variables de la solución del problema dual, en caso de que se introduzca True, como último parámetro. No es necesario que se introduzca el problema en forma estándar puesto que el método ya realiza la transformación internamente.En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

# Si se pasa False no devuelve la solución dual
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
signs=["<=","<=",">="]
function="max 2 1"
solutionOfDualProblem=False
sol=Simplex.solveProblem(matrix,resources,sign,function,solutionOfDualProblem)
print(Simplex.printMatrix(np.asmatrix(sol[0])))
print(Simplex.printMatrix(sol[1]))
print(sol[2])

# Si se pasa True devolverá la soución dual
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
signs=["<=","<=",">="]
function="max 2 1"
solutionOfDualProblem=True
sol=Simplex.solveProblem(matrix,resources,sign,function,solutionOfDualProblem)
print(Simplex.printMatrix(np.asmatrix(sol[0])))
print(Simplex.printMatrix(sol[1]))
print(sol[2])
print(Simplex.printMatrix(np.asmatrix(sol[3])))

# Si la longitud del vector de recursos, es diferente del número de filas de la matriz, devuelve None
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1)])
signs=["<=","<=",">="]
function="max 2 1"
solutionOfDualProblem=True
print(Simplex.solveProblem(matrix,resources,sign,function,solutionOfDualProblem))

# Si el número de signos es diferente a la longitud del vector de recursos o diferente del número de filas de la matriz,
# devuelve None
matrix=np.matrix([[rational(2,1),rational(1,1)],[rational(1,1),rational(-1,1)],[rational(5,1),rational(2,1)]])
resources=np.array([rational(18,1),rational(8,1),rational(0,1)])
sign=["<=","<=",">=","="]
function="max 2 1"
solutionOfDualProblem=True
print(Simplex.solveProblem(matrix,resources,sign,function,solutionOfDualProblem))

# Si se pasa por parámetro algo que no es una matriz de numpy con elementos rational en el primer parámetro, algo que no es un
# array de numpy con elementos rational en el...


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
thereIsAnotherIteration
Este método recibe los valores de la regla de entrada en un array de numpy. Devuelve True, si hay otra iteración; -1, si hay infinitas soluciones o False, si no hay más iteraciones. El método funciona tanto con elementos rational, como con elementos enteros. En caso de que los parámetros introducidos no sean correctos(ver ejemplos), devolverá None. Ejemplos:
Can you write Python code for it?

inputRuleValues=np.array([3,-6])
Simplex.thereIsAnotherIteration(inputRuleValues)

inputRuleValues=np.array([0,-6])
Simplex.thereIsAnotherIteration(inputRuleValues)

inputRuleValues=np.array([0,6])
Simplex.thereIsAnotherIteration(inputRuleValues)

inputRuleValues=np.array([1,6])
Simplex.thereIsAnotherIteration(inputRuleValues)

# El método funciona también con rational
inputRuleValues=np.array([rational(1,3),rational(-2,3)])
Simplex.thereIsAnotherIteration(inputRuleValues)

#Si se le pasa algo que no sea un array de numpy, devuelve None
print(Simplex.thereIsAnotherIteration(2))


I am working on the file "Documentation/Tutorial librería Simplex.py.ipynb".
The first task is:
twoMatrixEqual
Este método recibe dos matrices de numpy, con componentes rational, y devuelve True,si son iguales, o False, si no lo son. Si se introduce algo que no es una matriz de numpy, con elementos rational, devuelve None. Ejemplos:
Can you write Python code for it?

matrix1=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
matrix2=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
Simplex.twoMatrixEqual(matrix1, matrix2)

matrix1=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
matrix2=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(9,6),rational(6,1)]])
Simplex.twoMatrixEqual(matrix1, matrix2)

# Si las dimensiones no son iguales, devuelve False
matrix1=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)],[rational(4,6),rational(9,1)]])
matrix2=np.matrix([[rational(4,7),rational(8,9)],[rational(2,4),rational(3,4)]])
Simplex.twoMatrixEqual(matrix1, matrix2)

# Si recibe algo que no es una matriz de numpy, con elementos rational, devuelve None
print(Simplex.twoMatrixEqual(matrix1, 3))


I am working on the file "Documentation/Yahtzee Analysis.ipynb".
The first task is:
Add a Title:
Can you write Python code for it?

# Add title to graph
plt.text(33,8500, "Amount of times a given score occured in games of Yahtzee",
		fontsize=16, ha='center');


I am working on the file "Documentation/Yahtzee Analysis.ipynb".
The first task is:
Next we import the data, and grab the integer values from the 'scored?' column in our dataset using our wonderful function we created above.
Can you write Python code for it?

data_file = 'C:/Users/Erik Sorensen/Desktop/Data/Freethedice.com Yahtzee/dataByGameHeldShift.csv'

scores = fileIntegerParser(data_file,'scored?')


I am working on the file "Documentation/Yahtzee Analysis.ipynb".
The first task is:
Now I remove any unecessary chartjunk that clutters the graph:
Can you write Python code for it?

# Remove unecessary plot frame lines
ax = plt.subplot()
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)

# We only need the ticks on the bottom and left of the graph
# top and right ticks are unessessary
ax.get_yaxis().tick_left()
ax.get_xaxis().tick_bottom()

# Graph some horizontal dotted lines
for y in range(0,8501 ,1000):
	plt.plot(range(0,66), [y] * len(range(0,66)), "--",lw=0.5, color="black",alpha=0.3);


I am working on the file "Documentation/Yahtzee Analysis.ipynb".
The first task is:
Now we plot the data!
Can you write Python code for it?

# Plot the data in a bar graph
plt.bar(range(bins), count, width=1, align='center' ,color='#3F5D7D')
plt.show();