1 M.Cr.C. No.13852/2016 THE HIGH COURT OF MADHYA PRADESH AT JABALPUR (Single Bench - Rajendra Mahajan, J.) M.Cr.C.No. 13852/2016 1. M/s. Parle Agro Private Ltd., Plot No.44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.) through Balchandra S Virkar. 2. Ashok Bhave, Director, M/s. Parle Agro Private Ltd., Plot No. 44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.), through Balchandra S Vikar. Petitioners. V e r s u s Madhya Pradesh Pollution Control Board (M.P.P.C.B.), through Dr. N.K. Verma (Scientist), Regional Office, Paryawaran Parisar, Arera Colony, E-5 Bhopal (M.P.). Respondent. ----------------------------------------------------------- For Petitioners : Shri Surendra Singh, learned senior counsel with Shri Avinash Zargar, learned counsel. For Respondent: Shri Ashish Shroti, learned counsel. ----------------------------------------------------------- O R D E R
(Passed on the 11 t h Day of April, 2017) The petitioners have invoked the extraordinary jurisdiction and powers of this court by filing this petition under Section 482 of the Cr.P.C. to quash the complaint registered at the instance of the respondent against them and one Manish Kumar in the court of Chief Judicial Magistrate, Raisen being R.C.T. No.00938/2015 and subsequent proceedings in the case.
2. The brief facts which are necessary for adjudication of this petition are infra:-
2M.Cr.C. No.13852/2016 (2.1) On 30.07.2014, on behalf of respondent M.P. Pollution Control Board (for short the "Board") its officer Dr. N.K. Verma filed the complaint under Section 200 of the Cr.P.C. r/w Section 43 of the Air (Prevention and Control of Pollution) Act, 1981 (for short the "Air Act) and 49 of the Water (Prevention and Control of Pollution) Act, 1974 (for short the "Water Act") against the petitioners and one Manish Kumar. The sum and substance of the complaint is that the Board is constituted under Sections 4 of the Air Act and the Water Act. As per the provisions of Sections 44 of the Air Act and 50 of the Water Act, its members, officers and employees are public servants. The Regional Officer of the Board at Bhopal has authorized Dr. N.K. Verma to file this complaint. Petitioner No.1 company has its factory at the address given in the complaint. Petitioner No.2 Ashok Bhave is the occupier of the factory and one Manish Kumar is the plant manager of it. They are responsible for the conduct and the business of the factory as per the provisions of Sections 47 and 40 of the Water Act and the Air Act respectively.
(2.2) The further case of the respondent is that 3 M.Cr.C. No.13852/2016 it has given the consent to petitioner No.1 to run the factory, upon the mandatory compliance of the following conditions in addition to other conditions mentioned in the consent letters.
(i) It shall not discharge any effluent outside the premises of the factory in any circumstance and zero discharge condition shall be maintained.
(ii) It shall install all necessary devices to regulate air pollution in the factory.
(iii) It shall obtain consent for renewal in advance from the respondent before the expiry of existing consent.
(2.3) The still further case of the respondent is that on 03.02.2014 and 19.04.2014, its officers had carried out the spot inspections of the factory. In the course of inspections, it is found that petitioner No.1 does not possess the valid permission to run the factory. It is being run in violation of the aforestated conditions. It is also found that the Effluent Treatment Plant (ETP) was not in operation, the emergency response center was not established, the house keeping was also not put in place and ETP log book was not maintained. Thus, the 4 M.Cr.C. No.13852/2016 factory is being run by them in viloation of provisions of Sections 25 and 26 of the Water Act punishable under Sections 44, 45(A) and 47 of the Act and 21 of the Air Act punishable under Sections 37 and 39 of the Act. Hence, they are liable to be punished for which this complaint is filed.
3. The complaint being filed in the court of Chief Judicial Magistrate, Raisen, the learned Chief Judicial Magistrate by order dated 11.08.2015 directed to register the complaint which is registered after the order as R.C.T. No. 00938/15, and issue notices to the accused persons, who are petitioner No.1 and 2 and Manish Kumar, for their presence in the court.
4. Feeling grieved by the aforesaid order, the petitioners filed criminal revision being No.100123/15 before the Sessions Court, Raisen. The learned Sessions Judge dismissed the revision vide the order dated 25.05.2016, affirming the order dated 11.08.2015 passed by the learned Chief Judicial Magistrate.
5. Now, the petitioners have filed this petition for quashment of the complaint and the subsequent proceedings being held thereunder.
6. It is submitted on behalf of the petitioners by Shri Surendra Singh learned senior counsel that petitioner No.1 applied to the respondent for grant of consent in both the Acts submitting online application No. 64201 dated 05.08.2013. Thereupon, the respondent granted online consent No. AWH-42822 5 M.Cr.C. No.13852/2016 dated 24.12.2013, which is valid upto 31.10.2014. Thus, on the inspection-dates i.e. 03.02.2014 and 19.04.2014, the factory is being run on valid consent. Prior to the said consent, petitioner No.1 had obtained permission under the Water Act and the Air Act for the period of one year i.e. 01.01.2013 to 31.12.2013 vide consent letters dated 06.04.2013 (Annexures P/9 and P/10). It is submitted that vide letter dated 29.09.2014 (Annexure P/4) the respondent acknowledged that its officers inspected the factory on 31.07.2014 and found that ETP has been installed of proper capacity and units, that ETP is found in operation and that treated effluent water is being reused for washing and in toilets. It is submitted that the respondent took the Bank guarantee of Rs.5,00,000/- (five lacs) from petitioner No.1 to comply with the condition enumerated by respondent in its letter dated 29.09.2014 (Ex. P/4). It is submitted that petitioner No.1 furnished the Bank guarantee on 16.12.2014, which was provided by Kotak Mahindra Bank Ltd. The respondent released the Bank guarantee vide letter dated 05.01.2016 (Ex. P/18) certifying that petitioner No.1 had carried out in time the action plan in the factory as submitted by it. It is submitted that since petitioner No.1 has complied with all the directions and conditions imposed by the respondent, the prosecution against the petitioners and co-accused Manish Kumar has become infructuous, and it is also against the law.
7. It is also submitted by Shri Surendra Singh 6 M.Cr.C. No.13852/2016 learned senior counsel that petitioner No.2 Ashok Bhave is the Director of the petitioner No.1 and that he is not concerned with day to day functions of the factory for which co-accused Manish Kumar, who is the plant manager, is solely responsible. Hence, his prosecution in the case is against the law. It is submitted that the respondent has authority to cancel the license of petitioner No.1. Therefore, instead of launching the prosecution against the petitioners and co-accused Manish Kumar, the respondent should have cancelled the license. Upon these submissions, it is prayed by him to quash the complaint and the subsequent proceedings in the case.
8. In reply, learned counsel for the respondent Shri Ashish Shroti has conceded that the respondent had granted consent to petitioner No.1 to run the factory vide consent No. AWH-42822 from 24.12.2013 to 31.10.2014. However, he has contended that on the dates of inspections i.e. 03.02.2014 and 19.04.2014, the officers of the respondent found violations of the provisions of the Acts, which are mentioned in paras-9 and 10 of the complaint, for which the prosecution is launched against the petitioners and co-accused Manish Kumar. The respondent sent in the inspection notes (Annexures Ex.P/4 and Ex.P/8) to the occupier of the factory with covering letters dated 11.04.2014 and 29.09.2014, which were acknowledged on behalf of the petitioner No.1 vide letters dated 29.04.2014 and 14.10.2014 ( Annexures P/7 and Ex.P/15). Therefore, the subsequent compliance of the 7 M.Cr.C. No.13852/2016 conditions by petitioner No.1 will not wipe out the offences having been committed by the petitioners No. 1, 2 and co-accused Manish Kumar. It is submitted that the status of petitioner No.2 Ashok Bhave in the case is an occupier as defined in clause (d) of Section 2 of the Water Act and clause (m) of Section 2 of the Air Act. Therefore, he is also responsible for violations of the provisions of the Acts as mentioned in the complaint. It is submitted that the respondent has no Authority to cancel the license of petitioner No1. It has only power to prosecute the petitioners and co- accused Manish Kumar for the violations of the provisions of the Acts. Upon these submissions, it is prayed by him that this petition deserves to be dismissed being devoid of merits and substance.
9. I have considered the rival submissions made by the learned counsel for the parties across the Bar and perused the entire materials on record.
10. Upon the perusal of the provisions of the Water Act and the Air Act, I have found that no provisions are there whereby the subsequent compliance of the provisions of the Act having already been violated would wipe out the offence(s). Therefore, the prosecution against the petitioners cannot be quashed on the sole ground that later petitioner No.1 has complied with the conditions imposed upon it in the consent letters issued by the respondent.
11. From the material on record, it is manifest that on the basis of inspections dated 03.02.2014 and 19.04.2014, the respondent issued notices to the 8 M.Cr.C. No.13852/2016 occupier of the factory. The acts of giving notices prima-facie prove the violations of the provisions of the Acts by the petitioners and co-accused Manish Kumar as stated in the complaint.
12. Upon the meticulous reading of provisions of the Acts and the rules made thereunder, I have found that the respondent has no authority to cancel the license of petitioner No.1. It has only power to prosecute the violator(s).
13. Now, I refer to some illuminating decisions of the Supreme Court wherein the parameters of quashment of the FIR/complaint and subsequent proceedings thereunder are laid down in exercise of the power under Section 482 Cr.P.C.
14. In the case of Zandu Pharmaceutical Works Ltd. Vs. Mohd. Sharful Haque and another [(2005) 1 SCC 122], the Supreme Court has laid down that the High Court may exercise extraordinary power conferred under Section 482 of the Cr.P.C. in the following three circumstances namely:-
(i) to give effect to an order under the Cr.P.C.,
(ii) to prevent abuse of the process of the court.
(iii) to secure the ends of justice.
In view of the above propositions of law, I have examined the entire record and found that none of the above circumstances exists in the instant case, warranting the exercise of power by me under Section 482 of the Cr.P.C. to quash the complaint and the 9 M.Cr.C. No.13852/2016 subsequent proceedings.
15. In the case of MCD Vs. Ram Kishan Rohtagi [(1983) 1 SCC 1], the Supreme Court has held thus:-
"The inherent power should not be exercised to stifle a legitimate prosecution. The High Court should refrain from giving a prima facie decision unless there are compelling circumstances to do so. Taking the allegations and the complaint as they were, without adding or subtracting anything, if no offence was made out, only then the High Court would be justified in quashing the proceedings in the exercise of its power under Section 482 Cr.P.C."
Upon the examination of the complainant in the light of the aforesaid ratio, I have found that the complaint prima facie discloses the offences committed by the petitioners, which are punishable under the Acts. Hence, the complaint cannot be quashed.
16. In the case of Taramani Parakh Vs. State of M.P. and ors., (2015 Cr.L.J. (SC) 2031) the Supreme Court has held as under:-
"27.1. Though there are no limits of the power of this Court under Section 482 of the Code but the more the power, the more due care and caution is to be exercised in invoking these powers. The power of quashing criminal proceedings, particularly, the charge framed in terms of Section 228 of the Code should be exercised very sparingly and with circumspection and that too in the rarest of the rare cases.
"27.2. The Court should apply the test as to whether the uncontroverted allegations as made from the record of the case and the documents submitted therewith prima 10 M.Cr.C. No.13852/2016 facie establish the offence or not. If the allegations are so patently absurd and inherently improbable that no prudent person can ever reach such a conclusion and where the basic ingredients of a criminal offence are not satisfied then the Court may interfere.
27.13. Quashing of a charge is an exception to the rule of continuous prosecution. Where the offence is even broadly satisfied, the Court should be more inclined to permit continuation of prosecution rather than its quashing at that initial stage. The Court is not expected to marshal the records with a view to decide admissibility and reliability of the documents or records but is an opinion formed prima facie."
As already stated the learned C.J.M. has taken the cognizance against the petitioners and co-accused Manish Kumar vide the order dated 11.08.2015 and the revision filed by the petitioners against the said cognizance was dismissed by the learned Sessions Judge vide the order dated 25.05.2016 passed in criminal revision No. 100123/2015. Therefore, in the light of the aforesaid parameters the complaint cannot be quashed.
17. The Supreme Court in the cases of Indian Oil Corporation Vs. NEPC India Limited [(2009) 1 SCC
516)], R. Kalyani Vs. Janak C. Mehta (AIR 1992 SCW
237), State of Haryana Vs. Bhajanlal (AIR 1992 SCW
237) and Prashant Bharti Vs. State of NCT of Delhi (AIR 2013 SC 275) has laid down certain principles of law for quashing the FIRs/Complaints/Investigations and subsequent criminal proceedings. After testing the 11 M.Cr.C. No.13852/2016 contentions raised on behalf of the petitioners on the touchstone of the said principles of law, I have found that not a single ground is made out by the petitioners to quash the complaint and the subsequent proceedings in the case.
18. Thus, in the totality of circumstances, the legal position and the fact situation of the case, no ground is made out by the petitioners for interference under Section 482 Cr.P.C.
19. In the result, this petition must fail and is hereby dismissed. The interim order dated 17.08.2016 passed by this court in the instant case stands vacated. It is made clear that the status of petitioner No.2 as the occupier of the factory is not decided finally in this order. Therefore, he has a liberty to challenge his said status in the course of trial of the case.
20. Accordingly, this petition is finally disposed of.
(Rajendra Mahajan) Judge dixit/-
12M.Cr.C. No.13852/2016 THE HIGH COURT OF MADHYA PRADESH AT JABALPUR (Single Bench - Rajendra Mahajan, J.) M.Cr.C.No. 13852/2016
1. M/s. Parle Agro Private Ltd., Plot No.44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.) through Balchandra S Virkar.
2. Ashok Bhave, Director, M/s. Parle Agro Private Ltd., Plot No. 44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.), through Balchandra S Vikar.
Petitioners.
V e r s u s Madhya Pradesh Pollution Control Board (M.P.P.C.B.), through Dr. N.K. Verma (Scientist), Regional Office, Paryawaran Parisar, Arera Colony, E-5 Bhopal (M.P.).
Respondent.
Post for : 11.04.2017 (Rajendra Mahajan) Judge 10.04.2017 13 M.Cr.C. No.13852/2016 Cause-List Section Posting for 11.04.2017 (Single Bench - Rajendra Mahajan, J.) M.Cr.C.No. 13852/2016
1. M/s. Parle Agro Private Ltd., Plot No.44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.) through Balchandra S Virkar.
2. Ashok Bhave, Director, M/s. Parle Agro Private Ltd., Plot No. 44-46, New Industrial Area-2, Mandideep, District Raisen (M.P.), through Balchandra S Vikar.
Petitioners.
V e r s u s Madhya Pradesh Pollution Control Board (M.P.P.C.B.), through Dr. N.K. Verma (Scientist), Regional Office, Paryawaran Parisar, Arera Colony, E-5 Bhopal (M.P.).
Respondent.
----------------------------------------------------------- For Petitioners : Shri Surendra Singh, learned senior counsel with Shri Avinash Zargar, learned counsel for the petitioners. For Respondent: Shri Ashish Shroti, learned counsel for the respondent.
----------------------------------------------------------


