API tools faq
paste
Advertisement
TiesTienhoven

Untitled

TiesTienhoven
Oct 20th, 2018
101
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.89 KB | None | 0 0
raw download clone embed print report
  1. import java.text.DecimalFormat;
  2. import java.time.*;
  3. import java.time.temporal.*;
  4. import java.util.ArrayList;
  5. import java.util.Collections;
  6.  
  7. /**
  8. * A class to contain a period of time
  9. *
  10. * @author Johan Talboom
  11. * @version 2.0
  12. */
  13. public class Period {
  14. private LocalDate beginPeriod;
  15. private LocalDate endPeriod;
  16.  
  17. /**
  18. * default constructor, sets the period to today
  19. */
  20. public Period() {
  21. beginPeriod = LocalDate.now();
  22. endPeriod = LocalDate.now();
  23. }
  24.  
  25. public Period(LocalDate beginPeriod, LocalDate endPeriod) {
  26. this.beginPeriod = beginPeriod;
  27. this.endPeriod = endPeriod;
  28. }
  29.  
  30. public Period(LocalDate beginPeriod) {
  31. this.beginPeriod = beginPeriod;
  32. this.endPeriod = LocalDate.now();
  33. }
  34.  
  35. public Period(int days) {
  36. this.beginPeriod = LocalDate.now().minus(java.time.Period.ofDays(days));
  37. this.endPeriod = LocalDate.now();
  38. }
  39.  
  40.  
  41.  
  42. /**
  43. * Simple setter for start of period
  44. */
  45. public void setStart(int year, int month, int day) {
  46. beginPeriod = LocalDate.of(year, month, day);
  47. }
  48.  
  49. /**
  50. * simple setter for end of period
  51. */
  52. public void setEnd(int year, int month, int day) {
  53. endPeriod = LocalDate.of(year, month, day);
  54. }
  55.  
  56. /**
  57. * alternative setter for start of period
  58. *
  59. * @param beginPeriod
  60. */
  61. public void setStart(LocalDate beginPeriod) {
  62. this.beginPeriod = beginPeriod;
  63. }
  64.  
  65. /**
  66. * alternative setter for end of period
  67. *
  68. * @param endPeriod
  69. */
  70. public void setEnd(LocalDate endPeriod) {
  71. this.endPeriod = endPeriod;
  72. }
  73.  
  74. /**
  75. * calculates the number of days in the period
  76. */
  77. public long numberOfDays() {
  78. return ChronoUnit.DAYS.between(beginPeriod, endPeriod);
  79. }
  80.  
  81.  
  82. /**
  83. * gets all raw measurements of this period from the database
  84. * @return a list of raw measurements
  85. */
  86. public ArrayList<RawMeasurement> getRawMeasurements() {
  87. return DatabaseConnection.getMeasurementsBetween(LocalDateTime.of(beginPeriod, LocalTime.of(0, 1)), LocalDateTime.of(endPeriod, LocalTime.of(23, 59)));
  88. }
  89.  
  90. /**
  91. * Builds an ArrayList of measurements. This method also filters out any 'bad' measurements
  92. * @return a filtered list of measurements
  93. */
  94. public ArrayList<Measurement> getMeasurements() {
  95. ArrayList<Measurement> measurements = new ArrayList<>();
  96. ArrayList<RawMeasurement> rawMeasurements = getRawMeasurements();
  97. for (RawMeasurement rawMeasurement : rawMeasurements) {
  98. Measurement measurement = new Measurement(rawMeasurement);
  99. if(measurement.isValid()) {
  100. measurements.add(measurement);
  101. }
  102. }
  103. return measurements;
  104. }
  105.  
  106.  
  107.  
  108.  
  109. /**
  110. * todo
  111. * @return
  112. */
  113. /*public double getAverageOutsideTemperature()
  114. {
  115. ArrayList<Measurement> measurements = getMeasurements();
  116.  
  117. //calculate average outside temperature and return it
  118. return measurements.get(0).getTemperature();
  119. } */
  120.  
  121. /**
  122. * Todo
  123. */
  124. public ArrayList<Period> hasHeatWave() {
  125. return null;
  126. }
  127.  
  128. /**
  129. * Todo
  130. */
  131. public Period longestDraught() {
  132. return new Period();
  133. }
  134.  
  135. /**
  136. * Todo more methods
  137. */
  138.  
  139. public double standardDeviationInsideTemp(){
  140. ArrayList<Measurement> measurements = getMeasurements();
  141. ArrayList<Double> insideTempList = new ArrayList<>();
  142.  
  143.  
  144. for (Measurement measurement : measurements){
  145. insideTempList.add(measurement.insideTemp());
  146. }
  147.  
  148. double suminsidetemp = 0.0;
  149. double average = 0.0;
  150. double suminsidetempdeviation = 0.0;
  151.  
  152. for (double number : insideTempList){
  153. suminsidetemp += number;
  154. }
  155.  
  156. average = suminsidetemp / insideTempList.size();
  157.  
  158. for (double number : insideTempList){
  159. suminsidetempdeviation += (number - average) * (number - average);
  160. }
  161. return Math.sqrt(suminsidetempdeviation / (insideTempList.size() - 1) );
  162.  
  163. }
  164.  
  165. public double standardDeviationOutsideTemp(){
  166. ArrayList<Measurement> measurements = getMeasurements();
  167. ArrayList<Double> outsideTempList = new ArrayList<>();
  168.  
  169. for (Measurement measurement : measurements){
  170. outsideTempList.add(measurement.outsideTemp());
  171. }
  172.  
  173. double sumoutsidetemp = 0.0;
  174. double average = 0.0;
  175. double sumoutsidetempdeviation = 0.0;
  176.  
  177. for (double number : outsideTempList){
  178. sumoutsidetemp += number;
  179. }
  180.  
  181. average = sumoutsidetemp / outsideTempList.size();
  182.  
  183. for (double number : outsideTempList){
  184. sumoutsidetempdeviation += (number - average) * (number - average);
  185. }
  186.  
  187. return Math.sqrt(sumoutsidetempdeviation / (outsideTempList.size() - 1));
  188. }
  189.  
  190. public double standardDeviationOutsideHum(){
  191. ArrayList<Measurement> measurements = getMeasurements();
  192. ArrayList<Double> outsideHumList = new ArrayList<>();
  193.  
  194. for (Measurement measurement : measurements){
  195. outsideHumList.add(measurement.outsideHum());
  196. }
  197.  
  198. double sumoutsidehum = 0.0;
  199. double average = 0.0;
  200. double sumoutsidehumdeviation = 0.0;
  201.  
  202. for (double number : outsideHumList){
  203. sumoutsidehum += number;
  204. }
  205.  
  206. average = sumoutsidehum / outsideHumList.size();
  207.  
  208. for (double number : outsideHumList){
  209. sumoutsidehumdeviation += (number - average) * (number - average);
  210. }
  211. return Math.sqrt(sumoutsidehumdeviation / (outsideHumList.size() - 1));
  212.  
  213. }
  214.  
  215. public double standardDeviationAirpressure(){
  216. ArrayList<Measurement> measurements = getMeasurements();
  217. ArrayList<Double> airpressureList = new ArrayList<>();
  218.  
  219. for (Measurement measurement : measurements) {
  220. airpressureList.add(measurement.barometer());
  221. }
  222.  
  223. double sumairpressure = 0.0;
  224. double average = 0.0;
  225. double sumairpressuredeviation = 0.0;
  226.  
  227. for(double number : airpressureList){
  228. sumairpressure += number;
  229. }
  230.  
  231. average = sumairpressure / airpressureList.size();
  232.  
  233. for (double number : airpressureList){
  234. sumairpressuredeviation += (number - average) * (number - average);
  235. }
  236.  
  237. return Math.sqrt(sumairpressuredeviation / (airpressureList.size() - 1));
  238. }
  239.  
  240. public ArrayList<String> standarddeviation (){
  241. ArrayList<Measurement> measurements = getMeasurements();
  242. ArrayList<Double> insideTempList = new ArrayList<>();
  243. ArrayList<Double> outsideTempList = new ArrayList<>();
  244. ArrayList<Double> outsideHumList = new ArrayList<>();
  245. ArrayList<Double> airpressureList = new ArrayList<>();
  246. ArrayList<String> output = new ArrayList<>();
  247. DecimalFormat format = new DecimalFormat("0.00");
  248.  
  249.  
  250. for (Measurement measurement : measurements){
  251. insideTempList.add(measurement.insideTemp());
  252. outsideTempList.add(measurement.outsideTemp());
  253. outsideHumList.add(measurement.outsideHum());
  254. airpressureList.add(measurement.barometer());
  255. }
  256.  
  257. //
  258. // Inside Temperature
  259. //
  260.  
  261. double suminsidetemp = 0.0;
  262. double average1 = 0.0;
  263. double suminsidetempdeviation = 0.0;
  264.  
  265. for (double number : insideTempList){
  266. suminsidetemp += number;
  267. }
  268.  
  269. average1 = suminsidetemp / insideTempList.size();
  270.  
  271. for (double number : insideTempList){
  272. suminsidetempdeviation += (number - average1) * (number - average1);
  273. }
  274.  
  275. String deviationinsidetemp = "Standard deviation inside temperature: "+ format.format(Math.sqrt(suminsidetempdeviation / (insideTempList.size() - 1) )) + " °C";
  276. output.add(0, deviationinsidetemp);
  277.  
  278. //
  279. // Outside Temperature
  280. //
  281.  
  282. double sumoutsidetemp = 0.0;
  283. double average2 = 0.0;
  284. double sumoutsidetempdeviation = 0.0;
  285.  
  286. for (double number : outsideTempList){
  287. sumoutsidetemp += number;
  288. }
  289.  
  290. average2 = sumoutsidetemp / outsideTempList.size();
  291.  
  292. for (double number : outsideTempList){
  293. sumoutsidetempdeviation += (number - average2) * (number - average2);
  294. }
  295.  
  296. String deviationoutsidetemp = "Standard deviation outside temperature: "+ format.format(Math.sqrt(sumoutsidetempdeviation / (outsideTempList.size() - 1))) + " °C";
  297. output.add(1, deviationoutsidetemp);
  298.  
  299. //
  300. // Outside Humidity
  301. //
  302.  
  303. double sumoutsidehum = 0.0;
  304. double average3 = 0.0;
  305. double sumoutsidehumdeviation = 0.0;
  306.  
  307. for (double number : outsideHumList){
  308. sumoutsidehum += number;
  309. }
  310.  
  311. average3 = sumoutsidehum / outsideHumList.size();
  312.  
  313. for (double number : outsideHumList){
  314. sumoutsidehumdeviation += (number - average3) * (number - average3);
  315. }
  316.  
  317. String deviationoutsidehum = "Standard deviation outside humidity: "+ format.format(Math.sqrt(sumoutsidehumdeviation / (outsideHumList.size() - 1))) + " %";
  318. output.add(2, deviationoutsidehum);
  319.  
  320. //
  321. // Air pressure
  322. //
  323.  
  324. double sumairpressure = 0.0;
  325. double average4 = 0.0;
  326. double sumairpressuredeviation = 0.0;
  327.  
  328. for(double number : airpressureList){
  329. sumairpressure += number;
  330. }
  331.  
  332. average4 = sumairpressure / airpressureList.size();
  333.  
  334. for (double number : airpressureList){
  335. sumairpressuredeviation += (number - average4) * (number - average4);
  336. }
  337.  
  338. String deviationairpressure = "Standard deviation airpressure: " + format.format(Math.sqrt(sumairpressuredeviation / (airpressureList.size() - 1))) + " hPa";
  339. output.add(3, deviationairpressure);
  340.  
  341. return output;
  342. }
  343.  
  344.  
  345.  
  346.  
  347. public Double mediaanBinnenTempratuur(){
  348.  
  349. ArrayList<Measurement> new1 = getMeasurements();
  350. ArrayList<Double> new2 = new ArrayList<>();
  351. for(Measurement list : new1){
  352. double get = list.insideTemp();
  353. new2.add(get);
  354. }
  355. Collections.sort(new2);
  356. double mediaan;
  357. int list1 = new2.size();
  358. if(list1 % 2 ==0){
  359. double som = new2.get(list1/2) + new2.get(list1/2-1);
  360. mediaan = som/2;
  361. }else{
  362. mediaan = new2.get(list1/2);
  363. }
  364. return mediaan;
  365. }
  366.  
  367. public Double mediaanBuitenTempratuur(){
  368.  
  369. ArrayList<Measurement> new1 = getMeasurements();
  370. ArrayList<Double> new2 = new ArrayList<>();
  371. for(Measurement list : new1){
  372. double get = list.outsideTemp();
  373. new2.add(get);
  374. }
  375. Collections.sort(new2);
  376. double mediaan;
  377. int list1 = new2.size();
  378. if(list1 % 2 ==0){
  379. double som = new2.get(list1/2) + new2.get(list1/2-1);
  380. mediaan = som/2;
  381. }else{
  382. mediaan = new2.get(list1/2);
  383. }
  384. return mediaan;
  385. }
  386.  
  387. public Double mediaanBarometer(){
  388.  
  389. ArrayList<Measurement> new1 = getMeasurements();
  390. ArrayList<Double> new2 = new ArrayList<>();
  391. for(Measurement list : new1){
  392. double get = list.barometer();
  393. new2.add(get);
  394. }
  395. Collections.sort(new2);
  396. double mediaan;
  397. int list1 = new2.size();
  398. if(list1 % 2 ==0){
  399. double som = new2.get(list1/2) + new2.get(list1/2-1);
  400. mediaan = som/2;
  401. }else{
  402. mediaan = new2.get(list1/2);
  403. }
  404. return mediaan;
  405. }
  406.  
  407. public Double mediaanOutsideHum(){
  408.  
  409. ArrayList<Measurement> new1 = getMeasurements();
  410. ArrayList<Double> new2 = new ArrayList<>();
  411. for(Measurement list : new1){
  412. double get = list.outsideHum();
  413. new2.add(get);
  414. }
  415. Collections.sort(new2);
  416. double mediaan;
  417. int list1 = new2.size();
  418. if(list1 % 2 ==0){
  419. double som = new2.get(list1/2) + new2.get(list1/2-1);
  420. mediaan = som/2;
  421. }else{
  422. mediaan = new2.get(list1/2);
  423. }
  424. return mediaan;
  425. }
  426.  
  427. public double averageOudsideTemp() {
  428. ArrayList<Measurement> measurements = getMeasurements();
  429. ArrayList<Double> outsideTempList = new ArrayList<>();
  430.  
  431.  
  432. for (Measurement measurement : measurements){
  433. outsideTempList.add(measurement.outsideTemp());
  434. }
  435.  
  436.  
  437. double sum = 0;
  438.  
  439. for (int i = 0; i < outsideTempList.size(); i++) {
  440. sum += outsideTempList.get(i);
  441. }
  442. double avg = sum / outsideTempList.size();
  443. return avg;
  444. }
  445.  
  446.  
  447. public double averageInsideTemp(){
  448.  
  449. ArrayList<Measurement> measurements = getMeasurements();
  450. ArrayList<Double> insideTempList = new ArrayList<>();
  451.  
  452.  
  453. for (Measurement measurement : measurements){
  454. insideTempList.add(measurement.insideTemp());
  455. }
  456.  
  457. double sum = 0;
  458.  
  459. for (int i = 0; i < insideTempList.size(); i++) {
  460. sum += insideTempList.get(i);
  461. }
  462. double avg = sum / insideTempList.size();
  463. return avg;
  464. }
  465.  
  466. public double averageairPressure(){
  467. ArrayList<Measurement> measurements = getMeasurements();
  468. ArrayList<Double> airpressureList = new ArrayList<>();
  469.  
  470.  
  471. for (Measurement measurement : measurements){
  472. airpressureList.add(measurement.barometer());
  473. }
  474.  
  475. double sum = 0;
  476.  
  477. for (int i = 0; i < airpressureList.size(); i++) {
  478. sum += airpressureList.get(i);
  479. }
  480. double avg = sum / airpressureList.size();
  481. return avg;
  482. }
  483.  
  484. public double averagehumidityOutside(){
  485. ArrayList<Measurement> measurements = getMeasurements();
  486. ArrayList<Double> outsideHumList = new ArrayList<>();
  487.  
  488.  
  489. for (Measurement measurement : measurements){
  490. outsideHumList.add(measurement.outsideHum());
  491. }
  492. double sum = 0;
  493.  
  494. for (int i = 0; i < outsideHumList.size(); i++) {
  495. sum += outsideHumList.get(i);
  496. }
  497. double avg = sum / outsideHumList.size();
  498. return avg;
  499. }
  500.  
  501. public double minimumInsideTemp(){
  502. ArrayList<Measurement> measurements = getMeasurements();
  503. ArrayList<Double> insideTempList = new ArrayList<>();
  504.  
  505.  
  506. for (Measurement measurement : measurements){
  507. insideTempList.add(measurement.insideTemp());
  508. }
  509.  
  510. double lowest = insideTempList.get(0);
  511. for (double getal : insideTempList){
  512. if (getal < lowest){
  513. lowest = getal;
  514. }
  515. }
  516.  
  517. return lowest;
  518. }
  519.  
  520. public double minimumOutsideTemp(){
  521. ArrayList<Measurement> measurements = getMeasurements();
  522. ArrayList<Double> outsideTempList = new ArrayList<>();
  523. for (Measurement measurement : measurements){
  524. outsideTempList.add(measurement.outsideTemp());
  525. }
  526.  
  527. double lowest = outsideTempList.get(0);
  528. for (double getal : outsideTempList){
  529. if (getal < lowest){
  530. lowest = getal;
  531. }
  532. }
  533. return lowest;
  534. }
  535.  
  536. public double minimumOutsideHum(){
  537. ArrayList<Measurement> measurements = getMeasurements();
  538. ArrayList<Double> outsideHumList = new ArrayList<>();
  539.  
  540.  
  541. for (Measurement measurement : measurements){
  542. outsideHumList.add(measurement.outsideHum());
  543. }
  544.  
  545. double lowest = outsideHumList.get(0);
  546. for (double getal : outsideHumList){
  547. if (getal < lowest){
  548. lowest = getal;
  549. }
  550. }
  551. return lowest;
  552. }
  553.  
  554. public double minimumAirPressure(){
  555. ArrayList<Measurement> measurements = getMeasurements();
  556. ArrayList<Double> airpressureList = new ArrayList<>();
  557.  
  558.  
  559. for (Measurement measurement : measurements){
  560. airpressureList.add(measurement.barometer());
  561. }
  562. double lowest = airpressureList.get(0);
  563. for (double getal : airpressureList){
  564. if (getal < lowest){
  565. lowest = getal;
  566. }
  567. }
  568. return lowest;
  569. }
  570.  
  571. public double maximumInsideTemp(){
  572. ArrayList<Measurement> measurements = getMeasurements();
  573. ArrayList<Double> insideTempList = new ArrayList<>();
  574.  
  575.  
  576. for (Measurement measurement : measurements){
  577. insideTempList.add(measurement.insideTemp());
  578. }
  579.  
  580. double highest = insideTempList.get(0);
  581. for (double getal : insideTempList){
  582. if (getal > highest){
  583. highest = getal;
  584. }
  585. }
  586.  
  587. return highest;
  588. }
  589.  
  590. public double maximumOutsideTemp(){
  591. ArrayList<Measurement> measurements = getMeasurements();
  592. ArrayList<Double> outsideTempList = new ArrayList<>();
  593. for (Measurement measurement : measurements){
  594. outsideTempList.add(measurement.outsideTemp());
  595. }
  596.  
  597. double highest = outsideTempList.get(0);
  598. for (double getal : outsideTempList){
  599. if (getal > highest){
  600. highest = getal;
  601. }
  602. }
  603. return highest;
  604. }
  605.  
  606. public double maximumOutsideHum(){
  607. ArrayList<Measurement> measurements = getMeasurements();
  608. ArrayList<Double> outsideHumList = new ArrayList<>();
  609.  
  610.  
  611. for (Measurement measurement : measurements){
  612. outsideHumList.add(measurement.outsideHum());
  613. }
  614.  
  615. double highest = outsideHumList.get(0);
  616. for (double getal : outsideHumList){
  617. if (getal > highest){
  618. highest = getal;
  619. }
  620. }
  621. return highest;
  622. }
  623.  
  624. public double maximumAirPressure(){
  625. ArrayList<Measurement> measurements = getMeasurements();
  626. ArrayList<Double> airpressureList = new ArrayList<>();
  627.  
  628.  
  629. for (Measurement measurement : measurements){
  630. airpressureList.add(measurement.barometer());
  631. }
  632. double highest = airpressureList.get(0);
  633. for (double getal : airpressureList){
  634. if (getal > highest){
  635. highest = getal;
  636. }
  637. }
  638. return highest;
  639. }
  640.  
  641. //MODUS
  642. public void ModusOutsideTemp() {
  643. ArrayList<Measurement> new1 = getMeasurements();
  644. ArrayList<Double> modus = new ArrayList<>();
  645. ArrayList<Double> meerDanEenModus = new ArrayList<>();
  646. for (Measurement list : new1) {
  647. double get = list.outsideTemp();
  648. modus.add(get);
  649. }
  650.  
  651. double modus1 = modus.get(0);
  652. double maxCount = modus.get(0);
  653. int amount = 0;
  654.  
  655. for (int i = 0; i < modus.size(); i++) {
  656.  
  657. int count = 0;
  658. double comparison = modus.get(i);
  659.  
  660. for (Double m : modus) {
  661.  
  662. if (m == comparison) {
  663.  
  664. count++;
  665. }
  666. }
  667.  
  668. if (count >= amount) {
  669. if (count == amount) {
  670. maxCount = comparison;
  671.  
  672. if (!meerDanEenModus.contains(comparison)) {
  673. meerDanEenModus.add(comparison);
  674. }
  675.  
  676. } else {
  677. modus1 = comparison;
  678. amount = count;
  679. meerDanEenModus.clear();
  680. meerDanEenModus.add(comparison);
  681. }
  682. }
  683. }
  684.  
  685. if (maxCount == modus1) {
  686.  
  687. System.out.println("Modus: " + modus1 + " aantal: " + amount);
  688. } else {
  689.  
  690. int sum = 0;
  691. int amountMod = meerDanEenModus.size();
  692.  
  693. double comparisonMod;
  694.  
  695. for (Double singleModus : meerDanEenModus) {
  696.  
  697. sum += singleModus;
  698. }
  699.  
  700. comparisonMod = ((double) sum / amountMod);
  701.  
  702. System.out.print("De modussen zijn: ");
  703. System.out.println(meerDanEenModus);
  704. System.out.print("Het gemiddelde van de modussen is: ");
  705. System.out.print(comparisonMod);
  706. }
  707. }
  708.  
  709. public void ModusInsideTemp() {
  710. ArrayList<Measurement> new1 = getMeasurements();
  711. ArrayList<Double> modus = new ArrayList<>();
  712. ArrayList<Double> meerDanEenModus = new ArrayList<>();
  713. for (Measurement list : new1) {
  714. double get = list.insideTemp();
  715. modus.add(get);
  716. }
  717.  
  718. double modus1 = modus.get(0);
  719. double maxCount = modus.get(0);
  720. int amount = 0;
  721.  
  722. for (int i = 0; i < modus.size(); i++) {
  723.  
  724. int count = 0;
  725. double comparison = modus.get(i);
  726.  
  727. for (Double m : modus) {
  728.  
  729. if (m == comparison) {
  730.  
  731. count++;
  732. }
  733. }
  734.  
  735. if (count >= amount) {
  736. if (count == amount) {
  737. maxCount = comparison;
  738.  
  739. if (!meerDanEenModus.contains(comparison)) {
  740. meerDanEenModus.add(comparison);
  741. }
  742.  
  743. } else {
  744. modus1 = comparison;
  745. amount = count;
  746. meerDanEenModus.clear();
  747. meerDanEenModus.add(comparison);
  748. }
  749. }
  750. }
  751.  
  752. if (maxCount == modus1) {
  753.  
  754. System.out.println("Modus: " + modus1 + " aantal: " + amount);
  755. } else {
  756.  
  757. int sum = 0;
  758. int amountMod = meerDanEenModus.size();
  759.  
  760. double comparisonMod;
  761.  
  762. for (Double singleModus : meerDanEenModus) {
  763.  
  764. sum += singleModus;
  765. }
  766.  
  767. comparisonMod = ((double) sum / amountMod);
  768.  
  769. System.out.print("De modussen zijn: ");
  770. System.out.println(meerDanEenModus);
  771. System.out.print("Het gemiddelde van de modussen is: ");
  772. System.out.print(comparisonMod);
  773. }
  774. }
  775.  
  776. public void ModusInsideHum() {
  777. ArrayList<Measurement> new1 = getMeasurements();
  778. ArrayList<Double> modus = new ArrayList<>();
  779. ArrayList<Double> meerDanEenModus = new ArrayList<>();
  780. for (Measurement list : new1) {
  781. double get = list.insideHum();
  782. modus.add(get);
  783. }
  784.  
  785. double modus1 = modus.get(0);
  786. double maxCount = modus.get(0);
  787. int amount = 0;
  788.  
  789. for (int i = 0; i < modus.size(); i++) {
  790.  
  791. int count = 0;
  792. double comparison = modus.get(i);
  793.  
  794. for (Double m : modus) {
  795.  
  796. if (m == comparison) {
  797.  
  798. count++;
  799. }
  800. }
  801.  
  802. if (count >= amount) {
  803. if (count == amount) {
  804. maxCount = comparison;
  805.  
  806. if (!meerDanEenModus.contains(comparison)) {
  807. meerDanEenModus.add(comparison);
  808. }
  809.  
  810. } else {
  811. modus1 = comparison;
  812. amount = count;
  813. meerDanEenModus.clear();
  814. meerDanEenModus.add(comparison);
  815. }
  816. }
  817. }
  818.  
  819. if (maxCount == modus1) {
  820.  
  821. System.out.println("Modus: " + modus1 + " aantal: " + amount);
  822. } else {
  823.  
  824. int sum = 0;
  825. int amountMod = meerDanEenModus.size();
  826.  
  827. double comparisonMod;
  828.  
  829. for (Double singleModus : meerDanEenModus) {
  830.  
  831. sum += singleModus;
  832. }
  833.  
  834. comparisonMod = ((double) sum / amountMod);
  835.  
  836. System.out.print("De modussen zijn: ");
  837. System.out.println(meerDanEenModus);
  838. System.out.print("Het gemiddelde van de modussen is: ");
  839. System.out.print(comparisonMod);
  840. }
  841. }
  842.  
  843. public void ModusOutsideHum() {
  844. ArrayList<Measurement> new1 = getMeasurements();
  845. ArrayList<Double> modus = new ArrayList<>();
  846. ArrayList<Double> meerDanEenModus = new ArrayList<>();
  847. for (Measurement list : new1) {
  848. double get = list.outsideHum();
  849. modus.add(get);
  850. }
  851.  
  852. double modus1 = modus.get(0);
  853. double maxCount = modus.get(0);
  854. int amount = 0;
  855.  
  856. for (int i = 0; i < modus.size(); i++) {
  857.  
  858. int count = 0;
  859. double comparison = modus.get(i);
  860.  
  861. for (Double m : modus) {
  862.  
  863. if (m == comparison) {
  864.  
  865. count++;
  866. }
  867. }
  868.  
  869. if (count >= amount) {
  870. if (count == amount) {
  871. maxCount = comparison;
  872.  
  873. if (!meerDanEenModus.contains(comparison)) {
  874. meerDanEenModus.add(comparison);
  875. }
  876.  
  877. } else {
  878. modus1 = comparison;
  879. amount = count;
  880. meerDanEenModus.clear();
  881. meerDanEenModus.add(comparison);
  882. }
  883. }
  884. }
  885.  
  886. if (maxCount == modus1) {
  887.  
  888. System.out.println("Modus: " + modus1 + " aantal: " + amount);
  889. } else {
  890.  
  891. int sum = 0;
  892. int amountMod = meerDanEenModus.size();
  893.  
  894. double comparisonMod;
  895.  
  896. for (Double singleModus : meerDanEenModus) {
  897.  
  898. sum += singleModus;
  899. }
  900.  
  901. comparisonMod = ((double) sum / amountMod);
  902.  
  903. System.out.print("De modussen zijn: ");
  904. System.out.println(meerDanEenModus);
  905. System.out.print("Het gemiddelde van de modussen is: ");
  906. System.out.print(comparisonMod);
  907. }
  908. }
  909.  
  910. public void Barometer() {
  911. ArrayList<Measurement> new1 = getMeasurements();
  912. ArrayList<Double> modus = new ArrayList<>();
  913. ArrayList<Double> meerDanEenModus = new ArrayList<>();
  914. for (Measurement list : new1) {
  915. double get = list.barometer();
  916. modus.add(get);
  917. }
  918.  
  919. double modus1 = modus.get(0);
  920. double maxCount = modus.get(0);
  921. int amount = 0;
  922.  
  923. for (int i = 0; i < modus.size(); i++) {
  924.  
  925. int count = 0;
  926. double comparison = modus.get(i);
  927.  
  928. for (Double m : modus) {
  929.  
  930. if (m == comparison) {
  931.  
  932. count++;
  933. }
  934. }
  935.  
  936. if (count >= amount) {
  937. if (count == amount) {
  938. maxCount = comparison;
  939.  
  940. if (!meerDanEenModus.contains(comparison)) {
  941. meerDanEenModus.add(comparison);
  942. }
  943.  
  944. } else {
  945. modus1 = comparison;
  946. amount = count;
  947. meerDanEenModus.clear();
  948. meerDanEenModus.add(comparison);
  949. }
  950. }
  951. }
  952.  
  953. if (maxCount == modus1) {
  954.  
  955. System.out.println("Modus: " + modus1 + " aantal: " + amount);
  956. } else {
  957.  
  958. int sum = 0;
  959. int amountMod = meerDanEenModus.size();
  960.  
  961. double comparisonMod;
  962.  
  963. for (Double singleModus : meerDanEenModus) {
  964.  
  965. sum += singleModus;
  966. }
  967.  
  968. comparisonMod = ((double) sum / amountMod);
  969.  
  970. System.out.print("De modussen zijn: ");
  971. System.out.println(meerDanEenModus);
  972. System.out.print("Het gemiddelde van de modussen is: ");
  973. System.out.print(comparisonMod);
  974. }
  975. }
  976. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!