SoluçãoInicial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementação de Referência\n",
    "\n",
    "Esta é uma implementação de referência das interfaces `IEnquirer` e `IResponder` que serão usadas no trabalho.\n",
    "\n",
    "Ela também está montada sobre a lógica de componentes de software apresentada no notebook que está no diretório `s04components`.\n",
    "\n",
    "Nessa implementação é criado um componente paciente `Patient` que sorteia uma das doenças e um componente doutor `CrazyDoctor` que tentará descobrir a doença.\n",
    "\n",
    "Como o doutor é louco, ele apenas sorteia uma das doenças também. Apesar de fazer perguntas ao paciente, ele ignora as respostas e tenta advinhar a doença. Na maioria das vezes ele erra. Mas, lembre-se, essa não é a solução para o problema, é apenas uma implementação mostrando como se usa as interfaces e a lógica de componentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interfaces relacionadas ao componente `DataSet`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface IDataSource {\n",
    "  public String getDataSource();\n",
    "  public void setDataSource(String dataSource);\n",
    "}\n",
    "\n",
    "public interface ITableProducer {\n",
    "  String[] requestAttributes();\n",
    "  String[][] requestInstances();\n",
    "}\n",
    "\n",
    "public interface ITableProducerReceptacle {\n",
    "  public void connect(ITableProducer producer);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Componente `DataSet`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.io.BufferedReader;\n",
    "import java.io.FileReader;\n",
    "import java.io.IOException;\n",
    "import java.util.ArrayList;\n",
    "\n",
    "public interface IDataSet extends IDataSource, ITableProducer {\n",
    "}\n",
    "\n",
    "public class DataSetComponent implements IDataSet {\n",
    "  private String dataSource = null;\n",
    "  private String[] attributes = null;\n",
    "  private String[][] instances = null;\n",
    "  \n",
    "  public DataSetComponent() {\n",
    "    /* nothing */\n",
    "  }\n",
    "\n",
    "  public String getDataSource() {\n",
    "    return dataSource;\n",
    "  }\n",
    "\n",
    "  public void setDataSource(String dataSource) {\n",
    "    this.dataSource = dataSource;\n",
    "    if (dataSource == null) {\n",
    "      attributes = null;\n",
    "      instances = null;\n",
    "    } else\n",
    "      readDS();\n",
    "  }\n",
    "  \n",
    "  public String[] requestAttributes() {\n",
    "    return attributes;\n",
    "  }\n",
    "  \n",
    "  public String[][] requestInstances() {\n",
    "    return instances;\n",
    "  }\n",
    "  \n",
    "  private void readDS() {\n",
    "    ArrayList<String[]> instArray = new ArrayList<String[]>();\n",
    "    try {\n",
    "      BufferedReader file = new BufferedReader(new FileReader(dataSource));\n",
    "        \n",
    "      String line = file.readLine();\n",
    "      if (line != null) {\n",
    "        attributes = line.split(\",\");\n",
    "        line = file.readLine();\n",
    "        while (line != null) {\n",
    "          String[] instLine = line.split(\",\");\n",
    "          instArray.add(instLine);\n",
    "          line = file.readLine();\n",
    "        }\n",
    "        instances = instArray.toArray(new String[0][]);\n",
    "      }\n",
    "        \n",
    "      file.close();\n",
    "    } catch (IOException erro) {\n",
    "      erro.printStackTrace();\n",
    "    }\n",
    "  }\n",
    "  \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interfaces de Referência\n",
    "\n",
    "Estas são as três interfaces de referência `IResponder`, `IResponderReceptacle` e `IEnquirer`, que deverão ser usadas na sua solução. Elas não podem ser modificadas para a **Parte 1** do trabalho."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface IResponder {\n",
    "    public String ask(String question);\n",
    "    public boolean finalAnswer(String answer);\n",
    "}\n",
    "\n",
    "public interface IResponderReceptacle {\n",
    "    public void connect(IResponder responder);\n",
    "}\n",
    "\n",
    "public interface IEnquirer {\n",
    "    public void startInterview();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Componente `Patient`\n",
    "\n",
    "Implementação de referência de um componente `Patient` que é ligado ao componente `DataSet` (pela interface `ITableProducerReceptacle`) e implementa a interface `IResponder`. A interface `IPatient` foi criada para juntar a interface provida (`IResponder`) e a interface requerida (`ITableProducerReceptacle`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.Random;\n",
    "\n",
    "// combinando duas interfaces para IPatient\n",
    "public interface IPatient extends IResponder, ITableProducerReceptacle {\n",
    "}\n",
    "\n",
    "public class Patient implements IPatient {\n",
    "    private int patientN = 0;\n",
    "    \n",
    "    private ITableProducer producer;\n",
    "    \n",
    "    private String attributes[];\n",
    "    private String patientInstance[];\n",
    "    \n",
    "    public void connect(ITableProducer producer) {\n",
    "        this.producer = producer;\n",
    "\n",
    "        attributes = producer.requestAttributes();\n",
    "        String instances[][] = producer.requestInstances();\n",
    "\n",
    "        patientN = (int)(Math.random() * instances.length);\n",
    "        patientInstance = instances[patientN];\n",
    "        \n",
    "        System.out.println(\"Patient selected: \" + patientN);\n",
    "        System.out.println(\"Patient's disease: \" + patientInstance[attributes.length - 1]);\n",
    "    }\n",
    "    \n",
    "    public String ask(String question) {\n",
    "        String result = \"unknown\";\n",
    "        \n",
    "        for (int a = 0; a < attributes.length - 1; a++)\n",
    "            if (question.equalsIgnoreCase(attributes[a]))\n",
    "                result = (patientInstance[a].equals(\"t\")) ? \"yes\" : \"no\";\n",
    "        \n",
    "        return result;\n",
    "    }\n",
    "\n",
    "    public boolean finalAnswer(String answer) {\n",
    "        boolean result = false;\n",
    "        if (answer.equalsIgnoreCase(patientInstance[attributes.length - 1]))\n",
    "            result = true;\n",
    "        return result;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Componente `CrazyDoctor`\n",
    "\n",
    "Implementação de um médico louco. Este médico não faz o diagnóstico correto na maioria das vezes, mas usa as interfaces corretamente. Ele serve como referência para o uso das interfaces e componentes.\n",
    "\n",
    "O componente `CrazyDoctor` que é ligado ao componente `DataSet` (pela interface `ITableProducerReceptacle`), é ligado ao componente `Patient` (pela interface `IResponderReceptacle`) e implementa a interface `IEnquirer`. A interface `IDoctor` foi criada para juntar a interface provida (`IEnquirer`) e as interfaces requeridas (`IResponderReceptacle` e `ITableProducerReceptacle`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.Random;\n",
    "\n",
    "// combinando duas interfaces para IPatient\n",
    "public interface IDoctor extends IEnquirer, IResponderReceptacle, ITableProducerReceptacle {\n",
    "}\n",
    "\n",
    "public class CrazyDoctor implements IDoctor {\n",
    "    private int patientN = 0;\n",
    "    private boolean diagnosed = false;\n",
    "\n",
    "    private ITableProducer producer;\n",
    "    private IResponder responder;\n",
    "  \n",
    "    public void connect(ITableProducer producer) {\n",
    "        this.producer = producer;\n",
    "    }\n",
    "    \n",
    "    public void connect(IResponder responder) {\n",
    "        this.responder = responder;\n",
    "    }\n",
    "        \n",
    "    public void startInterview() {\n",
    "        String attributes[] = producer.requestAttributes();\n",
    "        String instances[][] = producer.requestInstances();\n",
    "        boolean possibilities[] = new boolean[instances.length];//pacientes possíveis\n",
    "        for (int i = 0; i<possibilities.length; i++)//todos têm potencial =p\n",
    "            possibilities[i] = true;\n",
    "        \n",
    "        for (int a = 0; a < attributes.length - 1; a++){\n",
    "            String answer = responder.ask(attributes[a]);\n",
    "            System.out.println(\"Question: \" + answer);\n",
    "            \n",
    "            possibilities = checkPossibilities(possibilities, instances, a, answer);\n",
    "            \n",
    "            if (diagnosed)\n",
    "                break;\n",
    "        }\n",
    "        \n",
    "        patientN = getPatient(possibilities);\n",
    "\n",
    "        System.out.println(\"Disease guess: \" + instances[patientN][attributes.length - 1]);\n",
    "        boolean result = responder.finalAnswer(instances[patientN][attributes.length - 1]);\n",
    "        System.out.println(\"Result: \" + ((result) ? \"I am right =)\" : \"I am wrong =(\"));\n",
    "    }\n",
    "    \n",
    "    private boolean[] checkPossibilities(boolean possibilities[], String instances[][], int a, String answer){\n",
    "        int cont = 0;\n",
    "        \n",
    "        if (answer.equalsIgnoreCase(\"yes\"))//converter resposta\n",
    "            answer = \"t\";\n",
    "        else\n",
    "            answer = \"f\";\n",
    "        \n",
    "        for (int i = 0; i<instances.length; i++){\n",
    "            if (!possibilities[i])//ignorar o que já foi eliminado\n",
    "                continue;\n",
    "            \n",
    "            possibilities[i] = instances[i][a].equals(answer);\n",
    "        }\n",
    "        \n",
    "        for (int i = 0; i<instances.length; i++){\n",
    "            if (possibilities[i])\n",
    "                cont++;\n",
    "        }\n",
    "        \n",
    "        if (cont <= 1)//já pode parar\n",
    "            diagnosed = true;\n",
    "        \n",
    "        return possibilities;\n",
    "    }\n",
    "    \n",
    "    private int getPatient(boolean possibilities[]){\n",
    "        int i, returnValue = 0;\n",
    "        \n",
    "        for (i=0; i<possibilities.length; i++){//Retornar o primeiro paciente que não foi eliminado,\n",
    "                                                //não resolve quando há mais de uma possibilidade\n",
    "            if (possibilities[i]){\n",
    "                returnValue = i;\n",
    "                break;\n",
    "            }\n",
    "        }\n",
    "        return returnValue;\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patient selected: 15\n",
      "Patient's disease: bite_deficit\n",
      "Question: no\n",
      "Question: yes\n",
      "Question: yes\n",
      "Question: no\n",
      "Question: yes\n",
      "Question: no\n",
      "Question: no\n",
      "Disease guess: bite_deficit\n",
      "Result: I am right =)\n"
     ]
    }
   ],
   "source": [
    "// instanciando o componente DataSet\n",
    "IDataSet dataset = new DataSetComponent();\n",
    "dataset.setDataSource(\"zombie-health-spreadsheet-ml-training.csv\");\n",
    "\n",
    "// instanciando o componente paciente\n",
    "IPatient aPatient = new Patient();\n",
    "\n",
    "// conectando-o no componente DataSet\n",
    "aPatient.connect(dataset);\n",
    "\n",
    "// instanciando o componente doutor louco\n",
    "IDoctor cDoctor = new CrazyDoctor();\n",
    "\n",
    "// conectando-o ao componente DataSet\n",
    "cDoctor.connect(dataset);\n",
    "\n",
    "// conectando-o ao componente paciente\n",
    "cDoctor.connect(aPatient);\n",
    "\n",
    "// executando a entrevista\n",
    "cDoctor.startInterview();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".java",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "10.0.1+10-Debian-4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}