Meeting Analysis Tool
Upload a .wav audio file to analyze.
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{message}}
{% endfor %}
{% endif %}
{% endwith %}
{% block body %}{% endblock %}
Upload a new file
Choose an uploaded file to analyze
Uploaded files:
{% if data.type == "individual" %}
{% elif data.type == "aggregate" %}
{% endif %}
Analysis of audio file {{ data.name }}
Total time (seconds) of audio:
{{ data.total_time }}
Time talked by males:
{{ data.m_time }}
Time talked by females:
{{ data.f_time }}
Ratio male:
{{ data.m_ratio }}
Ratio female:
{{ data.f_ratio }}
Analysis of all audio files
Total time (seconds) of audio:
{{ data.total_time }}
Time talked by males:
{{ data.m_time }}
Time talked by females:
{{ data.f_time }}
Ratio male:
{{ data.m_ratio }}
Ratio female:
{{ data.f_ratio }}


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
S
save()
- Method in class anomaly.
AnomalyStructure
Schedule
- Class in
sync
Schedule(int, boolean)
- Constructor for class sync.
Schedule
scheduleGen
- Class in
anomaly
scheduleGen(Context, Model, DeclaredObjects, ArrayList<Table>, Map<Tuple<Expr, Expr>, Tuple<Expr, Integer>>, List<Expr>, List<Expr>, Application)
- Constructor for class anomaly.
scheduleGen
Scheduler
- Class in
sync
Scheduler(int, boolean, String, int)
- Constructor for class sync.
Scheduler
schedules
- package schedules
setApp(Application)
- Method in class anomaly.
Anomaly
setArray(int, Array)
- Method in class
MyPreparedStatement
setAsciiStream(int, InputStream, int)
- Method in class
MyPreparedStatement
setAsciiStream(int, InputStream, long)
- Method in class
MyPreparedStatement
setAsciiStream(int, InputStream)
- Method in class
MyPreparedStatement
setAutoCommit(boolean)
- Method in class
MyConnection
setBigDecimal(int, BigDecimal)
- Method in class
MyPreparedStatement
setBinaryStream(int, InputStream, int)
- Method in class
MyPreparedStatement
setBinaryStream(int, InputStream, long)
- Method in class
MyPreparedStatement
setBinaryStream(int, InputStream)
- Method in class
MyPreparedStatement
setBlob(int, Blob)
- Method in class
MyPreparedStatement
setBlob(int, InputStream, long)
- Method in class
MyPreparedStatement
setBlob(int, InputStream)
- Method in class
MyPreparedStatement
setBoolean(int, boolean)
- Method in class
MyPreparedStatement
setByte(int, byte)
- Method in class
MyPreparedStatement
setBytes(int, byte[])
- Method in class
MyPreparedStatement
setCatalog(String)
- Method in class
MyConnection
setCharacterStream(int, Reader, int)
- Method in class
MyPreparedStatement
setCharacterStream(int, Reader, long)
- Method in class
MyPreparedStatement
setCharacterStream(int, Reader)
- Method in class
MyPreparedStatement
setClientInfo(String, String)
- Method in class
MyConnection
setClientInfo(Properties)
- Method in class
MyConnection
setClob(int, Clob)
- Method in class
MyPreparedStatement
setClob(int, Reader, long)
- Method in class
MyPreparedStatement
setClob(int, Reader)
- Method in class
MyPreparedStatement
setCore(boolean)
- Method in class anomaly.
Anomaly
setCtx(Context)
- Method in class anomaly.
Anomaly
setCursorName(String)
- Method in class
MyPreparedStatement
setCursorName(String)
- Method in class
MyStatement
setDate(int, Date)
- Method in class
MyPreparedStatement
setDate(int, Date, Calendar)
- Method in class
MyPreparedStatement
setDouble(int, double)
- Method in class
MyPreparedStatement
setEscapeProcessing(boolean)
- Method in class
MyPreparedStatement
setEscapeProcessing(boolean)
- Method in class
MyStatement
setExps(Map<Value, Expression>)
- Method in class ar.
Transaction
setExtractionTime(long, long)
- Method in class anomaly.
Anomaly
setFetchDirection(int)
- Method in class
MyPreparedStatement
setFetchDirection(int)
- Method in class
MyStatement
setFetchSize(int)
- Method in class
MyPreparedStatement
setFetchSize(int)
- Method in class
MyStatement
setFloat(int, float)
- Method in class
MyPreparedStatement
setHoldability(int)
- Method in class
MyConnection
setI_values(List<Expression>)
- Method in class ar.statement.
Query
setInt(int, int)
- Method in class
MyPreparedStatement
setLong(int, long)
- Method in class
MyPreparedStatement
setMaxFieldSize(int)
- Method in class
MyPreparedStatement
setMaxFieldSize(int)
- Method in class
MyStatement
setMaxRows(int)
- Method in class
MyPreparedStatement
setMaxRows(int)
- Method in class
MyStatement
setModel(Model)
- Method in class anomaly.
Anomaly
setName(String)
- Method in class anomaly.
Anomaly
setNCharacterStream(int, Reader, long)
- Method in class
MyPreparedStatement
setNCharacterStream(int, Reader)
- Method in class
MyPreparedStatement
setNClob(int, NClob)
- Method in class
MyPreparedStatement
setNClob(int, Reader, long)
- Method in class
MyPreparedStatement
setNClob(int, Reader)
- Method in class
MyPreparedStatement
setNetworkTimeout(Executor, int)
- Method in class
MyConnection
setNString(int, String)
- Method in class
MyPreparedStatement
setNull(int, int)
- Method in class
MyPreparedStatement
setNull(int, int, String)
- Method in class
MyPreparedStatement
setObject(int, Object, int)
- Method in class
MyPreparedStatement
setObject(int, Object)
- Method in class
MyPreparedStatement
setObject(int, Object, int, int)
- Method in class
MyPreparedStatement
setPathCond(Expression)
- Method in class ar.statement.
Statement
setPoolable(boolean)
- Method in class
MyPreparedStatement
setPoolable(boolean)
- Method in class
MyStatement
setQueryTimeout(int)
- Method in class
MyPreparedStatement
setQueryTimeout(int)
- Method in class
MyStatement
setReadOnly(boolean)
- Method in class
MyConnection
setRef(int, Ref)
- Method in class
MyPreparedStatement
setRowId(int, RowId)
- Method in class
MyPreparedStatement
setSavepoint()
- Method in class
MyConnection
setSavepoint(String)
- Method in class
MyConnection
setSchema(String)
- Method in class
MyConnection
setShort(int, short)
- Method in class
MyPreparedStatement
setSQLXML(int, SQLXML)
- Method in class
MyPreparedStatement
setString(int, String)
- Method in class
MyPreparedStatement
setsVar(Expression)
- Method in class ar.statement.
Query
setTime(int, Time)
- Method in class
MyPreparedStatement
setTime(int, Time, Calendar)
- Method in class
MyPreparedStatement
setTimestamp(int, Timestamp)
- Method in class
MyPreparedStatement
setTimestamp(int, Timestamp, Calendar)
- Method in class
MyPreparedStatement
setTransactionIsolation(int)
- Method in class
MyConnection
setType(SqlStmtType)
- Method in class ar.statement.
InvokeStmt
setTypeMap(Map<String, Class<?>>)
- Method in class
MyConnection
setTypes()
- Method in class ar.
Transaction
setU_updates(Map<Column, Expression>)
- Method in class ar.statement.
Query
setUnicodeStream(int, InputStream, int)
- Method in class
MyPreparedStatement
setURL(int, URL)
- Method in class
MyPreparedStatement
size()
- Method in class anomaly.
AnomalyStructure
SqlStmtType
- Class in
ar.statement
SqlStmtType(String, String, int, boolean, int)
- Constructor for class ar.statement.
SqlStmtType
SqlTypeNotFoundException
- Exception in
exceptions
SqlTypeNotFoundException()
- Constructor for exception exceptions.
SqlTypeNotFoundException
SqlTypeNotFoundException(String)
- Constructor for exception exceptions.
SqlTypeNotFoundException
SqlTypeNotFoundException(Throwable)
- Constructor for exception exceptions.
SqlTypeNotFoundException
SqlTypeNotFoundException(String, Throwable)
- Constructor for exception exceptions.
SqlTypeNotFoundException
SqlTypeNotFoundException(String, Throwable, boolean, boolean)
- Constructor for exception exceptions.
SqlTypeNotFoundException
Statement
- Class in
ar.statement
Statement(Expression)
- Constructor for class ar.statement.
Statement
StaticAssertions
- Class in
Z3
StaticAssertions(Context, DeclaredObjects)
- Constructor for class Z3.
StaticAssertions
suite()
- Static method in class com.github.kiarahmani.replayer.
AppTest
sync
- package sync
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


SMBC taps into Toronto AI scene through Mars partnership
Sumitomo Mitsui Banking Corporation (SMBC) is looking to gain access to Toronto's AI expertise through a partnership with the Canadian city's Mars fintech cluster.
SMBC joins the likes of CIBC and Interac as partners in the fintech cluster at the Mars Discovery District innovation hub in downtown Toronto.
Toronto has established itself as a leading AI centre, with a host of world class research institutions and a thriving startup scene.
SMBC says it wants to use the Mars network of startups working in AI and other cutting edge areas to accelerate its own digital innovation strategy, exploring collaboration that can benefit its corporate clients in Japan.


QUIZ 6
DRAG AND DROP THE CORRECT ANSWER
PERTH (GMT+8)
TOKYO (GMT+9)
MOSCOW (GMT+3)
JAKARTA (GMT+7)
LONDON (GMT+1)


About Garamond
The font is named after a French engraver, Claude Garamond, who lived during the late 1400s and early 1500s. He used old-style serif letter design for his engraving punches. Some of the characteristics of his punches resemble the Garamond typeface, which may be why it was named after him.
For example, the circle on the lowercase letter “e” is quite small and closed. The capital letters resemble Roman square capitals, and the letter “M” has serifs that edge outwards. On some letters, such as the letter “R,” the leg of the letter extends out past the rest of the letter. These characteristics make Garamond easily recognizable and regal-looking in nature. The accents, such as the leg of the “R,” make this font immediately recognizable.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/automatic.20help.20for.20diagnosing.20.60erw.60.html ---
I would _love_ to have some tactic level help for diagnosing erw
. The general problem is that sometimes implicit arguments are not syntactically in the expected form (although definitionally correct), and while rw
and simp
won't work, erw
will. I'd love to be able to see quickly which subexpression(s) is making the difference that causes rw
to fail but erw
to succeed.
Can anyone suggest a strategy for achieving this?
I'm pretty confident I can do the tactic writing required, or at least start, but I'm not sure what I should even try to do.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


--- layout: default title: About | Indivisible Brooklyn ---
Indivisible Brooklyn is a community of citizens in Brooklyn, New York, organizing to take sustainable, consistent, collective political action aimed at the federal, New York State, and New York City governments, to
We're part of the nationwide grassroots movement inspired by the Indivisible Guide. We welcome Brooklynites of all races, classes, sexual orientations, gender identities, ethnicities, ages, religions, and physical abilities. We aim to provide each other with support and accountability in a community that shares values, goals, and the desire to defend against the regressive policies of this administration.
We're currently organizing in three teams. Each team works with its members to define pressing issues, set goals, and organize actions, sharing information with the rest of the group. Every member of Indivisible Brooklyn is always encouraged to join actions coordinated by other teams.
If you have any questions, please email us at indivisiblebrooklyn [at] gmail [dot] com. If you're interested in joining our group or receiving updates from us, please sign up! (We won't share your personal information with anyone outside Indivisible Brooklyn.)


Roasted Red Bell Peppers
Chicken Wild Rice Soup
Sausage, Potato, and Cabbage Soup
Chicken Barley Soup
Baked Fish in Lemon Cream Sauce
Chicken On A Stick
Breakfast Casserole
Pizza
Mushroom Stroganoff
Pesto Pasta
Thai Fried Rice
Easy Ramen
Dinner Rolls
Dark Chcocolate Chip Banana Bread
Cinnamon Rolls
Apple Cake
Pumpkin Pie
Fruit Pizza
Nestle Chocolate Chip Cookies
Gingersnap Cookies
Meringue Cookies
Rice Crispie Treats


{% load staticfiles %} {% load website_tags %}
Select the questions you wish to include in the dataset download. Please note that the download may take some time due to the size of the database.
{{key}}


Loading Screen Example with a button to enter. The button is available only when all assets are loaded. This example also loads an audio that will be played when the button is pressed.


Class LaserRandom
- All Implemented Interfaces:
java.io.Serializable
public class LaserRandom
extends java.util.Random
implements java.io.Serializable
Random
.
This allows many different random number streams that don't overlap, and offers a much more substantial
API for commonly-used functions.
This fills in much of the functionality of MathUtils in libGDX, though with all code as instance methods instead of static methods, and some things renamed (randomTriangular() became
nextTriangular()
,
for instance, and random() became nextFloat()
). It also supplies some rare and sometimes-useful
code: skip(long)
allows "fast-forward" and "rewind," you can get and set the exact state with
getStateA()
, getStateB()
, setStateA(long)
, and setStateB(long)
(which
is useful if you want to save a LaserRandom and reload it later), and there's bounded int and long
generators which can use a negative number as their exclusive outer bound nextSignedInt(int)
and
nextSignedLong(long)
, plus overloads that take an inner bound).
Every method defined in this class advances the state by the same amount unless otherwise documented (only
nextTriangular()
and nextTriangular(float)
advance the state twice). The state can
advance 2 to the 64 times before the sequence of random numbers repeats, which would take a few years of
continuous generation. There are also 2 to the 63 possible sequences this can produce; you can tell which
one you're using with getStream()
. Note, Random
can only advance 2 to the 48 times, which
takes under half a day to make it repeat on recent laptop hardware while also analyzing the numbers for
statistical issues. This generator is more comparable to SplittableRandom, introduced in JDK 8 but not
available in Android (even with desugaring) or GWT currently. SplittableRandom also can produce 2 to the
64 numbers before repeating the sequence, but it will always produce each possible long value exactly once
over the course of that sequence. Each of LaserRandom's streams produces a different sequence of numbers
with a different set of numbers it omits and a different set of numbers it produces more than once; each
of SplittableRandom's streams simply rearranges the order of all possible longs. Though it might seem like
an issue that a LaserRandom stream has gaps in its possible output, if you appended all 2 to the 63
possible LaserRandom streams in full, the gargantuan result would include all longs equally often. So, if
the stream is selected effectively at random, then the subset of that stream that actually gets used
should be fair (and it's very unlikely that any usage will need a full stream of over 18 quintillion
pseudo-random longs).
If statistical quality is a concern, don't use
Random
, since the aforementioned
analysis finds statistical failures in about a minute when checking about 16GB of output; this class can
produce 64TB of random output without a tool like PractRand finding any failures (sometimes it can't find
any minor anomaly over several days of testing). RandomXS128 has some flaws, though they are not nearly as
severe as Random's; mostly they are limited to a particular kind of failure affecting the least
significant bits. RandomXS128's flaws would be permissible if it was faster than any competitors, but it
isn't, and there have been two improved relatives of its algorithm published since it was created. Both of
these improvements, xoroshiro128** and xoshiro256**, are slower when implemented in Java than LaserRandom
(also when all are implemented in C and compiled with GCC or Clang, typically). There are also some
concerns about specific failure cases when the output of xoroshiro128** or xoshiro256** is multiplied by
any of quadrillions of constants and tested after that multiplication (see M.E. O'Neill's dissection of
xoshiro256** here).
You can copy this class independently of the library it's part of; it's meant as a general replacement for Random and also RandomXS128. LaserRandom is generally faster than RandomXS128, and can be over 3x faster when running on OpenJ9 (generating over 3 billion random long values per second).
Pew pew! Lasers!
- See Also:
- Serialized Form
-
Field Summary
-
Constructor Summary
Constructors Constructor Description LaserRandom()
Creates a new LaserRandom.LaserRandom(long seed)
Creates a new LaserRandom using a singlelong
seed; the stream depends on whether the seed is even or odd.LaserRandom(long seedA, long seedB)
Creates a new LaserRandom usingseedA
exactly to set stateA (as withsetStateA(long)
,, and usingseedB
to set stateB as withsetStateB(long)
(meaning seedB will be used exactly if odd, otherwise it will have 1 added to it and then used). -
Method Summary
Modifier and Type Method Description LaserRandom
copy()
long
getStateA()
Get the "A" part of the internal state as a long.long
getStateB()
Get the "B" part of the internal state as a long.long
getStream()
Gets a long that identifies which stream of numbers this generator is producing; this stream identifier is always an odd long and won't change by generating numbers.int
next(int bits)
Generates the next pseudorandom number with a specific maximum size in bits (not a max number).boolean
nextBoolean()
Returns the next pseudorandom, uniformly distributedboolean
value from this random number generator's sequence.boolean
nextBoolean(float chance)
Returns true if a random value between 0 and 1 is less than the specified value.void
nextBytes(byte[] bytes)
Generates random bytes and places them into a user-supplied byte array.double
nextDouble()
Returns the next pseudorandom, uniformly distributeddouble
value between0.0
(inclusive) and1.0
(exclusive) from this random number generator's sequence.double
nextDouble(double outerBound)
double
nextDouble(double innerBound, double outerBound)
float
nextFloat()
Returns the next pseudorandom, uniformly distributedfloat
value between0.0
(inclusive) and1.0
(exclusive) from this random number generator's sequence.float
nextFloat(float outerBound)
float
nextFloat(float innerBound, float outerBound)
double
nextGaussian()
Returns the next pseudorandom, Gaussian ("normally") distributeddouble
value with mean0.0
and standard deviation1.0
from this random number generator's sequence.int
nextInt()
Returns the next pseudorandom, uniformly distributedint
value from this random number generator's sequence.int
nextInt(int bound)
Returns a pseudorandom, uniformly distributedint
value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.int
nextInt(int innerBound, int outerBound)
Returns a pseudorandom, uniformly distributedint
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive).long
nextLong()
Returns the next pseudorandom, uniformly distributedlong
value from this random number generator's sequence.long
nextLong(long bound)
Returns a pseudorandom, uniformly distributedlong
value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.long
nextLong(long innerBound, long outerBound)
Returns a pseudorandom, uniformly distributedlong
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive).int
nextSign()
Returns -1 or 1, randomly.int
nextSignedInt(int outerBound)
Returns a pseudorandom, uniformly distributedint
value between an inner bound of 0 (inclusive) and the specifiedouterBound
(exclusive).int
nextSignedInt(int innerBound, int outerBound)
Returns a pseudorandom, uniformly distributedint
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive).long
nextSignedLong(long outerBound)
Returns a pseudorandom, uniformly distributedlong
value between an inner bound of 0 (inclusive) and the specifiedouterBound
(exclusive).long
nextSignedLong(long innerBound, long outerBound)
Returns a pseudorandom, uniformly distributedlong
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive).float
nextTriangular()
Returns a triangularly distributed random number between -1.0 (exclusive) and 1.0 (exclusive), where values around zero are more likely.float
nextTriangular(float max)
Returns a triangularly distributed random number between-max
(exclusive) andmax
(exclusive), where values around zero are more likely.float
nextTriangular(float min, float max)
Returns a triangularly distributed random number betweenmin
(inclusive) andmax
(exclusive), where themode
argument defaults to the midpoint between the bounds, giving a symmetric distribution.float
nextTriangular(float min, float max, float mode)
Returns a triangularly distributed random number betweenmin
(inclusive) andmax
(exclusive), where values aroundmode
are more likely.static double
probit(double d)
A way of taking a double in the (0.0, 1.0) range and mapping it to a Gaussian or normal distribution, so high inputs correspond to high outputs, and similarly for the low range.<T> T
randomElement(T[] array)
void
setSeed(long seed)
Sets the seed of this random number generator using a singlelong
seed.void
setState(long stateA, long stateB)
Sets both parts of the internal state with one call;stateA
is used verbatim, butstateB
has its least significant bit ignored and always overwritten with a '1' bit (meaning stateB will always be odd).void
setStateA(long stateA)
Set the "A" part of the internal state with a long.void
setStateB(long stateB)
Set the "B" part of the internal state with a long; the least significant bit is ignored (will always be odd).void
shuffle(boolean[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(char[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(double[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(float[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(int[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(long[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.void
shuffle(short[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.<T> void
shuffle(T[] items)
Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.long
skip(long advance)
Advances or rolls back theLaserRandom
' state without actually generating each number.Methods inherited from class java.util.Random
doubles, doubles, doubles, doubles, ints, ints, ints, ints, longs, longs, longs, longs
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Field Details
-
stateA
protected long stateACan be any long value. -
stateB
protected long stateBMust be odd.
-
-
Constructor Details
-
LaserRandom
public LaserRandom()Creates a new LaserRandom. This constructor sets the states of the random number generator to values very likely to be distinct from any other invocation of this constructor. -
LaserRandom
public LaserRandom(long seed)Creates a new LaserRandom using a singlelong
seed; the stream depends on whether the seed is even or odd.- Parameters:
seed
- the initial seed- See Also:
setSeed(long)
-
LaserRandom
public LaserRandom(long seedA, long seedB)Creates a new LaserRandom usingseedA
exactly to set stateA (as withsetStateA(long)
,, and usingseedB
to set stateB as withsetStateB(long)
(meaning seedB will be used exactly if odd, otherwise it will have 1 added to it and then used).- Parameters:
seedA
- any long; will be used exactly to set stateA as withsetStateA(long)
seedB
- any odd long will be used exactly to set stateB, otherwise, as withsetStateB(long)
, it will be made odd
-
-
Method Details
-
getStateA
public long getStateA()Get the "A" part of the internal state as a long.- Returns:
- the current internal "A" state of this object.
-
setStateA
public void setStateA(long stateA)Set the "A" part of the internal state with a long.- Parameters:
stateA
- a 64-bit long
-
getStateB
public long getStateB()Get the "B" part of the internal state as a long.- Returns:
- the current internal "B" state of this object.
-
setStateB
public void setStateB(long stateB)Set the "B" part of the internal state with a long; the least significant bit is ignored (will always be odd). That is, if stateB is odd, this uses it verbatim; if stateB is even, it adds 1 to it to make it odd.- Parameters:
stateB
- a 64-bit long; the lowest bit will be ignored and the result always used as an odd number
-
setState
public void setState(long stateA, long stateB)Sets both parts of the internal state with one call;stateA
is used verbatim, butstateB
has its least significant bit ignored and always overwritten with a '1' bit (meaning stateB will always be odd). You can use any long for stateA without it being changed, and can use any odd long for stateB without it being changed; as such, keepingstateB
an odd number should be optimal.- Parameters:
stateA
- a 64-bit longstateB
- a 64-bit long; the lowest bit will be ignored and the result always used as an odd number
-
setSeed
public void setSeed(long seed)Sets the seed of this random number generator using a singlelong
seed. The general contract ofsetSeed
is that it alters the state of this random number generator object so as to be in exactly the same state as if it had just been created with the argumentseed
as a seed.The implementation of
setSeed
by classRandom
uses all 64 bits of the given seed. In general, however, an overriding method may use all 64 bits of thelong
argument as a seed value.- Overrides:
setSeed
in classjava.util.Random
- Parameters:
seed
- the initial seed
-
next
public int next(int bits)Generates the next pseudorandom number with a specific maximum size in bits (not a max number). If you want to get a random number in a range, you should usually usenextInt(int)
instead. For some specific cases, this method is more efficient and less biased thannextInt(int)
. Forbits
values between 1 and 30, this should be similar in effect tonextInt(1 << bits)
; though it won't typically produce the same values, they will have the correct range. Ifbits
is 31, this can return any non-negativeint
; note thatnextInt(1 << 31)
won't behave this way because1 << 31
is negative. Ifbits
is 32 (or 0), this can return anyint
.The general contract of
next
is that it returns anint
value and if the argumentbits
is between1
and32
(inclusive), then that many low-order bits of the returned value will be (approximately) independently chosen bit values, each of which is (approximately) equally likely to be0
or1
.- Overrides:
next
in classjava.util.Random
- Parameters:
bits
- random bits- Returns:
- the next pseudorandom value from this random number generator's sequence
-
nextBytes
public void nextBytes(byte[] bytes)Generates random bytes and places them into a user-supplied byte array. The number of random bytes produced is equal to the length of the byte array.- Overrides:
nextBytes
in classjava.util.Random
- Parameters:
bytes
- the byte array to fill with random bytes- Throws:
java.lang.NullPointerException
- if the byte array is null
-
nextInt
public int nextInt()Returns the next pseudorandom, uniformly distributedint
value from this random number generator's sequence. The general contract ofnextInt
is that oneint
value is pseudorandomly generated and returned. All 232 possibleint
values are produced with (approximately) equal probability.- Overrides:
nextInt
in classjava.util.Random
- Returns:
- the next pseudorandom, uniformly distributed
int
value from this random number generator's sequence
-
nextInt
public int nextInt(int bound)Returns a pseudorandom, uniformly distributedint
value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract ofnextInt
is that oneint
value in the specified range is pseudorandomly generated and returned. Allbound
possibleint
values are produced with (approximately) equal probability.
It should be mentioned that the technique this uses has some bias, depending onbound
, but it typically isn't measurable without specifically looking for it. Using the method this does allows this method to always advance the state by one step, instead of a varying and unpredictable amount with the more typical ways of rejection-sampling random numbers and only using numbers that can produce an int within the bound without bias. See M.E. O'Neill's blog about random numbers for discussion of alternative, unbiased methods.- Overrides:
nextInt
in classjava.util.Random
- Parameters:
bound
- the upper bound (exclusive). If negative or 0, this always returns 0.- Returns:
- the next pseudorandom, uniformly distributed
int
value between zero (inclusive) andbound
(exclusive) from this random number generator's sequence
-
nextSignedInt
public int nextSignedInt(int outerBound)Returns a pseudorandom, uniformly distributedint
value between an inner bound of 0 (inclusive) and the specifiedouterBound
(exclusive). This is meant for cases where the outer bound may be negative, especially if the bound is unknown or may be user-specified. A negative outer bound is used as the lower bound; a positive outer bound is used as the upper bound. An outer bound of -1, 0, or 1 will always return 0, keeping the bound exclusive (except for outer bound 0). This method is slightly slower thannextInt(int)
.- Parameters:
outerBound
- the outer exclusive bound; may be any int value, allowing negative- Returns:
- a pseudorandom int between 0 (inclusive) and outerBound (exclusive)
-
nextInt
public int nextInt(int innerBound, int outerBound)Returns a pseudorandom, uniformly distributedint
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive). IfouterBound
is less than or equal toinnerBound
, this always returnsinnerBound
.
For any case where outerBound might be valid but less than innerBound, you can usenextSignedInt(int, int)
.- Parameters:
innerBound
- the inclusive inner bound; may be any int, allowing negativeouterBound
- the exclusive outer bound; must be greater than innerBound (otherwise this returns innerBound)- Returns:
- a pseudorandom int between innerBound (inclusive) and outerBound (exclusive)
-
nextSignedInt
public int nextSignedInt(int innerBound, int outerBound)Returns a pseudorandom, uniformly distributedint
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive). This is meant for cases where either bound may be negative, especially if the bounds are unknown or may be user-specified. It is slightly slower thannextInt(int, int)
.- Parameters:
innerBound
- the inclusive inner bound; may be any int, allowing negativeouterBound
- the exclusive outer bound; may be any int, allowing negative- Returns:
- a pseudorandom int between innerBound (inclusive) and outerBound (exclusive)
-
nextLong
public long nextLong()Returns the next pseudorandom, uniformly distributedlong
value from this random number generator's sequence. The general contract ofnextLong
is that onelong
value is pseudorandomly generated and returned.
An individualLaserRNG
can't return all 18-quintillion possiblelong
values, but the full set of 9-quintillion possible random number streams that this class can produce will, as a whole, produce alllong
values with equal likelihood.- Overrides:
nextLong
in classjava.util.Random
- Returns:
- the next pseudorandom, uniformly distributed
long
value from this random number generator's sequence
-
nextLong
public long nextLong(long bound)Returns a pseudorandom, uniformly distributedlong
value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract ofnextLong
is that onelong
value in the specified range is pseudorandomly generated and returned. Allbound
possiblelong
values are produced with (approximately) equal probability.
Note that this advances the state by the same amount as a single call tonextLong()
, which allows methods likeskip(long)
to function correctly, but introduces some bias whenbound
is very large. This will also advance the state ifbound
is 0 or negative, so usage with a variable bound will advance the state reliably.
This method has some bias, particularly on larger bounds. Actually measuring bias with bounds in the trillions or greater is challenging but not impossible, so don't use this for a real-money gambling purpose. The bias isn't especially significant, though.- Parameters:
bound
- the upper bound (exclusive). If negative or 0, this always returns 0.- Returns:
- the next pseudorandom, uniformly distributed
long
value between zero (inclusive) andbound
(exclusive) from this random number generator's sequence
-
nextSignedLong
public long nextSignedLong(long outerBound)Returns a pseudorandom, uniformly distributedlong
value between an inner bound of 0 (inclusive) and the specifiedouterBound
(exclusive). This is meant for cases where the outer bound may be negative, especially if the bound is unknown or may be user-specified. A negative outer bound is used as the lower bound; a positive outer bound is used as the upper bound. An outer bound of -1, 0, or 1 will always return 0, keeping the bound exclusive (except for outer bound 0).Note that this advances the state by the same amount as a single call to
nextLong()
, which allows methods likeskip(long)
to function correctly, but introduces some bias whenbound
is very large. This method should be about as fast asnextLong(long)
, unlike the speed difference betweennextInt(int)
andnextSignedInt(int)
.- Parameters:
outerBound
- the outer exclusive bound; may be any long value, allowing negative- Returns:
- a pseudorandom long between 0 (inclusive) and outerBound (exclusive)
-
nextLong
public long nextLong(long innerBound, long outerBound)Returns a pseudorandom, uniformly distributedlong
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive). IfouterBound
is less than or equal toinnerBound
, this always returnsinnerBound
.
For any case where outerBound might be valid but less than innerBound, you can usenextSignedLong(long, long)
.- Parameters:
innerBound
- the inclusive inner bound; may be any long, allowing negativeouterBound
- the exclusive outer bound; must be greater than innerBound (otherwise this returns innerBound)- Returns:
- a pseudorandom long between innerBound (inclusive) and outerBound (exclusive)
-
nextSignedLong
public long nextSignedLong(long innerBound, long outerBound)Returns a pseudorandom, uniformly distributedlong
value between the specifiedinnerBound
(inclusive) and the specifiedouterBound
(exclusive). This is meant for cases where either bound may be negative, especially if the bounds are unknown or may be user-specified.- Parameters:
innerBound
- the inclusive inner bound; may be any long, allowing negativeouterBound
- the exclusive outer bound; may be any long, allowing negative- Returns:
- a pseudorandom long between innerBound (inclusive) and outerBound (exclusive)
-
nextBoolean
public boolean nextBoolean()Returns the next pseudorandom, uniformly distributedboolean
value from this random number generator's sequence. The general contract ofnextBoolean
is that oneboolean
value is pseudorandomly generated and returned. The valuestrue
andfalse
are produced with (approximately) equal probability.- Overrides:
nextBoolean
in classjava.util.Random
- Returns:
- the next pseudorandom, uniformly distributed
boolean
value from this random number generator's sequence
-
nextFloat
public float nextFloat()Returns the next pseudorandom, uniformly distributedfloat
value between0.0
(inclusive) and1.0
(exclusive) from this random number generator's sequence.The general contract of
nextFloat
is that onefloat
value, chosen (approximately) uniformly from the range0.0f
(inclusive) to1.0f
(exclusive), is pseudorandomly generated and returned. All 224 possiblefloat
values of the form m x 2-24, where m is a positive integer less than 224, are produced with (approximately) equal probability.The hedge "approximately" is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose
float
values from the stated range with perfect uniformity.- Overrides:
nextFloat
in classjava.util.Random
- Returns:
- the next pseudorandom, uniformly distributed
float
value between0.0
and1.0
from this random number generator's sequence
-
nextFloat
public float nextFloat(float outerBound) -
nextFloat
public float nextFloat(float innerBound, float outerBound) -
nextDouble
public double nextDouble()Returns the next pseudorandom, uniformly distributeddouble
value between0.0
(inclusive) and1.0
(exclusive) from this random number generator's sequence.The general contract of
nextDouble
is that onedouble
value, chosen (approximately) uniformly from the range0.0d
(inclusive) to1.0d
(exclusive), is pseudorandomly generated and returned.The hedge "approximately" is used in the foregoing description only because the
next
method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choosedouble
values from the stated range with perfect uniformity.- Overrides:
nextDouble
in classjava.util.Random
- Returns:
- the next pseudorandom, uniformly distributed
double
value between0.0
and1.0
from this random number generator's sequence
-
nextDouble
public double nextDouble(double outerBound) -
nextDouble
public double nextDouble(double innerBound, double outerBound) -
nextGaussian
public double nextGaussian()Returns the next pseudorandom, Gaussian ("normally") distributeddouble
value with mean0.0
and standard deviation1.0
from this random number generator's sequence.The general contract of
nextGaussian
is that onedouble
value, chosen from (approximately) the usual normal distribution with mean0.0
and standard deviation1.0
, is pseudorandomly generated and returned.This uses an approximation as implemented by
probit(double)
, which can't produce as extreme results in extremely-rare cases as methods like Box-Muller and Marsaglia Polar can. All but one possible result are between-8.209536145151493
and8.209536145151493
, and the one result outside that is38.5
.- Overrides:
nextGaussian
in classjava.util.Random
- Returns:
- the next pseudorandom, Gaussian ("normally") distributed
double
value with mean0.0
and standard deviation1.0
from this random number generator's sequence
-
skip
public long skip(long advance)Advances or rolls back theLaserRandom
' state without actually generating each number. Skips forward or backward a number of steps specified by advance, where a step is equal to one call tonextLong()
, and returns the random number produced at that step. Negative numbers can be used to step backward, or 0 can be given to get the most-recently-generated long fromnextLong()
.Note that none of the number-generating methods here advance state differently from
nextLong()
except for the Stream APIs. This is somewhat unusual; in many generators, calls tonextInt(int)
and similar bounded-range random generators can advance the state by a variable amount. Using a fixed advance permits this method and also allows guaranteeing the cycle length (also called period), but introduces a tiny amount of bias for some bounds (mostly very large ones).- Parameters:
advance
- Number of future generations to skip over; can be negative to backtrack, 0 gets the most-recently-generated number- Returns:
- the random long generated after skipping forward or backwards by
advance
numbers
-
copy
-
getStream
public long getStream()Gets a long that identifies which stream of numbers this generator is producing; this stream identifier is always an odd long and won't change by generating numbers. It is determined at construction and will usually (not always) change ifsetStateA(long)
orsetStateB(long)
are called. Each stream is a probably-unique sequence of 2 to the 64 longs, where approximately 1/3 of all possible longs will not ever occur (while others occur twice or more), but this set of results is different for every stream. There are 2 to the 63 possible streams, one for every odd long.- Returns:
- an odd long that identifies which stream this LaserRandom is generating from
-
probit
public static double probit(double d)A way of taking a double in the (0.0, 1.0) range and mapping it to a Gaussian or normal distribution, so high inputs correspond to high outputs, and similarly for the low range. This is centered on 0.0 and its standard deviation seems to be 1.0 (the same asRandom.nextGaussian()
). If this is given an input of 0.0 or less, it returns -38.5, which is slightly less than the result when givenDouble.MIN_VALUE
. If it is given an input of 1.0 or more, it returns 38.5, which is significantly larger than the result when given the largest double less than 1.0 (this value is further from 1.0 thanDouble.MIN_VALUE
is from 0.0). If givenDouble.NaN
, it returns whateverMath.copySign(double, double)
returns for the arguments38.5, Double.NaN
, which is implementation-dependent. It uses an algorithm by Peter John Acklam, as implemented by Sherali Karimov. Original source. Information on the algorithm. Wikipedia's page on the probit function may help, but is more likely to just be confusing.
Acklam's algorithm and Karimov's implementation are both quite fast. This appears faster than generating Gaussian-distributed numbers using either the Box-Muller Transform or Marsaglia's Polar Method, though it isn't as precise and can't produce as extreme min and max results in the extreme cases they should appear. If given a typical uniform randomdouble
that's exclusive on 1.0, it won't produce a result higher than8.209536145151493
, and will only produce results of at least-8.209536145151493
if 0.0 is excluded from the inputs (if 0.0 is an input, the result is38.5
). A chief advantage of using this with a random number generator is that it only requires one random double to obtain one Gaussian value;Random.nextGaussian()
generates at least two random doubles for each two Gaussian values, but may rarely require much more random generation.
This can be used both as an optimization for generating Gaussian random values, and as a way of generating Gaussian values that match a pattern present in the inputs (which you could have by using a sub-random sequence as the input, such as those produced by a van der Corput, Halton, Sobol or R2 sequence). Most methods of generating Gaussian values (e.g. Box-Muller and Marsaglia polar) do not have any way to preserve a particular pattern.- Parameters:
d
- should be between 0 and 1, exclusive, but other values are tolerated- Returns:
- a normal-distributed double centered on 0.0; all results will be between -38.5 and 38.5, both inclusive
-
nextBoolean
public boolean nextBoolean(float chance)Returns true if a random value between 0 and 1 is less than the specified value.- Parameters:
chance
- a float between 0.0 and 1.0; higher values are more likely to result in true- Returns:
- a boolean selected with the given
chance
of being true
-
nextSign
public int nextSign()Returns -1 or 1, randomly.- Returns:
- -1 or 1, selected with approximately equal likelihood
-
nextTriangular
public float nextTriangular()Returns a triangularly distributed random number between -1.0 (exclusive) and 1.0 (exclusive), where values around zero are more likely. Advances the state twice.This is an optimized version of
randomTriangular(-1, 1, 0)
-
nextTriangular
public float nextTriangular(float max)Returns a triangularly distributed random number between-max
(exclusive) andmax
(exclusive), where values around zero are more likely. Advances the state twice.This is an optimized version of
randomTriangular(-max, max, 0)
- Parameters:
max
- the upper limit
-
nextTriangular
public float nextTriangular(float min, float max)Returns a triangularly distributed random number betweenmin
(inclusive) andmax
(exclusive), where themode
argument defaults to the midpoint between the bounds, giving a symmetric distribution. Advances the state once.This method is equivalent of
randomTriangular(min, max, (min + max) * 0.5f)
- Parameters:
min
- the lower limitmax
- the upper limit
-
nextTriangular
public float nextTriangular(float min, float max, float mode)Returns a triangularly distributed random number betweenmin
(inclusive) andmax
(exclusive), where values aroundmode
are more likely. Advances the state once.- Parameters:
min
- the lower limitmax
- the upper limitmode
- the point around which the values are more likely
-
randomElement
public <T> T randomElement(T[] array) -
shuffle
public void shuffle(int[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- an int array; must be non-null
-
shuffle
public void shuffle(long[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a long array; must be non-null
-
shuffle
public void shuffle(float[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a float array; must be non-null
-
shuffle
public void shuffle(char[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a char array; must be non-null
-
shuffle
public void shuffle(double[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a double array; must be non-null
-
shuffle
public void shuffle(short[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a short array; must be non-null
-
shuffle
public void shuffle(boolean[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- a boolean array; must be non-null
-
shuffle
public <T> void shuffle(T[] items)Shuffles the given array in-place pseudo-randomly, using this to determine how to shuffle.- Parameters:
items
- an array of some reference type; must be non-null but may contain null items
-


Uses of Package
org.drip.spaces.metric
| Package | Description |
|---|---|
| org.drip.learning.kernel |
Statistical Learning Banach Mercer Kernels
|
| org.drip.learning.regularization |
Statistical Learning Empirical Loss Regularizer
|
| org.drip.learning.svm |
Kernel SVM Decision Function Operator
|
| org.drip.spaces.functionclass |
Normed Finite Spaces Function Class
|
| org.drip.spaces.metric |
Hilbert/Banach Normed Metric Spaces
|
| org.drip.spaces.rxtor1 |
Rx To R1 Normed Function Spaces
|
| org.drip.spaces.rxtord |
Rx To Rd Normed Function Spaces
|
-
Classes in org.drip.spaces.metric used by org.drip.learning.kernel Class Description R1Combinatorial R1Combinatorial implements the Normed, Bounded/Unbounded Combinatorial lp Rd Spaces.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.learning.regularization Class Description R1Combinatorial R1Combinatorial implements the Normed, Bounded/Unbounded Combinatorial lp Rd Spaces.R1Continuous R1Continuous implements the Normed, Bounded/Unbounded Continuous lp R1 Spaces.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdCombinatorialBanach RdCombinatorialBanach implements the Bounded/Unbounded Combinatorial lp Rd Spaces.RdContinuousBanach RdContinuousBanach implements the Normed, Bounded/Unbounded Continuous lp Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.learning.svm Class Description RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.spaces.functionclass Class Description GeneralizedMetricVectorSpace GeneralizedMetricVectorSpace exposes the basic Properties of the General Normed Metric Vector Space.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.spaces.metric Class Description GeneralizedMetricVectorSpace GeneralizedMetricVectorSpace exposes the basic Properties of the General Normed Metric Vector Space.R1Combinatorial R1Combinatorial implements the Normed, Bounded/Unbounded Combinatorial lp Rd Spaces.R1CombinatorialBall R1CombinatorialBall extends the Combinatorial R1 Banach Space by enforcing the Closed Bounded Metric.R1Continuous R1Continuous implements the Normed, Bounded/Unbounded Continuous lp R1 Spaces.R1ContinuousBall R1ContinuousBall extends the Continuous R1 Banach Space by enforcing the Closed Bounded Metric.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdCombinatorialBall RdCombinatorialBall extends the Combinatorial Rd Banach Space by enforcing the Closed Bounded Metric.RdCombinatorialBanach RdCombinatorialBanach implements the Bounded/Unbounded Combinatorial lp Rd Spaces.RdContinuousBall RdContinuousBall extends the Continuous Rd Banach Space by enforcing the Closed Bounded Metric.RdContinuousBanach RdContinuousBanach implements the Normed, Bounded/Unbounded Continuous lp Rd Spaces.RdContinuousHilbert RdContinuousHilbert implements the Bounded/Unbounded, Continuous l2 Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.spaces.rxtor1 Class Description GeneralizedMetricVectorSpace GeneralizedMetricVectorSpace exposes the basic Properties of the General Normed Metric Vector Space.R1Combinatorial R1Combinatorial implements the Normed, Bounded/Unbounded Combinatorial lp Rd Spaces.R1Continuous R1Continuous implements the Normed, Bounded/Unbounded Continuous lp R1 Spaces.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdCombinatorialBanach RdCombinatorialBanach implements the Bounded/Unbounded Combinatorial lp Rd Spaces.RdContinuousBanach RdContinuousBanach implements the Normed, Bounded/Unbounded Continuous lp Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces. -
Classes in org.drip.spaces.metric used by org.drip.spaces.rxtord Class Description GeneralizedMetricVectorSpace GeneralizedMetricVectorSpace exposes the basic Properties of the General Normed Metric Vector Space.R1Combinatorial R1Combinatorial implements the Normed, Bounded/Unbounded Combinatorial lp Rd Spaces.R1Continuous R1Continuous implements the Normed, Bounded/Unbounded Continuous lp R1 Spaces.R1Normed R1Normed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.RdCombinatorialBanach RdCombinatorialBanach implements the Bounded/Unbounded Combinatorial lp Rd Spaces.RdContinuousBanach RdContinuousBanach implements the Normed, Bounded/Unbounded Continuous lp Rd Spaces.RdNormed RdNormed Abstract Class implements the Normed, Bounded/Unbounded Continuous/Combinatorial lp Rd Spaces.


{% extends 'base.html' %} {% load staticfiles %} {% block breadcrumb %}
{% endblock %} {% block body %}The Association for Information Systems (AIS) serves society through the advancement of knowledge and the promotion of excellence in the practice and study of information systems. AIS is the premier professional association for individuals and organizations who lead the research, teaching, practice, and study of information systems worldwide.
BYU founded a local student chapter of AIS in 1993 in order to further this mission through Information Systems graduates.
We serve our members by promoting and developing Information Systems-related skills, career exploration, and dynamic relationships with professionals, recruiters, and students.
AIS, in conjunction with the Information Systems department, provides the means for students to gain world-class experience. Alumni are encouraged to give back to the program for those that come after.
Donate today


Light Blue Admin Template is next-generation, well-designed and powerful front-end template. It's very useful for designing either your next web application or admin entrance for it.
It's base on super powerful Bootstrap front-end framework which uses 12-column responsive grid layout.
Light Blue package goes with following folders:
Next folders are not essential and can be removed from package:
Light Blue uses scss to generate css. This choice has been made because of significant boost scss gives when developing front-end apps like this one. We used compass to compile scss to css, but what to use is absolutely up to your choice. Anyway editing css is a good old way, right? :)
The main scss file is application.scss. It includes all libraries and partial files.
general.scss - all application styles. Only element styles
(body
, a
, h2
, etc).
base.scss - all application styles. Everything except elements. Every class used in Light Blue is defined here.
There are lots of sections like:
/***********************************/
/** LOGO **/
/**********************************/
in this file. You can simply remove sections you don't need and recompile stylesheets. The essential sections are:
LOGO, SIDEBAR, CONTENT, WIDGET, HEADER, MESSAGES, SUPPORT, SETTINGS, ACCOUNT, BUTTONS, FORMS, TABLES, UTILS. All other sections can be removed.
font.scss - downloaded version of Open Sans font.
responsive.scss - responsive styles.
variables.scss - all template variables like colors, button sizes, etc.
svg.scss - svg-related styles. This one can be easily removed if you don't need nvd3 charts.
Light Blue uses jquery-pjax library that uses ajax and pushState which makes page loading super fast.
In case you want to turn off ajax page loading you need to just set window.PJAX_ENABLED
variable to false
(js/app.js file):
window.PJAX_ENABLED = false;
If you have any questions or problems when installing template feel free to contact us via email -<EMAIL_ADDRESS>We will provide as much help as possible.
See statistics section.
Left sidebar is based on Bootstrap's collapse component. Settings.js holds additional javascript code which is used to change sidebar state and sidebar position depending on chosen option (icons, auto) and (left, right).
Is simple Bootstrap's Navbar. User profile and settings popovers are implemented via Bootstrap's popover
Charts are built with D3.js-based nvd3 library. Read more in charts section


Man grabs woman, tries pulling her out of apartment, police say
by Logan RudeMADISON, Wis. - A 67-year-old woman said she was terrified when a 40-year-old man grabbed her and tried pulling her out of her apartment when she answered the door Monday night, according to an incident report.
The woman, who was already in pain due to her arthritis, told police she feared the man might hurt her. The woman said the man spoke in a loud voice and told her, "I'm the president, come with me," when he grabbed her, according to the report.
Police said when they arrived, the man spit at them while making incoherent statements. According to the report, it took several officers to subdue and calm the man.
He was taken to a hospital, and there is probable cause to arrest him on suspicion of battery, disorderly conduct and resisting/obstructing upon his release from the medical facility, according to the report.


When running the amount never gets recalculated becuase we add it during the eval of the script, this causes the diff to be static
this may be ok, i can run it once which will go based on the last ran time stamp, then for the repeaters the gap will be fixed anyway,,,,,so the thought is
when starting execute the script once, then start the repeating process which will use a fixed interval.


About Me
I was born and raised in Hawaii and spent most of my childhood there. When I was
a
kid
I played a variety of sports and spent a lot of time at the beach. I also really liked to fish and some of
my
best memories as a kid was going out on the ocean with my friend in his 10 foot dingy and 2.5hp motor,
trolling
around the island. We would never really catch that much but always had a blast and when the fishing wasn't
good
we would take our surf boards and check out breaks nearby. After graduating highschool, I moved to southern
California to do my undergrad at UC Irvine. During my time in college, I studied abroad in Singapore and
traveled quite a bit over the summers. One of my favorite trips was when I went up to Whister Canada with a
couple friends and snowboarded for a week. I also picked up snowboarding in southern California and ended up
getting a pass at Big Bear mountain. After spending 3 years in Irvine, I decided to move back to Hawaii and
continue school back at home since I wasn't the biggest fan of socal. I spent about 2 years back at home
going
to University of Hawaii and then ended up moving back to California again, this time to San Francisco. I
have
been here for about a year and a half and really enjoy it so far. Spent the first 16 month working at a beer
company called Hopsy, and ended up quitting that to start this coding bootcamp!